0%

Python学习笔记 - list 列表

相关名词列表

  • 列表
  • 元素
  • 索引
  • 元素的值

创建列表

在 python 中,[] 代表了列表,其中的元素以逗号分隔,里面可以加入任意的数据类型。

1
2
3
4
a = [] # 创建空列表
a = [1] # 创建只有一个元素的列表时,元素后面无需加逗号
a = [1, 2, '3'] # 创建有多个元素的列表,列表元素数据类型可以不同
a = [1, 2, [3, '4']] # 列表可以嵌套

range 创建列表

  1. 通过 range 创建列表的方式为 range(b)range(a, b)range(a, b, s)
  2. range(b) 等价于 range(0,b,1)range(a, b) 等价于 range(a,b,1)
  3. range(a, b, s) 会返回 a 到索引 b 中间的数字(包括 a 而不包括 b ,有顺序)组成的列表,其中每两个相邻元素的差值是步长值
  4. 步长值为负数代表从大到小生成列表
  5. 在新版本 python 中需要通过 list(range(...)) 来将 range 类转换为 list
1
2
3
4
5
a = range(10) # a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
a = range(1,10) # a = [1, 2, 3, 4, 5, 6, 7, 8, 9]
a = range(1,10,2) # a = [1, 3, 5, 7, 9]
a = range(10,1) # a=[]
a = range(10,1,-1) # a = [10, 9, 8, 7, 6, 5, 4, 3, 2]

Todo: 通过索引值列表获取新列表

获取元素

1
2
m = a[0] # 可以直接通过索引获得列表的元素,列表索引以 0 开始
m = a[1:2] # 列表的切片,返回值为一个新列表

列表的索引

  1. 列表索引以 0 开始,以列表长度减一为截止。
  2. 列表索引为负数代表列表从后数,-x 的意思是从后数 x 个元素,例如 -1 代表了列表的最后一个元素

列表的切片

  1. 切片的使用形式是列表元素后跟 [a:b][a:b:s],其返回值是一个新列表
  2. 列表切片元素的 ab 代表了元素索引,s 代表了步长值
  3. 列表切片,会返回索引 a 到索引 b 中间的内容(包括索引 a 对应的内容而不包括索引 b 对应的内容)组成的新列表,其中新列表的每两个相邻元素的索引差值是步长值
  4. 未提供索引 a 则默认为 0,未提供索引 b 则默认为列表长度(即 最后一个元素索引 + 1),未提供步长值 s 则默认为 1
  5. 省略元素时应注意至少有一个 : 存在才会被认为是切片;且只有一个 : 时会认为是 a:b 形式而非其他样式
  6. 步长值为负数时意味着新列表产生方向为从右到左
1
2
3
4
5
6
7
8
9
10
11
12
a = [1, 2, 3, 4, 5, 6, 7, 8, 9]
x = a[4:] # x = [5, 6, 7, 8, 9]
x = a[:3] # x = [1, 2, 3]
x = a[:] # x = [1, 2, 3, 4, 5, 6, 7, 8, 9]
x = a[2:7] # x = [3, 4, 5, 6, 7]
x = a[2:7:2] # x = [3, 5, 7]
x = a[-5:] # x = [5, 6, 7, 8, 9]
x = a[:-3] # x = [1, 2, 3, 4, 5, 6]
x = a[::-1] # x = [9, 8, 7, 6, 5, 4, 3, 2, 1]
x = a[5:1] # x = [] 默认的列表产生方式为从左到右,列表索引 a 在 b 之后会返回空列表
x = a[5:1:-1] # x = [6, 5, 4, 3]
x = a[-1:-5] # x = [] 新列表的产生方式只与步长值的正负有关而与索引的查询方式无关

关于元素的索引的操作

1
2
3
4
a = [1, 1, 3, 4, 5, 5, 6]
i = a.index(5) # i = 4,返回第一个值为 5 的元素的索引
n = a.count(5) # n = 2,返回值为 5 的元素的个数
n = len(a) # n = 6,返回列表的元素数量

查询元素是否在列表中

