AI算法工程师 | 02人工智能基础-Python基础（三）集合 *** 作

文章目录

• Python基础语法之 集合 *** 作
• • 一、列表（list）
  • • 1. 列表创建
    • 2. 基本 *** 作
    • 3. 常用方法
  • 二、元组（tuple）
  • • 1. 元组创建
    • 2. 基本 *** 作
    • 3. zip
    • 4. 生成器推导式创建元组
  • 三、字典（dict）
  • • 1. 字典创建
    • 2. 字典访问
    • 3. 常用 *** 作
    • 4. items、keys、values、enumerate方法
  • 四、集合（set）
  • • 1. 集合创建
    • 2. 基本 *** 作

Python基础语法之 集合 *** 作

一、列表（list）

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

在 Python 中，用方括号 [ ] 来表示列表，并用逗号来分隔其中的元素。

1. 列表创建

① 基本语法 [ ] 创建

语法格式：

list=[元素 1,元素 2,…]

示例：

aList = [2 , 3, 1, 1, 2, 3, 'a string'] # 同一个列表中不仅可以包含相同类型的元素，还可以包含不同类型的值
aList # 与 print(aList) 效果一样

[2, 3, 1, 1, 2, 3, 'a string']

② list() 创建

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

示例：

• 示例1：创建一个空的列表对象、字符串 → 列表

a = list()  #创建一个空的列表对象
b = list("gaoqi,sxt")
print(a)
print(b)

[]
['g', 'a', 'o', 'q', 'i', ',', 's', 'x', 't']

• 示例2：列表 → 列表

alist = list([2 , 3, 1, 1, 2, 3, 'a string'])
alist

[2, 3, 1, 1, 2, 3, 'a string']

• 注意：list() 是一个 Python 内建函数。在起变量名时，不要和内建的方法名重复

list = list([2 , 3, 1, 1, 2, 3, 'a string']) # 起变量名时，不要和内建的方法名重复
list

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Input In [70], in ()
----> 1 list = list([2 , 3, 1, 1, 2, 3, 'a string']) # 起变量名时，不要和内建的方法名重复
      2 list

TypeError: 'list' object is not callable

参考： 问题|TypeError: ‘list‘ object is not callable @Python

③ range() 创建整数列表

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

语法格式：

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

# 生成的数值序列从 start 开始到 end 结束（不包含 end）
# 若未填写start，则默认从 0 开始。step 是可选的步长，默认为 1

示例：

a=list(range(6,16,2)) # 从 6 开始步长是 2 及从开始每次增加 2
b=list(range(16,6,-1)) # 从 16 开始每次减 1
c=list(range(6,-10,-1)) # 从 6 开始每次递减 1
print(a)
print(b)
print(c)

[6, 8, 10, 12, 14]
[16, 15, 14, 13, 12, 11, 10, 9, 8, 7]
[6, 5, 4, 3, 2, 1, 0, -1, -2, -3, -4, -5, -6, -7, -8, -9]

④ 列表推导式

优点：简洁，在一行中能完成原本需多行完成的事

语法结构：

[表达式 for item in 可迭代对象 ]

示例：

• 对比，感受列表推导式的优点

#一行就能完成多行的任务
[x  for  x  in "abcdefg"] 

['a', 'b', 'c', 'd', 'e', 'f', 'g']

#若不用 列表推导式 ，需多行才能完成
aList = []
for x in 'abcdefg':
    aList.append(x)  # append 往列表中添加元素
    
aList

['a', 'b', 'c', 'd', 'e', 'f', 'g']

• 配合 range() 使用

[x*2 for x in range(1,5)]

[2, 4, 6, 8]

#以下语句分析： ①遍历（1~19） ②判断 是否能被5整除  ③符合判断条件的数才会x*2，最终装到列表元素中
[x*2 for x in range(1,20) if x%5==0] 

[10, 20, 30]

2. 基本 *** 作

① 列表的添加

• append() 方法：在列表的末尾追加一个新对象

a = [10,20,30,40]
a.append(60) # 列表中添加元素
a

[10, 20, 30, 40, 60]

