python列表操作

对序列使用+和*

Python 程序员会默认序列是支持 + 和 * 操作的。通常 + 号两侧的序列由相同类型的数据所构成，在拼接的过程中，两个被操作的序列都不会被修改，Python 会新建一个包含同样类型数据的序列来作为拼接的结果。

把一个序列复制几份然后再拼接起来：

l = [1, 2, 3] print(l * 5) # [1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3] print(5 * 'abcd') # abcdabcdabcdabcdabcd 

建立由列表组成的列表

有时我们会需要初始化一个嵌套着几个列表的列表，譬如一个列表可能需要用来存放不同的学生名单，或者是一个井字游戏板 上的一行方块。想要达成这些目的，最好的选择是使用列表推导。

board = [['_'] * 3 for i in range(3)] print(board) board[1][2] = 'X' print(board) 

错误做法：

# 下面的列表其实包含 3 个指向同一个列表的引用。当我们不做修改的时候，看起来都还好 weird_board = [['_'] * 3] * 3 print(weird_board) # 试图标记第 1 行第 2 列的元素，就立马暴露了列表内的3个引用指向同一个对象的事实 weird_board[1][2] = 'O' print(weird_board) 

序列的增量赋值

增量赋值运算符 += 和 *= 的表现取决于它们的第一个操作对象。+= 背后的特殊方法是 __iadd__ （用于“就地加法”）。但是如果一个类没有实现这个方法的话，Python 会退一步调用 __add__ 。

以下面一个简单表达式为例：

 a += b 

如果 a 实现了 __iadd__ 方法，就会调用这个方法。同时对可变序列（例如 list、bytearray 和 array.array）来说，a 会就地改动，就像调用了 a.extend(b) 一样。但是如果 a 没有实现 __iadd__ 的话，a+= b 这个表达式的效果就变得跟 a = a + b 一样了：首先计算 a +b，得到一个新的对象，然后赋值给 a。也就是说，在这个表达式中，变量名会不会被关联到新的对象，完全取决于这个类型有没有实现__iadd__ 这个方法。

总体来讲，可变序列一般都实现了 __iadd__ 方法，因此 += 是就地加法。上面所说的这些关于 += 的概念也适用于 *=，不同的是，后者相对应的是 __imul__。

*= 在可变和不可变序列上的作用：

l = [1, 2, 3] print(id(l)) # 185123464 l *= 2 print(l) # [1, 2, 3, 1, 2, 3] print(id(l)) # 185123464 t = (1, 2, 3) print(id(t)) # 35891096 t *= 2 print(t) # (1, 2, 3, 1, 2, 3) print(id(t)) # 35453832 

对不可变序列进行重复拼接操作的话，效率会很低，因为每次都有一个新对象，而解释器需要把原来对象中的元素先复制到新的对象里，然后再追加新的元素。¹

list.sort方法和内置函数sorted²

list.sort 方法会就地排序列表，也就是说不会把原列表复制一份。这也是这个方法的返回值是 None 的原因，提醒你本方法不会新建一个列表。

python惯例：如果一个函数或者方法对对象进行的是就地改动，那它就应该返回 None³。

与 list.sort 相反的是内置函数 sorted，它会新建一个列表作为返回值。这个方法可以接受任何形式的可迭代对象作为参数，甚至包括不可变序列或生成器。而不管 sorted 接受的是怎样的参数，它最后都会返回一个列表。

关键字参数	list.sort	sorted	描述
reverse	●	●	为 True，被排序的序列里的元素会以降序输出。默认值为False。
key4	●	●	一个只有一个参数的函数，这个函数会被用在序列里的每一个元素上，所产生的结果将是排序算法依赖的对比关键字。例如，在对一些字符串排序时，可以用 key=str.lower 来实现忽略大小写的排序，或者是用 key=len 进行基于字符串长度的排序。这个参数的默认值是恒等函数（identity function），默认用元素自己的值来排序。

示例：

