python列表操作 - 不止于python

1

列表基本操作

创建空列表

方式1：

变量 = []

方式2：

变量 = list()

In [1]: l1 = []  
In [2]: l1  
Out[2]: []  
  
In [3]: l2 = list()  
In [4]: l2  
Out[4]: []

有数据(元素)的列表

变量 = [值]

具有多个数据的列表

变量 = [值,值,值….]

1
2
3

In [5]: l3 = [1,2,3,4]  
In [6]: l3  
Out[6]: [1, 2, 3, 4]

访问列表中的元素

变量[索引]

1 2	In [7]: l3[0] Out[7]: 1

修改列表中的元素

变量[索引] = 新值

1
2
3

In [9]: l3[0] = 2  
In [10]: l3  
Out[10]: [2, 2, 3, 4]

删除列表中的元素

del 变量[索引]

1
2
3

In [15]: del l3[0]  
In [16]: l3  
Out[16]: [2, 3, 4]

删除整个列表

del 列表变量

In [23]: del l3  
In [24]: l3  
---------------------------------------------------------------------------  
NameError Traceback (most recent call last)  
<ipython-input-24-b8fff4990345> in <module>  
----> 1 l3  
NameError: name 'l3' is not defined

列表相加操作

变量 = 列表1 + 列表2

In [25]: l1 = [1, 2]  
In [26]: l2 = [3, 4]  
In [27]: l3 = l1 + l2  
In [28]: l3  
Out[28]: [1, 2, 3, 4]

列表相乘操作

变量 = 列表 * 整数

1
2
3

In [29]: l4 = l3 * 2  
In [30]: l4  
Out[30]: [1, 2, 3, 4, 1, 2, 3, 4]

分片操作

9.1 获取整个列表

变量 = 列表[:]

1
2
3

In [31]: l5 = [1,2,3,4,5,6]  
In [32]: l5[:]  
Out[32]: [1, 2, 3, 4, 5, 6]

9.2 获取列表开头到结束索引之前的数据组成的列表

变量 = 列表[:结束索引]

In [33]: l5[:2]  
Out[33]: [1, 2]  
In [34]: l5[:-2]  
Out[34]: [1, 2, 3, 4]

9.3 获取列表开始索引到列表末尾的数据组成的列表

变量 = 列表[开始索引:]

In [35]: l5[2:]  
Out[35]: [3, 4, 5, 6]  
In [36]: l5[-2:]  
Out[36]: [5, 6]

9.4 获取开始索引和结束索引之间的数据组成的列表（包含开始索引，不包含结束索引）

变量 = 列表[开始索引:结束索引]

1 2	In [37]: l5[2:4] Out[37]: [3, 4]

9.5 获取开始索引和结束索引之间的数据（按照间隔值来获取）组成的列表（包含开始索引，不包含结束索引）

变量 = 列表[开始索引:结束索引:间隔值]

1 2	In [38]: l5[1:4:2] Out[38]: [2, 4]

成员检测

10.1 检测一个数据是否在列表中

值 in 列表

In [39]: 1 in l5  
Out[39]: True  
In [40]: 11 in l5  
Out[40]: False

10.2 检测一个数据是否不在列表中

值 not in 列表

In [41]: 2 not in l5  
Out[41]: False  
In [42]: 22 not in l5  
Out[42]: True

2

列表常用函数操作

index(索引): 查看值在列表中的索引

1
2
3

In [42]: l5 = [1,2,3,4,5,6]  
In [43]: l5.index(2)  
Out[43]: 1

count(值): 查看值在列表中的数量

1
2
3

In [44]: l5.append(2)  
In [45]: l5.count(2)  
Out[45]: 2

sort: 列表排序, 默认从小到大排序

In [57]: l5 = [1, 2, 2, 3, 4, 5, 6]  
In [58]: l5.sort()  
In [59]: l5  
Out[59]: [1, 2, 2, 3, 4, 5, 6]  
  
## 从大到小排序  
In [60]: l5.sort(reverse=True)  
In [61]: l5  
Out[61]: [6, 5, 4, 3, 2, 2, 1]  
  
## 对值进行指定函数处理后排序, 从大到小  
In [62]: l5.sort(key=lambda x:x, reverse=True)  
In [63]: l5  
Out[63]: [6, 5, 4, 3, 2, 2, 1]  
  
## 对值进行指定函数处理后排序, 从小到大  
In [64]: l5.sort(key=lambda x:x)  
In [65]: l5  
Out[65]: [1, 2, 2, 3, 4, 5, 6]