• 使用 + 运算符：实现列表添加元素
  • 但并不是真正的尾部添加元素，而是创建新的列表对象；
  • 将原列表的元素和新列表的元素，依次复制到新的列表对象中。
  • 当 *** 作大量元素时不建议使用（因为 + 会涉及大量的复制 *** 作）

a = [10, 20 ,30]
b = [40, 50]
a + b  # 会返回新的列表

[10, 20, 30, 40, 50]

# 列表使用+ *** 作符后，变量a的内存地址不同（说明创建了新的列表对象）
a = [10,20,30]
print('a 的地址：',id(a))
b = [40,50]
a = a + b 
print('a 列表的元素：',a)
print('a 的地址：',id(a))

a 的地址： 1435426839616
a 列表的元素： [10, 20, 30, 40, 50]
a 的地址： 1435426839360

• extend() 方法：将目标列表的所有元素添加到本列表的尾部

a = [10, 20 ,30]
b = [40, 50]
a.extend(b) # 并未返回新的列表，而在原来的基础上添加
a

[10, 20, 30, 40, 50]

• insert() 方法：实现列表插入元素
  • 可将指定的元素插入到列表对象的任意指定位置
  • 涉及大量元素时，尽量避免使用（因为该方法会让插入位置后面所有的元素进行移动，影响处理速度）

a = [10,20,30]
a.insert(2,66) #在列表 a 的索引 2 处插入元素 66
print(a)

[10, 20, 66, 30]

② 列表的查找

• 通过索引直接访问元素（索引号从 0 开始递增）

a = [10,20,30,40,50,60,70,80,90]

# 如果索引是 0 或正整数 => Python 语言会从列表的左侧第一个元素开始获取
print(a[0]) # 列表中的第一个元素
print(a[2])  # 列表中的第三个元素

# 如果索引是负数 => Python 语言会从列表右侧第一个元素开始获
print(a[-1])  # 列表中倒数第一个元素 
print(a[-3]) # 列表中倒数第三个元素

10
30
90
70

a = [10,20,30]
a[3]  # 索引超过列表的索引范围(0~2)，会抛出异常（下标越界）

-------------------------------------------------------------
IndexError                   Traceback (most recent call last)
Input In [16], in ()
      1 a = [10,20,30]
----> 2 a[3]

IndexError: list index out of range

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

a = [10,20,30,40,50,20,30,20,30]
a.index(20) # 从列表中搜索第一个 20

1

a.index(20, 3) #从 索引位置 3 开始往后搜索的第一个 20

5

③ 列表的修改

# 修改：① 使用一对中括号指定元素在列表中的索引，② 使用赋值运算符（=）进行赋值
a[1] = 5000   
a

[10, 5000, 30, 40, 50, 20, 30, 20, 30]

④ 列表的删除

• del ：删除列表指定位置的元素（语法格式：del元素）

del a[1] # 删除列表中第二个元素
a

[10, 30, 40, 50, 20, 30, 20, 30]

del a   # 删除整个列表
a

-------------------------------------------------------------
NameError                   Traceback (most recent call last)
Input In [24], in ()
----> 1 a

NameError: name 'a' is not defined

• pop ：删除并返回指定位置元素（若未指定位置，则默认 *** 作列表最后一个元素）

a=[1,2,3,4,5,6]
a.pop() # 未指定位置，默认的是最后一个元素（d出来）

6

a

[1, 2, 3, 4, 5]

a.pop(2) # 删除下标为 2 的元素

3

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

a = [10,20,30,40,50,20,30,20,30]
a.remove(20) # 删除的是第一个目标值的元素
a

[10, 30, 40, 50, 20, 30, 20, 30]

a.remove(60) # 不存在该元素，会抛出异常

-----------------------------------------------------------
ValueError                 Traceback (most recent call last)
Input In [31], in ()
----> 1 a.remove(60)

ValueError: list.remove(x): x not in list

⑤ 列表的乘法

a = ['sxt',100]
b = a*3   # 乘法，数值表示复制列表的份数（复制三份，即：列表重复3次）
print(a)
print(b)

['sxt', 100]
['sxt', 100, 'sxt', 100, 'sxt', 100]

'#' * 10    # 字符串也可用乘法

'##########'

⑥ 列表的长度、最大值和最小值

