Python-列表【list】

阅读目录(Content)

• 1、特点
• 2、初始化
• 2.1、语法
• 2.2、示例
• 3、索引
• 4、查询
• 5、修改
• 6、增加
• 6.1、增加单个元素
• 6.1.1、语法
• 6.2、增加多个元素
• 6.2.1、语法
• 6.2.2、示例
• 7、删除
• 8、反转
• 9、排序
• 10、in成员操作
• 11、列表复制
• 12、copy、deepcopy
• 12.1、列表的内存模型和深浅拷贝
• 12.1.1、原理图
• 12.1.2、shadow copy
• 12.1.3、deep copy
• 12.2、copy
• 12.3、deepcopy

回到顶部(go to top)

1、特点

一个排列整齐的队伍，Python采用顺序表实现
列表内的个体称作元素，由若干元素组成列表
元素可以是任意对象（数字、字符串、对象、列表等）
列表内元素有顺序，可以使用索引
线性的数据结构
使用 [ ] 表示
列表是可变的

回到顶部(go to top)

2、初始化

2.1、语法

list() -> new empty list
list(iterable) -> new list initialized from iterable's items
[]
# 注意：列表不能一开始就定义大小

2.2、示例

ls1 = []
ls2 = list()
ls3 = [2, 'ab', [3, 'abc'], (5, 30, 50)] # 列表是一个容器，元素可以是其它类型
ls4 = list(range(5)) # 非常常用的构造方式，将一个可迭代对象转换为一个列表[0, 1, 2, 3, 4]

回到顶部(go to top)

3、索引

索引，也叫下标
正索引：从左至右，从0开始，为列表中每一个元素编号，如果列表有元素，索引范围[0, 长度-1]
负索引：从右至左，从-1开始，如果列表有元素，索引范围[-长度, -1]
正、负索引不可以超界，否则引发异常IndexError

为了理解方便，可以认为列表是从左至右排列的，左边是头部，右边是尾部，左边是下界，右边是上界
列表通过索引访问，list[index] ，index就是索引，使用中括号访问
使用索引定位访问元素的时间复杂度为O(1)，这是最快的方式，是列表最好的使用方式。

回到顶部(go to top)

4、查询

index(value,[start,[stop]])
通过值value，从指定区间查找列表内的元素是否匹配
匹配第一个就立即返回索引
匹配不到，抛出异常ValueError

count(value)
返回列表中匹配value的次数

时间复杂度
index和count方法都是O(n)
随着列表数据规模的增大，而效率下降

len()

回到顶部(go to top)

5、修改

# 索引定位元素，然后修改。注意索引不能超界
ls1 = [1,2,3,4]
ls1[2] = 200

回到顶部(go to top)

6、增加

6.1、增加单个元素

6.1.1、语法

append(object) -> None
列表尾部追加元素，返回None
返回None就意味着没有新的列表产生，就地修改
定位时间复杂度是O(1)

insert(index, object) -> None
在指定的索引index处插入元素object
返回None就意味着没有新的列表产生，就地修改

定位时间复杂度是O(1)
索引能超上下界吗？
超越上界，尾部追加
超越下界，头部追加

6.2、增加多个元素

6.2.1、语法

extend(iteratable) -> None
将可迭代对象的元素追加进来，返回None,就地修改，本列表自身扩展

+ -> list
连接操作，将两个列表连接起来，产生新的列表，原列表不变
本质上调用的是魔术方法__add__()方法

* -> list
重复操作，将本列表元素重复n次，返回新的列表

6.2.2、示例

ls1 = [1] * 5
ls2 = [None] * 6
ls3 = [1,2] * 3
ls4 = [[1]] * 3

x = [1] * 3
x[0] = 100
print(x) # 结果是[100, 1, 1]

y = [[1]] * 3
print(y) # 结果是[[1], [1], [1]]
y[0] = 100
print(y) # 结果是[100, [1], [1]]
y[1][0] = 200
print(y) # 结果是[100, [200], [200]]

回到顶部(go to top)

7、删除

remove(value) -> None
从左至右查找第一个匹配value的值，找到就移除该元素，并返回None，否则ValueError就地修改

pop([index]) -> item
不指定索引index，就从列表尾部弹出一个元素
指定索引index，就从索引处弹出一个元素，索引超界抛出IndexError错误

clear() -> None
清除列表所有元素，剩下一个空列表

回到顶部(go to top)

8、反转

reverse() -> None
将列表元素反转，返回None
就地修改
这个方法最好不用，可以倒着读取，都不要反转。

回到顶部(go to top)

9、排序

sort(key=None, reverse=False) -> None
对列表元素进行排序，就地修改，默认升序
reverse为True，反转，降序
key一个函数，指定key如何排序，lst.sort(key=function)
如果排序是必须的，那么排序。

回到顶部(go to top)

10、in成员操作

'a' in ['a', 'b', 'c']
[3,4] in [1, 2, 3, [3,4]]

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

回到顶部(go to top)

11、列表复制

a = list(range(4))
b = list(range(4))
print(a == b) # True
c = a
c[2] = 10# [0, 1, 10, 3]
print(a == b) # False
print(a == c) # True

回到顶部(go to top)

12、copy、deepcopy

12.1、列表的内存模型和深浅拷贝

12.1.1、原理图

12.1.2、shadow copy

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

12.1.3、deep copy

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

12.2、copy

a = [1, [2, 3, 4], 5]
b = a.copy()
print(a == b) # True
a[2] = 10
print(a == b) # False
a[2] = b[2]
print(a == b) # True
a[1][1] = 100
print(a == b) # True
print(a) # [1, [2, 100, 4], 5]
print(b) # [1, [2, 100, 4], 5]

# Python内建数据类型，内部都实现了 == ，它的意思是内容比较

12.3、deepcopy

import copy
a = [1, [2, 3], 4]
b = copy.deepcopy(a)
print(a == b) # True
a[1][1] = 100
print(a == b) # Flase
print(a) # [1, [2, 100], 4]
print(b) # [1, [2, 3], 4]