Python列表详解

格式

[ 数据 1 , 数据 2 , 数据 3 , 数据 4 ......]

列表元素增加或删除时，列表对象自动进行扩展或收缩内存，保证元素之间没有缝隙；

列表可以⼀次性存储多个数据，且可以为不同数据类型。

列表的创建

1.使用”=”直接将一个列表赋值给变量即可创建列表对象

2.使用list()函数将元组、range对象、字符串或其他类型的可迭代对象类型的数据转换为列表。

列表的常⽤操作：增、删、改、查。

查找

下标

name_list = ['Tom', 'Lily', 'Rose']
print(name_list[0]) # Tom
print(name_list[1]) # Lily

函数

index()：返回指定数据x所在位置的下标 ，若不存在值为x的元素则抛出异常

列表序列 . index ( 数据 , 开始位置下标 , 结束位置下标 )

name_list = ['Tom', 'Lily', 'Rose']
print(name_list.index('Lily', 0, 2)) # 1

注意：如果查找的数据不存在则报错。

count() ：统计指定数据在当前列表中出现的次数。

name_list = ['Tom', 'Lily', 'Rose']
print(name_list.count('Lily')) # 1

len() ：访问列表⻓度，即列表中数据的个数。

name_list = ['Tom', 'Lily', 'Rose']
print(len(name_list)) # 3

判断是否存在

in ：判断指定数据在某个列表序列，如果在返回 True ，否则返回 False

name_list = ['Tom', 'Lily', 'Rose']
# 结果：True
print('Lily' in name_list)
# 结果：False
print('Lilys' in name_list)

not in ：判断指定数据不在某个列表序列，如果不在返回 True ，否则返回 False

name_list = ['Tom', 'Lily', 'Rose']
# 结果：False
print('Lily' not in name_list)
# 结果：True
print('Lilys' not in name_list)

增加

“+”运算符

>>> aList = [3,4,5]
>>> aList = aList + [7]
>>> aList
[3, 4, 5, 7]

 实质：并未真的为列表添加元素，而是创建一个新列表，并将原列表中的元素和新元素依次复制到新列表的内存空间。    

涉及大量元素的复制，速度较慢，在涉及大量元素添加时不建议使用该方法。

append() ：列表结尾追加数据。

列表序列 . append ( 数据 )

name_list = ['Tom', 'Lily', 'Rose']
name_list.append('xiaoming')
# 结果：['Tom', 'Lily', 'Rose', 'xiaoming']
print(name_list)

列表追加数据的时候，直接在原列表⾥⾯追加了指定数据，即修改了原列表，故列表为可变类型

数据。

实质：原地修改列表，真正意义上的在列表尾部添加元素，速度较快。 所谓“原地”，是指不改变列表在内存中的首地址。

【注意点】

如果 append() 追加的数据是⼀个序列，则追加整个序列到列表

name_list = ['Tom', 'Lily', 'Rose']
name_list.append(['xiaoming', 'xiaohong'])
# 结果：['Tom', 'Lily', 'Rose', ['xiaoming', 'xiaohong']]
print(name_list)

extend() ：列表结尾追加数据，如果数据是⼀个序列，则将这个序列的数据逐⼀添加到列表。

列表序列 . extend ( 数据 )

【 单个数据】

name_list = ['Tom', 'Lily', 'Rose']
name_list.extend('xiaoming')
# 结果：['Tom', 'Lily', 'Rose', 'x', 'i', 'a', 'o', 'm', 'i', 'n', 'g']
print(name_list)

【序列数据】

name_list = ['Tom', 'Lily', 'Rose']
name_list.extend(['xiaoming', 'xiaohong'])
# 结果：['Tom', 'Lily', 'Rose', 'xiaoming', 'xiaohong']
print(name_list)

insert() ：指定位置新增数据。

列表序列 . insert ( 位置下标 , 数据 )

name_list = ['Tom', 'Lily', 'Rose']
name_list.insert(1, 'xiaoming')
# 结果：['Tom', 'xiaoming', 'Lily', 'Rose']
print(name_list)

尽量从列表尾部进行元素的增加与删除操作。