a=[10,20,30,40,50,60]
len(a), max(a), min(a) # python 内建函数

(6, 60, 10)

3. 常用方法

方法	描述
copy()	用于赋值一个列表
count()	用于统计某个元素在列表中出现的次数
reverse()	用于将列表中的元素反向存放
sort()	用于对列表进行排序，调用该方法会改变原来的列表
sorted()	用于对列表排序，返回新列表，不对原列表做修改
clear()	用于清空列表的内容

① copy() 方法

在 AI 人工智能 中的用处：

• AI中，需要 Data 数据才能训练算法模型，而对于数据集，训练时需要TrainSet 训练集；
• 对于有监督的机器学习，训练集中有x，y，有些时候 y 与 x 类似，即：y 会从 x 演变而来（通过 x 创建出来的，但与 x 又不同）；
• 比如：自然语言处理 NLP 中，写唐诗的案例里，x 与 y 错位一个字（若 x 为 “床前明月光”，则 y 为 “前明月光。” ）；
• 通过 copy 方法，将 x 复制一份，再去修改复制后的副本数据，改变完后将其赋给 y 。

示例：copy() 与 = 的对比

aa=[10,20,30]
bb=aa.copy()  # 使用copy()，创建了新对象
bb[1] = 5000
aa, bb

([10, 20, 30], [10, 5000, 30])

aa = [10, 20, 30]
bb = aa  # 使用 = ，bb 指向原对象 aa
bb[1] = 5000 # 修改，会影响原对象 aa
aa, bb

([10, 5000, 30], [10, 5000, 30])

② count() 方法

a=[10,20,40,30,10,20,50,10]
a.count(10) # 统计 元素10 在列表中出现的次数

3

③ reverse() 方法

a=[1,2,3,4,5,6,7]
print(a[::-1])  # 切片[::-1]的效果 和 reverse() 效果一样
a.reverse() #reverse()用于将列表中的元素反向存放
print(a)

[7, 6, 5, 4, 3, 2, 1]
[7, 6, 5, 4, 3, 2, 1]

④ sort() 、sorted() 方法

• sort() ：对列表进行排序，调用该方法会改变原来的列表

a=[11,20,13,34,5,36,17]
a.sort(reverse=True) # reverse=True 表示逆序排序； sort() 默认正序排序
a

[36, 34, 20, 17, 13, 11, 5]

• sorted() ：对列表排序，返回新列表，不对原列表做修改

sorted(a), a #原来列表不会被修改

([5, 11, 13, 17, 20, 34, 36], [36, 34, 20, 17, 13, 11, 5])

• sorted() 可配合 lambda “匿名函数” 使用

# 以下语句含义：根据 -x 去做正序排序。但返回的结果还是原来那些元素，不是 -x
sorted(a, key=lambda x: -x) 

[36, 34, 20, 17, 13, 11, 5]

⑤ clear() 方法

a=[34,5,36,'a']
a.clear() # clear()用于清空列表内容
a

[]

二、元组（tuple）

元组不能修改，即：元组是只读的，不能对元组进行增加、删除、修改。

定义元组非常简单，只需要用逗号( , ) 分隔值即可。

1. 元组创建

① () 创建元组，小括号可以省略

示例：

a = 1,2,3,4,5,6,7         #创建一个元组  省略了括号
b = (1,2,3,4,5,6,7)       #创建一个元组
c = (42,)               #创建一个只有一个元素值的元组，但逗号不可省略
d = ()                 #创建一个空的元组
type(a), type(b), type(c), type(d)

(tuple, tuple, tuple, tuple)

② tuple() 创建元组

tuple 函数的功能与 list 函数基本上是一样的。以一个序列作为参数并把它转换为元祖。

示例：

a = tuple("abc")  
b = tuple(range(3))
c = tuple((1,2,3,4,5)) # 若元素的参数就是元祖，那么该参数会被原样返回
print(a)
print(b)
print(c)

('a', 'b', 'c')
(0, 1, 2)
(1, 2, 3, 4, 5)

2. 基本 *** 作

• 对元组取值

a = (1,2,3,4,5,6,7) 
a[1] # 可通过索引号取值

2

• 元祖不可修改

a[1] = 20 # 元组不可被修改

