一学就废|Python基础碎片，列表(List)

        列表(数组)是一种常见的数据结构，通常，列表的共性操作包括获取、设置、搜索、过滤和排序。以下是对列表的一些常用的操作方法。

基本操作

        我们可以在 Python 中操作列表的方法有很多。在我们开始学习这些通用操作之前，以下片段显示了列表最常见的操作。

a = [1, 2, 3, 4, 5]
# 判断列表中是否含有某元素
2 in a
True


# 通过正数索引获取值
a[0]
1

# 通过负数索引获取值
a[-1]
5

# 切片[开始:结束:步长]
a[1:]
[2, 3, 4, 5]

a[1:-1]
[2, 3, 4]

a[1:-1:2]
[2, 4]

# 列表逆向输出
a[::-1]
[5, 4, 3, 2, 1]

a[:0:-1]
[5, 4, 3, 2]

# 赋值
a[0] = 0
a
[0, 2, 3, 4, 5]

# 向列表中添加元素或对象
a.append(6)
a
[0, 2, 3, 4, 5, 6]

a.extend([7, 8, 9])
a
[0, 2, 3, 4, 5, 6, 7, 8, 9]

# 删除元素值
del a[-1]
a
[0, 2, 3, 4, 5, 6, 7, 8]

# 推导式生成列表
b = [x for x in range(3)]
b
[0, 1, 2]

# 两个列表合并，不会去重
a + b
[0, 2, 3, 4, 5, 6, 7, 8, 0, 1, 2]

初始化

        一般来说，如果列表表达式中的项目是不可变对象，我们可以通过 * 运算符创建一个列表。

a = [None] * 3
a
[None, None, None]

a[0] = "foo"
a
['foo', None, None]

        然而，如果列表表达式中的项目是可变对象，* 运算符将复制该项目的引用 N 次。为了避免这个陷阱，我们应该使用列表推导来初始化列表。

a = [[]] * 3
b = [[] for _ in range(3)]

a[0].append("Hello")
a
[['Hello'], ['Hello'], ['Hello']]

b[0].append("Python")
b
[['Python'], [], []]

列表复制

        将列表分配给变量是一个常见的陷阱。此赋值不会将列表复制到变量。变量仅引用列表并增加列表的引用计数。

import sys
>>> a = [1, 2, 3]
>>> sys.getrefcount(a)
2
>>> b = a
>>> sys.getrefcount(a)
3
>>> b[2] = 123456  # a[2] = 123456
>>> b
[1, 2, 123456]
>>> a
[1, 2, 123456]

        拷贝有两种，第一种叫浅拷贝（非递归拷贝），第二种叫深拷贝（递归拷贝），很多时候我们用浅拷贝的方式拷贝一个列表就足够了，但是如果一个列表是嵌套的，就得用深拷贝。

# 浅拷贝
a = [1, 2]
b = list(a)
b[0] = 123
a
[1, 2]

b
[123, 2]

a = [[1], [2]]
b = list(a)
b[0][0] = 123
a
[[123], [2]]

b
[[123], [2]]

# 深拷贝
import copy
a = [[1], [2]]
b = copy.deepcopy(a)
b[0][0] = 123
a
[[1], [2]]

b
[[123], [2]]

列表推导式

[x for x in range(10)]
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

[(lambda x: x**2)(i) for i in range(10)]
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

[x for x in range(10) if x > 5]
[6, 7, 8, 9]

[x if x > 5 else 0 for x in range(10)]
[0, 0, 0, 0, 0, 0, 6, 7, 8, 9]

[x + 1 if x < 5 else x + 2 if x > 5 else x + 5 for x in range(10)]
[1, 2, 3, 4, 5, 10, 8, 9, 10, 11]

[(x, y) for x in range(3) for y in range(2)]
[(0, 0), (0, 1), (1, 0), (1, 1), (2, 0), (2, 1)]