copy: 列表复制

1
2
3

In [48]: l55 = l5.copy()  
In [49]: l55  
Out[49]: [1, 2, 2, 3, 4, 5, 6]

reverse: 列表反转

1
2
3

In [50]: l5.reverse()  
In [51]: l5  
Out[51]: [6, 5, 4, 3, 2, 2, 1]

append(值): 向列表末尾添加元素

In [10]: l3 = [2,2,3,4]  
In [11]: l3.append(5)  
In [12]: l3  
Out[12]: [2, 2, 3, 4, 5]

insert(索引, 值): 向列表中插入值

1
2
3

In [13]: l3.insert(0, 66)  
In [14]: l3  
Out[14]: [66, 2, 2, 3, 4, 5]

pop(索引): 根据值索引删除列表中的元素

In [17]: l3.pop(1)  
Out[17]: 2  
In [18]: l3  
Out[18]: [2, 3, 4, 5]

remove(值): 根据值删除列表中的元素

1
2
3

In [19]: l3.remove(5)  
In [20]: l3  
Out[20]: [2, 3, 4]

clear: 清空列表值

1
2
3

In [21]: l3.clear()  
In [22]: l3  
Out[22]: []

extend(列表): 合并两个列表

In [53]: l5 = [6, 5, 4, 3, 2, 2, 1]  
In [54]: l5.extend([11,22,33])  
In [55]: l5  
Out[55]: [6, 5, 4, 3, 2, 2, 1, 11, 22, 33]

len(列表): 列表长度

1 2	In [66]: l5Out[66]: [1, 2, 2, 3, 4, 5, 6] In [67]: len(l5)Out[67]: 7

max(列表): 列表中的最大值

1 2	In [68]: max(l5) Out[68]: 6

min(列表): 列表中的最小值

1 2	In [69]: min(l5) Out[69]: 1

sum(列表): 计算列中所有元素的和

1 2	In [70]: sum(l5) Out[70]: 23

3

列表推导式

简单的列表推导式

格式：[变量 for 变量 in 列表]

结果：遍历列表中的每个值，将每个值获取之后组成新的列表, 可以对获取的值进行修改

[变量可以其他操作 for 变量 in 列表]

In [70]: l1 = [1,2,3,4,5]  
In [71]: l2 = [i for i in l1]  
In [72]: l2  
Out[72]: [1, 2, 3, 4, 5]

带有判断条件的列表推导式

格式：[变量 for 变量 in 列表 if 条件表达式]

结果：遍历列表中的每个值，根据判断条件决定是否取出指定的值组成新的列表，可以对获取的值进行修改

1
2
3

In [73]: l3 = [i for i in l1 if i > 2]  
In [74]: l3  
Out[74]: [3, 4, 5]

多个列表的同时循环的列表推导式

变量1和变量2可以进行其他操作, 变量1和变量2可以进行其它计算或操作

格式：[变量1+变量2 for 变量1 in 列表1 for 变量2 in 列表2]

结果：同时遍历列表1和列表2中的每个值，将列表1中的每个值和列表2中的每个值进行运算得到新的列表

新的列表中元素个数=列表1中元素个数 * 列表2中的元素个数

1
2
3

In [75]: l4 = [i + ii for i in l1 for ii in l2]  
In [76]: l4  
Out[76]: [2, 3, 4, 5, 6, 3, 4, 5, 6, 7, 4, 5, 6, 7, 8, 5, 6, 7, 8, 9, 6, 7, 8, 9, 10]

带有判断条件的多个列表的同时循环列表推导式

格式：[变量1+变量2 for 变量1 in 列表1 for 变量2 in 列表2 if 条件表达式]

结果：同时遍历列表1和列表2中的每个值，根据判断条件将列表1中的值和列表2中的值进行运算，得到新的列表

新的列表数量由判断条件决定 = 符合条件的剩余的列表1个数 * 符合条件的剩余的列表2个数

In [77]: l5 = [i + ii for i in l1 for ii in l2 if i > 2 and ii > 2]  
In [78]: l5  
Out[78]: [6, 7, 8, 7, 8, 9, 8, 9, 10]  
  
In [79]: l5 = [i + ii for i in l1 for ii in l2 if i > 2 and ii > 3]  
In [80]: l5  
Out[80]: [7, 8, 8, 9, 9, 10]

扫描二维码

获取更多精彩

不止于python