----------------------------------------------------------
TypeError                    Traceback (most recent call last)
 in ()
----> 1 a[1] = 20

TypeError: 'tuple' object does not support item assignment

• 元组的切片

print(a[1])
print(a[1:3])
print(a[:4])
print(a[::-1]) # 相当于逆序输出

2
[2, 3]
[1, 2, 3, 4]
[7, 6, 5, 4, 3, 2, 1]

• 元组的排序

# 列表关于排序的方法 list.sort()是修改原列表对象，元组没有该方法
a.sort() 

----------------------------------------------------------
AttributeError               Traceback (most recent call last)
 in ()
----> 1 a.sort()

AttributeError: 'tuple' object has no attribute 'sort'

# 若要对元组排序，只能使用内置函数 sorted(tupleObj)，并生成新的列表对象
sorted(a, reverse=True) # 逆序

[7, 6, 5, 4, 3, 2, 1]

3. zip

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

示例：

a = [10,20,30]
b = [40,50,60]
tuple(zip(a, b))  # 将 zip 对象放到元组中

((10, 40), (20, 50), (30, 60))

在机器学习中的用途：

• 用途①：自然语言处理 LNP 中，构建 a. index 索引号对 word 词 的字典 或 b. 词对索引号的字典，可通过 zip 将 index 与 word 整合在一起。

a = [1, 2, 3]
b = ['我', '你', '他']
list(zip(a,b))   # 整合后，未来方便 通过索引号查询词是什么

[(1, '我'), (2, '你'), (3, '他')]

a = [1, 2, 3]
b = ['我', '你', '他']
list(zip(b,a))   # 整合后，未来方便 通过词查询索引号

[('我', 1), ('你', 2), ('他', 3)]

• 用途②：训练时，往往 TrainSet 训练集既有 x 又有 y （x 为m行n列，y 为m行1列），其中，m行指的是 m个样本 samples
  • x 的第一行与 y 的第一行对应，x 的第二行与 y 的第二行对应（x 与 y 的行一一对应）
  • 可通过 zip(x,y) 将 x 同 y 整合在一起
  • zip 完后里面每一个元素变成 二元组：x的第1条样本（x：影响结果的维度或因素）对应y的第1条样本（y：样本的目标变量或标签） —— (x₁,y₁) ，(x₂,y₂)，(x₃,y₃) … x的第m条样本对应y的第m条样本

4. 生成器推导式创建元组

从形式上看，生成器推导式与列表推导式类似，只是生成器推导式使用小括号。

示例：

• 对比（元组-生成器推导式 与 列表推导式）

# 元组生成器的使用
s = (x*2 for x in range(5))  # 使用小括号 ()
print(s) # 生成：生成器对象
print(tuple(s)) # tuple 函数转换为元组
print(tuple(s)) # 只能访问一次元素。第二次就为空了。需要再生成一次

 at 0x0000014E37D97890>
(0, 2, 4, 6, 8)
()

# 列表推导式的使用
s = [x*2 for x in range(5)]  # 使用中括号 []
print(s) # 列表推导式直接生成：列表对象
print(s) # 可多次访问

[0, 2, 4, 6, 8]
[0, 2, 4, 6, 8]

• 可以使用生成器对象的 __next__() 方法进行遍历（注意：next 前后均是两个连续的下划线_ ）

s = (x*2 for x in range(5))
print('next 方法获取元素：',s.__next__()) # 遍历，每次一个获取元素
print('next 方法获取元素：',s.__next__())
print('next 方法获取元素：',s.__next__())

next 方法获取元素： 0
next 方法获取元素： 2
next 方法获取元素： 4

三、字典（dict）

优点：既可以存储多个数据，又可快速定位到某个元素。

字典是无序的（而列表和元组是有序的）。它的每个元素都是由两部分组成的，分别是键（key）和值（value）。

• 键：不可重复，必须是唯一的；是任意的不可变数据
• 值：可重复；可以是任意的数据

语法格式：

# 字典的每个键值对用 冒号(:) 分割，每对之间用 逗号(,) 分割，整个字典包括在 花括号{} 中
d = {key1 : value1, key2 : value2 }

1. 字典创建