fruits = ['grape', 'raspberry', 'apple', 'banana'] print(sorted(fruits)) # ['apple', 'banana', 'grape', 'raspberry'] print(fruits) # ['grape', 'raspberry', 'apple', 'banana'] print(sorted(fruits, reverse=True)) # ['raspberry', 'grape', 'banana', 'apple'] # 排序算法稳定，grape和apple的相对位置不变。 print(sorted(fruits, key=len)) # ['grape', 'apple', 'banana', 'raspberry'] print(sorted(fruits, key=len, reverse=True)) # ['raspberry', 'banana', 'grape', 'apple'] print(fruits) # ['grape', 'raspberry', 'apple', 'banana'] fruits.sort() print(fruits) # ['apple', 'banana', 'grape', 'raspberry'] 

Python 的排序算法——Timsort⁵——是稳定的，意思是就算两个元素比不出大小，在每次排序的结果里它们的相对位置是固定的。

用bisect来管理已排序的序列

bisect 模块包含两个主要函数，bisect 和 insort，两个函数都利用二分查找算法来在有序序列中查找或插入元素。

用bisect来搜索

bisect(haystack, needle) 在 haystack（干草垛）里搜索needle（针）的位置，该位置满足的条件是，把 needle 插入这个位置之后，haystack 还能保持升序。也就是在说这个函数返回的位置前面的值，都小于或等于 needle 的值。其中 haystack 必须是一个有序的序列。你可以先用 bisect(haystack, needle) 查找位置 index，再用 haystack.insert(index, needle) 来插入新值。但你也可用insort 来一步到位，并且后者的速度更快一些。

在有序序列中用 bisect 查找某个元素的插入位置:

bisect_demo.py

import bisect import sys

HAYSTACK = [1, 4, 5, 6, 8, 12, 15, 20, 21, 23, 23, 26, 29, 30] NEEDLES = [0, 1, 2, 5, 8, 10, 22, 23, 29, 30, 31] ROW_FMT = '{0:2d} @ {1:2d}    {2}{0:<2d}' def demo(bisect_fn): for needle in reversed(NEEDLES): # 倒序，美观点 position = bisect_fn(HAYSTACK, needle) # 用bisect计算元素出现的位置 offset = position * '  |' # 需要的分隔符号个数 print(ROW_FMT.format(needle, position, offset)) # 打印出元素和位置 if __name__ == '__main__': if sys.argv[-1] == 'left': # 根据命令上最后一个参数来选用 bisect 函数 bisect_fn = bisect.bisect_left else: bisect_fn = bisect.bisect print('DEMO:', bisect_fn.__name__) # 把选定的函数在抬头打印出来 print('haystack ->', ' '.join('%2d' % n for n in HAYSTACK)) demo(bisect_fn) 

$ python3 bisect_demo.py # 命令行运行bisect_demo.py 

#--------------------结果-------------------------------
DEMO: bisect_right
haystack ->  1  4  5  6  8 12 15 20 21 23 23 26 29 30
31 @ 14      |  |  |  |  |  |  |  |  |  |  |  |  |  |31
30 @ 14      |  |  |  |  |  |  |  |  |  |  |  |  |  |30
29 @ 13      |  |  |  |  |  |  |  |  |  |  |  |  |29
23 @ 11      |  |  |  |  |  |  |  |  |  |  |23
22 @  9      |  |  |  |  |  |  |  |  |22
10 @  5      |  |  |  |  |10
 8 @  5      |  |  |  |  |8 
 5 @  3      |  |  |5 
 2 @  1      |2 
 1 @  1      |1 
 0 @  0    0 

bisect可以用它的两个可选参数——lo 和 hi——来缩小搜寻的范围。lo的默认值是 0，hi 的默认值是序列的长度。

bisect 函数其实是 bisect_right 函数的别名，后者还有个姊妹函数叫 bisect_left。它们的区别在于，bisect_left 返回的插入位置是原序列中跟被插入元素相等的元素的位置，也就是新元素会被放置于它相等的元素的前面。

$ python3 bisect_demo.py left 

DEMO: bisect_left
haystack -> 1 4 5 6 8 12 15 20 21 23 23 26 29 30 31 @ 14 | | | | | | | | | | | | | |31 30 @ 13 | | | | | | | | | | | | |30 29 @ 12 | | | | | | | | | | | |29 23 @ 9 | | | | | | | | |23 22 @ 9 | | | | | | | | |22 10 @ 5 | | | | |10 8 @ 4 | | | |8 5 @ 2 | |5 2 @ 1 |2 1 @ 0 1 0 @ 0 0 

