我在CSDN学python-8

1、什么是元组

# Name：      Python study
# Designer：  MilesHugh
# Time：      2023/4/7  16:45

# 不变可变序列：没有增、删，改的操作
# -字符串
# -元组：Python内置的数据结构之一，与列表相似，但是为( , ,)
s = 'hello'
print(id(s))
s = s + 'world'
print(id(s))
print(s)
# 可变序列：可以对序列执行增、删、改操作，对象地址不发生更改
# -列表:[, , ]
# -字典
lst = [1, 5, 10]
print(id(lst))
lst.append(30)
print(id(lst))
# 列表增删改操作后，标识不变

2、元组的创建方式

# Name：      Python study
# Designer：  MilesHugh
# Time：      2023/4/10  10:42

# 元组的创建方式
# -直接小括号
# -使用内置函数tuple()
# -只包含一个元组的元素需要使用逗号和小括号
print('------第一种方式，使用()------')
t = ('Python', 'world', 33)
print(t)
print(type(t))
t2 = 'Python', 'world', 33  # 省略小括号
print(t2)
print(type(t2))
t3 = ('Python' )
print(t3)
print(type(t3))
t4 = ('Python', )  # 如果元组中只有一个元素，逗号不能省
print(t4)
print(type(t4))
print('------第二种方式，使用内置函数tuple()------')
t1 = tuple(('Python', 'world', 33))
print(t1)
print(type(t1))
print('------空元组的创建方式------')
print('------空列表的创建方式------')
lst = []
lst1 = list()
d = {}
d2 = dict()
t5 = ()
t6 = tuple()
print(lst, type(lst), id(lst))
print(lst1, type(lst1), id(lst1))
print(d, type(d), id(d))
print(d2, type(d2), id(d2))
print(t5, type(t5), id(t5))
print(t6, type(t6), id(t6))
print('空列表', lst, lst1)
print('空字典', d, d2)
print('空元组', t5, t6)

# 为什么要将元组设计成不可变序列？
# -在多任务环境下，同时操作对象时不需要加锁，所以在程序中尽量使用不可变序列
# （可变序列同时操作对象时，需要加锁，防止数据冲突）
# 注意：元组中存储的是对象的引用
# -如果元组中的对象本身是不可变对象，则不能再引用其他对象
# -如果元组中的对象是可变对象，则可变对象的引用不允许改变，但数据可以改变
t = (1, [2, 3], 9)
print(t)
print(type(t))
print(t[0], type(t[0]), id(t[0]))
print(t[1], type(t[1]), id(t[1]))
print(t[2], type(t[2]), id(t[2]))
print('------尝试将t[1]修改为10------')
print(id(10))
# t[1]=10   #元组是不允许修改元素的
print('------列表[2,3]是可变序列，可向列中添加元素，列表的内存地址不变------')
t[1].append(10)  # 向列表中添加元素
print(t, id(t[1]))

3、元组的遍历

# Name：      Python study
# Designer：  MilesHugh
# Time：      2023/4/10  11:12

# 元组的遍历
# -元组时可迭代对象，可用for...in...进行遍历
print('------元组的遍历------')
t = ('Python', 'world', 33)
print('------第一种获取元组的方式，使用索引------')
print(t[0])
print(t[1])
print(t[2])
# print(t[3]) # 报错，元组中元素不存在 IndexError: tuple index out of range
print('------遍历元组------')
for i in t:
    print(i)

4、集合的定义及创建

# Name：      Python study
# Designer：  MilesHugh
# Time：      2023/4/10  11:50

# 集合：
# -python语言提供的内置数据结构
# -与列表、字典一样都属于可变类型的序列
# -集合是没有value的字典

# 集合的创建方式 -直接{} -使用内置函数set()
print('------第一种创建方式，使用{}------')
s = {2, 3, 4, 5, 5, 6, 7, 7}  # 集合中的元素不允许重复，重复的元素会去掉
print(s)
print('------第一种创建方式，使用set()------')
s1 = set(range(6))
print(s1)
s2 = set([1, 2, 4, 5, 5, 5, 6, 6])  # 元组元素会转换为集合类型
print(s2, type(s2))
s3 = set((1, 2, 4, 4, 5, 65))  # 集合中的元素无序
print(s3, type(s3))
s4 = set('python')  # 集合中的元素无序
print(s4, type(s4))
s5 = set({12, 4, 34, 55, 66, 44, 4})  # 集合中的元素无序
print(s5, type(s5))
print('------定义一个空集合------')
s6 = {}
print(type(s6))
s7 = set()
print(type(s7))

