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

最新推荐文章于 2024-08-16 17:10:40 发布

艾伦！

最新推荐文章于 2024-08-16 17:10:40 发布

阅读量2k

点赞数

分类专栏： AI算法工程师文章标签：人工智能 python 集合

本文链接：https://blog.csdn.net/thisamy/article/details/124279634

版权

AI算法工程师专栏收录该内容

21 篇文章 40 订阅

订阅专栏

文章目录

Python基础语法之集合操作

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 <cell line: 1>()
----> 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]) # 列表中倒数第三个元素

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

-------------------------------------------------------------
IndexError                   Traceback (most recent call last)
Input In [16], in <cell line: 2>()
      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

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

③ 列表的修改

# 修改：① 使用一对中括号指定元素在列表中的索引，② 使用赋值运算符（=）进行赋值
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 <cell line: 1>()
----> 1 a

NameError: name 'a' is not defined

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

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

[1, 2, 3, 4, 5]

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

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 <cell line: 1>()
----> 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 在列表中出现的次数

③ 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] # 可通过索引号取值

元祖不可修改

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

----------------------------------------------------------
TypeError                    Traceback (most recent call last)
<ipython-input-6-793aca927300> in <module>()
----> 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)
<ipython-input-7-e7eb8b51a6fa> in <module>()
----> 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)) # 只能访问一次元素。第二次就为空了。需要再生成一次

<generator object <genexpr> 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中，方便未来做索引化）

扩：索引化

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 <cell line: 1>()
----> 1 c['她']

KeyError: '她'

② get 方法获取 key 对应的 value

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

c.get('我')

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

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 弹出随机的项（每次删除一个键值对）
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

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基础语法之集合操作