《流畅的Python》 读书笔记 第二章数据结构(2) 231011
2.5 對(duì)序列使用+和*
通常 + 號(hào)兩側(cè)的序列由相同類(lèi)型的數(shù)據(jù)所構(gòu)成，在拼接的過(guò)程中，兩個(gè)被操作的序列都不會(huì)被修改，Python 會(huì)新建一個(gè)包含同樣類(lèi)型數(shù)據(jù)的序列來(lái)作為拼接的結(jié)果
+和*都遵循這個(gè)規(guī)律，不修改原有的操作對(duì)象，而是構(gòu)建一個(gè)全新的序列
l1 = [1,2,3]
l2 = [4,5,6]
print(id(l1))
print(id(l2))
l3 = l1+l2
print(id(l3)) # 變了
l4 = l1 * 3
print(id(l4)) # 變了
print(id(l1)) # 沒(méi)變
print(id(l2)) # 沒(méi)變
2.5.1 建立由列表組成的列表
如果在 a * n 這個(gè)語(yǔ)句中，序列 a 里的元素是對(duì)其他可變對(duì)象的引用的話(huà)，你就需要格外注意了
你想用my_list = [[]] * 3 來(lái)初始化一個(gè)由列表組成的列表，但是你得到的列表里包含的 3 個(gè)元素其實(shí)是 3 個(gè)引用，而且這 3 個(gè)引用指向的都是同一個(gè)列表
這一段在Python官方的doc中就有描述
參考: https://docs.python.org/zh-cn/3.9/library/stdtypes.html
board = [['_'] * 3 for i in range(3)]
print(board)
board[1][2] = 'X'
print(board)
other_board = [['_'] * 3] * 3
print(other_board)
other_board[1][2] = 'X'
print(other_board)
看完上面的代碼，你知道結(jié)果是什么嗎?
你要做啥，完全取決于你
# 第一個(gè)print
[['_', '_', '_'], ['_', '_', 'X'], ['_', '_', '_']]
# 第二個(gè)print
[['_', '_', 'X'], ['_', '_', 'X'], ['_', '_', 'X']]
2.6 序列的增量賦值
+= 背后的特殊方法是
__iadd__（用于“就地加法”）。但是如果一個(gè)類(lèi)沒(méi)有實(shí)現(xiàn)這個(gè)方法的話(huà)，Python 會(huì)退一步調(diào)用__add__
看下面的示例代碼就能很好的說(shuō)明這段
class A:
def __init__(self,age):
self.age = age
def __iadd__(self, other):
print('calling iadd')
self.age+=other.age
return self
class B:
def __init__(self,age):
self.age = age
def __add__(self, other):
print('calling add')
self.age+=other.age
return self
a1 = A(1)
a2 = A(2)
a1+=a2 # calling iadd
print(a1.age) # 3
b1 = B(1)
b2 = B(2)
b1+=b2 # calling add
print(b1.age) # 3
a += b
對(duì) 可 變 序 列（ 例 如 list、bytearray 和 array.array）來(lái)說(shuō)，a 會(huì)就地改動(dòng)，就像調(diào)用了 a.extend(b) 一樣
但是如果 a 沒(méi)有實(shí)現(xiàn)
__iadd__的話(huà)，a += b 這個(gè)表達(dá)式的效果就變得跟 a = a + b 一樣了：首先計(jì)算 a + b，得到一個(gè)新的對(duì)象，然后賦值給 a。也就是說(shuō)，在這個(gè)表達(dá)式中，變量名會(huì)不會(huì)被關(guān)聯(lián)到新的對(duì)象，完全取決于這個(gè)類(lèi)型有沒(méi)有實(shí)現(xiàn)__iadd__這個(gè)方法總體來(lái)講，可變序列一般都實(shí)現(xiàn)了
__iadd__方法，因此 += 是就地加法。而不可變序列根本就不支持這個(gè)操作，對(duì)這個(gè)方法的實(shí)現(xiàn)也就無(wú)從談起
我覺(jué)得說(shuō)的有點(diǎn)啰嗦了，從"也就是說(shuō)，在這個(gè)..."中的"這個(gè)"是有點(diǎn)歧義的。可以概括為
可變序列調(diào)用a+=b，就地加法，a不變
不可變序列調(diào)用a+=b，就會(huì)產(chǎn)生一個(gè)新的對(duì)象a(來(lái)自a+b的賦值)
看下面的例子，ae是不可變的， 因此做了+=后id都變了，而c是可變的，id沒(méi)有變化
a = 1
b = 2
print(id(a))
a += b
print(id(a))
c = [1]
print(id(c))
d = [2]
c +=d
print(id(c))
e = 'e'
print(id(e))
f = 'f'
e +=f
print(id(e))
+= 的概念也適用于 *=，不同的是，后者相對(duì)應(yīng)的是
__imul__
我在https://zhuanlan.zhihu.com/p/656429071 中對(duì)此參考官方文檔詳細(xì)的描述了
| 方法 | 說(shuō)明 |
|---|---|
__iadd__(self, other) |
+= |
__isub__(self, other) |
-= |
__imul__(self, other) |
*= |
__imatmul__(self, other) |
@= |
__itruediv__(self, other) |
/= |
__ifloordiv__(self, other) |
//= |
__imod__(self, other) |
%= |
__ipow__(self, other[,modulo]) |
**= |
__ilshift__(self, other) |
<<= |
__irshift__(self, other) |
>>= |
__iand__(self, other) |
&= |
__ixor__(self, other) |
^= |
__ior__(self, other) |
|= |
很重要的一句話(huà)
對(duì)不可變序列進(jìn)行重復(fù)拼接操作的話(huà)，效率會(huì)很低，因?yàn)槊看味加幸粋€(gè)新對(duì)象，而解釋器需要把原來(lái)對(duì)象中的元素先復(fù)制到新的對(duì)象里，然后再追加新的元素
2.6.1 一個(gè)關(guān)于+=的謎題
t = (1, 2, [30, 40])
t[2] += [50, 60]
到底會(huì)發(fā)生下面 4 種情況中的哪一種？
a. t 變成 (1, 2, [30, 40, 50, 60])。
b. 因?yàn)?tuple 不支持對(duì)它的元素賦值，所以會(huì)拋出 TypeError 異常。
c. 以上兩個(gè)都不是。
d. a 和 b 都是對(duì)的。
這種問(wèn)題一般來(lái)講，不用想，肯定是a、b中的一個(gè)，c可能性不大，d怎么都不可能（又異常又正常）
可答案就是d
稍作改動(dòng)你能看到異常也能看到改變后的t
t = (1, 2, [30, 40])
try:
t[2] += [50, 60]
except TypeError as e:
print(e)
print(t)
書(shū)中還對(duì)此展開(kāi)了字節(jié)碼
>>> s = [1,2,[3,4]]
>>> s = (1,2,[30,40])
>>> b = [50,60]
>>> import dis
>>> dis.dis('s[2]+=b') # 此處 原文是s[a]
1 0 LOAD_NAME 0 (s)
2 LOAD_CONST 0 (2)
4 DUP_TOP_TWO
6 BINARY_SUBSCR①
8 LOAD_NAME 1 (b)
10 INPLACE_ADD②
12 ROT_THREE
14 STORE_SUBSCR③
16 LOAD_CONST 1 (None)
18 RETURN_VALUE
上面是我的結(jié)果，跟書(shū)中的不太一樣(這種我就不懂了，懂的大神可以說(shuō)說(shuō))
對(duì)上面的①②③作者闡述了
? 將 s[a] 的值存入 TOS（Top Of Stack，棧的頂端）。
? 計(jì)算 TOS += b。這一步能夠完成，是因?yàn)?TOS 指向的是一個(gè)可變對(duì)象（也就是示例 2-15
里的列表）。
? s[a] = TOS 賦值。這一步失敗，是因?yàn)?s 是不可變的元組（示例 2-15 中的元組 t）。
至此我得到了 3 個(gè)教訓(xùn)。
? 不要把可變對(duì)象放在元組里面。
? 增量賦值不是一個(gè)原子操作。我們剛才也看到了，它雖然拋出了異常，但還是完成了操作。
? 查看 Python 的字節(jié)碼并不難，而且它對(duì)我們了解代碼背后的運(yùn)行機(jī)制很有幫助
難倒是不難，就是看不懂有點(diǎn)愁，背后都是C，全忘了~
有讀者提出，如果寫(xiě)成 t[2].extend([50, 60]) 就能避免這個(gè)異常。確實(shí)是這樣，但這個(gè)例子是為了
展示這種奇怪的現(xiàn)象而專(zhuān)門(mén)寫(xiě)的
2.7 list.sort方法和內(nèi)置函數(shù)sorted
Python 的一個(gè)慣例：如果一個(gè)函數(shù)或者方法對(duì)對(duì)象進(jìn)行的是就地改動(dòng)，那它就應(yīng)該返回None，好讓調(diào)用者知道傳入的參數(shù)發(fā)生了變動(dòng)，而且并未產(chǎn)生新的對(duì)象
list.sort就是這么一個(gè)例子，還要random.shuffle等
以前有學(xué)員問(wèn)為何返回是None，我總是回復(fù)，這個(gè)在于對(duì)方的設(shè)計(jì)，現(xiàn)在總算有了一個(gè)新的說(shuō)辭，聽(tīng)著還蠻高大上的。
用返回 None 來(lái)表示就地改動(dòng)這個(gè)慣例有個(gè)弊端，那就是調(diào)用者無(wú)法將其串聯(lián)起來(lái)。而返回一個(gè)新對(duì)象的方法（比如說(shuō) str 里的所有方法）則正好相反，它們可以串聯(lián)起來(lái)調(diào)用，從而形成連貫接口（fluent interface）。詳情參見(jiàn)維基百科中有關(guān)連貫接口的討論（https://en.wikipedia.org/wiki/Fluent_
interface）
我習(xí)慣稱(chēng)之為鏈?zhǔn)秸{(diào)用，就像selenium庫(kù)中ActionChains類(lèi)的API的調(diào)用
list.sort 方法還是 sorted 函數(shù)，都有兩個(gè)可選的關(guān)鍵字參數(shù)
| 參數(shù) | 說(shuō)明 |
|---|---|
| reverse | 如果被設(shè)定為 True，被排序的序列里的元素會(huì)以降序輸出（也就是說(shuō)把最大值當(dāng)作最小值來(lái)排序）。這個(gè)參數(shù)的默認(rèn)值是 False。 |
| key | 一個(gè)只有一個(gè)參數(shù)的函數(shù)，這個(gè)函數(shù)會(huì)被用在序列里的每一個(gè)元素上，所產(chǎn)生的結(jié)果將是排序算法依賴(lài)的對(duì)比關(guān)鍵字。比如說(shuō)，在對(duì)一些字符串排序時(shí)，可以用 key=str.lower 來(lái)實(shí)現(xiàn)忽略大小寫(xiě)的排序，或者是用 key=len 進(jìn)行基于字符串長(zhǎng)度的排序。這個(gè)參數(shù)的默認(rèn)值是恒等函數(shù)（identity function），也就是默認(rèn)用元素自己的值來(lái)排序 |
一個(gè)只有一個(gè)參數(shù)的函數(shù) 你會(huì)想到lambda吧~
作者給的例子
>>> fruits = ['grape', 'raspberry', 'apple', 'banana']
>>> sorted(fruits)
['apple', 'banana', 'grape', 'raspberry'] ?
>>> fruits
['grape', 'raspberry', 'apple', 'banana'] ?
>>> sorted(fruits, reverse=True)
['raspberry', 'grape', 'banana', 'apple'] ?
>>> sorted(fruits, key=len)
['grape', 'apple', 'banana', 'raspberry'] ?
>>> sorted(fruits, key=len, reverse=True)
['raspberry', 'banana', 'grape', 'apple'] ?
>>> fruits
['grape', 'raspberry', 'apple', 'banana'] ?
>>> fruits.sort() ?
>>> fruits
['apple', 'banana', 'grape', 'raspberry'] ?
我在https://zhuanlan.zhihu.com/p/658316452中也詳細(xì)闡述了一些簡(jiǎn)單的用法
可選參數(shù) key 還可以在內(nèi)置函數(shù) min() 和 max() 中起作用。另外，還有些標(biāo)準(zhǔn)庫(kù)里的函數(shù)也接受這個(gè)參數(shù)，像 itertools.groupby() 和 heapq.nlargest() 等
headq示例代碼
import heapq
# 創(chuàng)建一個(gè)列表
numbers = [1,-4,3,10,-15,9]
# 使用 heapq.nlargest() 并設(shè)置 key 參數(shù)為 square（平方）
largest_three = heapq.nlargest(3, numbers, key=lambda x: x ** 2)
print(largest_three) # 輸出：[-15, 10, 9]
groupby示例代碼
from itertools import groupby
# 示例數(shù)據(jù)，假設(shè)這是一組學(xué)生的成績(jī)記錄，每個(gè)學(xué)生有姓名和數(shù)學(xué)成績(jī)
students = [('Alice', 90), ('Bob', 80), ('Charlie', 85), ('David', 90), ('Eva', 85)]
# 使用 lambda 函數(shù)將學(xué)生按照數(shù)學(xué)成績(jī)進(jìn)行分組
grouped_students = groupby(sorted(students, key=lambda x: x[1]), key=lambda x: x[1])
# 遍歷每個(gè)組并打印組名（數(shù)學(xué)成績(jī)）和組中的學(xué)生列表
for name, group in grouped_students:
print(f"Group name: {name}")
for student in group:
print(f" - {student[0]}")
示例輸出
Group name: 80
- Bob
Group name: 85
- Charlie
- Eva
Group name: 90
- Alice
- David
2.8 用bisect來(lái)管理已排序的序列
bisect 模塊包含兩個(gè)主要函數(shù)，bisect 和 insort，兩個(gè)函數(shù)都利用二分查找算法來(lái)在有序序列中查找或插入元素
2.8.1 用bisect來(lái)搜索
Bisection 二分法
bisect(haystack, needle)
haystack 干草垛是一個(gè)已經(jīng)排好序的序列
needle是待插入的針
插入完畢后的newstack依然是有序的
bisect(haystack, needle) 查找位置 index
haystack.insert(index,needle) 來(lái)插入新值
insort 可以一步到位，并且速度更快一些
bisect默認(rèn)情況下遇到等值，插入到右側(cè)(bisect = bisect_right)，bisect_left可以插入到左側(cè)
bisect_right(a, x, lo=0, hi=None) 完整的有4個(gè)參數(shù)，lo默認(rèn)是0即第一個(gè)數(shù)，hi默認(rèn)是len(a)
作者給的代碼，稍作更改
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 = 'Needle: {0:2d} ,index: {1:2d}==> {2}{0:<2d}'
def demo(bisect_fn):
for needle in reversed(NEEDLES):
position = bisect_fn(HAYSTACK, needle) #?
offset = position * ' |' #?
print(ROW_FMT.format(needle, position, offset)) #?
if __name__ == '__main__':
if sys.argv[-1] == 'left': #?
bisect_fn = bisect.bisect_left
else:
bisect_fn = bisect.bisect
print('DEMO:', bisect_fn.__name__) #?
print('haystack ->')
print(' ',' '.join('%2d' % n for n in HAYSTACK))
demo(bisect_fn)
作者的解釋
? 用特定的 bisect 函數(shù)來(lái)計(jì)算元素應(yīng)該出現(xiàn)的位置。
? 利用該位置來(lái)算出需要幾個(gè)分隔符號(hào)。
? 把元素和其應(yīng)該出現(xiàn)的位置打印出來(lái)。
? 根據(jù)命令上最后一個(gè)參數(shù)來(lái)選用 bisect 函數(shù)。
? 把選定的函數(shù)在抬頭打印出來(lái)
你可能看到的輸出是這樣的
DEMO: bisect_right
haystack ->
1 4 5 6 8 12 15 20 21 23 23 26 29 30
Needle: 31 ,index: 14==> | | | | | | | | | | | | | |31
Needle: 30 ,index: 14==> | | | | | | | | | | | | | |30
Needle: 29 ,index: 13==> | | | | | | | | | | | | |29
Needle: 23 ,index: 11==> | | | | | | | | | | |23
Needle: 22 ,index: 9==> | | | | | | | | |22
Needle: 10 ,index: 5==> | | | | |10
Needle: 8 ,index: 5==> | | | | |8
Needle: 5 ,index: 3==> | | |5
Needle: 2 ,index: 1==> |2
Needle: 1 ,index: 1==> |1
Needle: 0 ,index: 0==> 0
你可以執(zhí)行python demo.py left 得到不一樣的結(jié)果，這個(gè)代碼接受參數(shù)，只不過(guò)它處理的 是最后一個(gè)參數(shù)if sys.argv[-1] == 'left':
bisect一個(gè)經(jīng)典的案例，我在https://www.liujiangblog.com/course/python/57也看到過(guò)，第一次見(jiàn)的時(shí)候覺(jué)得還蠻厲害的，后來(lái)發(fā)現(xiàn)在官網(wǎng)就有了，https://docs.python.org/3/library/bisect.html
>>> def grade(score, breakpoints=[60, 70, 80, 90], grades='FDCBA'):
... i = bisect.bisect(breakpoints, score)
... return grades[i]
...
>>> [grade(score) for score in [33, 99, 77, 70, 89, 90, 100]]
['F', 'A', 'C', 'C', 'B', 'A', 'A']
通過(guò)計(jì)算score在breakpoints中的位置，得到對(duì)應(yīng)grades(必須要與breakpoints對(duì)應(yīng))的等級(jí)
雖然你可以用字典來(lái)做，但這個(gè)方法也是非常不錯(cuò)的案例
拓展閱讀
Raymond Hettinger 寫(xiě)了一個(gè)排序集合模塊（http://code.activestate.com/recipes/577197-sortedcollection
2.8.2 用bisect.insort插入新元素
insort(seq, item) 把變量 item 插入到序列 seq 中，并能保持 seq 的升序順序
import bisect
import random
SIZE=7
random.seed(1729)
my_list = []
for i in range(SIZE):
new_item = random.randrange(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的源碼很簡(jiǎn)單，底層就是bisect_right或bisect_left得到索引后用a.insert來(lái)插入
def insort_right(a, x, lo=0, hi=None):
lo = bisect_right(a, x, lo, hi)
a.insert(lo, x)
def insort_left(a, x, lo=0, hi=None):
lo = bisect_left(a, x, lo, hi)
a.insert(lo, x)
insort = insort_right
insort 跟 bisect 一樣，有 lo 和 hi 兩個(gè)可選參數(shù)用來(lái)控制查找的范圍
目前所提到的內(nèi)容都不僅僅是對(duì)列表或者元組有效，還可以應(yīng)用于幾乎所有的序列類(lèi)型上
如果是所有的序列類(lèi)型，那從源碼看，你得支持.insert才可以，元組其實(shí)就不支持了，你要實(shí)現(xiàn)必須轉(zhuǎn)換下
2.9 當(dāng)列表不是首選時(shí)
要存放1000 萬(wàn)個(gè)浮點(diǎn)數(shù)的話(huà)，數(shù)組（array）的效率要高得多，因?yàn)閿?shù)組在背后存的并不是 float
對(duì)象，而是數(shù)字的機(jī)器翻譯，也就是字節(jié)表述
如果需要頻繁對(duì)序列做先進(jìn)先出的操作，deque（雙端隊(duì)列）的速度應(yīng)該會(huì)更快。
如果在你的代碼里，包含操作（比如檢查一個(gè)元素是否出現(xiàn)在一個(gè)集合中）的頻率很高，用 set（集合）會(huì)更合適
用什么數(shù)據(jù)結(jié)構(gòu)是應(yīng)該利用數(shù)據(jù)結(jié)構(gòu)的特點(diǎn)再結(jié)合你的應(yīng)用場(chǎng)景而定的
下面這幾個(gè)我工作中反正是幾乎沒(méi)用過(guò)
2.9.1 數(shù)組 array
我也是一直把Python的list當(dāng)做array來(lái)處理的，其實(shí)不然
如果我們需要一個(gè)只包含數(shù)字的列表，那么 array.array 比 list 更高效
數(shù)組支持所有跟可變序列有關(guān)的操作，包括 .pop、.insert 和 .extend。另外，數(shù)組還提供從文件讀取和存
入文件的更快的方法，如 .frombytes 和 .tofile。
在Python的array.array函數(shù)中，第一個(gè)參數(shù)是一個(gè)表示類(lèi)型的代碼，它決定了數(shù)組中元素的數(shù)據(jù)類(lèi)型。以下是可以使用的類(lèi)型代碼：
'b'：布爾型（Boolean），取值為T(mén)rue（1）或False（0）。'B'：無(wú)符號(hào)布爾型（Unsigned Byte），取值為0或1。'u'：Unicode字符（Unicode Character）。'i'：有符號(hào)整數(shù)（Signed Integer）。'I'：無(wú)符號(hào)整數(shù)（Unsigned Integer）。'l'：長(zhǎng)整數(shù)（Long Integer）。'L'：無(wú)符號(hào)長(zhǎng)整數(shù)（Unsigned Long Integer）。'f'：浮點(diǎn)數(shù)（Floating Point）。'd'：十進(jìn)制浮點(diǎn)數(shù)（Decimal Floating Point）。'g'：十進(jìn)制浮點(diǎn)數(shù)或定點(diǎn)數(shù)（General Purpose）。
這些類(lèi)型代碼的長(zhǎng)度也代表了數(shù)組中元素的數(shù)據(jù)類(lèi)型的長(zhǎng)度，例如'i'代表的是有符號(hào)的整數(shù)類(lèi)型，長(zhǎng)度為當(dāng)前平臺(tái)下int的對(duì)齊長(zhǎng)度，而'B'則代表的是無(wú)符號(hào)的8位整數(shù)類(lèi)型。
請(qǐng)注意，創(chuàng)建的數(shù)組只能包含一種數(shù)據(jù)類(lèi)型的元素。
array('b') 創(chuàng)建出的數(shù)組就只能存放一個(gè)字節(jié)大小的整數(shù)，范圍從 -128 到127，這樣在序列很大的時(shí)候，我們能節(jié)省很多空間。而且 Python 不會(huì)允許你在數(shù)組里存放除指定類(lèi)型之外的數(shù)據(jù)
書(shū)中給出的代碼(稍作更改)
from array import array # 1
from random import random
floats1 = array('d', (random() for i in range(10**7))) # 2
print(floats1[-1]) # 3
with open('floats.bin', 'wb') as fp1: # 4
floats1.tofile(fp1)
floats2 = array('d') # 5
with open('floats.bin', 'rb') as fp2:
floats2.fromfile(fp2, 10**7) # 6
print(floats2[-1]) # 7
print(floats1 == floats2) # 8
? 引入 array 類(lèi)型。
? 利用一個(gè)可迭代對(duì)象來(lái)建立雙精度浮點(diǎn)數(shù)組（類(lèi)型碼是 'd'），這里我們用的可迭代對(duì)象是一個(gè)生成器表達(dá)式。
? 查看數(shù)組的最后一個(gè)元素。
? 把數(shù)組存入一個(gè)二進(jìn)制文件里。
? 新建一個(gè)雙精度浮點(diǎn)空數(shù)組。
? 把 1000 萬(wàn)個(gè)浮點(diǎn)數(shù)從二進(jìn)制文件里讀取出來(lái)。
? 查看新數(shù)組的最后一個(gè)元素。
? 檢查兩個(gè)數(shù)組的內(nèi)容是不是完全一樣。
劃下重點(diǎn)
- 用 array.fromfile 從一個(gè)二進(jìn)制文件里讀出 1000 萬(wàn)個(gè)雙精度浮點(diǎn)數(shù)只需要 0.1 秒，這比從文本文件里讀取的速度要快60 倍。
- 使用 array.tofile 寫(xiě)入到二進(jìn)制文件，比以每行一個(gè)浮點(diǎn)數(shù)的方式把所有數(shù)字寫(xiě)入到文本文件要快 7倍
- 1000 萬(wàn)個(gè)這樣的數(shù)在二進(jìn)制文件里只占用 80 000 000 個(gè)字節(jié)（每個(gè)浮點(diǎn)數(shù)占用8 個(gè)字節(jié)，不需要任何額外空間），如果是文本文件的話(huà)，我們需要 181 515 739 個(gè)字節(jié)(20多倍)
另外一個(gè)快速序列化數(shù)字類(lèi)型的方法是使用 pickle（https://docs.python.org/3/library/pickle.html）模塊。pickle.dump 處理浮點(diǎn)數(shù)組的速度幾乎跟 array.tofile 一樣快。不過(guò)前者可以處理幾乎所有的內(nèi)置數(shù)字類(lèi)型，包含復(fù)數(shù)、嵌套集合，甚至用戶(hù)自定義的類(lèi)。前提是這些類(lèi)沒(méi)有什么特別復(fù)雜的實(shí)現(xiàn)
| 操作 | 列表 | 數(shù)組 | 說(shuō)明 |
|---|---|---|---|
s.__add__(s2) |
√ | √ | s + s2 ，拼接 |
s.__iadd__(s2) |
√ | √ | s += s2 ，就地拼接 |
| s.append(e) | √ | √ | 在尾部添加一個(gè)元素 |
| s.byteswap | √ | 翻轉(zhuǎn)數(shù)組內(nèi)每個(gè)元素的字節(jié)序列，轉(zhuǎn)換字節(jié)序 | |
| s.clear() | √ | 刪除所有元素 | |
s.__contains__(e) |
√ | √ | s 是否含有 e |
| s.copy() | √ | 對(duì)列表淺復(fù)制 | |
s.__copy__() |
√ | 對(duì) copy.copy 的支持 | |
| s.count(e) | √ | √ | s 中 e 出現(xiàn)的次數(shù) |
s.__deepcopy__() |
√ | 對(duì) copy.deepcopy 的支持 | |
s.__delitem__(p) |
√ | √ | 刪除位置 p 的元素 |
| s.extend(it) | √ | √ | 將可迭代對(duì)象 it 里的元素添加到尾部 |
| s.frombytes(b) | √ | 將壓縮成機(jī)器值的字節(jié)序列讀出來(lái)添加到尾部 | |
| s.fromfile(f, n) | √ | 將二進(jìn)制文件 f 內(nèi)含有機(jī)器值讀出來(lái)添加到尾部，最多添加 n 項(xiàng) | |
| s.fromlist(l) | √ | 將列表里的元素添加到尾部，如果其中任何一個(gè)元素導(dǎo)致了TypeError 異常，那么所有的添加都會(huì)取消 | |
s.__getitem__(p) |
√ | √ | s[p]，讀取位置 p 的元素 |
| s.index(e) | √ | √ | 找到 e 在序列中第一次出現(xiàn)的位置 |
| s.insert(p, e) | √ | √ | 在位于 p 的元素之前插入元素 e |
| s.itemsize | √ | 數(shù)組中每個(gè)元素的長(zhǎng)度是幾個(gè)字節(jié) | |
s.__iter__() |
√ | √ | 返回迭代器 |
s.__len__() |
√ | √ | len(s)，序列的長(zhǎng)度 |
s.__mul__(n) |
√ | √ | s * n，重復(fù)拼接 |
s.__imul__(n) |
√ | √ | s *= n ，就地重復(fù)拼接 |
s.__rmul__(n) |
√ | √ | n * s ，反向重復(fù)拼接 * |
| s.pop([p]) | √ | √ | 刪除位于 p 的值并返回這個(gè)值，p 的默認(rèn)值是最后一個(gè)元素的位置 |
| s.remove(e) | √ | √ | 刪除序列里第一次出現(xiàn)的 e 元素 |
| s.reverse() | √ | √ | 就地調(diào)轉(zhuǎn)序列中元素的位置 |
s.__reversed__() |
√ | 返回一個(gè)從尾部開(kāi)始掃描元素的迭代器 | |
s.__setitem__(p, e) |
√ | √ | s[p] = e，把位于 p 位置的元素替換成 e |
| s.sort([key], [revers]) | √ | 就地排序序列，可選參數(shù)有 key 和 reverse | |
| s.tobytes() | √ | 把所有元素的機(jī)器值用 bytes 對(duì)象的形式返回 | |
| s.tofile(f) | √ | 把所有元素以機(jī)器值的形式寫(xiě)入一個(gè)文件 | |
| s.tolist() | √ | 把數(shù)組轉(zhuǎn)換成列表，列表里的元素類(lèi)型是數(shù)字對(duì)象 | |
| s.typecode | √ | 返回只有一個(gè)字符的字符串，代表數(shù)組元素在 C 語(yǔ)言中的類(lèi)型 |
從 Python 3.4 開(kāi)始，數(shù)組（array）類(lèi)型不再支持諸如 list.sort() 這種就地排序方法
要給數(shù)組排序的話(huà)，得用 sorted 函數(shù)新建一個(gè)數(shù)組：a = array.array(a.typecode, sorted(a))
2.9.2 內(nèi)存視圖 memoryview
memoryview 是一個(gè)內(nèi)置類(lèi)，它能讓用戶(hù)在不復(fù)制內(nèi)容的情況下操作同一個(gè)數(shù)組的不同切片
在數(shù)據(jù)結(jié)構(gòu)之間共享內(nèi)存。其中數(shù)據(jù)結(jié)構(gòu)可以是任何形式，比如 PIL 圖片、SQLite數(shù)據(jù)庫(kù)和 NumPy 的數(shù)組，等等。這個(gè)功能在處理大型數(shù)據(jù)集合的時(shí)候非常重要
示例 2-21 : 通過(guò)改變數(shù)組中的一個(gè)字節(jié)來(lái)更新數(shù)組里某個(gè)元素的值
>>> numbers = array.array('h', [-2, -1, 0, 1, 2])
>>> memv = memoryview(numbers) ?
>>> len(memv)
5
>>> memv[0] ?
-2
>>> memv_oct = memv.cast('B') ?
>>> memv_oct.tolist() ?
[254, 255, 255, 255, 0, 0, 1, 0, 2, 0]
>>> memv_oct[5] = 4 ?
>>> numbers
array('h', [-2, -1, 1024, 1, 2]) ?
? 利用含有 5 個(gè)短整型有符號(hào)整數(shù)的數(shù)組（類(lèi)型碼是 'h'）創(chuàng)建一個(gè) memoryview。
? memv 里的 5 個(gè)元素跟數(shù)組里的沒(méi)有區(qū)別。
? 創(chuàng)建一個(gè) memv_oct，這一次是把 memv 里的內(nèi)容轉(zhuǎn)換成 'B' 類(lèi)型，也就是無(wú)符號(hào)字符。
? 以列表的形式查看 memv_oct 的內(nèi)容。
? 把位于位置 5 的字節(jié)賦值成 4。
? 因?yàn)槲覀儼颜?2 個(gè)字節(jié)的整數(shù)的高位字節(jié)改成了 4，所以這個(gè)有符號(hào)整數(shù)的值就變成
了 1024。
2.9.3 NumPy和SciPy
這部分多少有點(diǎn)跑偏，簡(jiǎn)單瞄一眼就行了，我基本就是CTRL+C/V
憑借著 NumPy 和 SciPy 提供的高階數(shù)組和矩陣操作，Python 成為科學(xué)計(jì)算應(yīng)用的主流語(yǔ)言
NumPy 實(shí)現(xiàn)了多維同質(zhì)數(shù)組（homogeneous array）和矩陣，這些數(shù)據(jù)結(jié)構(gòu)不但能處理數(shù)字，還能存放其他由用戶(hù)定義的記錄
SciPy 是基于 NumPy 的另一個(gè)庫(kù)，它提供了很多跟科學(xué)計(jì)算有關(guān)的算法，專(zhuān)為線(xiàn)性代數(shù)、數(shù)值積分和統(tǒng)計(jì)學(xué)而設(shè)計(jì)
SciPy 把基于C 和 Fortran 的工業(yè)級(jí)數(shù)學(xué)計(jì)算功能用交互式且高度抽象的 Python 包裝起來(lái)
這些跟計(jì)算有關(guān)的部分都源自于 Netlib 庫(kù)（http://www.netlib.org）
示例 2-22：NumPy 二維數(shù)組的基本操
>>> import numpy ?
>>> a = numpy.arange(12) ?
>>> a
array([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11])
>>> type(a)
<class 'numpy.ndarray'>
>>> a.shape ?
(12,)
>>> a.shape = 3, 4 ?
>>> a
array([[ 0, 1, 2, 3],
[ 4, 5, 6, 7],
[ 8, 9, 10, 11]])
>>> a[2] ?
array([ 8, 9, 10, 11])
>>> a[2, 1] ?
9
>>> a[:, 1] ?
array([1, 5, 9])
>>> a.transpose() ?
array([[ 0, 4, 8],
[ 1, 5, 9],
[ 2, 6, 10],
[ 3, 7, 11]])
? 安裝 NumPy 之后，導(dǎo)入它（NumPy 并不是 Python 標(biāo)準(zhǔn)庫(kù)的一部分）。
? 新建一個(gè) 0~11 的整數(shù)的 numpy.ndarray，然后把它打印出來(lái)。
? 看看數(shù)組的維度，它是一個(gè)一維的、有 12 個(gè)元素的數(shù)組。
? 把數(shù)組變成二維的，然后把它打印出來(lái)看看。
? 打印出第 2 行。
? 打印第 2 行第 1 列的元素
? 把第 1 列打印出來(lái)。
? 把行和列交換，就得到了一個(gè)新數(shù)組
>>> import numpy
>>> floats = numpy.loadtxt('floats-10M-lines.txt') ?
>>> floats[-3:] ?
array([ 3016362.69195522, 535281.10514262, 4566560.44373946])
>>> floats *= .5 ?
>>> floats[-3:]
array([ 1508181.34597761, 267640.55257131, 2283280.22186973])
>>> from time import perf_counter as pc ?
>>> t0 = pc(); floats /= 3; pc() - t0 ?
0.03690556302899495
>>> numpy.save('floats-10M', floats) ?
>>> floats2 = numpy.load('floats-10M.npy', 'r+') ?
>>> floats2 *= 6
>>> floats2[-3:] ?
memmap([3016362.69195522, 535281.10514262, 4566560.44373946])
? 從文本文件里讀取 1000 萬(wàn)個(gè)浮點(diǎn)數(shù)。
? 利用序列切片來(lái)讀取其中的最后 3 個(gè)數(shù)。
? 把數(shù)組里的每個(gè)數(shù)都乘以 0.5，然后再看看最后 3 個(gè)數(shù)。
? 導(dǎo)入精度和性能都比較高的計(jì)時(shí)器（Python 3.3 及更新的版本中都有這個(gè)庫(kù)）。
? 把每個(gè)元素都除以 3，可以看到處理 1000 萬(wàn)個(gè)浮點(diǎn)數(shù)所需的時(shí)間還不足 40 毫秒。
? 把數(shù)組存入后綴為 .npy 的二進(jìn)制文件。
? 將上面的數(shù)據(jù)導(dǎo)入到另外一個(gè)數(shù)組里，這次 load 方法利用了一種叫作內(nèi)存映射的機(jī)制，
它讓我們?cè)趦?nèi)存不足的情況下仍然可以對(duì)數(shù)組做切片。
? 把數(shù)組里每個(gè)數(shù)乘以 6 之后，再檢視一下數(shù)組的最后 3 個(gè)數(shù)
2.9.4 雙向隊(duì)列和其他形式的隊(duì)列
利用 .append 和 .pop 方法，我們可以把列表當(dāng)作棧或者隊(duì)列來(lái)用（比如，把 .append和 .pop(0) 合起來(lái)用，就能模擬隊(duì)列的“先進(jìn)先出”的特點(diǎn)）
此處貼一下LeetCode 232 用棧實(shí)現(xiàn)隊(duì)列的某個(gè)題解，你能很好的理解上面這句話(huà)
class MyQueue:
def __init__(self):
self.A, self.B = [], []
def push(self, x: int) -> None:
self.A.append(x)
def pop(self) -> int:
peek = self.peek()
self.B.pop()
return peek
def peek(self) -> int:
if self.B: return self.B[-1]
if not self.A: return -1
# 將棧 A 的元素依次移動(dòng)至棧 B
while self.A:
self.B.append(self.A.pop())
return self.B[-1]
def empty(self) -> bool:
return not self.A and not self.B
但是刪除列表的第一個(gè)元素（抑或是在第一個(gè)元素之前添加一個(gè)元素）之類(lèi)的操作是很耗時(shí)的，因?yàn)檫@些操作會(huì)牽扯到移動(dòng)列表里的所有元素。
常見(jiàn)的列表操作的復(fù)雜度
| 列表操作 | 時(shí)間復(fù)雜度 |
|---|---|
| append | O(1) |
| list[0] 或 list[-1] 或 list[0] = 1 | O(1) # 下標(biāo)訪(fǎng)問(wèn)或賦值 |
| pop | O(1) |
| pop(index) | O(n) |
| insert | O(n) |
| del list[0] | O(n) |
| reverse | O(n) |
| sort | O(n log n) |
| sorted(list) | O(n log n) |
| remove | O(n) |
| list[a:b] | O(n) # 切片 |
| len(list) | O(1) |
| count | O(n) |
| n in nums | O(n) |
collections.deque 類(lèi)（雙向隊(duì)列）是一個(gè)線(xiàn)程安全、可以快速?gòu)膬啥颂砑踊蛘邉h除元素的數(shù)據(jù)類(lèi)型。而且如果想要有一種數(shù)據(jù)類(lèi)型來(lái)存放“最近用到的幾個(gè)元素”，deque 也是一個(gè)很好的選擇
示例 2-23 使用雙向隊(duì)列
>>> from collections import deque
>>> dq = deque(range(10), maxlen=10) ?
>>> dq
deque([0, 1, 2, 3, 4, 5, 6, 7, 8, 9], maxlen=10)
>>> dq.rotate(3) ?
>>> dq
deque([7, 8, 9, 0, 1, 2, 3, 4, 5, 6], maxlen=10)
>>> dq[1]
8
>>> dq[-1]
6
>>> dq.rotate(-4)
>>> dq
deque([1, 2, 3, 4, 5, 6, 7, 8, 9, 0], maxlen=10)
>>> dq.appendleft(-1) ?
>>> dq
deque([-1, 1, 2, 3, 4, 5, 6, 7, 8, 9], maxlen=10)
>>> dq.extend([11, 22, 33]) ?
>>> dq
deque([3, 4, 5, 6, 7, 8, 9, 11, 22, 33], maxlen=10)
>>> dq.extendleft([10, 20, 30, 40]) ?
>>> dq
deque([40, 30, 20, 10, 3, 4, 5, 6, 7, 8], maxlen=10)
? maxlen 是一個(gè)可選參數(shù)，代表這個(gè)隊(duì)列可以容納的元素的數(shù)量，而且一旦設(shè)定，這個(gè)屬性就不能修改了。
? 隊(duì)列的旋轉(zhuǎn)操作接受一個(gè)參數(shù) n，當(dāng) n > 0 時(shí)，隊(duì)列的最右邊的 n 個(gè)元素會(huì)被移動(dòng)到隊(duì)列的左邊。當(dāng) n < 0 時(shí)，最左邊的 n 個(gè)元素會(huì)被移動(dòng)到右邊。
? 當(dāng)試圖對(duì)一個(gè)已滿(mǎn)（len(d) == d.maxlen）的隊(duì)列做頭部appendleft添加操作的時(shí)候，它尾部的元素會(huì)被刪除掉。注意在下一行里，元素 0 被刪除了。
? 在尾部添加 3 個(gè)元素的操作會(huì)擠掉 -1、1 和 2(就是前三個(gè))。
? extendleft(iter) 方法會(huì)把迭代器里的元素逐個(gè)添加到雙向隊(duì)列的左邊，因此迭代器里的元素會(huì)逆序出現(xiàn)在隊(duì)列里。這非常有特點(diǎn)
雙向隊(duì)列實(shí)現(xiàn)了大部分列表所擁有的方法，也有一些額外的符合自身設(shè)計(jì)的方法，比如說(shuō)
popleft 和 rotate。但是為了實(shí)現(xiàn)這些方法，雙向隊(duì)列也付出了一些代價(jià)，從隊(duì)列中間刪
除元素的操作會(huì)慢一些，因?yàn)樗粚?duì)在頭尾的操作進(jìn)行了優(yōu)化。
append 和 popleft 都是原子操作，也就說(shuō)是 deque 可以在多線(xiàn)程程序中安全地當(dāng)作先進(jìn)先
出的隊(duì)列使用，而使用者不需要擔(dān)心資源鎖的問(wèn)題
| 操作 | 列表 | 雙向隊(duì)列 | 說(shuō)明 |
|---|---|---|---|
s.__add__(s2) |
√ | s + s2 ，拼接 | |
s.__iadd__(s2) |
√ | √ | s += s2 ，就地拼接 |
| s.append(e) | √ | √ | 添加一個(gè)元素到最右側(cè)（到最后一個(gè)元素之后） |
| s.appendleft(e) | √ | 添加一個(gè)元素到最左側(cè)（到第一個(gè)元素之前） | |
| s.clear() | √ | √ | 刪除所有元素 |
s.__contains__(e) |
√ | s 是否含有 e | |
| s.copy() | √ | 對(duì)列表淺復(fù)制 | |
s.__copy__() |
√ | 對(duì) copy.copy （淺復(fù)制）的支持 | |
| s.count(e) | √ | √ | s 中 e 出現(xiàn)的次數(shù) |
s.__delitem__(p) |
√ | √ | 刪除位置 p 的元素 |
| s.extend(it) | √ | √ | 將可迭代對(duì)象 it 里的元素添加到尾部 |
| s.extendleft(i) | √ | 將可迭代對(duì)象 i 中的元素添加到頭部 | |
s.__getitem__(p) |
√ | √ | s[p]，讀取位置 p 的元素 |
| s.index(e) | √ | 找到 e 在序列中第一次出現(xiàn)的位置 | |
| s.insert(p, e) | √ | 在位于 p 的元素之前插入元素 e | |
s.__iter__() |
√ | √ | 返回迭代器 |
s.__len__() |
√ | √ | len(s)，序列的長(zhǎng)度 |
s.__mul__(n) |
√ | s * n，重復(fù)拼接 | |
s.__imul__(n) |
√ | s *= n ，就地重復(fù)拼接 | |
s.__rmul__(n) |
√ | n * s ，反向重復(fù)拼接 * | |
| s.pop([p]) | √ | √ | 刪除位于 p 的值并返回這個(gè)值，p 的默認(rèn)值是最后一個(gè)元素的位置 |
| s.popleft() | √ | 移除第一個(gè)元素并返回它的值 | |
| s.remove(e) | √ | √ | 刪除序列里第一次出現(xiàn)的 e 元素 |
| s.reverse() | √ | √ | 就地調(diào)轉(zhuǎn)序列中元素的位置 |
s.__reversed__() |
√ | √ | 返回一個(gè)從尾部開(kāi)始掃描元素的迭代器 |
| s.rotate(n) | √ | 把 n 個(gè)元素從隊(duì)列的一端移到另一端 | |
s.__setitem__(p, e) |
√ | √ | s[p] = e，把位于 p 位置的元素替換成 e |
| s.sort([key], [revers]) | √ | 就地排序序列，可選參數(shù)有 key 和 reverse |
a_list.pop(p) 這個(gè)操作只能用于列表，雙向隊(duì)列的這個(gè)方法不接收參數(shù)
其他形式的隊(duì)列的實(shí)現(xiàn)
| 其他形式 | 說(shuō)明 |
|---|---|
| queue | 提供了同步（線(xiàn)程安全）類(lèi) Queue、LifoQueue 和 PriorityQueue，不同的線(xiàn)程可以利用 這些數(shù)據(jù)類(lèi)型來(lái)交換信息。這三個(gè)類(lèi)的構(gòu)造方法都有一個(gè)可選參數(shù) maxsize，它接收正 整數(shù)作為輸入值，用來(lái)限定隊(duì)列的大小。但是在滿(mǎn)員的時(shí)候，這些類(lèi)不會(huì)扔掉舊的元素 來(lái)騰出位置。相反，如果隊(duì)列滿(mǎn)了，它就會(huì)被鎖住，直到另外的線(xiàn)程移除了某個(gè)元素而 騰出了位置。這一特性讓這些類(lèi)很適合用來(lái)控制活躍線(xiàn)程的數(shù)量 |
| multiprocessing | 這個(gè)包實(shí)現(xiàn)了自己的 Queue，它跟 queue.Queue 類(lèi)似，是設(shè)計(jì)給進(jìn)程間通信用的。同時(shí) 還有一個(gè)專(zhuān)門(mén)的 multiprocessing.JoinableQueue 類(lèi)型，可以讓任務(wù)管理變得更方便 |
| asyncio | Python 3.4 新提供的包，里面有 Queue、LifoQueue、PriorityQueue 和 JoinableQueue， 這些類(lèi)受到 queue 和 multiprocessing 模塊的影響，但是為異步編程里的任務(wù)管理提供 了專(zhuān)門(mén)的便利 |
| heapq | 跟上面三個(gè)模塊不同的是，heapq 沒(méi)有隊(duì)列類(lèi)，而是提供了 heappush 和 heappop 方法， 讓用戶(hù)可以把可變序列當(dāng)作堆隊(duì)列或者優(yōu)先隊(duì)列來(lái)使用 |
2.10 本章小結(jié)
Python 序列類(lèi)型最常見(jiàn)的分類(lèi)就是可變和不可變序列
另外一種分類(lèi)方式 扁平序列和容器序列
前者的體積更小、速度更快而且用起來(lái)更簡(jiǎn)單，但是它只能保存一些原子性的數(shù)據(jù)，比如數(shù)字、字符和字節(jié)
后者更加靈活，如果用到可變對(duì)象，還要嵌套的數(shù)據(jù)結(jié)構(gòu)，尤其要注意
列表推導(dǎo)和生成器表達(dá)式則提供了靈活構(gòu)建和初始化序列的方式
元組它既可以用作無(wú)名稱(chēng)的字段的記錄，又可以看作不可變的列表
前者的使用中，拆包是一個(gè)典型的做法，*句法更加便利
具名元組的實(shí)例也很節(jié)省空間，同時(shí)提供了方便地通過(guò)名字來(lái)獲取元組各個(gè)字段信息的方式
Python 里最受歡迎的一個(gè)語(yǔ)言特性就是序列切片
用戶(hù)自定義的序列類(lèi)型也可以選擇支持 NumPy 中的多維切片和省略（...）
對(duì)切片賦值是一個(gè)修改可變序列的捷徑
增量賦值 += 和 *= 會(huì)區(qū)別對(duì)待可變和不可變序列
在遇到不可變序列時(shí)，這兩個(gè)操作會(huì)在背后生成新的序列。但如果被賦值的對(duì)象是可變的，那么這個(gè)序列會(huì)就地修改
序列的 sort 方法和內(nèi)置的 sorted 函數(shù)，都接受一個(gè)函數(shù)作為可選參數(shù)來(lái)指定排序算法如何比較大小
這個(gè)參數(shù)名為key
如果在插入新元素的同時(shí)還想保持有序序列的順序，那么需要用到 bisect.insort。bisect.bisect 的作用則是快速查找
返回索引
2.11 延伸閱讀
| 素材 | URL | 相關(guān)信息 |
|---|---|---|
| Python 官 方 網(wǎng) 站的Sorting HOW TO | https://docs.python.org/3/howto/sorting.html | 講解了 sorted 和 list.sort 的高級(jí)用法 |
| PEP 3132 — Extended Iterable Unpacking | https://www.python.org/dev/peps/pep-3132/ | 使用 *extra 句法進(jìn)行平行賦值的權(quán)威指南 |
| Missing *-unpacking generalizations | http://bugs.python.org/issue2292 | 關(guān)于如何更廣泛地使用可迭代對(duì)象拆包的討論和提議 |
| PEP 448—Additional Unpacking Generalizations | https://www.python.org/dev/peps/pep-0448/ | 上面討論的直接結(jié)果 |
| Less Copies in Python with the Buffer Protocol and memoryviews | http://eli.thegreenplace.net/2011/11/28/less-copies-in-python-with-the-buffer-protocol-and-memoryviews/ | |
| 利用 Python 進(jìn)行數(shù)據(jù)分析 | Wes McKinney | |
| 8.3. collections — Container datatypes | https://docs.python.org/3/library/collections.html | 有一些關(guān)于雙向隊(duì)列和其他集合類(lèi)型的使用技巧 |
| Why Numbering Should Start at Zero | http://www.cs.utexas.edu/users/EWD/transcriptions/EWD08xx/EWD831.html | |
ABC 里的 compounds 類(lèi)型算得上是 Python 元組的鼻祖
容器”一詞來(lái)自“Data Model”文檔（https://docs.python.org/3/reference/datamodel.
html#objects-values-and-types）
有些對(duì)象里包含對(duì)其他對(duì)象的引用；這些對(duì)象稱(chēng)為容器
扁平序列因?yàn)橹荒馨訑?shù)據(jù)類(lèi)型，比如整數(shù)、浮點(diǎn)數(shù)或字符，所以不能嵌套使用
這個(gè)名字是本書(shū)作者創(chuàng)造的！主要是為了跟容器序列做對(duì)比
列表是可以同時(shí)容納不同類(lèi)型的元素的，但是實(shí)際上這樣做并沒(méi)有什么特別的好處
不推薦這么用
元組則恰恰相反，它經(jīng)常用來(lái)存放不同類(lèi)型的的元素
list.sort、sorted、max 和 min 函數(shù)的 key 參數(shù)是一個(gè)很棒的設(shè)計(jì)
用 key 參數(shù)能把事情變得簡(jiǎn)單且高效。
說(shuō)它更簡(jiǎn)單，是因?yàn)橹恍枰峁┮粋€(gè)單參數(shù)函數(shù)來(lái)提取或者計(jì)算一個(gè)值作為比較大小的標(biāo)準(zhǔn)即可
說(shuō)它更高效，是因?yàn)樵诿總€(gè)元素上，key 函數(shù)只會(huì)被調(diào)用一次。
sorted 和 list.sort 背后的排序算法是 Timsort，它是一種自適應(yīng)算法，會(huì)根據(jù)原始數(shù)據(jù)的順序特點(diǎn)交替使用插入排序和歸并排序，以達(dá)到最佳效率
https://en.wikipedia.org/wiki/Timsort
2009年起，Java 和 Android 也開(kāi)始使用這個(gè)算法
Timsort 的創(chuàng)始人是 Tim Peters，也是“Python 之禪”（import this）的作者
總結(jié)
以上是生活随笔為你收集整理的《流畅的Python》 读书笔记 第二章数据结构(2) 231011的全部?jī)?nèi)容，希望文章能夠幫你解決所遇到的問(wèn)題。
- 上一篇： 嵌入式BI的精解与探索
- 下一篇： P34_数据请求 - GET和POST请