python从零基础直达神经网络之基础篇 第 三 章 序 列

第 三 章 序 列

前言

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

由于 Python3 中一切皆对象，在内存中实际是按照如下方式存储的：

a = [10,20,30,40]

从图示中，我们可以看出序列中存储的是整数对象的地址，而不是整数对象的值。python 中常用的序列结构有：

字符串、列表、元组、字典、集合

除了上一篇博客已经介绍了的字符串序列，下面我会一一介绍列表、元组、字典、集合。

列表简介

列表：用于存储任意数目、任意类型的数据集合。

列表是内置可变序列，是包含多个元素的有序连续的内存空间。列表定义的标准语法格式：

a = [10,20,30,40] 

其中，10,20,30,40 这些称为：列表a的元素。

列表中的元素可以各不相同，可以是任意类型。比如： a = [10,20,‘abc’,True]

列表对象的常用方法汇总如下，方便大家学习和查阅。：

Python的列表大小可变，根据需要随时增加或缩小。

字符串和列表都是序列类型，一个字符串是一个字符序列，一个列表是任何元素的序列。在上一篇博客中关于字符串的方法，在列表中也有类似的方法使用。

列表的创建

基本语法[]创建

>>>a = [10,20,'shy-2','hah']
>>>a = [] #创建一个空的列表对象

list()创建

使用list()可以将任何可迭代的数据转化成列表

>>> a = list()  #创建一个空的列表对象
>>>a = list(range(10))
>>>a 
[0,1,2,3,4,5,6,7,8,9]
>>>a = list('shy-2,hah')
>>>a
['s','h','y','-','2',',','h','a','h']

range()创建整数列表

range()可以帮助我们非常方便的创建整数列表，这在开发中及其有用。语法格式为：

range([start,] end [,step]) 

start 参数：可选，表示起始数字。默认是 0
end参数：必选，表示结尾数字。
step参数：可选，表示步长，默认为1

python3中range()返回的是一个range对象，而不是列表，需要通过list()方法将其转换成列表对象
示例：

>>> type(range(1,10))
<class 'range'>
>>> list(range(3,15,2))
[3, 5, 7, 9, 11, 13]
>>> list(range(15,3,-1))
[15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4]

推导式生成列表（重点在于for循环）

使用列表推导式可以非常方便的创建列表，在开发中经常使用。但是，由于涉及到for 循环 和 if 语句，我会在后面的控制语句一篇中详细的讲解更多列表推导式的细节。

>>> a = [x*2 for x in range(5)]    #循环创建多个元素
>>> a
[0, 2, 4, 6, 8]
>>> a = [x*2 for x in range(100) if x%9 == 0]  #通过if来过滤元素
>>> a
[0, 18, 36, 54, 72, 90, 108, 126, 144, 162, 180, 198]

列表元素的增加

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

append()方法

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

>>> a = [20,40]
>>> a.append(80)
>>> a
[20, 40, 80]

+运算符操作

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

>>> a = [20,40]
>>> id(a)
1598711871752
>>> a = a+[50]
>>> a
[20, 40, 50]
>>> id(a)
1598679900744

extend()方法

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

>>> a = [20,40]
>>> id(a)
1598711871752
>>> a.extend([50,60])
>>> a
[20, 40, 50, 60]
>>> id(a)
1598711871752

insert()插入元素

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

>>> a = [10,20,30] 
>>> a.insert(2,100) 
>>> a 
[10, 20, 100, 30]

乘法扩展

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

>>> a = ['hy-2',100]
>>> b = a*4
>>> a
['hy-2', 100]
>>> b
['hy-2', 100, 'hy-2', 100, 'hy-2', 100, 'hy-2', 100]

适用于乘法操作的，还有：字符串、元组。

列表元素的删除

del删除

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

>>> a = [100,200,888,300,400]
>>> del a[1]
>>> a
[100, 888, 300, 400]

pop()方法

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

>>> a = [10,20,30,40,50] 
>>> a.pop()
50 
>>> a 
[10, 20, 30, 40] 
>>> a.pop(1) 
20 
>>> a 
[10, 30, 40]

remove()方法

删除首次出现的指定元素，若不存在该元素抛出异常。

>>> a = [10,20,30,40,50,20,30,20]
>>> a
[10, 20, 30, 40, 50, 20, 30, 20]
>>> a.remove(20)
>>> a
[10, 30, 40, 50, 20, 30, 20]
>>> a.remove(11)
Traceback (most recent call last):
  File "", line 1, in <module>
ValueError: list.remove(x): x not in list

列表元素访问和计数

通过索引直接访问元素

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

>>> a = [10,20,30,40,50,20,30,20,30]
>>> a[2]
30
>>> a[10
... ]
Traceback (most recent call last):
  File "", line 1, in <module>
