文章目录
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
③ 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 <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
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 <cell line: 1>()
----> 1 a
NameError: name 'a' is not defined
- pop ：删除并返回指定位置元素（若未指定位置，则默认操作列表最后一个元素）
a=[1,2,3,4,5,6]
a.pop() # 未指定位置，默认的是最后一个元素（弹出来）
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 <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 在列表中出现的次数
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)
<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中，方便未来做索引化）
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 <cell line: 1>()
----> 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 弹出随机的项（每次删除一个键值对）
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
2569
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
