python--列表list

列表list是python基本的数据结构，是可变序列，允许有重复元素。

环境

• win10 64bit
• python 3.9

创建

列表的创建可以通过内置的list类创建，也可以用方括号[]创建，列表中的元素可以是任意数据类型，列表可嵌套列表。

list

通过list类创建列表实例，传入的参数必须是可迭代对象。常见的数据类型tuple,list,set,dict,str等都是可迭代对象。

# 元组创建列表
list((1,2,3))

# 集合创建列表
list({1,2,3})

[1, 2, 3]

通过字典创建列表时，只有字典的key会转为列表。

# 字典创建列表
list({'a':1,'b':2})

['a', 'b']

# 字符串创建列表
list('abc')

['a', 'b', 'c']

# 空列表
list()

[]

空列表取布尔值，返回False。

bool(list())

False

[]

用方括号[]包裹对象，并用,分割，可创建列表。

# []创建列表
[1,2,'a',True]

[1, 2, 'a', True]

# 嵌套列表
[1,2,[3,4,['a',True]]]

[1, 2, [3, 4, ['a', True]]]

# 空列表
[]

[]

计数

count

count方法计算列表中某一个元素出现的次数。

# 列表元素计数
[1,2,1].count(1)

2

len

__len__()方法计算列表的总长度。

[1,2,1].__len__()

3

查询

[]

方括号[]除了可以构造列表外，还可以通过索引查询列表中的元素。可传入整数或切片进行查询。

l=['a','b','c','d','e']
# 整数查询单个元素
l[0]

'a'

# 切片查询多个元素
l[1:3]

['b', 'c']

# 切片反向查询多个元素
l[-3:]

['c', 'd', 'e']

通过[]方法索引目标元素，并赋值，可以修改列表中的元素。

l=['a','b','c']
l[0]='A'
l

['A', 'b', 'c']

index

index方法查询元素第一次出现的索引位置。可设置查找的起止范围。

l=['b','a','b','c']
# 查询元素第一次出现的索引位置
l.index('b')

0

# 查询元素第一次出现的索引位置(指定索引1到4查找)
l.index('b',1,3)

2

插入

在列表中插入值有append,extend,insert三种方法，三种方法均返回None，会修改列表。

append

append方法在列表末尾插入一个新元素。

# 末尾插入新元素
l=[1,2,3]
l.append(4)
l

[1, 2, 3, 4]

insert

insert方法在列表指定位置插入一个新元素。

# 在索引1的位置插入一个元素
l=[1,2,3]
l.insert(1,11)
l

[1, 11, 2, 3]

extend

extend方法在列表末尾插入一个可迭代对象，可迭代对象可以是list,tuple等数据类型。

# 末尾插入可迭代对象
l=[1,2,3]
l.extend((4,5,6))
l

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

删除

删除列表中的元素有clear,pop,remove三种方法，用关键字del删除整个列表。

clear

clear方法删除列表中的所有元素，返回None，列表变成空列表。

l=[1,2,3]
l.clear()
l

[]

pop

pop方法根据索引删除列表中的元素，并返回删除的元素。默认从最后一个位置开始删除。

# 删除最后一个位置元素
l=[1,2,3]
e=l.pop()
print(f'删除后列表：{l}，删除的元素：{e}')

删除后列表：[1, 2]，删除的元素：3

# 删除索引为2的元素
l=[1,2,3]
e=l.pop(1)
print(f'删除后列表：{l}，删除的元素：{e}')

删除后列表：[1, 3]，删除的元素：2

remove

remove方法删除第一次出现的元素，返回None，会修改列表。

# 删除第一次出现的元素
l=['b','a','c','a']
l.remove('a')
l

['b', 'c', 'a']

del

del会删除整个列表，从当前命名空间中移除。

l=[1,2,3]
del l

重复

copy

copy方法复制一个完全相同的列表。

l=[1,2,3]
ll=l.copy()
ll

[1, 2, 3]

*

乘号*用于重复多个列表。

l=[1,2,3]
l*3

[1, 2, 3, 1, 2, 3, 1, 2, 3]

反转

reverse方法反转列表，返回None，会修改列表。

l=[1,2,3]
l.reverse()
l

[3, 2, 1]

排序

sort方法对列表进行排序，返回None，会修改列表。默认升序排序，设置reverse=True为降序排序。

# 升序排序
l=[1,8,2,6,3]
l.sort()
l

[1, 2, 3, 6, 8]

# 降序排序
l=[1,8,2,6,3]
l.sort(reverse=True)
l

[8, 6, 3, 2, 1]

设置key参数，可以对元素是可迭代对象的列表进行排序，
key参数设置为函数，指定根据可迭代对象的哪个元素进行列表排序。

# 根据元组的第一个元素升序排序
l=[(2,4),(5,1),(1,8)]
l.sort(key=lambda t:t[0])
l

[(1, 8), (2, 4), (5, 1)]

合并

符号+可以合并列表。

# 合并列表
l1=[1,2,3]
l2=[4,5,6]
l1+l2

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

结合reduce函数，可以批量合并多个列表。

# 批量合并多个列表
from functools import reduce
l=[[1,2],[3,4],[5,6]]
list(reduce(lambda x,y:x+y,l))

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

推导式

推导式comprehensions是python的一种独有特性，可以从一个数据序列构建新的数据序列。
列表推导式的主要形式有：[exp for x in data if condition]，[exp1 if condition else exp2 for x in data]。
通过列表推导式，可以很方便的筛选、修改列表。

# if条件筛选列表
l=[1,2,3,7,1]
[x for x in l if x>1]

[2, 3, 7]

# if-else条件筛选列表
l=[1,2,3,7,1]
[x if x>1 else 0 for x in l]

[0, 2, 3, 7, 0]

多层for循环也可以在列表推导式中使用。一般不超过2层，否则可读性会大大降低。

l=[[1,2],[3,4],[3,7]]
# 筛选第一个元素是3的嵌套列表
[x for x in l for i in x if i==3]

[[3, 4], [3, 7]]

扁平化

有时候需要对嵌套列表进行扁平化操作，即多层嵌套列表展开到一层。可以通过列表推导式和递归函数完成。

# 定义列表扁平化函数
def flat_list(obj):
    return [i for g in obj for i in flat_list(g)] if isinstance(obj, list) else [obj]
# 嵌套列表
l=[[1,2,3],4,[5,[6,[7]]]]
# 扁平化嵌套列表
flat_list(l)

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