列表拆包

        有时，我们想将列表解压缩为变量，以使我们的代码变得更具可读性。在这种情况下，我们将 N 个元素分配给 N 个变量，如下例所示。

arr = [1, 2, 3]
a, b, c = arr
a, b, c
(1, 2, 3)

        在 Python 3 中，我们可以使用单个星号将 N 个元素解包到数量少于 N 的变量中。

arr = [1, 2, 3, 4, 5]
a, b, *c, d = arr

a, b, d
(1, 2, 5)

c
[3, 4]

使用枚举

        enumerate 是一个内置函数。它帮助我们同时获取索引（或计数）和元素，而无需使用 range（len（list））的写法。

for i, v in enumerate(range(3)):
    print(i, v)

0 0
1 1
2 2

for i, v in enumerate(range(3), 1): # start = 1
    print(i, v)

1 0
2 1
3 2

zip函数

        zip 使我们能够一次遍历多个列表中包含的项目。每当其中一个列表用尽时，迭代就会停止。结果，迭代的长度与最短列表相同。如果不希望这种行为，我们可以使用 itertools。zip_longest 在 Python 3 或 itertools。izip_longest 在 Python 2 中。

a = [1, 2, 3]
b = [4, 5, 6]
list(zip(a, b))
[(1, 4), (2, 5), (3, 6)]

c = [1]
list(zip(a, b, c))
[(1, 4, 1)]

from itertools import zip_longest
list(zip_longest(a, b, c))
[(1, 4, 1), (2, 5, None), (3, 6, None)]

filter函数

        filter 是一个内置函数，帮助我们删除不必要的元素。在 Python 2 中，filter 返回一个列表。但是，在 Python 3 中，filter 返回一个可迭代对象。请注意，列表推导或生成器表达式提供了一种更简洁的方法来顾虑列表中的元素。

[x for x in range(5) if x > 1]
[2, 3, 4]

l = ['1', '2', 3, 'Hello', 4]
f = lambda x: isinstance(x, int)
filter(f, l)
<filter object at 0x10bee2198>

list(filter(f, l))
[3, 4]

list((i for i in l if f(i)))
[3, 4]

排序

        Python list 提供了一个内置的 list. sort 方法，可以在不使用额外内存的情况下对列表进行就地排序。此外，list.sort 的返回值为无，以避免与 sorted 混淆，该函数只能用于 list。

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

# 倒序
l.sort(reverse=True)
l
[5, 4, 3, 2, 1]

        sorted 函数不会就地修改任何可迭代对象。相反，它返回一个新的排序列表。如果某些列表的元素是只读的或不可变的，使用 sorted 比 list. sort 更安全。此外，list.sorted 和 sorted 的另一个区别是 sorted 接受任何可迭代对象。

l = [5, 4, 3, 2, 1]
new = sorted(l)
new
[1, 2, 3, 4, 5]

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

d = {3: 'andy', 2: 'david', 1: 'amy'}
sorted(d)  # sort iterable
[1, 2, 3]

        要对元素为元组的列表进行排序，使用 operator. itemgetter 很有帮助，因为它为排序的键参数分配了一个键函数。请注意，键应该是可比较的；否则，它将引发 TypeError。

from operator import itemgetter
l = [('andy', 10), ('david', 8), ('amy', 3)]
l.sort(key=itemgetter(1))
l
[('amy', 3), ('david', 8), ('andy', 10)]

        operator. itemgetter 很有用，因为该函数返回一个 getter 方法，该方法可以用方法__getitem__应用于其他对象。例如，由于所有元素都__getitem__，因此可以使用 operator.itemgetter 对包含其元素的列表进行排序。

from pprint import pprint
from operator import itemgetter
l = [
    {'name': 'andy', 'age': 10},
    {'name': 'david', 'age': 8},
    {'name': 'amy', 'age': 3},
]
l.sort(key=itemgetter('age'))

pprint(l)
[{'age': 3, 'name': 'amy'},
 {'age': 8, 'name': 'david'},
 {'age': 10, 'name': 'andy'}]