bisect可以用来建立一个用数字作为索引的查询表格，比如对应分数和成绩评级⁶:

def grade(score, breakpoints=[60, 70, 80, 90], grades='FDCBA'): """根据一个分数，找到它所对应的等级""" i = bisect.bisect(breakpoints, score) return grades[i] print([grade(score) for score in [33, 99, 77, 70, 89, 90, 100]]) # ['F', 'A', 'C', 'C', 'B', 'A', 'A'] 

bisect.insort插入新元素

insort(seq, item) 把变量item插入到序列seq中，并能保持seq的升序顺序。

insort 可以保持有序序列的顺序：

import bisect import random

SIZE = 7 random.seed(1729) # 随机数的种子 my_list = [] for i in range(SIZE): new_item = random.randrange(SIZE * 2) # 从 0-SIZE*2选取一个随机数 bisect.insort(my_list, new_item) print('%2d ->' % new_item, my_list) #-----------------结果---------------- 10 -> [10] 0 -> [0, 10] 6 -> [0, 6, 10] 8 -> [0, 6, 8, 10] 7 -> [0, 6, 7, 8, 10] 2 -> [0, 2, 6, 7, 8, 10] 10 -> [0, 2, 6, 7, 8, 10, 10] 

insort 跟 bisect 一样，有 lo 和 hi 两个可选参数用来控制查找的范围。它也有个变体叫 insort_left，这个变体在背后用的是bisect_left。

目前所提到的内容都不仅仅是对列表或者元组有效，还可以应用于几乎所有的序列类型上。如果你只需要处理数字列表的话，数组可能是个更好的选择。

当列表不是首选时

数组

如果我们需要一个只包含数字的列表，那么 array.array 比 list 更高效。数组支持所有跟可变序列有关的操作，包括 .pop、.insert 和.extend。另外，数组还提供从文件读取和存入文件的更快的方法，如.frombytes 和 .tofile。

Python 数组跟 C 语言数组一样精简。创建数组需要一个类型码，这个类型码用来表示在底层的 C 语言应该存放怎样的数据类型。比如 b 类型码代表的是有符号的字符（signed char），因此 array('b') 创建出的数组就只能存放一个字节大小的整数，范围从 -128 到 127，这样在序列很大的时候，我们能节省很多空间。而且 Python 不会允许你在数组里存放除指定类型之外的数据。

创建一个有1000万个随机浮点数的数组，把这个数组存放到文件里，再从文件读取这个数组：

from array import array from random import random

floats = array('d', (random() for i in range(10 ** 7))) # 建立一个双精度浮点数组（类型码是 'd'） print(floats[-1]) # 0.07802343889111107 fp = open('floats.bin', 'wb') floats.tofile(fp) # 将数组存入一个二进制文件里 fp.close() floats2 = array('d') # 新建一个双精度浮点空数组 fp = open('floats.bin', 'rb') floats2.fromfile(fp, 10 ** 7) # 把1000万个浮点数从二进制文件里读取出来 fp.close() print(floats2[-1]) # 0.07802343889111107 print(floats2 == floats) # True 

用 array.fromfile 从一个二进制文件里读出 1000 万个双精度浮点数只需要 0.1 秒，这比从文本文件里读取的速度要快 60倍，因为后者会使用内置的 float 方法把每一行文字转换成浮点数。另外，使用 array.tofile 写入到二进制文件，比以每行一个浮点数的方式把所有数字写入到文本文件要快 7 倍。另外，1000 万个这样的数在二进制文件里只占用 80 000 000 个字节（每个浮点数占用 8 个字节，不需要任何额外空间），如果是文本文件的话，我们需要 181 515 739个字节。

另外一个快速序列化数字类型的方法pickle模块。pickle.dump 处理浮点数组的速度几乎跟 array.tofile 一样快。不过前者可以处理几乎所有的内置数字类型，包含复数、嵌套集合，甚至用户自定义的类。前提是这些类没有什么特别复杂的实现。

