當(dāng)前位置：首頁 > 编程语言 > python >内容正文

python

Python拾遗1：collections、itertools和内存io

發(fā)布時間：2025/3/8 python 62 豆豆

生活随笔收集整理的這篇文章主要介紹了 Python拾遗1：collections、itertools和内存io 小編覺得挺不錯的,現(xiàn)在分享給大家,幫大家做個參考.

Python拾遺1：collections、itertools和內(nèi)存io

轉(zhuǎn)自：https://www.liaoxuefeng.com/wiki/1016959663602400

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

collections

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

namedtuple

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

p = (1, 2)

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

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

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

namedtuple是一個函數(shù)，它用來創(chuàng)建一個自定義的tuple對象，并且規(guī)定了tuple元素的個數(shù)，并可以用屬性而不是索引來引用tuple的某個元素。

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

可以驗證創(chuàng)建的Point對象是tuple的一種子類：

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

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

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

deque

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

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

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

輸出：

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

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

defaultdict

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

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

注意默認(rèn)值是調(diào)用函數(shù)返回的，而函數(shù)在創(chuàng)建defaultdict對象時傳入。

除了在Key不存在時返回默認(rèn)值，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可以實現(xiàn)一個FIFO（先進(jìn)先出）的dict，當(dāng)容量超出限制時，先刪除最早添加的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，但是查找的時候，會按照順序在內(nèi)部的dict依次查找。

什么時候使用ChainMap最合適？舉個例子：應(yīng)用程序往往都需要傳入?yún)?shù)，參數(shù)可以通過命令行傳入，可以通過環(huán)境變量傳入，還可以有默認(rèn)參數(shù)。我們可以用ChainMap實現(xiàn)參數(shù)的優(yōu)先級查找，即先查命令行參數(shù)，如果沒有傳入，再查環(huán)境變量，如果沒有，就使用默認(rèn)參數(shù)。

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

from collections import ChainMap import os, argparse# 構(gòu)造缺省參數(shù): defaults = {'color': 'red','user': 'guest' }# 構(gòu)造命令行參數(shù): 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)# 打印參數(shù): print('color=%s' % combined['color']) print('user=%s' % combined['user'])

沒有任何參數(shù)時，打印出默認(rèn)參數(shù)：

python3 use_chainmap.py color=red user=guest

當(dāng)傳入命令行參數(shù)時，優(yōu)先使用命令行參數(shù)：

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

同時傳入命令行參數(shù)和環(huán)境變量，命令行參數(shù)的優(yōu)先級較高：

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

Counter

Counter是一個簡單的計數(shù)器，例如，統(tǒng)計字符出現(xiàn)的個數(shù)：

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的一個子類，上面的結(jié)果可以看出每個字符出現(xiàn)的次數(shù)。

itertools

Python的內(nèi)建模塊itertools提供了非常有用的用于操作迭代對象的函數(shù)。

”無限“迭代器

count

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

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

輸出：

1 2 3 4 5 6 ...

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

cycle

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

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

輸出：

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

同樣停不下來。

repeat

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

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

輸出：

A A A

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

幾個有用的迭代器操作函數(shù)

takewile

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

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() 可以把一組迭代對象串聯(lián)起來，形成一個更大的迭代器：

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

輸出：

A B C X Y Z

groupby

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

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']

實際上挑選規(guī)則是通過函數(shù)完成的，只要作用于函數(shù)的兩個元素返回的值相等，這兩個元素就被認(rèn)為是在一組的，而函數(shù)返回值作為組的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

很多時候，數(shù)據(jù)讀寫不一定是文件，也可以在內(nèi)存中讀寫。

StringIO顧名思義就是在內(nèi)存中讀寫str。

要把str寫入StringIO，我們需要先創(chuàng)建一個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，如果要操作二進(jìn)制數(shù)據(jù)，就需要使用BytesIO。

BytesIO實現(xiàn)了在內(nèi)存中讀寫bytes，我們創(chuàng)建一個BytesIO，然后寫入一些bytes：

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

輸出：

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

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

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

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

輸出：