第七章：Python基本数据结构——元组和集合

一、元祖

1.1 什么是元祖

1.1.1 元组

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

• 从外观的角度：元组使用（）；列表使用 [ ]

1.2 元组的创建方式

• 直接使用小括号，小括号可省略

• 使用内置函数tuple()

• 只包含一个元祖的元素需要使用逗号和小括号（与列表不同）

代码演示

"""
    元组的创建方式
"""
"""直接使用小括号"""
t = ('Python', 'world', 98)
t2 = 'Python', 'world', 98  # 省略小括号
print(t)
print(type(t))
print(type(t2))

"""使用内置函数tuple()"""
t1 = tuple(('python', 'world', 98))
print(t1)
print(type(t1))

"""只包含一个元祖的元素需要使用逗号和小括号"""
t3 = ('Python',)
print(t3, id(t3))

"""空元组创建"""
# 空列表创建
lst = []
lst1 = list()
# 空字典
d = {}
d2 = dict()
# 空元组
t4 = ()
t5 = tuple()

1.3 可变序列与不可变序列

1.2.1 不可变序列与可变序列类型

• 不可变序列
  • 字符串、元祖
  • 没有增删改的操作
• 可变序列
  • 列表、字典、集合
  • 可以对序列执行增删改操作，对象地址不发生更改

代码演示

"""可变序列：列表、字典"""
lst = [10, 20, 45]
print(id(lst))
lst.append(100)
print(id(lst))  # 地址不发生更改

"""不可变序列：字符串，元组"""
s = 'hello'
print(id(s))
s = s + 'world'
print(id(s))  # 地址发生改变

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

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

注意事项

1. 元组中存储的是对象的引用
2. 如果元祖中对象本身不可变对象，则不能在引用其他对象
3. 如果元祖中对象本身是可变对象，则可变对象的引用不允许改变，但数据可以改变

图示

代码演示

t = (10, [20, 30], 9)
print('1.', t, type(t))
print('t[0].', t[0], '\t\ttype:', type(t[0]), id(t[0]))
print('t[1].', t[1], '\ttype:', type(t[1]), id(t[1]))
print('t[2].', t[2], '\t\ttype:', type(t[2]), id(t[2]))

"""尝试将t[1]修改成100"""
# t[1] = 100  # 报错，元组不允许修改元素

"""由于[20,30]是列表，可以向列表中添加元素，列表内存地址不变"""
t[1].append(100)
print('t[1].', t[1], '\ttype:', type(t[1]), id(t[1]))

1.4 元组的遍历

• 元组是可迭代对象，所以可以使用 for ...in 进行遍历

代码演示

"""
    元组的遍历
"""
t = ('Python', 'world', 98)
"""第一种获取元组元素的方式，使用索引，前提是知道元组的个数"""
print(t[0])
print(t[1])
print(t[2])

"""第二种，遍历元组"""
for item in t:
    print(item)

二、集合

2.1 什么是集合

• 集合是Python中的内置数据结构之一
• 与列表、字典一样都属于可变序列
• 集合是没有value的字典
• 集合中的元素是无序的

2.2 集合的创建

• 直接使用 {} 创建
• 使用内置函数 set() 方法

代码演示

"""
    集合的创建方式
"""
"""定义一个空集合"""
ss = {}  # 类型为字典类型
sss = set()

"""第一种创建方式：使用{}"""
s = {2, 3, 4, 5, 6, 3, 2, 7, 7}
print(s)  # 集合中的元素不允许重复，重复的会被去掉

"""第二种创建方式，set()"""
s2 = set(range(6))
print(s2)

s3 = set([1, 2, 3, 4, 5])  # 将列表类型转成集合类型
print(s3, type(s3))

s4 = set((1, 2, 3, 4, 5))  # 将元组类型转成集合类型
print(s4, type(s4))

s5 = set('Python')  # 将字符串类型转成集合类型
print(s5, type(s5))

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

2.3.1 集合元素的判断操作

• in 或者 not in

代码演示

s = {10, 20, 30, 40, 50}
# 判断元素是否存在
print(10 in s)
print(10 not in s)
print(100 not in s)
print(100 in s)