1
2
1 in a # 若 1 在列表 a 中返回 True,否则返回 False
1 not in a # 若 1 不在列表 a 中返回 True,否则返回 False

Todo: 返回列表全部元素的索引

添加元素

1
2
3
4
5
6
a.append(x) # 在列表末尾添加元素 x,每次只能添加一个
a.insert(i, x) # 在列表索引的 i 位置,添加元素 x,每次只能添加一个
a.extend([a, b, c]) # 在列表末尾添加一个新列表(直接合并元素)
a += [1, 2, 3] # 在列表末尾添加一个新列表(直接合并元素)(列表可以相加,结果为一个新列表)
a = [1, 2, 3]
a *= 2 # a = [1, 2, 3, 1, 2, 3],将列表元素复制两份

删除元素

1
2
3
4
5
6
7
a = [1, 2, 3, 4, 5, 5, 7, 8, 9]
x = a.pop() # x = 9, a = [1, 2, 3, 4, 5, 5, 7, 8],删除最后一个元素并返回这个元素
x = a.pop(3) # x = 4, a = [1, 2, 3, 5, 5, 7, 8],删除索引为 3 的元素并返回它
a.remove(5) # a = [1, 2, 3, 5, 7, 8],删除第一个值为5的元素,不返回任何数据
del a[2] # a = [1, 2, 5, 7, 8],删除索引值为 2 的元素
a.clear() # a=[],清空列表中全部元素
del a # a不再存在,删除列表,直接取消了定义

Todo: 删除全部元素

Todo: 按索引值列表删除全部元素

修改元素

1
2
3
4
5
a = [1, 2, 3]
a[0] = 2 # a = [2, 2, 3],修改指定索引对应的元素
a[0:1] = [0,1] # a = [0, 1, 3],通过切片修改对应的元素
a.reverse() # a = [3, 1, 0],将 a 中的元素按索引值反向
b = list(reversed(a)) # a = [3, 1, 0], b = [0, 1, 3],返回 a 反向后的列表而保持 a 不变

列表排序

  1. 方法语法:a.sort(key=None, reverse=False),直接修改 a,返回 None
  2. 如果省略了 key 参数,则按照升序(从小到大)排序(只能同类元素比较)
  3. 如果需要自定义比较,则需要对 key 参数传入一个接受一个参数的函数,并返回一个值,python 将会把此值作为排序的依据
  4. Todo: sorted(a)

列表遍历

  1. 可以通过简单的 for 循环来实现遍历
  2. 可以通过先获取元素数量再循环这个次数来实现遍历
  3. 可以通过 enumerate() 函数来同时遍历元素和其对应的下标,此函数返回一个类似拥有两个元素的列表的类,此类的每一项都是拥有两个元素的元组,第一个元素为索引,第二个元素为此索引对应的对象。
1
2
3
4
5
6
7
8
9
10
a = [1, 2, 3, 4]
for (i, x) in enumerate(a):
print(i, x)
'''
输出结果为:
0 1
1 2
2 3
3 4
'''

提示:第一个元素实际上并不是索引,而是简单的一个数,此数的起始值可以通过在第二个参数传入起始值而改变

1
2
3
4
5
6
7
8
9
10
a = [1, 2, 3, 4]
for (i, x) in enumerate(a, 2):
print(i, x)
'''
输出结果为:
2 1
3 2
4 3
5 4
'''

应该注意,若在循环中同时需要元素和其下标应避免使用 .index() 方法而选择上面的 2 或 3 所给出的方法,因为 .index() 方法在遇到相同元素时只会返回元素的第一个下标

1
2
3
4
5
6
7
8
9
10
a = [1, 1, 2, 3]
for x in a:
print(a.index(x), x)
'''
输出结果为:
0 1
0 1
2 2
3 3
'''

其他列表函数、方法

1
2
3
4
a = [1, 2, 3, 4, 5, 5, 7, 8, 9]
max(a) # 返回列表 a 中最大的元素(只能同类元素比较)
min(a) # 返回列表 a 中最大的元素(只能同类元素比较)
type(a) is list # True,判断 a 是不是列表

欢迎关注我的其它发布渠道