Python基础之序列

序列是一种数据存储方式，用来存储一系列的数据。在内存中，序列就是一块用来存放多个值的连续的内存空间。比如一个整数序列[10,20,30,40]，可以这样示意表示：

由于 Python3 中一切皆对象，在内存中实际是按照如下方式存储的：a = [10,20,30,40]

从图示中，我们可以看出序列中存储的是整数对象的地址，而不是整数对象的值。python中常用的序列结构有：
字符串、列表、元组、字典、集合

一：列表list

列表：用于存储任意数目、任意类型的数据集合。
列表是内置可变序列，是包含多个元素的有序连续的内存空间。列表定义的标准语法格式：a = [10,20,30,40]
其中，10,20,30,40 这些称为：列表 a 的元素。
列表中的元素可以各不相同，可以是任意类型。比如：a = [10,20,‘abc’,True]
列表对象的常用方法汇总：

方法	要点	描述
list.append(x)	增加元素	将元素x增加到列表list尾部
list.extend(aList)	增加元素	将列表aList所有元素加到列表list尾部
list.insert(index,x)	增加元素	在列表list指定位置index处插入元素x
list.remove(x)	删除元素	在列表list中删除首次出现的指定元素x
list.pop([index])	删除元素	删除并返回列表list指定为index处的元素，默认是最后一个元素
list.clear()	删除所有元素	删除列表所有元素，并不是删除列表对象
list.index(x)	访问元素	返回第一个x的索引位置，若不存在x元素则抛出异常
list.count(x)	计数	返回指定元素x在列表list中出现的次数
len(list)	列表长度	返回列表中包含元素的个数
list.reverse()	翻转列表	所有元素原地翻转
list.sort()	排序	所有元素原地排序
list.copy()	浅拷贝	返回列表对象的浅拷贝

Python 的列表大小可变，根据需要随时增加或缩小。
字符串和列表都是序列类型，一个字符串是一个字符序列，一个列表是任何元素的序列。

1.1 列表的创建

a = [10,20,'good','man']
b = []
c = list(range(10))
d = list(range(10,20,2))
e = list(range(16,5,-1))
f = list('Bruce, Jet, Jacky')

1.2 列表推导式

a = [x for x in range(5)]
# [0, 1, 2, 3, 4]
b = [x*2 for x in range(5)]
# [0, 2, 4, 6, 8]
c = [x*2 for x in range(100) if x%9 == 0]
# [0, 18, 36, 54, 72, 90, 108, 126, 144, 162, 180, 198]
lis = [[x,x+1,x*x] for x in range(10)]
# [[0, 1, 0], [1, 2, 1], [2, 3, 4], [3, 4, 9], [4, 5, 16], [5, 6, 25], [6, 7, 36], [7, 8, 49], [8, 9, 64], [9, 10, 81]]

1.3 列表元素的增加

当列表增加和删除元素时，列表会自动进行内存管理，大大减少了程序员的负担。但这个特点涉及列表元素的大量移动，效率较低。除非必要，我们一般只在列表的尾部添加元素或删除元素，这会大大提高列表的操作效率。

append()方法：原地修改对象，是真正的列表尾部添加新的元素，速度最快，推荐使用。

a = [10, 20]
a.append(30)
print(a)			# [10, 20, 30]

加号运算符操作：并不是真正的尾部添加元素，而是创建新的列表对象；将原列表的元素和新列表的元素依次复制到新的列表对象中。这样，会涉及大量的复制操作，对于操作大量元素不建议使用。

a = [10, 20]
print(id(a))		# 1756083343944
a = a+[50]
print(id(a))		# 1756089798088
print(a)			# [10, 20, 50]

extend()方法：将目标列表的所有元素添加到本列表的尾部，属于原地操作，不创建新的列表对象。

a = [10, 20]
print(id(a))			# 2601761526344
a.extend([30,50])
print(id(a))			# 2601761526344
print(a)				# [10, 20, 30, 50]

insert()插入元素：使用 insert()方法可以将指定的元素插入到列表对象的任意制定位置。这样会让插入位置后面所有的元素进行移动，会影响处理速度。涉及大量元素时，尽量避免使用。类似发生这种移动的函数还有：remove()、pop()、del()，它们在删除非尾部元素时也会发生操作位置后面元素的移动。

扫描二维码关注公众号，回复： 9150675 查看本文章

