Python拾遺1：collections、itertools和內存io

轉自：https://www.liaoxuefeng.com/wiki/1016959663602400

本系列旨在補充python中一些很好用但是并非常規課程主線中的知識。

collections

collections是Python內建的一個集合模塊，提供了許多有用的集合類。

namedtuple

我們知道tuple可以表示不變集合，例如，一個點的二維坐標就可以表示成：

p = (1, 2)

但是，看到 (1, 2)，很難看出這個tuple是用來表示一個坐標的。

定義一個class又小題大做了，這時，namedtuple就派上了用場：

from collections import namedtuplePoint = namedtuple('Point', ['x', 'y'])
p = Point(1, 2)
print(p.x, p.y)

namedtuple是一個函數，它用來創建一個自定義的tuple對象，并且規定了tuple元素的個數，并可以用屬性而不是索引來引用tuple的某個元素。

這樣一來，我們用namedtuple可以很方便地定義一種數據類型，它具備tuple的不變性，又可以根據屬性來引用，使用十分方便。

可以驗證創建的Point對象是tuple的一種子類：

print(isinstance(p, Point))
print(isinstance(p, tuple))

類似的，如果要用坐標和半徑表示一個圓，也可以用namedtuple定義：

# namedtuple('名稱', [屬性list]):
Circle = namedtuple('Circle', ['x', 'y', 'r'])

deque

使用list存儲數據時，按索引訪問元素很快，但是插入和刪除元素就很慢了，因為list是線性存儲，數據量大的時候，插入和刪除效率很低。

deque是為了高效實現插入和刪除操作的雙向列表，適合用于隊列和棧：

from collections import dequeq = deque(['a', 'b', 'c'])
q.append('x')
q.appendleft('y')
print(q)

輸出：

deque(['y', 'a', 'b', 'c', 'x'])

deque除了實現list的append()和pop()外，還支持appendleft()和popleft()，這樣就可以非常高效地往頭部添加或刪除元素。

defaultdict

使用dict時，如果引用的Key不存在，就會拋出KeyError。如果希望key不存在時，返回一個默認值，就可以用defaultdict：

from collections import defaultdictdd = defaultdict(lambda: 'N/A')
dd['key1'] = 'abc'
print(dd['key1'], dd['key2'])

注意默認值是調用函數返回的，而函數在創建defaultdict對象時傳入。

除了在Key不存在時返回默認值，defaultdict的其他行為跟dict是完全一樣的。

OrderedDict

使用dict時，Key是無序的。在對dict做迭代時，我們無法確定Key的順序。

如果要保持Key的順序，可以用OrderedDict：

from collections import OrderedDictod = OrderedDict([('a', 1), ('b', 2), ('c', 3)])
print(od)

輸出：

OrderedDict([('a', 1), ('b', 2), ('c', 3)])

注意，OrderedDict的Key會按照插入的順序排列，不是Key本身排序：

od = OrderedDict()
od['z'] = 1
od['y'] = 2
od['x'] = 3
list(od.keys()) # 按照插入的Key的順序返回

輸出：

['z', 'y', 'x']

OrderedDict可以實現一個FIFO（先進先出）的dict，當容量超出限制時，先刪除最早添加的Key：

from collections import OrderedDictclass LastUpdatedOrderedDict(OrderedDict):def __init__(self, capacity):super(LastUpdatedOrderedDict, self).__init__()self._capacity = capacitydef __setitem__(self, key, value):containsKey = 1 if key in self else 0if len(self) - containsKey >= self._capacity:last = self.popitem(last=False)print('remove:', last)if containsKey:del self[key]print('set:', (key, value))else:print('add:', (key, value))OrderedDict.__setitem__(self, key, value)

ChainMap

ChainMap可以把一組dict串起來并組成一個邏輯上的dict。ChainMap本身也是一個dict，但是查找的時候，會按照順序在內部的dict依次查找。

什么時候使用ChainMap最合適？舉個例子：應用程序往往都需要傳入參數，參數可以通過命令行傳入，可以通過環境變量傳入，還可以有默認參數。我們可以用ChainMap實現參數的優先級查找，即先查命令行參數，如果沒有傳入，再查環境變量，如果沒有，就使用默認參數。

下面的代碼演示了如何查找user和color這兩個參數：

from collections import ChainMap
import os, argparse# 構造缺省參數:
defaults = {'color': 'red','user': 'guest'
}# 構造命令行參數:
parser = argparse.ArgumentParser()
parser.add_argument('-u', '--user')
parser.add_argument('-c', '--color')
namespace = parser.parse_args()
command_line_args = { k: v for k, v in vars(namespace).items() if v }# 組合成ChainMap:
combined = ChainMap(command_line_args, os.environ, defaults)# 打印參數:
print('color=%s' % combined['color'])
print('user=%s' % combined['user'])

沒有任何參數時，打印出默認參數：

python3 use_chainmap.py 
color=red
user=guest

當傳入命令行參數時，優先使用命令行參數：

python3 use_chainmap.py -u bob
color=red
user=bob

同時傳入命令行參數和環境變量，命令行參數的優先級較高：

user=admin color=green python3 use_chainmap.py -u bob
color=green
user=bob

Counter

Counter是一個簡單的計數器，例如，統計字符出現的個數：

