Python学习笔记_元组与集合

元组
元组是Python内置的数据结构之一，是一个不可变序列
列表用方括号，元组用小括号

不可变序列与可变序列
不可变序列与可变序列
不可变序列：没有增、删、改操作。字符串、元组。
可变序列：可以对序列执行增、删、改操作，对象地址不发生更改

元组的创建方式
①直接使用小括号
注意：小括号可以省略，但只包含一个元素的元组需要使用逗号和小括号
②使用内置函数tuple()，只包含一个元素的元组也要使用逗号

# 元组的创建方式
# 第一种方式，使用()
t = ('Python', 'world', 98)
print(t)
print(type(t))
# 第一种创建方式()可以省略不写
t1 = 'Python', 'world', 98  # 省略了小括号
print(t1)
print(type(t1))

# 第二种创建方式，使用内置函数tuple()
t2 = tuple(('Python', 'world', 98))
print(t2)
print(type(t2))

# 空元组的创建方式
lst = []
lst1 = list()  # 上述两语句是创建空列表
d = {}
d2 = dict()  # 上述两语句是创建空字典

t3 = ()
t4 = tuple()  # 创建空元组

为什么要将元组设计成不可变序列
在多任务环境下，同时操作对象时不需要加锁，因此，在程序中尽量使用不可变序列
注意：元组中存储的是对象的引用。如果元组中对象本身是不可变对象，则不能再引用其他对象；如果元组中的对象是可变对象，则可变对象的引用不允许改变，但数据可以改变。

t = (10, [20, 30], 9)
print(t)
print(type(t))
print(t[0], type(t[0]))  # 我的理解是，元素的获取，无论是列表还是字典还是元组，都用[]
print(t[1], type(t[1]))
print(t[2], type(t[2]))
# 由于[20, 30]是列表，列表是可变序列，所以可以向列表中添加元素，而列表的内存地址不变
t[1].append(100)
print(t)  # (10, [20, 30, 100], 9)

元组的遍历
元组的元素的获取可以像列表一样，通过索引获取，但使用索引获取元素时需要预知元组中有多少元素，否则会出现索引边界的问题。
最常用的方式是，用 for…in
元组是可迭代对象，所以可以使用 for…in 进行遍历

# 元组的遍历
t = ('Python', 'world', 98)
# 第一种获取元组元素的方式，使用索引，前提是预知元素的个数
print(t[0])
print(t[1])
print(t[2])
# print(t[3])  # IndexError: tuple index out of range

# 第二种获取元组元素的方式，使用for...in
for item in t:
    print(item)

集合
集合是Python语言提供的内置数据结构，与列表、集合一样都属于可变类型的序列。
集合是没有value的字典
集合的创建方式
①直接{}
②使用内置函数set()

# 集合的创建方式
# 第一种创建方式，使用{}
s = {2, 3, 4, 5, 5, 6, 7, 7}
print(s)  # {2, 3, 4, 5, 6, 7},集合与字典一样，元素不能重复

# 第二种创建方式，使用内置函数set()
s1 = set(range(6))
print(s1)  # {0, 1, 2, 3, 4, 5}

s2 = set([1, 2, 4, 5, 5, 5, 6, 6])  # 将列表转成集合
print(s2, type(s2))  # {1, 2, 4, 5, 6} <class 'set'>
s3 = set((1, 2, 4, 4, 5, 65))  # 将元组转成集合
print(s3, type(s3))  # {65, 1, 2, 4, 5} <class 'set'>  集合中的元素是无序的，且不能重复
s4 = set('python')  # 将字符串转成集合
print(s4, type(s4))  # {'h', 'p', 't', 'n', 'y', 'o'} <class 'set'>

# 定义一个空集合
s6 = {}  # 这样是定义一个空字典
print(s6, type(s6))  # {} <class 'dict'>
s7 = set()  # 这样才是定义一个空集合
print(s7, type(s7))  # set() <class 'set'>

集合的相关操作（集合元素的增、删、改）

集合元素的判断操作
用 in、not in 检查集合中是否存在指定的元素

# 检查集合中是否存在指定的元素
s = {10, 20, 30, 40}
print(10 in s)  # True
print(50 in s)  # False
print(20 not in s)  # False

集合元素的新增操作
调用add()方法，一次添加一个元素
调用update()方法，至少添加一个元素
注意：集合中的元素没有顺序，所以没有在指定位置添加元素这种说法

