第五弹 python的数据类型 之 列表 list

简介：

以方括号标注，逗号分隔的一组值，列表可以包含不同类型的元素；但一般情况下，各元素的类型相同；列表是有序集合，支持切片和索引；是可变的；
列表的索引从0开始，第一个列表元素的索引为0。

操作

拷贝

1. 赋值操作

格式：

l1 = l

l和l1都是指向同一个列表

例子：

l = [1, 2, 3, 4]
l1 = 1
# id(l1): 140534014646528
# id(l): 140534014646528

2. 使用索引

格式：

l1 = l[:]

同时省略开始索引和结束索引，可以创建一个包含整个列表的切片；首先创建一个列表l的副本，再将该副本赋值给l1；

例子：

l = [1, 2, 3, 4]
l1 = l[:]
# id(l1): 140533986418304
# id(l):  140534014646528

3. 列表生成式

格式：

l1 = [i for i in l]

基于其他迭代器创建列表；将整个输出列表加载到内存中，对于中小型列表，它可以使操作更快。

例子：

l = [1, 2, 3, 4]
l1 = [i * 10 for i in l]

4. 使用copy

格式：

list.copy()

复制列表，返回复制后的新列表；类似于list[:]

例子：

l = ['python', 'golang', 'javascript', 'baidu']
l2  = l.copy()
# ['python', 'golang', 'javascript', 'baidu']

5. 使用list

格式：

list(iterable)

转换为列表；返回一个新的列表；

例子：

l = [1, 2, 3, 4]
l2 = list(l)
# [1, 2, 3, 4]

切片

格式：

list[start : stop : step]

• start：开始下标，默认为0
• stop：结束下标，默认为列表末尾
• step：步长；默认为1

区间范围：[start, stop)；

例子：

>>> l = [1, 2, 3, 4, 5, 6]
>>> l[0:3:2]
[1, 3]
>>> l[:2:-1]
>>> l
[6, 5, 4]

列表推导式

列表推导式创建列表的方式更简洁。对序列或可迭代对象中的每个元素应用某种操作，用生成的结果创建新的列表；
列表推导式的方括号内包含以下内容：一个表达式，后面一个for子句，然后是零个或多个for或if子句。结果是由表达式for或if子句求值计算而得出的一个新列表；

1. 简单模式

l = [1, 2, 3]
l2 = [x for x in l]

2. 嵌套模式

m = [[1,2,3,4], [5,6,7,8], [9,10,11,12]]
[[r[i] for r  in m] for i in range(4)]
# [[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 12]]

添加元素

1. 在末尾追加一个元素

格式：

list.append(x)

在列表末尾追加一个元素

例子：

l = [1, 2, 3, 4]
l.append(5)
# [1, 2, 3, 4, 5]

2. 在末尾追加多个元素

格式：

list.extend(iterable)

在列表末尾一次性追加另一个序列中的多个值

例子：

l = [1, 2, 3, 4]
l.extend([100, 200, 300])
# [1, 2, 3, 4, 100, 200, 300]

3. 在指定位置插入

格式：

list.insert(i, x)

在制定位置插入元素。第一个参数为插入元素的索引；第二个参数为插入的值

例子：

l = [1, 2, 3, 4]
l.insert(0, 5)
# [5, 1, 2, 3,  4]

移除元素

1. 通过del删除

格式：

del list[i]

通过del语句和列表对应的索引，执行删除操作；del语句不仅可以通过索引删除指定元素，还可以通过清除切片以及清空整个列表；同样也可以使用del删除整个变量，删除之后再次引用此变量，会触发异常；

例子：

l = [1, 2, 3, 4, 5]
del l[1]
#[1, 3, 4, 5]

del l[:2]
#[4, 5]

del l[:]
#[]

del l

2. 移除指定值的元素

格式：

list.remove(x)

移除列表中第一个匹配到的值为 x 的元素；如果要删除的值在列表中出现多次，则需要循环删除。未找到元素则会触发ValueError异常

例子：

l =  [1, 2, 3, 4, 5]
l.remove(1)
# [2, 3, 4, 5]

3. 移除指定位置的元素

格式：

list.pop([i])

删除列表中指定位置的元素，并返回被删除的元素。未指定位置时，list.pop()删除并返回列表最后一个元素；

如果列表为空 或 指定的索引超出范围，则会触发IndexError异常;

例子：

>>> l = [1, 2, 3, 4, 5]
>>> l.pop()
5
>>> l
[1, 2, 3, 4]
>>> l.pop(2)
3
>>> l
[1, 2, 4]

4. 删除所有元素

格式：

list.clear()

删除列表里所有的元素，相当于del list[:]

例子：

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

查找元素所在索引

格式：

list.index(x[, start[, end]])

查找列表中某个元素第一个匹配项的索引位置；如果未查询到，则会触发ValueError异常

例子：

l = [1, 2, 3, 4, 5]
l.index(2)
# 1

元素出现次数

格式：

list.count(x)

返回列表中元素x出现的次数；

例子：

l = ['a', 'e',  'a', 'c']
l.count('a')
# 2

排序

1. sort对列表永久排序

格式：

list.sort(*, key=None, reverse=Falsse)

直接对原列表进行排序，没有返回值；如果指定参数，则使用比较函数指定的比较函数进行排序

• key：主要用来进行比较的元素，只有一个参数，具体的函数的参数就取自于可迭代对象中，指定迭代对象中的一个元素来进行排序；
• reverse：排序规则；True：降序；False：升序；

例子：

l = ['123', 'abc',  'python', 'Golang', 't']
l.sort()
# ['123', 'Golang', 'abc', 'python', 't']

l.sort(reverse=True)
# ['t', 'python', 'abc', 'Golang', '123']

l = [(1, 2), (5, 10), (2, 11), (100, 4)]
l.sort(key=lambda x: x[0])
# [(1, 2), (2, 11), (5, 10), (100, 4)]

2. sorted临时排序

格式：

sorted(iterable, /, *, key=None, reverse=False)

对所有可迭代对象进行排序操作；返回重新排序的列表，不影响原列表的顺序；原列表顺序不变；

• key：主要用来第进行比较的元素进行处理，只有一个参数，可以是一个函数，也可以是一个类。通过key对迭代对象中的元素进行处理，用处理后的值进行排序；
• reverse：排序规则；True：降序；False：升序；
  例子：

例子：

l = ['123', 'abc',  'python', 'Golang', 't']
sorted(l)
# l1: ['123', 'Golang', 'abc', 'python', 't']
# l: ['123', 'abc',  'python', 'Golang', 't']

3. 翻转列表

格式：

list.reverse()

翻转列表中的元素

例子：

l = ['a', 'd', 'f', 'e', 'u']
l.reverse()
# ['u', 'e', 'f', 'd', 'a'