IndexError: list index out of range

index()获得指定元素在列表中首次出现的索引

index()可以获取指定元素首次出现的索引位置。语法是：

index(value,[start,[end]])。

其中， start 和end指定了搜索的范围。

>>> a = [10,20,30,40,50,20,30,20,30]
>>> a.index(20)
1
>>>
>>> a.index(20,3)    #从索引位置3开始往后搜索的第一个20
5
>>> a.index(30,5,7)  #从索引位置5到7这个区间 第一次出现39元素的位置
6

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

count()可以返回指定元素在列表中出现的次数。

>>> a = [10,20,30,40,50,20,30,20,30]
>>> a.count(20)
3

len()返回列表长度

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

>>> a = [10,20,30,40,50,20,30,20,30]
>>> len(a)
9

成员资格判断

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

>>> a = [10,20,30,40,50,20,30,20,30]
>>> 20 in a
True
>>> 100 in a
False
>>> 30 not in a
False

切片操作

在上一篇博客讲字符串的时候，我们学习了字符串的切片操作。对于列表的切片操作和字符串类似。切片是python序列极其重要的操作，适用于列表、元素、字符串。

切片 slice 操作可以让我们快速提取子列表或修改。标准格式为：

[起始偏移量start:终止偏移量end[:步长 step]]

注：当步长省略时顺便可以省略第二个冒号

【操作】（三个数都为正数的情况下）：

【操作】（三个数都是负数的情况）：

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

>>> [10,20,30,40][1:30] 
[20, 30, 40]  #没有报错

列表的遍历

列表的遍历用到了for循环，在本篇博客了解即可，后续我会重点画一篇博客讲述。

for obj in listobj:
	print(obj)

复制列表所有的元素到新列表对象

思考以下代码是否实现了列表元素的复制：

list = [10,20,30]
list1 = list

答案是没有，因为这只是将list1也指向列表对象，list和list1是共用一个地址，列表对象本身的元素没有被复制。

那么怎么实现列表复制呢？我们可以通过如下的简单方式：

list = [10,20,30]
list1 = [] + list

注：这里我们简单做个了解，在后面当我们学习了copy模块后，使用浅复制或深复制实现复制操作

列表排序

修改原列表 不建新列表的排序

>>> a = [20,10,30,40]
>>> id(a)
1598711871752
>>> a.sort()    #默认是升序排列
>>> a
[10, 20, 30, 40]
>>> a.sort(reverse=True)   #降序排列
>>> a
[40, 30, 20, 10]
>>> id(a)
1598711871752
>>> import random
>>> random.shuffle(a)  #打乱顺序
>>> a
[20, 40, 10, 30]
>>> id(a)
1598711871752

建新列表的排序

我们也可以通过内置函数sorted()进行排序，这个方法返回新列表，不对原列表做修改。

>>> a = [20,10,30,40]
>>> id(a)
1598680382408
>>> a = sorted(a)
>>> a      #sorted默认升序
[10, 20, 30, 40]
>>> id(a)
1598711871752
>>> c = sorted(a,reverse=True)
>>> c
[40, 30, 20, 10]
>>> id(a)
1598711871752
>>> id(c)
1598680382408

reversed()返回迭代器

内置函数reversed()也支持进行逆序排列，与列表对象 reverse()方法不同的是，内置函数 reversed()不对原列表做任何修改，只是返回一个逆序排列的迭代器对象。

>>> a = [20,10,30,40]
>>> c = reversed(a)
>>> c
<list_reverseiterator object at 0x000001743AA89470>
>>>
>>> list(c)
[40, 30, 10, 20]
>>>
>>> list(c)
[]

打印输出c发现提示：list_reverseiterator 这是一个迭代对象。我们使用list©进行输出时，发现只能使用依次，第一次输出元素，第二次为空。这是因为第一次时已经遍历结束了，第二次不能再使用。

列表相关的其他内置函数汇总

max()和min()

用于返回列表中最大和最小值

>>>a = [3,10,20,15,9]
>>>max(a)
20
>>>min(a)
3

sum

对数值型列表的所有元素进行求和操作，对非数值型列表运算则会报错

>>>a = [3,10,20,15,9]
>>>sum(a)
57

多维列表

二维列表

一维列表可以帮助我们存储一维、线性的数据。 二维列表可以帮助我们存储二维、表格的数据。例如下表的数据：

代码：

a = [
		["髙小一",18,30000,'北京'],
		['高小二',19,20000,'上海'],
		['高小五',20,10000,'深圳']
	]

内存结构图：

print(a[1][0],a[1][1],a[1][2])
高小二 19 20000

【练习】使用嵌套循环打印二维列表所有的数据：