# 集合元素的添加操作
s = {10, 20, 30, 40, 50}
print(s)  # {50, 20, 40, 10, 30}
s.add(100)
print(s)  # {50, 20, 100, 40, 10, 30}

s.update({200, 400, 300})
print(s)  # {100, 40, 200, 10, 300, 400, 50, 20, 30}

# update()的括号中除了集合，还可以放列表、元组
s1 = {10, 20, 30, 40, 50}
s1.update([100, 200])
print(s1)  # {50, 20, 100, 40, 10, 30, 200}
s2 = {10, 20, 30, 40, 50}
s2.update((100, 200))
print(s2)  # {50, 20, 100, 40, 10, 30, 200}

集合元素的删除操作
①调用remove()方法，一次删除一个指定的元素，如果指定的元素不存在则抛出KeyError
②调用discard()方法，一次删除一个指定的元素，如果指定的元素不存在不抛出异常
③调用pop()方法，一次只删除一个任意元素
④调用clear()方法，清空集合

# 集合元素的删除操作
s = {10, 20, 30, 40, 50, 100}
s.remove(100)
print(s)  # {50, 20, 40, 10, 30}
# s.remove(500)  # KeyError: 500
s.discard(500)  # 不抛出异常
print(s)  # {50, 20, 40, 10, 30}
s.pop()  # 删除任意一个元素，每次运行删除的元素不一定相同
print(s)  # {20, 40, 10, 30}
s.clear()  # 清空集合
print(s)  # set()

集合间的关系
两个集合是否相等：使用运算符 ==、!=进行判断
一个集合是否是另一个集合的子集：可以调用方法issubset进行判断
一个集合是否是另一个集合的超集：可以调用方法issuperset进行判断
两个集合是否没有交集：可以调用方法isdisjoint进行判断

# 判断两个集合是否相等
s1 = {10, 20, 30, 40}
s2 = {10, 20, 40, 30}
print(s1 == s2)  # True 因为集合没有顺序，所以s1与s2是相同的
print(s1 != s2)  # False

# 判断一个集合是否是另一个集合的子集
s3 = {10, 30, 20}
print(s3.issubset(s1))  # True
print(s1.issubset(s3))  # False

# 判断一个集合是否是一个集合的超集
print(s1.issuperset(s3))  # True

# 判断两个集合是否没有交集
print(s1.isdisjoint(s2))  # False 即s1与s2是有交集的

集合的数学操作
交集、并集、差集、对称差集

# 求交集
s1 = {10, 20, 30, 40}
s2 = {20, 40, 30, 50}
print(s1.intersection(s2))  # {40, 20, 30}
print(s1 & s2)  # {40, 20, 30} 用 & 同样可以求交集

# 求并集
print(s1.union(s2))  # {40, 10, 50, 20, 30}
print(s1 | s2)  # {40, 10, 50, 20, 30} 用 | 同样可以求并集

# 求差集
print(s1.difference(s2))  # {10}
print(s1 - s2)  # {10} 用 - 同样可以求差集

# 求对称差集
print(s1.symmetric_difference(s2))  # {10, 50}
print(s1 ^ s2)  # {10, 50}

集合生成式
用于生成集合的公式

公式：{i*i for i in range(1,10)}
# i*i表示集合元素的表达式， i 是自定义变量， range(1,10) 是可迭代列表对象
# 将{}修改为[]就是列表生成式

注意： 没有元组生成式，因为元组是已经提到的四种数据结构中唯一一个不可变序列，所以元组没有生成式

# 列表生成式
lst = [i*i for i in range(6)]
print(lst)  # [0, 1, 4, 9, 16, 25]

# 集合生成式
s = {i*i for i in range(6)}
print(s)  # {0, 1, 4, 9, 16, 25}
s2 = {i*i for i in range(10)}
print(s2)  # {0, 1, 64, 4, 36, 9, 16, 49, 81, 25} 不按照大小顺序排列，可见集合中的元素是没有顺序的

列表、字典、元组、集合总结与对比

列表 list： 可变 可重复 有序 []
元组 tuple ： 不可变 可重复 有序 ()
字典 dict ： 可变 key不可重复，value可重复 无序 {key:value}
集合 set ： 可变 不可重复 无序 {}