5、集合的增、删、改、查操作

# Name：      Python study
# Designer：  MilesHugh
# Time：      2023/4/10  12:03

# 集合的相关操作
# -集合元素的判断操作
# -集合元素的新增操作
# -集合元素的删除操作
s = {1, 2, 3, 4, 5, 6}
print('------集合元素的判断操作：in、not in------')
print(1 in s)  # True
print(10 in s)  # False
print(1 not in s)  # False
print(10 not in s)  # True
print('------集合元素的新增操作：add(),update()------')
s.add(8)  # 一次添加一个元素
print(s)
s.update({20, 40, 30})  # 一次至少添加一个元素
print(s)
s.update((12, 34, 56))
print(s)
print('------集合元素的删除操作：remove(),discard(),pop(),clear()------')
s.remove(1)
print(s)
# s.remove(10)  # 元素10不在s中，remove()删除操作时会显示异常
# print(s)
s.discard(10)  # 元素10不在s中，discard()删除操作时不会显示异常
print(s)
s.discard(12)
print(s)
s.pop()  # 一次删除任意元素，pop()内不可指定元素
print(s)
# s.pop(34)
# print(s)
s.clear()
print(s)


# 集合间的关系
# -两个集合是否相等：可以使用运算符==或!=进行判断
# -一个集合是否是另一个集合的子集：可以调用方法issubset进行判断，B是A的子集
# -一个集合是否是另一个集合的超集：可以调用方法issuperset进行判断，A是B的超集
# -两个集合是否含有交集：可以调用方法isdisjoint进行判断
print('------两个集合是否相等------')
s1 = {1, 2, 3, 4}
s2 = {1, 3, 2, 4}
print(s1 == s2)  # True
print(s1 != s2)  # False
print('------一个集合是否是另一个集合的子集------')
s1 = {1, 2, 3, 4, 5, 6}
s2 = {1, 3, 2, 4}
s3 = {1, 2, 4, 9}
print(s2.issubset(s1))  # True
print(s3.issubset(s1))  # False
print('------一个集合是否是另一个集合的超集------')
s1 = {1, 2, 3, 4, 5, 6}
s2 = {1, 3, 2, 4}
s3 = {1, 2, 4, 9}
print(s1.issuperset(s2))  # True
print(s1.issuperset(s3))  # False
print('------两个集合是否含有交集------')
print(s2.isdisjoint(s3))  # 有交集为False
s4 = {12, 34, 56}
print(s4.isdisjoint(s2))  # 无交集为True


# 集合的数学操作
print('------两个集合之间的交集操作------')
s1 = {1, 2, 3, 4}
s2 = {2, 3, 4, 5, 6}
print(s1.intersection(s2))
print(s1 & s2)
print(s1)
print(s2)
print('------两个集合之间的并集操作------')
print(s1.union(s2))
print(s1 | s2)
print(s1)
print(s2)
print('------两个集合之间的差集操作------')
print(s1.difference(s2))
print(s1 - s2)
print(s2.difference(s1))
print(s2 - s1)
print(s1)
print(s2)
print('------两个集合之间的对称差集操作------')
# 对称差集：两个集合的并集-交集
print(s1.symmetric_difference(s2))
print(s1 ^ s2)
print(s1)
print(s2)

6、集合生成式

# Name：      Python study
# Designer：  MilesHugh
# Time：      2023/4/10  13:44

# 集合生成式
# 用于生成集合的公式：{i*i for i in range(1, 10)}
# -i*i表示集合元素的表达式
# -i自定义变量
# -range(1,10)可迭代对象
# 注意：将{}修改为[]就是列表生成式，且没有元组生成式
lst = [i*i for i in range(6)]  # 列表生成式
print(lst)
s = {i*i for i in range(6)}  # 集合生成式
print(s)
s = {i*i for i in range(9)}  # 集合生成式
print(s)

列表、字典、元组、集合总结

数据结构	是否可变	是否重复	是否有序	定义符号
列表(list)	可变	可重复	有序	[ ]
元组(tuple)	不可变	可重复	有序	( )
字典(dict)	可变	key不可重复，value可重复	无序	{key:value}
集合(set)	可变	不可重复（相当于key）	无序	{ }