① {}、dict() 创建

a = {'name':'xiaofei','age':26,'job':'programmer'} # 通过 {} 创建 (无序输出)
b = dict(name='xiaofei',age=26,job='programmer')  # 通过 dict() 方法创建
c = dict([("name","xiaofei"),("age",26),("job",'programmer')])  # 通过 dict() 强转，把列表（每个元素为二元组）转为字典
d = {} # 空的字典对象
e = dict() # 空的字典对象
print('字典 a：',a)
print('字典 b：',b)
print('字典 c：',c)
print('字典 d：',d)
print('字典 e：',e)

字典 a： {'name': 'xiaofei', 'age': 26, 'job': 'programmer'}
字典 b： {'name': 'xiaofei', 'age': 26, 'job': 'programmer'}
字典 c： {'name': 'xiaofei', 'age': 26, 'job': 'programmer'}
字典 d： {}
字典 e： {}

② zip() 创建

a = [1, 2, 3, 4, 5]
b = ['我', '你', '他', '爱', '橘子']
dict(zip(b,a))

{'他': 3, '你': 2, '橘子': 5, '我': 1, '爱': 4}

③ fromkeys 创建值为空的字典

a = dict.fromkeys(['name','age','job']) # 创建值为空的字典
a

{'name': None, 'age': None, 'job': None}

2. 字典访问

① 通过 键 获得 值

• 示例：通过键，访问字典的值

a = [1, 2, 3, 4, 5]
b = ['我', '你', '他', '爱', '橘子']
c = dict(zip(b,a))

c['你'] # 可把'你'对应的索引号 2 查询出来（好处：AI中，方便未来做索引化）

2

• 扩：索引化

sentence = '我 爱 橘子' # 分词后，把一句话变成索引号（在自然语言处理时，首先做的是索引化）
words = sentence.split(' ')  # 通过空格切分，split 返回一个列表
print(words)
[c[word] for word in words] # 列表生成式，根据字典c查每个词对应的索引号，并生成新的列表

['我', '爱', '橘子']
[1, 4, 5]

• 注意：若键不存在，则抛出异常

c['她']

-----------------------------------------------------------
KeyError                    Traceback (most recent call last)
Input In [78], in ()
----> 1 c['她']

KeyError: '她'

② get 方法获取 key 对应的 value

• 示例：get 方法用于返回指定键的值

c.get('我')

1

• 如果访问的键不在字典中，则会返回默认值

v = c.get('她')    # '她' 键不存在，值为 None
print(v)
v = c.get('她',10)   # 若c中不存在'她' 键，则返回默认值 10
print(v)

None
10

3. 常用 *** 作

字典是可变的，它支持元素进行修改 *** 作，包括：添加新的元素、修改或删除已经存在的元素。

① 字典的添加、修改

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

• 添加

c['芒果'] = 7  # 将新的 词（键）加到列表中
c

{'他': 3, '你': 2, '橘子': 5, '芒果': 7, '我': 1, '爱': 4}

• 修改

c['芒果'] = 6  # 若要添加的键已经存在，则字典中该键对应的值会被新值替代
c

{'他': 3, '你': 2, '橘子': 5, '芒果': 6, '我': 1, '爱': 4}

• update 方法：可用一个字典中的元素 更新 另外一个字典

a_dict = {'name':'xiaofei','age':26,'job':'programmer'}
print(a_dict)
b_dict = {'name':'zhangxiaofei','money':1000,'sex':'女'}
a_dict.update(b_dict)  # 如果 key 有重复，则直接覆盖
print(a_dict)

{'name': 'xiaofei', 'age': 26, 'job': 'programmer'}
{'name': 'zhangxiaofei', 'age': 26, 'job': 'programmer', 'money': 1000, 'sex': '女'}

② 字典的删除

• del() 、pop() 删除元素：与列表中删除元素类似

del(a_dict['name']) # del 删除元素
print(a_dict)

v=a_dict.pop('age') #pop 删除元素，返回对应的值
print(v)
print(a_dict)

a_dict.clear()  # 清空字典元素
print(a_dict)

{'age': 26, 'job': 'programmer', 'money': 1000, 'sex': '女'}
26
{'job': 'programmer', 'money': 1000, 'sex': '女'}
{}

