关于python: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}