>>> a = [
...             ['高小一',18,30000,'北京'],
...             ['高小二',19,20000,'上海'],
...             ['高小五',20,10000,'深圳']
... ]
>>> for m in range(3):
...     for n in range(4):
...             print(a[m][n],end='\t')
...     print()   #打印完一行 换行
...
#运行结果：
高小一  18      30000   北京
高小二  19      20000   上海
高小五  20      10000   深圳

元组tuple

列表属于可变序列，可以任意修改列表中的元素。元组属于不可变序列，不能修改元组中的 元素。因此，元组没有增加元素、修改元素、删除元素相关的方法。

因此我们主要学习的是元组的创建和删除，元组中的元素的访问和计数即可。元组支持的操作有：

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

元组的创建

1. 通过（）创建元组，小括号可以省略

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

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

>>> a = (1)
>>> type(a)
<class 'int'>
>>> a = (1,)  #a = 1,  也可以
>>> type(a)
<class 'tuple'>

2. 通过tuple()创建元组

   tuple(可迭代的对象) 
   

例如：
b = tuple() #创建一个空元组对象

b = tuple(“abc”)
b = tuple(range(3))
b = tuple([2,3,4])

总结：

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

元组的元素访问和计数

1. 元组的元素不能修改

>>> a = (20,10,30,9,8)
>>> a[3] = 33
Traceback (most recent call last):
  File "", line 1, in <module>
TypeError: 'tuple' object does not support item assignment

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

>>>a = (20,10,30,9,8)
>>>a[1]
10
>>>a[1:3]
(10,30)

3. 对元组排序只能使用内置函数sorted(tupleObj),并生成新的列表对象

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

zip

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

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

生成器推导式创建元组

从形式上看，生成器推导式与列表推导式类似，只是生成器推导式使用小括号。列表推 导式直接生成列表对象，生成器推导式生成的不是列表也不是元组，而是一个生成器对象。

我们可以通过生成器对象，转化成列表或者元组。也可以使用生成器对象的__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

元组总结

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

字典的介绍

字典是“键值对”的无序可变序列，字典中的每个元素都是一个“键值对”，包含：“键 对象”和“值对象”。可以通过“键对象”实现快速获取、删除、更新对应的“值对象”。

列表中我们通过“下标数字”找到对应的对象。字典中通过“键对象”找到对应的“值 对象”。“键”是任意的不可变数据，比如：整数、浮点数、字符串、元组。但是：列表、 字典、集合这些可变对象，不能作为“键”。并且“键”不可重复。

“值”可以是任意的数据，并且可重复。

一个典型的字典的定义方式：

a = {'name':'shy-2','age':18,'job':'programmer'}

字典的创建

1. 可以通过｛｝、dict()来创建字典对象

>>> a = {'name':'shy-2','age':18,'job':'programmer'}
>>> b = dict(name='shy-2',age=19,job='programmer')
>>> c = dict([('name','shy-2'),('age',18)])
>>> d = {} #空的字典对象
>>> f = dict()  #空的字典对象

2. 通过zip（）创建字典对象

>>> k = ['name','age','job']
>>> v = ['shy-2',18,'programmer']
>>> d = dict(zip(k,v))
>>> d
{'name': 'shy-2', 'age': 18, 'job': 'programmer'}

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

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

字典元素的访问

先创建一个字典对象：

	a = {'name':'shy-2','age':18,'job':'programmer'}

1. 通过[键] 获取值。如果键不存在则抛出异常

>>> a = {'name':'shy-2','age':18,'job':'programmer'}
>>> a['name']
'shy-2'
>>> a['age']
18
>>> a['job']
'programmer'
>>> a['sex']
Traceback (most recent call last):
  File "", line 1, in <module>
KeyError: 'sex'

2. 通过get() 方法获得’值‘。推荐使用！优点：指定键不存在返回None，也可以设置指定键对象不存在时默认返回的对象。

>>> a.get('name')
'shy-2'
>>> a.get('sex','一个男人')
'一个男人'

3. 列出所有的键值对

>>>a.items()
dict_items([('name', 'shy-2'), ('age', 18), ('job', 'programmer')])

4. 列出所有的键 列出所有的值

>>>a.keys()
dict_keys(['name', 'age', 'job']) 
>>> a.values() 
dict_values(['shy-2', 18, 'programmer'])

5. len() 键值对的个数
6. 检测一个键是否在字典中

>>> len(a)
3
>>> 'name' in a
True

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

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

>>> a = {'name':'shy-2','age':18,'job':'programmer'}
>>> a['address']='地球'
>>> a
{'name': 'shy-2', 'age': 18, 'job': 'programmer', 'address': '地球'}
>>> a['age'] = 22
>>> a
{'name': 'shy-2', 'age': 22, 'job': 'programmer', 'address': '地球'}

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