2.3.2 集合元素的新增操作

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

代码演示

# 新增操作
s2 = {10, 20, 30, 40, 50}
# add()方法，一次添加一个元素
s2.add(66)  # 无序添加
print(s2)
# update()方法，一次至少添加一个元素
s2.update((22, 33))
print(s2)

2.3.3 集合元素的删除操作

• 调用remove()方法，一次删除一个指定元素，如果指定的元素不存在，则抛出异常KeyError
• 调用discard()方法，一次删除一个指定元素，如果指定的元素不存在，则不会抛出异常
• 调用pop()方法，一次只删除一个任意元素；没有参数，不能指定参数，如果指定参数会抛出异常
• 调用clear()方法，清空集合

代码演示

# 删除操作
s3 = {33, 50, 66, 20, 22, 40, 10, 30}
# 调用remove()方法，一次删除一个指定元素，如果指定的元素不存在，则抛出异常KeyError
s3.remove(10)
print(s3)
# s3.remove(100)  # 元素不存在，抛出异常

# 调用discard()方法，一次删除一个指定元素，如果指定的元素不存在，则不会抛出异常
s3.discard(100)  # 元素不存在，不会抛出异常
s3.discard(22)
print(s3)

# 调用pop()方法，一次只删除一个任意元素
s3.pop()  # 没有参数，不能指定参数；指定参数会抛出异常
print(s3)

# 调用clear()方法，清空集合
s3.clear()
print(s3)

2.4 集合之间的关系

2.4.1 集合之间的关系

关系

• 两个集合是否相等
  • 可以使用运算符 == 或者 != 进行判断
  • 元素相同即相等，集合中的元素为无序
• 一个集合是否是另一个集合的子集
  • 可以调用方法 issubse 进行判断
• 一个集合是否是另一个集合的超集
  • 可以调用方法 issuperset 进行判断
• 两个集合是否有交集
  • 可以调用方法 isdisjoint 进行判断

代码演示

"""
    集合之间的关系
"""
s1 = {10, 20, 30, 40}
s2 = {40, 20, 10, 30}
s3 = {40, 20, 10, 30, 90, 100}
s4 = {10, 30}
# 两个集合是否相等，元素相同即相等
print('1.', s1 == s2)  # 集合中元素无序
print('2.', s1 != s2)

# 一个集合是否是另一个集合的子集
print('3.', s2.issubset(s3))
print('4.', s2.issubset(s4))

# 一个集合是否是另一个集合的超集
print('5.', s2.issuperset(s3))
print('6.', s2.issuperset(s4))

# 两个集合是否有交集
print('7.', s2.isdisjoint(s3))

2.4.2 集合之间的数学操作

数学操作

• 求两个集合的交集
  • 可以调用 intersection() 方法
  • 或者使用 &符号
• 求两个集合的并集
  • 可以调用 union() 方法
  • 或者使用 |符号
• 求两个集合的并集
  • 可以调用 difference() 方法
  • 或者使用 —符号
  • 两个集合有前后顺序而言
• 求两个集合的并集
  • 可以调用 symmetric_difference() 方法
  • 或者使用 ^符号

图示

代码演示

"""
    集合的数学操作
"""
s1 = {10, 20, 30, 40}
s2 = {20, 30, 40, 50, 60}

# 交集运算,intersection()方法 或者 &
print('1.', s1.intersection(s2))
print('2.', s1 & s2)

# 并集操作，union()方法 或者 |
print('3.', s1.union(s2))
print('4.', s1 | s2)

# 差集操作，
print('5.', s1.difference(s2))  # 差集前后两个集合有顺序而言
print('6.', s1 - s2)

print('7.', s2.difference(s1))
print('8.', s2 - s1)

# 对称差集
print('9.', s1.symmetric_difference(s2))
print('10.', s1 ^ s2)

2.5 集合的生成式

• 列表的生成式

lst = [i for i in range(6)]

• 集合的生成式

set={i for i in range(6)}

只需要把列表的 [] 换成 {}

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

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