a = [10, 20]
a.insert(1, 100)
print(a)			# [10, 100, 20]

乘法扩展：使用乘法扩展列表，生成一个新列表，新列表元素是原列表元素的多次重复。

a = [10, 20]
b = a * 3
print(b)			# [10, 20, 10, 20, 10, 20]

1.4 列表元素的删除

del 删除：删除列表指定位置的元素。

a = [100,200,888,300,400]
del a[1]
print(a)		# [100, 888, 300, 400]

pop()方法：删除并返回指定位置元素，如果未指定位置则默认操作列表最后一个元素。

a = [100,200,888,300,400]
a.pop()
print(a)		# [100, 200, 888, 300]

a = [100,200,888,300,400]
a.pop(1)
print(a)		# [100, 888, 300, 400]

remove()方法：删除首次出现的指定元素，若不存在该元素抛出异常。

a = [100,200,888,300,400]
a.remove(200)
print(a)		# [100, 888, 300, 400]

a = [100,200,888,300,400]
a.remove(800)
print(a)
# ValueError: list.remove(x): x not in list

1.5 列表元素访问和计数

通过索引直接访问元素：我们可以通过索引直接访问元素。索引的区间在[0, 列表长度-1]这个范围。超过这个范围则会抛出异常。

a = [100,200,888,300,400]
print(a[0])
print(a[100])	# IndexError: list index out of range

index()获得指定元素在列表中首次出现的索引：index()可以获取指定元素首次出现的索引位置。语法是：index(value,[start,[end]])。其中，start 和 end 指定了搜索的范围。

a = [100,200,888,300,400]
print(a.index(200))			# 1
print(a.index(300, 3))		# 3
print(a.index(300, 3,7))	# 3

count()：获得指定元素在列表中出现的次数

a = [100,200,888,300,400]
print(a.count(200))

len()：返回列表长度，即列表中包含元素的个数。

a = [100,200,888,300,400]
print(len(a))

成员资格判断：判断列表中是否存在指定的元素，我们可以使用 count()方法，返回 0 则表示不存在，返回大于 0 则表示存在。但是，一般我们会使用更加简洁的 in 关键字来判断，直接返回 True或 False。

a = [100,200,888,300,400]
print(100 in a)			# True
print(100 not in a)		# False

1.6 切片操作

操作和说明	示例	结果
[:] 提取整个列表	[10,20,30][:]	[10,20,30]
[start:]从 start 索引开始到结尾	[10,20,30][1:]	[20,30]
[:end]从头开始知道 end-1	[10,20,30][:2]	[10,20]
[start:end]从start到 end-1	[10,20,30,40][1:3]	[20,30]
[start: end:step] 从 start 提取到 end-1，步长是 step	[10,20,30,40,50,60,70][1:6:2]	[20, 40, 60]
倒数三个	[10,20,30,40,50,60,70][-3:]	[50,60,70]
倒数第五个到倒数第三个(包头不包尾)	10,20,30,40,50,60,70][-5:-3]	[30,40]
步长为负，从右到左反向提取	[10,20,30,40,50,60,70][::-1]	[70, 60, 50, 40, 30, 20, 10]

切片操作时，起始偏移量和终止偏移量不在[0,字符串长度-1]这个范围，也不会报错。
起始偏移量小于 0 则会当做 0，终止偏移量大于“长度-1”会被当成”长度-1”。

1.7 列表的遍历

a = [100,200,888,300,400]
for num in a:
    print(num)

1.8 列表字符串相互转换

字符串转列表：

str1 = 'say hello python'
list1 = str1.split(' ')
print(list1, type(list1))
# ['say', 'hello', 'python'] <class 'list'>

列表转字符串：

list1 = ['say', 'hello', 'python']
str1 = ' '.join(list1)
print(str1, type(str1))
# say hello python <class 'str'>

1.9 列表去重

list1 = [33581, 3306, 10050, 22, 22]
def deleteDuplicatedElement(lis):
    return sorted(list(set(lis)), key = lis.index)
list2 = deleteDuplicatedElement(list1)
print(list1)    # [33581, 3306, 10050, 22, 22]
print(list2)    # [33581, 3306, 10050, 22]

1.10 sorted函数排序

sorted() 函数对所有可迭代的对象进行排序操作

