python列表list

列表如同地铁站排好的队伍，有序，可以插队、离队，可以索引。

一个排列整齐的队伍，Python采用顺序表实现

列表内的个体称作元素，由若干元素组成列表

元素可以是任意对象（数字、字符串、对象、列表等）

列表内元素有顺序，可以使用索引

线性的数据结构

使用 [ ] 表示

列表是可变的

形式

ls1 = []

ls2 = list()

ls3 = [2, 'ab', [3 , 'abc'], (5, 30, 50)] # 列表是一个容器，元素可以是其它类型

ls4 = list(range(5)) # 非常常用的构造方式，将一个可迭代对象转换为一个列表

索引

索引，也叫下标

正索引：从左至右，从0开始，为列表中每一个元素编号

​ 如果列表有元素，索引范围[0, 长度-1]

负索引：从右至左，从-1开始

​ 如果列表有元素，索引范围[-长度, -1]

正、负索引不可以超界，否则引发异常IndexError

查询

1 通过下标搜索值

​ list[index] ，index就是索引，使用中括号访问

​ 例如

​ a[1]

2 通过值，搜索下标

​ list.index(value,[start,[stop]])

​ [start,[stop]] 包左不包右

​ 从左往右找

​ 通过值value，从指定区间查找列表内的元素是否匹配

​ 匹配第一个就立即返回索引

​ 匹配不到，抛出异常ValueError

a.index(2, 2, 6)

list.count(value)

​ 返回列表中匹配value的次数

​ 例如

a=[1,2,3,2,3,2,3,2]
print(a.count(2))

len(list)

返回列表的元素个数

print(len(a))

修改

直接赋值

ls1 = [1,2,3,4]
ls1[2] = 200

增加单个元素

list.append(object) -> None

​ 追加

​ 列表尾部追加元素，返回None

​ 返回None就意味着没有新的列表产生，就地修改

list.insert(index, object) -> None

​ 插入

​ 在指定的索引index处插入元素object

​ 返回None就意味着没有新的列表产生，就地修改

例子

a.append(100)
a.insert(2,222)

增加多个元素

list.extend(iteratable) -> None
将可迭代对象的元素尾部追加进来，返回None
就地修改，本列表自身扩展
+ -> list
连接操作，将两个列表拼接起来，产生新的列表，原列表不变
本质上调用的是魔术方法__add__()方法

* -> list

​ 重复操作，将本列表元素重复n次，返回新的列表，原列表不变

只是简单的一层是可以重复后更改元素

如果是列表套列表，再重复，然后替换，就会出现全部被替换的情况

列表中的列表位置存放的是列表的地址，所以修改b[1][0]也就相当于同时在修改b[2][0]``b[3][0]，*3相当于把b[1]的内存地址复制了3次，所以b[1]``b[2]``b[3]第一是同一个

删除

list.remove(value) -> None

​ 通过值来删除，没有返回值

​ 从左至右查找第一个匹配value的值，找到就移除该元素，并返回None，否则ValueError

​ 就地修改

​ 效率低，需要遍历列表

list.pop([index]) -> item

​ 通过下标来删除，返回值为下标对应的值

​ 不指定索引index，就从列表尾部弹出一个元素

​ 指定索引index，就从索引处弹出一个元素，索引超界抛出IndexError错误

​ 效率不高

list.clear() -> None

​ 清除列表所有元素，剩下一个空列表

反转

list.reverse() -> None

​ 将列表元素反转，返回None

​ 就地修改

这个方法最好不用，可以倒着读取，都不要反转

排序

list.sort(key=None, reverse=False) -> None

​ 对列表元素进行排序，就地修改，默认升序

​ reverse为True，反转，降序

​ key一个函数，指定key如何排序，lst.sort(key=function)

print(a)
[33, 44, 9, 'a']
a.sort(key=str,reverse=True)
print(a)
['a', 9, 44, 33]


b=[2,33,222,1111,7]
b.sort(key=str)
print(b)
[1111, 2, 222, 33, 7]

in成员操作

in判断在不在，返回的是个bool值

for x in [1,2,3,4]:

​ pass

性能低，需要遍历

列表复制

a=list(range(5))
b=list(range(5))
print(a==b)
True
c=a
print(a)
[0, 1, 2, 3, 4]
print(c)
[0, 1, 2, 3, 4]
id(a)
Out[81]: 2979549093064
id(c)
Out[82]: 2979549093064
c[2]=5
print(a)
[0, 1, 5, 3, 4]

print(c)
[0, 1, 5, 3, 4]

c=b

并不是赋值了数据

只是赋值了b的地址

is

a is b

就是比的内存地址

哪怕a的数据与b的数据相同，地址不一样，也是False

copy

copy复制的是内容

d=c.copy()
print(c)
[0, 1, 5, 3, 4]
print(d)
[0, 1, 5, 3, 4]
id(c)
Out[89]: 2979549093064
id(d)
Out[90]: 2979549210952

print(c==d,c is d)
True False

shadow copy

​ 影子拷贝，也叫浅拷贝。遇到引用类型数据，仅仅复制一个引用而已

单独用copy也是浅拷贝

a=[1,2,3,[1,2,3,4,5],3,4]
b=a.copy()
id(a)
Out[98]: 2979549219272
id(b)
Out[99]: 2979549280008
id(a[3])
Out[100]: 2979549217288
id(b[3])
Out[101]: 2979549217288

deep copy

​ 深拷贝，往往会递归复制一定深度

需要导入copy模块

import copy

a = [1, [2 , 3], 4]
b = copy.deepcopy(a)