rom collections import Counterc = Counter()
for ch in 'programming':c[ch] = c[ch] + 1
print(c)
c.update('hello')	# 也可以一次性update
print(c)

輸出：

Counter({'r': 2, 'g': 2, 'm': 2, 'p': 1, 'o': 1, 'a': 1, 'i': 1, 'n': 1})
Counter({'r': 2, 'o': 2, 'g': 2, 'm': 2, 'l': 2, 'p': 1, 'a': 1, 'i': 1, 'n': 1, 'h': 1, 'e': 1})

Counter實際上也是dict的一個子類，上面的結果可以看出每個字符出現的次數。

itertools

Python的內建模塊itertools提供了非常有用的用于操作迭代對象的函數。

”無限“迭代器

count

首先，我們看看itertools提供的幾個**“無限”迭代器**(包括 count, cycle, repeat)：

import itertoolsnaturals = itertools.count(1)
for n in naturals:print(n, end=' ')

輸出：

1 2 3 4 5 6 ...

因為**count()**會創建一個無限的迭代器，所以上述代碼會打印出自然數序列，根本停不下來，只能按Ctrl+C退出。

cycle

**cycle()**會把傳入的一個序列無限循環重復下去：

import itertoolscs = itertools.cycle('ABC')
for c in cs:print(c, end=' ')

輸出：

A B C A B C A B C ...

同樣停不下來。

repeat

**repeat()**負責把一個元素無限重復下去，不過如果提供第二個參數就可以限定重復次數：

import itertoolsns = itertools.repeat('A', 3)
for n in ns:print(n, end=' ')

輸出：

A A A

無限序列只有在 for 迭代時才會無限地迭代下去，如果只是創建了一個迭代對象，它不會事先把無限個元素生成出來，事實上也不可能在內存中創建無限多個元素，itertools 模塊提供的全部是處理迭代功能的函數，它們的返回值不是list，而是 Iterator，只有用 for 循環迭代的時候才真正計算。

幾個有用的迭代器操作函數

takewile

無限序列雖然可以無限迭代下去，但是通常我們會通過 takewhile() 等函數根據條件判斷來截取出一個有限的序列：

import itertoolsnaturals = itertools.count(1)
ns = itertools.takewhile(lambda x: x<=10, naturals)
for i in ns:print(i, end=' ')

輸出：

1 2 3 4 5 6 7 8 9 10

chain

chain() 可以把一組迭代對象串聯起來，形成一個更大的迭代器：

import itertoolsfor c in itertools.chain('ABC', 'XYZ'):print(c, end=' ')

輸出：

A B C X Y Z

groupby

groupby() 把迭代器中相鄰的重復元素挑出來放在一起

import itertoolsfor key, group in itertools.groupby('AAABBBCCAAA'):print(key, list(group))

輸出：

A ['A', 'A', 'A']
B ['B', 'B', 'B']
C ['C', 'C']
A ['A', 'A', 'A']如果換成AAABBBCCAAA
則輸出：
A ['A', 'A']
D ['D']
A ['A']
B ['B', 'B', 'B']
C ['C', 'C']
A ['A', 'A', 'A']

實際上挑選規則是通過函數完成的，只要作用于函數的兩個元素返回的值相等，這兩個元素就被認為是在一組的，而函數返回值作為組的key。比如我們要忽略大小寫分組，就可以讓元素'A'和'a'都返回相同的key：

for key, group in itertools.groupby('AaaBBbcCAAa', lambda c: c.upper()):print(key, list(group))

輸出：

A ['A', 'a', 'a']
B ['B', 'B', 'b']
C ['c', 'C']
A ['A', 'A', 'a']

StringIO與BytesIO

StringIO

很多時候，數據讀寫不一定是文件，也可以在內存中讀寫。

StringIO顧名思義就是在內存中讀寫str。

要把str寫入StringIO，我們需要先創建一個StringIO，然后，像文件一樣寫入即可：

from io import StringIO
f = StringIO()
f.write('hello')
f.write(' ')
f.write('world!')
print(f.getvalue())

輸出：

hello world!

getvalue()方法用于獲得寫入后的str。

要讀取StringIO，可以用一個str初始化StringIO，然后，像讀文件一樣讀取：

from io import StringIO
f = StringIO('Hello!\nHi!\nGoodbye!')
while True:s = f.readline()if s == '':breakprint(s.strip())

輸出：

Hello!
Hi!
Goodbye!

BytesIO

StringIO操作的只能是str，如果要操作二進制數據，就需要使用BytesIO。

BytesIO實現了在內存中讀寫bytes，我們創建一個BytesIO，然后寫入一些bytes：

from io import BytesIO
f = BytesIO()
f.write('中文'.encode('utf-8'))
print(f.getvalue())

輸出：

b'\xe4\xb8\xad\xe6\x96\x87'

請注意，寫入的不是str，而是經過UTF-8編碼的bytes。

和StringIO類似，可以用一個bytes初始化BytesIO，然后，像讀文件一樣讀取：

from io import BytesIO
f = BytesIO(b'\xe4\xb8\xad\xe6\x96\x87')
print(f.read())

輸出：

b'\xe4\xb8\xad\xe6\x96\x87'

StringIO和BytesIO是在內存中操作str和bytes的方法，使得和讀寫文件具有一致的接口。