sort 与 sorted 区别：
sort 是应用在 list 上的方法，sorted 可以对所有可迭代的对象进行排序操作。
list 的 sort 方法返回的是对已经存在的列表进行操作，而内建函数 sorted 方法返回的是一个新的 list，而不是在原来的基础上进行的操作。

sorted(iterable, key=None, reverse=False)
# iterable -- 可迭代对象。
# key -- 主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序。
# reverse -- 排序规则，reverse = True 降序 ， reverse = False 升序（默认）。

>>>sorted([5, 2, 3, 1, 4])
[1, 2, 3, 4, 5]                      # 默认为升序

也可以使用 list 的 list.sort() 方法。这个方法会修改原始的 list（返回值为None）。通常这个方法不如sorted()方便。如果你不需要原始的 list，list.sort()方法效率会稍微高一些。
另一个区别在于list.sort() 方法只为 list 定义。而 sorted() 函数可以接收任何的 iterable。

>>>sorted({1: 'D', 2: 'B', 3: 'B', 4: 'E', 5: 'A'})
[1, 2, 3, 4, 5]

利用key进行倒序排序

>>>example_list = [5, 0, 6, 1, 2, 7, 3, 4]
>>> result_list = sorted(example_list, key=lambda x: x*-1)
>>> print(result_list)
[7, 6, 5, 4, 3, 2, 1, 0]

1.11 列表去空技巧

li1 = [5, 10, '', 1, 2, '', 3, 4]
result = [x for x in filter(None, li1)]
print(result)
# [5, 10, 1, 2, 3, 4]

1.12 filter函数过滤

filter(function, iterable)

filter()函数用于过滤序列，过滤掉不符合条件的元素，返回由符合条件元素组成的新列表。
接收两个参数，第一个为函数，第二个为序列，序列的每个元素作为参数传递给函数进行判断，返回True或False，将返回True的元素放到新列表中。

# 过滤列表中所有奇数
def is_odd(n):
    return n % 2 == 1
newlist = list(filter(is_odd, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]))
print(newlist)

函数也可以使用lambda表达式代替：

new_list2 = list(filter(lambda n: n%2 ==1, [1,2,3,4,5,6,7,8,9]))
print(new_list2)

1.13 max，min，sum函数

a = [40, 30, 20, 10]
print(max(a))		# 返回列表中最大的元素
print(min(a))		# 返回列表中最小的元素
print(sum(a))		# 计算所有元素之和

二：元组tuple

列表属于可变序列，可以任意修改列表中的元素。元组属于不可变序列，不能修改元组中的元素。因此，元组没有增加元素、修改元素、删除元素相关的方法。
因此，我们只需要学习元组的创建和删除，元组中元素的访问和计数即可。元组支持如下操作：

1. 索引访问
2. 切片操作
3. 连接操作
4. 成员关系操作
5. 比较运算操作
6. 计数：元组长度 len()、最大值 max()、最小值 min()、求和 sum()等。

2.1 元组的创建

1：通过()创建元组。小括号可以省略

a = (10,20,30) 或者 a = 10,20,30

如果元组只有一个元素，则必须后面加逗号。这是因为解释器会把(1)解释为整数 1，(1,)解释为元组。

>>> a = (1)
>>> type(a)
<class 'int'>
>>> a = (1,)
>>> type(a)
<class 'tuple'>

2：通过 tuple()创建元组
tuple(可迭代的对象)

b = tuple() #创建一个空元组对象
b = tuple("abc")
b = tuple(range(3))
b = tuple([2,3,4])

3：总结
tuple()可以接收列表、字符串、其他序列类型、迭代器等生成元组。
list()可以接收元组、字符串、其他序列类型、迭代器等生成列表。

2.2 元组元素的访问与计数

1：元组的元素不可修改

a = (1,2,3)
a[2] = 5
print(a)
# TypeError: 'tuple' object does not support item assignment

2：元组的元素访问和列表一样，只不过返回的仍然是元组对象

a = (20,10,30,9,8)
print(a[1], type(a[1]))		# 10 <class 'int'>
print(a[:2])				# (20, 10)

3：列表关于排序的方法 list.sorted()是修改原列表对象，元组没有该方法。如果要对元组排
序，只能使用内置函数 sorted(tupleObj)，并生成新的列表对象

>>> a = (20,10,30,9,8)
>>> sorted(a)
[8, 9, 10, 20, 30]

2.3 zip函数

zip(列表 1，列表 2，…)将多个列表对应位置的元素组合成为元组，并返回这个 zip 对象。