方法或属性	列表	数组	详解
s.__add__(s2)	●	●	s + s2，拼接
s.__iadd__(s2)	●	●	s += s2，就地拼接
s.append(e)	●	●	在尾部添加一个新元素
s.byteswap		●	翻转数组内每个元素的字节序列，转换字节序
s.clear()	●		删除所有元素
s.__contains__(e)	●	●	s 是否包含 e
s.copy()	●		列表的浅复制
s.__copy__()		●	对 copy.copy 的支持
s.count(e)	●	●	s 中 e 出现的次数
s.__deepcopy__()		●	对 copy.deepcopy 的支持
s.__delitem__(p)	●	●	删除位置 p 的元素
s.extend(it)	●	●	将可迭代对象 it 里的元素添加到尾部
s.frombytes(b)		●	将压缩成机器值的字节序列读出来添加到尾部
s.fromfile(f, n)		●	将二进制文件 f 内含有机器值读出来添加到尾部，最多添加 n 项
s.fromlist(l)		●	将列表里的元素添加到尾部，如果其中任何一个元素导致了 TypeError 异常，那么所有的添加都会取消
s.__getitem__(p)	●	●	s[p]，获取位置 p 的元素
s.index(e)	●	●	在 s 中找到元素 e 第一次出现的位置
s.insert(p, e)	●	●	在位置 p 之前插入元素e
s.itemsize		●	数组中每个元素的长度是几个字节
s.__iter__()	●	●	获取 s 的迭代器
s.__len__()	●	●	len(s)，元素的数量
s.__mul__(n)	●	●	s * n，n 个 s 的重复拼接
s.__imul__(n)	●	●	s *= n，就地重复拼接
s.__rmul__(n)	●	●	n * s，反向拼接 *
s.pop([p])	●	●	删除最后或者是（可选的）位于 p 的元素，并返回它的值
s.remove(e)	●	●	删除 s 中的第一次出现的 e
s.reverse()	●	●	就地把 s 的元素倒序排列
s.__reversed__()	●		返回 s 的倒序迭代器
s.__setitem__(p,e)	●	●	s[p] = e，把元素 e 放在位置p，替代已经在那个位置的元素
s.sort([key],[reverse])	●		就地对 s 中的元素进行排序，可选的参数有键（key）和是否倒序（reverse）
s.tobytes()		●	返回 s 的倒序迭代器
s.tofile(f)		●	返回 s 的倒序迭代器
s.tolist()		●	返回 s 的倒序迭代器
s.typecode		●	返回只有一个字符的字符串，代表数组元素在 C 语言中的类型

从 Python 3.4 开始，数组类型不再支持诸如 list.sort() 这种就地排序方法。要给数组排序的话，得用 sorted 函数新建一个数组：

a = array.array(a.typecode, sorted(a)) 

想要在不打乱次序的情况下为数组添加新的元素，bisect.insort还是能派上用场。

---

1. str 是一个例外，因为对字符串做 += 实在是太普遍了，所以 CPython 对它做了优化。为 str初始化内存的时候，程序会为它留出额外的可扩展空间，因此进行增量操作的时候，并不会涉及复制原有字符串到新位置这类操作。 ↩︎

2. B2中涉及到sorted排序的位置：1.14 排序不支持原生比较的对象。 ↩︎

3. 用返回 None 来表示就地改动这个惯例有个弊端，那就是调用者无法将其串联起来。而返回一个新对象的方法（比如说 str 里的所有方法）则正好相反，它们可以串联起来调用，从而形成连贯接口（fluent interface）。 ↩︎

4. 可选参数 key 还可以在内置函数 min() 和 max() 中起作用。另外，还有些标准库里的函数也接受这个参数，像itertools.groupby() 和 heapq.nlargest() 等。 ↩︎

5. Timsort是结合了合并排序（merge sort）和插入排序（insertion sort）而得出的排序算法，它在现实中有很好的效率。Tim Peters在2002年设计了该算法并在Python中使用（TimSort 是 Python 中 list.sort 的默认实现）。该算法找到数据中已经排好序的块-分区，每一个分区叫一个run，然后按规则合并这些run。Pyhton自从2.3版以来一直采用Timsort算法排序，现在Java SE7和Android也采用Timsort算法对数组排序。 ↩︎

6. 示例代码来自 bisect 模块的文档。文档里列举了一些利用bisect的函数，它们可以在很长的有序序列中作为 index 的替代，用来更快地查找一个元素的位置。 ↩︎

本文地址：https://blog.csdn.net/qq_35289736/article/details/108986644