Python中的元组和集合

一、Python中的元组

1.元组的概念

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

 """不可变序列，可变序列"""
 '''可变序列  列表，字典'''
 lst = [10, 20, 45]
 print(id(lst))
 lst.append(300)
 print(id(lst))
 ​
 '''不可变序列  字符串，元组'''
 s = 'hello'
 print(id(s))
 s = s + 'world'
 print(id(s))
 print(s)

2.元组的创建方式

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

3.元组的特点

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

A: 在多任务环境下，同时操作对象时不需要加锁

注意事项：

元组中存储的是对象的引用

• 如果元组中的对象是不可变对象，则不能再引用其他对象

• 如果元组中的对象是可变对象，则可变对象的引用不可改变，但数据可以改变

示意图：

代码示例：

 t = (10, [20, 30], 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]))
 '''尝试将t[1]修改为100'''
 # t[1] = 100  # 元组是不允许修改元素的
 '''由于[20,30]是列表，而列表是可变序列，所以可以向列表中添加元素，而列表的内存地址不变'''
 t[1].append(100)  # 向列表中添加元素
 print(t, id(t[1]))

4.元组的遍历

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

二、Python中的集合

1.集合的概述与创建

集合

• Python语言提供的内置数据结构

• 与列表、字典一样都属于可变类型的序列

• 集合是没有value的字典

集合的创建

 """集合的创建方式"""
 '''第一种创建方式使用{}'''
 s = {2, 3, 4, 5, 5, 6, 7, 7}  # 集合中的元素不允许重复
 print(s)
 ​
 '''第二种创建方式使用set()'''
 s1 = set(range(6))
 print(s1, type(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))
 ​
 # 定义一个空集合
 s6 = {}  # dict字典类型
 print(type(s6))
 ​
 s7 = set()
 print(type(s7))

2.集合的相关操作

• 集合元素的判断操作

  • in或not in

• 集合元素的新增操作

  • 调用add()方法，一次添加一个元素

  • 调用update()方法，一次添加多个元素

• 集合元素的删除操作

  • 调用remove()方法，一次删除一个指定元素，如果指定的元素不存在抛出KeyError

  • 调用discard()方法，一次删除一个指定元素，如果指定的元素不存在不抛异常

  • 调用pop()方法，一次只删除一个任意元素

  • 调用clear()方法，清空集合

 s = {10, 20, 30, 405, 60}
 '''集合元素的判断操作'''
 print(10 in s)  # True
 print(100 in s)  # False
 print(10 not in s)  # False
 print(100 not in s)  # True
 '''集合元素的新增操作'''
 s.add(80)  # add一次添加一个元素
 print(s)
 s.update({200, 400, 300})  # 一次添加多个元素
 print(s)
 s.update([100, 99, 8])
 s.update((78, 64, 56))
 print(s)
 ​
 '''集合元素的删除操作'''
 s.remove(100)
 print(s)
 # s.remove(500)  # KeyError: 500
 s.discard(500)
 s.discard(300)
 print(s)
 s.pop()
 s.pop()
 # s.pop(400)  # TypeError: set.pop() takes no arguments (1 given)
 print(s)
 s.clear()
 print(s)

3.集合间的关系

 '''两个集合是否相等（元素相同，就相等）'''
 s = {10, 20, 30, 40}
 s2 = {30, 40, 20, 10}
 print(s == s2)  # True
 print(s != s2)  # False
 ​
 '''一个集合是否是另一个集合的子集'''
 s1 = {10, 20, 30, 40, 50, 60}
 s2 = {10, 20, 30, 40}
 s3 = {10, 20, 90}
 print(s2.issubset(s1))  # True
 print(s3.issubset(s1))  # False
 ​
 '''一个集合是否是另一个集合的超集（父集）'''
 print(s1.issuperset(s2))  # True
 print(s1.issuperset(s3))  # False
 ​
 '''两个集合是否含有交集'''
 # isdisjoint()方法表示，是否没有交集
 print(s2.isdisjoint(s3))  # False  有交集为False
 s4 = {100, 200, 300}
 print(s2.isdisjoint(s4))  # True  没有交集为True

4.集合的数学操作

 # (1)交集
 s1 = {10, 20, 30, 40}
 s2 = {20, 30, 40, 50, 60}
 print(s1.intersection(s2))
 print(s1 & s2)  # intersection()与&等价，交集操作
 print(s1)
 print(s2)
 ​
 # (2)并集操作
 print(s1.union(s2))
 print(s1 | s2)  # union与 | 等价，并集操作
 print(s1)
 print(s2)
 ​
 # (3)差集操作
 print(s1.difference(s2))
 print(s1 - s2)
 print(s1)
 print(s2)
 ​
 # (4)对称差集
 print(s1.symmetric_difference(s2))
 print(s1 ^ s2)
 ​
 #以上操作均不会改变原集合

5.集合生成式

# 列表生成式
lst = [i * i for i in range(10)]
print(lst)

# 集合生成式
s = {i * i for i in range(10)}
print(s)

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

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