• popitem() 删除元素：随机删除和返回该键值对

a = {'name':'xiaofei','age':26,'job':'programmer'}
print(a.popitem())  # popitem d出随机的项（每次删除一个键值对）
print(a.popitem())
print(a.popitem())

('job', 'programmer')
('age', 26)
('name', 'xiaofei')

4. items、keys、values、enumerate方法

① items、keys、values 方法

• items() 方法：返回字典中所有的 key-value 对

c = {'我': 1, '你': 2, '他': 3, '爱': 4, '橘子': 5, '芒果': 6}

print(c.items())  # 获得的每一个 key-value 对 均用一个元组表示 

for item in c.items(): # 遍历对象
    print(item)  

dict_items([('我', 1), ('你', 2), ('他', 3), ('爱', 4), ('橘子', 5), ('芒果', 6)])
('我', 1)
('你', 2)
('他', 3)
('爱', 4)
('橘子', 5)
('芒果', 6)

• keys() 方法：返回字典中所有的 键key

print(c.keys()) 

for key in c.keys():   # 通过遍历 key，根据 key 获取值
    print(key, c[key])

dict_keys(['我', '你', '他', '爱', '橘子', '芒果'])
我 1
你 2
他 3
爱 4
橘子 5
芒果 6

• values() 方法：以迭代器形式返回字典中 值value 的列表

print(c.values()) 

for value in c.values():
    print(value)

dict_values([1, 2, 3, 4, 5, 6])
1
2
3
4
5
6

② enumerate 方法

enumerate() 函数用于将一个可遍历的数据对象（如字典、列表、元组或字符串）组合为一个索引序列，同时列出数据和数据下标，一般用在 for 循环当中。

语法格式：

enumerate(sequence, [start=0])

# sequence 表示一个序列、迭代器或其他支持迭代对象；
# start 表示下标起始位置

示例：

• 示例1：enumerate() 方法遍历

for i, key in enumerate(c): # i 往往代表 index索引号
    print(i, key, c[key])

0 我 1
1 你 2
2 他 3
3 爱 4
4 橘子 5
5 芒果 6

• 示例2：enumerate() 对列表同样适用

aList = [10, 20 , 30]
for i, value in enumerate(aList):
    print(i, value)

0 10
1 20
2 30

四、集合（set）

集合是无序可变的，其元素不能重复。

问：为什么集合的元素不可重复?
答：集合底层实际上是字典实现，集合的所有元素都是字典中的 “键对象” ，因此是不能重复且唯一的。

1. 集合创建

① {} 创建

a = {1, 2, 3, 5, 5}  # 可去重（若存在重复数据，则只其中保留一个）
a

{1, 2, 3, 5}

b = {3,4,True,'abc',56.4}  # 可存储不同类型的数据
b

{3, 4, 56.4, True, 'abc'}

② set() 创建

a = ['a','b','c','b']   # 转为集合后会去重
b=set(a) # 将列表转换为集合（set()：将列表、元组等可迭代对象转成集合）
print(b)

{'a', 'b', 'c'}

2. 基本 *** 作

① 集合的添加

• add() 实现集合添加元素

a = {1, 2, 5}  
a.add('app')   # add 方法添加元素（无序）
a

{1, 2, 5, 'app'}

② 集合的删除

• remove() 实现集合删除指定元素

a.remove(5) # 删除集合中的元素
a

{1, 2, 'app'}

• clear() 清空整个集合

a.clear() # 将集合清空
a

set()

③ 集合的其他 *** 作

Python 集合提供了并集、交集、差集等运算

示例：

a = {1, 2, 'app'}
b = {'money',1, 'sex'}

print('并集：',a|b) # 并集
print('并集：',a.union(b)) # 并集

print('交集：',a&b) # 交集
print('交集：',a.intersection(b)) # 交集

print('差集：',a-b) # 差集
print('差集：',a.difference(b)) # 差集

并集： {1, 2, 'money', 'sex', 'app'}
并集： {1, 2, 'money', 'sex', 'app'}
交集： {1}
交集： {1}
差集： {'app', 2}
差集： {'app', 2}

—— 说明：本文内容基于python3.0