>>> a = [10,20,30]
>>> b = [40,50,60]
>>> c = [70,80,90]
>>> d = zip(a,b,c)
>>> list(d)
[(10, 40, 70), (20, 50, 80), (30, 60, 90)]

2.4 生成器推导式

从形式上看，生成器推导式与列表推导式类似，只是生成器推导式使用小括号。
列表推导式直接生成列表对象，生成器推导式生成的不是列表也不是元组，而是一个生成器对象。
我们可以通过生成器对象，转化成列表或者元组。也可以使用生成器对象的__next__()方法进行遍历，或者直接作为迭代器对象来使用。不管什么方式使用，元素访问结束后，如果需要重新访问其中的元素，必须重新创建该生成器对象。

>>> s = (x*2 for x in range(5))
>>> s
<generator object <genexpr> at 0x0000000002BDEB48>
>>> tuple(s)
(0, 2, 4, 6, 8)
>>> list(s) #只能访问一次元素。第二次就为空了。需要再生成一次
[]
>>> s
<generator object <genexpr> at 0x0000000002BDEB48>
>>> tuple(s)
()
>>> s = (x*2 for x in range(5))
>>> s.__next__()
0
>>> s.__next__()
2
>>> s.__next__()
4

2.5 元组总结

1. 元组的核心特点是：不可变序列。
2. 元组的访问和处理速度比列表快。
3. 与整数和字符串一样，元组可以作为字典的键，列表则永远不能作为字典的键使用。

三：字典dict

字典是“键值对”的无序可变序列，字典中的每个元素都是一个“键值对”，包含：“键对象”和“值对象”。可以通过“键对象”实现快速获取、删除、更新对应的“值对象”。
列表中我们通过“下标数字”找到对应的对象。字典中通过“键对象”找到对应的“值对象”。“键”是任意的不可变数据，比如：整数、浮点数、字符串、元组。但是：列表、字典、集合这些可变对象，不能作为“键”。并且“键”不可重复。“值”可以是任意的数据，并且可重复。
一个典型的字典的定义方式：

a = {'name':'Bruce','age':18,'job':'programmer'}

3.1 字典的创建

1：我们可以通过{}、dict()来创建字典对象

a = {'name': 'Bruce', 'age': 18, 'job': 'KongFu master'}
b = dict(name = 'Bruce', age = 18, job = 'KongFu master')
c = dict([('name','Bruce'), ('age', 18)])
d = {}
e = dict()

2： 通过 zip()创建字典对象

>>> k = ['name','age','job']
>>> v = ['gaoqi',18,'techer']
>>> d = dict(zip(k,v))
>>> d
{'name': 'gaoqi', 'age': 18, 'job': 'techer'}

3： 通过 fromkeys 创建值为空的字典

>>> a = dict.fromkeys(['name','age','job'])
>>> a
{'name': None, 'age': None, 'job': None}

3.2 字典元素的访问

1：通过 [键] 获得“值”。若键不存在，则抛出异常

a = {'name': 'Bruce', 'age': 18, 'job': 'KongFu master'}
print(a['name'])
print(a['sex'])			# KeyError: 'sex'

2：通过 get()方法获得“值”。推荐使用。优点是：指定键不存在，返回 None；也可以设
定指定键不存在时默认返回的对象。推荐使用 get()获取“值对象”

a = {'name': 'Bruce', 'age': 18, 'job': 'KongFu master'}
print(a.get('name'))
print(a.get('sex', 'male'))		# 字典中没有sex键则输入male

3：列出所有的键值对

a = {'name': 'Bruce', 'age': 18, 'job': 'KongFu master'}
print(a.items())
# dict_items([('name', 'Bruce'), ('age', 18), ('job', 'KongFu master')])

4：检测键是否在字典中

a = {'name': 'Bruce', 'age': 18, 'job': 'KongFu master'}
print('name' in a)		# True

3.3 字典元素添加、修改、删除

1：给字典新增“键值对”。如果“键”已经存在，则覆盖旧的键值对；如果“键”不存在，则新增“键值对”

>>>a = {'name':'Bruce','age':18,'job':'programmer'}
>>> a['address']='西三旗 1 号院'
>>> a['age']=16
>>> a
{'name': 'Bruce', 'age': 16, 'job': 'programmer', 'address': '西三旗 1 号院'}

