第七章: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 为什么要将元组设计为不可变序列
- 在多任务环境下,同时操作对象时不需要加锁
- 因此,在程序中尽量使用不可变序列
注意事项
- 元组中存储的是对象的引用
- 如果元祖中对象本身不可变对象,则不能在引用其他对象
- 如果元祖中对象本身是可变对象,则可变对象的引用不允许改变,但数据可以改变
图示
代码演示
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 } |
集合 | 可变 | 不可重复 | 无序 | { } |