Python：元组与集合

元组

Python内置的数据结构之一，不可变序列

不可变序列：字符串、元组（没有增删改的操作）

可变序列：列表、字典（对序列执行增删改操作，对象地址不发生更改）

创建方式

# 1.使用（）
t = ('12', 'mi', '123')
t1 = '12', 'mi', '123'  # 可以省略（）

# 2.使用内置函数tuple
t2 = tuple(('12', 'mi', '123'))
print(t2, type(t2))  # ('12', 'mi', '123') <class 'tuple'>

# 3.元组中只有一个元素时，需要加，.否则类型会为元素的类型
t3 = (1,)

# 空元组
t4 = ()
t5 = tuple()

为什么将元组设计为不可变序列？

多任务执行中，同时操作对象时不需要加锁，因此在程序中尽量使用不可变序列

注意事项：
元组中存储的是对象的引用
a.如果元组中元素本身是不可变对象，则不能再引用其他对象，即不可修改
b.如果元组中的对象是可变对象，则可变对象的引用不允许改变，但数据可改变

元组的遍历

# 获取元组的元素，可以使用索引
t6 = ('12', 'mi', '123')
print(t6[1])  # mi
# 遍历
for item in t6:
    print(item)

集合

Python内置的数据结构之一，可变序列，是没有value的字典

集合中的元素是无序的，不允许重复元素，会自动删除重复元素

创建方法

# 1.使用{}
s = {'12', 'mi', '123', '5', '5'}
print(s)  # {'12', 'mi', '123', '5'}，不允许重复，会自动删除重复元素
# 2.内置函数set()
s1 = set(range(6))
s2 = set([1, 2, 3])  # 列表转集合
s3 = set((1, 2, 3))  # 元组转集合
s4 = set('hello')
s5 = set({'12', 'mi', '123', '5', '5'})

# 空集合
s7 = set()

集合的常用操作

in/not in 判断元素是否存在于集合中

# in/not in 判断元素是否存在于集合中
s8 = {'12', 'mi', '123', '5', '5'}

print(10 in s8)  # False
print(10 not in s8)  # True

新增操作

# 单次新增一个
s8.add(80)
print(s8)  # {'12', 'mi', '5', '123', 80}

# 单次新增多个元素
s8.update({1, 2, 3})
print(s8)  # {1, 2, 3, '123', 80, '12', 'mi', '5'}

删除操作

# 单次删除一个指定元素
s8.remove(1)  # 指定元素不存在时，报错keyError
print(s8)  # {'12', 2, 3, 80, '123', 'mi', '5'}
s8.discard('12')  # 指定元素不存在时，不会报错
print(s8)  # {'123', 2, 3, 80, '5', 'mi'}

# 删除随机一个
s8.pop()
print(s8)  # {3, '123', 'mi', 80, '5'}
# 清空集合
s8.clear()
print(s8)  # set()

集合间的关系

# 两个集合的元素相同即相等
ss2 = {20, 10, 30, 40}
ss1 = {10, 20, 30, 40}
print(ss1 == ss2)  # True

# 一个集合是否为另一个集合的子集
ss1 = {10, 20, 30, 40}
ss2 = {20, 10, 30, 40, 50, 60}
ss3 = {10, 20, 90}
ss4 = {100, 200}
print(ss3.issubset(ss2))  # False
print(ss1.issubset(ss2))  # True

#  一个集合是否是另一个集合的超集
print(ss2.issuperset(ss1))  # True
print(ss2.issuperset(ss3))  # False

# 两个集合是否有交集
print(ss3.isdisjoint(ss2))  # False （有交集）
print(ss4.isdisjoint(ss2))  # True （无交集）

集合的数据操作（数学操作）

# 交集操作：不影响原集合
s11 = {10, 20, 30, 40}
s22 = {30, 40, 50, 60}
print(s11.intersection(s22))  # {40, 30}
print(s11 & s22)  # 替代符号

# 并集操作：不影响原集合
print(s11.union(s22))  # {40, 10, 50, 20, 60, 30}
print(s11 | s22)  # 替代符号

# 差集操作：不影响原集合
print(s11.difference(s22))  # {10, 20}
print(s11 - s22)  # 替代符号

# 对称差集：不影响原集合
print(s11.symmetric_difference(s22))  # {10, 50, 20, 60}
print(s11 ^ s22)  # 替代符号

集合生成式

语法：{i * i for i in range(1, 10)}，与列表生成式类似

sss = {i * i for i in range(1, 10)}
print(sss)  # {64, 1, 4, 36, 9, 16, 49, 81, 25}