2：使用 update()将新字典中所有键值对全部添加到旧字典对象上。如果 key 有重复，则直接覆盖

>>> a = {'name':'Bruce','age':18,'job':'programmer'}
>>> b = {'name':'Bruce Lee','money':1000,'sex':'男的'}
>>> a.update(b)
>>> a
{'name': 'Bruce Lee', 'age': 18, 'job': 'programmer', 'money': 1000, 'sex': '男的'}

字典的修改操作还有一个setdefault函数

a = {'name': 'Bruce', 'age': 18, 'job': 'KongFu master'}
a.setdefault('hobby', 'KongFu')		# 如果hobby键存在则不做任何操作，否则将值设置为KongFu
print(a)		# {'name': 'Bruce', 'age': 18, 'job': 'KongFu master', 'hobby': 'KongFu'}

3：字典中元素的删除
可以使用 del()方法；或者 clear()删除所有键值对；pop()删除指定键值对，并返回对应的“值对象”

>>> a = {'name':'Bruce','age':18,'job':'programmer'}
>>> del(a['name'])
>>> a
{'age': 18, 'job': 'programmer'}
>>> b = a.pop('age')
>>> b
18

popitem() ：随机删除和返回该键值对。字典是“无序可变序列”，因此没有第一个元素、最后一个元素的概念；popitem 弹出随机的项，因为字典并没有"最后的元素"或者其他有关顺序的概念。若想一个接一个地移除并处理项，这个方法就非常有效（因为不用首先获取键的列表）。

>>> a = {'name':'Bruce','age':18,'job':'programmer'}
>>> a.popitem()
('job', 'programmer')
>>> a
{'name': 'Bruce', 'age': 18}
>>> a.popitem()
('age', 18)
>>> a
{'name': 'Bruce'}

3.4 序列解包

序列解包可以用于元组、列表、字典。序列解包可以让我们方便的对多个变量赋值。

>>> x,y,z=(20,30,10)
>>> x
20
>>> y
30
>>> z
10
>>> (a,b,c)=(9,8,10)
>>> a
9
>>> [a,b,c]=[10,20,30]
>>> a
10
>>> b
20

序列解包用于字典时，默认是对“键”进行操作； 如果需要对键值对操作，则需要使用items()；如果需要对“值”进行操作，则需要使用 values()；

>>> s = {'name':'Bruce','age':18,'job':'teacher'}
>>> name,age,job=s 			# 默认对键进行操作
>>> name
'name'
>>> name,age,job=s.items() 	# 对键值对进行操作
>>> name
('name', 'Bruce')
>>> name,age,job=s.values() # 对值进行操作
>>> name
'Bruce'

3.5 字典核心底层原理(重要)

字典对象的核心是散列表。散列表是一个稀疏数组（总是有空白元素的数组），数组的每个单元叫做 bucket。每个 bucket 有两部分：一个是键对象的引用，一个是值对象的引用。由于，所有 bucket 结构和大小一致，我们可以通过偏移量来读取指定bucket。

将一个键值对放进字典的底层过程

>>> a = {}
>>>
a["name"]="gaoqi"

假设字典 a 对象创建完后，数组长度为 8：

我们要把”name”=”gaoqi”这个键值对放到字典对象 a 中，首先第一步需要计算键”name”的散列值。Python 中可以通过 hash()来计算。

>>> bin(hash("name"))
'-0b1010111101001110110101100100101'

由于数组长度为 8，我们可以拿计算出的散列值的最右边 3 位数字作为偏移量，即“101”，十进制是数字 5。我们查看偏移量 5，对应的 bucket 是否为空。如果为空，则将键值对放进去。如果不为空，则依次取右边 3 位作为偏移量，即“100”，十进制是数字
4。再查看偏移量为 4 的 bucket 是否为空。直到找到为空的 bucket 将键值对放进去。流程图如下：


根据键查找“键值对”的底层过程
我们明白了，一个键值对是如何存储到数组中的，根据键对象取到值对象，理解起来就简单了。

>>> a.get("name")
'gaoqi'

当我们调用 a.get(“name”)，就是根据键“name”查找到“键值对”，从而找到值对象“gaoqi”。
第一步，我们仍然要计算“name”对象的散列值：

>>> bin(hash("name"))
'-0b1010111101001110110101100100101'