>>> a = {'name':'shy-2','age':18,'job':'programmer'}
>>> b = {'name':'giao','money':100000,'sex':'男性'}
>>> a.update(b)
>>> a
{'name': 'giao', 'age': 18, 'job': 'programmer', 'money': 100000, 'sex': '男性'}

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

>>> a
{'name': 'giao', 'age': 18, 'job': 'programmer', 'money': 100000, 'sex': '男性'}
>>> del(a['name'])
>>> a
{'age': 18, 'job': 'programmer', 'money': 100000, 'sex': '男性'}
>>> a.pop('age')
18

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

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

序列解包

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

>>> x,y,z = (20,40,10)
>>> x
20
>>> y
40
>>> z
10

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

>>> a = {'name':'shy-2','age':18,'job':'student'}
>>> name,age,job = a
>>> name
'name'
>>> name,age,job = a.items()   #对键值对进行操作
>>> name
('name', 'shy-2')
>>> name,age,job = a.values()   #对值进行操作
>>> name
'shy-2'

表格数据使用 字典和列表存储 并实现访问

>>> r1 = {'name':'shy-1','age':18,'salary':10000,'city':'北京'}
>>> r2 = {'name':'shy-2','age':19,'salary':20000,'city':'上海'}
>>> r3 = {'name':'shy-2','age':20,'salary':30000,'city':'深圳'}
>>>
>>> tb = [r1,r2,r3]
>>>
>>> # 获得第二行的人的薪资
...
>>> print(tb[1].get('salary'))
20000
>>> #打印表中所有数据
...
>>> for i in range(len(tb)):
...     print(tb[i].get('name'),tb[i].get('age'),tb[i].get('salary'),tb[i].get('city'))
...
shy-1 18 10000 北京
shy-2 19 20000 上海
shy-2 20 30000 深圳

字典核心底层原理（重点）

字典对象的核心是散列表。散列表是一个稀疏数组（总是有空白元素的数组），数组的 每个单元叫做 bucket。每个 bucket 有两部分：一个是键对象的引用，一个是值对象的引用。

由于，所有bucket 结构和大小一致，我们可以通过偏移量来读取指定 bucket。

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

>>> a = {}
>>> a['name'] = 'shy-2'

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

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

>>> bin(hash('name'))
'-0b101011000011101001101000010100001010101011100111011100010000101'

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

扩容

python会根据散列表的拥挤程度扩容。“扩容”指的是:创造更大的数组，将原有内容 拷贝到新数组中。

接近 2/3 时，数组就会扩容。

根据键查找“键值对”的底层过程

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

>>> a.get('name')
'shy-2'

当我们调用a.get(“name”)，就是根据键“name”查找到“键值对”，从而找到值 对象“shy-2”。

第一步，我们仍然要计算“name”对象的散列值：

>>> bin(hash('name'))
'-0b101011000011101001101000010100001010101011100111011100010000101'

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

用法总结：

1. 键必须可散列

   （1）数字、字符串、元组都是可散列的
   （2）自定义对象需要支持下面三点：
   		支持hash()函数
   		支持通过__ eq__ ()方法检测相等性
   		若a == b为真 则hash(a) == hash(b) 也为真
   

2.字典在内存中开销巨大，典型的空间换时间
3.键查询速度很快
4.往字典里面添加新键可能导致扩容，导致散列表中的键次序发生改变。因此不要在遍历字典的同时进行字典的修改

集合

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

集合创建和过程

1. 使用{}创建集合对象，并使用 add()方法添加元素

>>> a = {3,5,7}
>>> a
{3, 5, 7}
>>> a.add(8)
>>> a
{8, 3, 5, 7}

2. 使用set()，将列表、元组等可迭代对象转成集合。如果原来数据存在重复数据，则只保 留一个。

>>> a = ['a','c','b','b']
>>> b = set(a)
>>> b
{'c', 'a', 'b'}

3. remove()删除指定元素；clear()清空整个集合

>>> a = {10,20,30,40,50} 
>>> a.remove(20) 
>>> a 
{10, 50, 30}

集合相关操作

像数学中概念一样，Python对集合也提供了并集、交集、差集等运算。

示例：

>>> a = {1,3,'s'} 
>>> b = {'he','it','s'} 
>>> a|b #并集 
{1, 3, 's', 'he', 'it'} 
>>> a&b #交集 
{'s'}
>>> a-b #差集 
{1, 3} 
>>> a.union(b) #并集 
{1, 3, 's', 'he', 'it'} 
>>> a.intersection(b) #交集 
{'s'} 
>>> a.difference(b) #差集 
{1, 3}