列表的insert()可以在列表的任意位置插入元素，但由于列表的自动内存管理功能，insert()方法会涉及到插入位置之后所有元素的移动，这会影响处理速度。

类似的还有remove()方法以及使用pop()函数弹出列表非尾部元素和使用del命令删除列表非尾部元素的情况。

乘法          

将列表与整数相乘，生成一个新列表，新列表是原列表中元素的重复。

删除

del

del ⽬标

【 删除列表】

name_list = ['Tom', 'Lily', 'Rose']
# 结果：报错提示：name 'name_list' is not defined
del name_list
print(name_list)

【删除指定数据】

name_list = ['Tom', 'Lily', 'Rose']
del name_list[0]
# 结果：['Lily', 'Rose']
print(name_list)

pop() ：删除指定下标的数据 ( 默认为最后⼀个 ) ，并返回该数据。

列表序列 . pop ( 下标 )

name_list = ['Tom', 'Lily', 'Rose']
del_name = name_list.pop(1)
# 结果：Lily
print(del_name)
# 结果：['Tom', 'Rose']
print(name_list)

remove() ：移除列表中某个数据的 第⼀个 匹配项。

列表序列 . remove ( 数据 )

name_list = ['Tom', 'Lily', 'Rose']
name_list.remove('Rose')
# 结果：['Tom', 'Lily']
print(name_list)

clear()：清空列表，但保留列表对象

name_list = ['Tom', 'Lily', 'Rose']
name_list.clear()
print(name_list) # 结果： []

修改

【修改指定下标数据 】

name_list = ['Tom', 'Lily', 'Rose']
name_list[0] = 'aaa'
# 结果：['aaa', 'Lily', 'Rose']
print(name_list)

逆置： reverse()

num_list = [1, 5, 2, 3, 6, 8]
num_list.reverse()
# 结果：[8, 6, 3, 2, 5, 1]
print(num_list)

排序： sort()

列表序列 . sort ( key = None , reverse = False )

注意： reverse 表示排序规则， reverse = True 降序， reverse = False 升序（默认）

num_list = [1, 5, 2, 3, 6, 8]
num_list.sort()
# 结果：[1, 2, 3, 5, 6, 8]
print(num_list)

复制

copy()返回列表lst的浅复制

name_list = ['Tom', 'Lily', 'Rose']
name_li2 = name_list.copy()
# 结果：['Tom', 'Lily', 'Rose']
print(name_li2)

列表的循环遍历

while

name_list = ['Tom', 'Lily', 'Rose'] i = 0
while i < len(name_list):
 print(name_list[i])
 i += 1

for

name_list = ['Tom', 'Lily', 'Rose']
for i in name_list:
 print(i)

列表嵌套

name_list = [['⼩明', '⼩红', '⼩绿'], ['Tom', 'Lily', 'Rose'], ['张三', '李四', '王五']]
# 第⼀步：按下标查找到李四所在的列表
print(name_list[2])
# 第⼆步：从李四所在的列表⾥⾯，再按下标找到数据李四
print(name_list[2][1])

列表元素的访问

下标

index()对象方法

count()对象方法

“in”

多维列表

>>> a = ['a',1] 
>>> n = ['b',2]
>>> x = [a,n]
>>> x
[['a',1],['b',2]]
>>> x[0] # 显示第一个元素 
['a', 1] 
>>> x[0][1] # 显示第一个元素中的第二个元素 
1

使用列表推导式实现嵌套列表的平铺

>>> vec = [[1,2,3], [4,5,6], [7,8,9]] 
>>> [num for elem in vec for num in elem] 
[1, 2, 3, 4, 5, 6, 7, 8, 9] 

相当于

>>> vec = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
>>> result = []
>>> for elem in vec:
	            for num in elem:
		          result.append(num)
>>> result
[1, 2, 3, 4, 5, 6, 7, 8, 9]

如果不使用列表推导式，可以这样做

>>> vec = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
>>> sum(vec, [])
[1, 2, 3, 4, 5, 6, 7, 8, 9]

或者

>>> vec = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
>>> from itertools import chain
>>> list(chain(*vec))
[1, 2, 3, 4, 5, 6, 7, 8, 9]

# chain()可以把一组迭代对象串联起来，形成一个更大的迭代器