和存储的底层流程算法一致，也是依次取散列值的不同位置的数字。 假设数组长度为8，我们可以拿计算出的散列值的最右边 3 位数字作为偏移量，即“101”，十进制是数字5。我们查看偏移量 5，对应的 bucket 是否为空。如果为空，则返回 None。如果不为空，则将这个 bucket 的键对象计算对应散列值，和我们的散列值进行比较，如果相等。则将对应“值对象”返回。如果不相等，则再依次取其他几位数字，重新计算偏移量。依次取完后，仍然没有找到。则返回 None。流程图如下：

用法总结：

1. 键必须可散列
   (1) 数字、字符串、元组，都是可散列的。
   (2) 自定义对象需要支持下面三点：
   1 支持 hash()函数
   2 支持通过__eq__()方法检测相等性。
   3 若 a==b 为真，则 hash(a)==hash(b)也为真。
2. 字典在内存中开销巨大，典型的空间换时间。
3. 键查询速度很快
4. 往字典里面添加新建可能导致扩容，导致散列表中键的次序变化。因此，不要在遍历字典的同时进行字典的修改。

3.6 字典的遍历

1：遍历键值对

d = {'name': 'Andy', "age": 40}
for key in d.items():
    print(key)
# ('name', 'Andy')
# ('age', 40)

2：遍历键值

for key, value in d.items():
    print(key, value)
# name Andy
# age 40

3：遍历键，通过键找值

for key in d:
    print(key, d[key])
# name Andy
# age 40

四：集合set

集合是无序可变，元素不能重复。实际上，集合底层是字典实现，集合的所有元素都是字典中的“键对象”，因此是不能重复的且唯一的。

4.1 集合创建

myset = set()
print(type(myset))
myset1 = {1,2,3,4,5,6,5,4}
print(print(myset1), type(myset1))

4.2 转换为set类型

set2 = set([1,2,3,4,5])
set3 = set((1,2,3,4,5))
set4 = set({1:2, 3:4})
set5 = set('abcdeftg')
print(set2, type(set2))  #{1, 2, 3, 4, 5} <class 'set'>
print(set3, type(set3))  #{1, 2, 3, 4, 5} <class 'set'>
print(set4, type(set4))  #{1, 3} <class 'set'> 字典转换为set后，只保存字典中的key
print(set5, type(set5))  #{'b', 'g', 'e', 'c', 'f', 't', 'a', 'd'} <class 'set'>

4.3 增加单个元素

myset = {1,2,3,4}
myset.add(5)
myset.add(3)
print(myset)  # {1, 2, 3, 4, 5}
# 重复的元素无法添加，由此可见set的特点就是去重

4.4 批量增加元素

myset = {1,2,3,4,5,6}
myset.update([1,2,8,9])  # 必须是一个可迭代对象
print(myset)

4.5 删除元素

myset = {1,2,3,4,5,6}
myset.remove(5)    # 删除指定元素，如果指定的元素不存在则抛出异常
myset.discard(14)  # 删除指定元素，如果指定元素不存在不做任何处理
myset.pop()        # 删除第一个元素，返回删除的元素
myset.clear()      # 清空所有元素

4.6 复制集合

myset = {1,2,3,4,5,6}
myset1= myset.copy()  # 深复制
myset.clear()
print(myset1)

4.7 set运算

set1 = {1,2,3,4,5}
set2 = {1,2,7,8,9}
set3 = {1,2,3,4,5,6,7}

差集运算：

print(set1 - set2)
print(set1.difference(set2))  # set1集合里有的而set2集合里没有的元素
# {3, 4, 5}
print(set2 - set1)
print(set2.difference(set1))  # set2集合里有的而set1集合里没有的元素
# {8, 9, 7}

交集运算：

print(set1 & set2)  			# 交集 （两个集合里都有的元素）
print(set1.intersection(set2))
# {1, 2}

并集运算：

print(set1 | set2)  # 并集
print(set1.union(set2))
# {1, 2, 3, 4, 5, 7, 8, 9}

对称差集：

print(set1 ^ set2)
print(set1.symmetric_difference(set2))  # 去除掉两个集合共有元素
# {3, 4, 5, 7, 8, 9}

子集与超集：

print(set1.issubset(set3))    # True
print(set3.issuperset(set1))  # True

4.8 不可变集合

fz = frozenset([1,2,3,4,5])
print(fz, type(fz))
# frozenset({1, 2, 3, 4, 5}) <class 'frozenset'>