Python collections模塊的使用方法

更新時間：2020年10月09日 10:49:33 作者：南枝向暖北枝寒MA

這篇文章主要介紹了Python collections模塊的使用方法，文中通過示例代碼介紹的非常詳細(xì)，對大家的學(xué)習(xí)或者工作具有一定的參考學(xué)習(xí)價值，需要的朋友們下面隨著小編來一起學(xué)習(xí)學(xué)習(xí)吧

collections模塊

這個模塊實現(xiàn)了特定目標(biāo)的容器，以提供Python標(biāo)準(zhǔn)內(nèi)建容器 dict、list、set、tuple 的替代選擇。

Counter：字典的子類，提供了可哈希對象的計數(shù)功能
defaultdict：字典的子類，提供了一個工廠函數(shù)，為字典查詢提供了默認(rèn)值
OrderedDict：字典的子類，保留了他們被添加的順序
namedtuple：創(chuàng)建命名元組子類的工廠函數(shù)
deque：類似列表容器，實現(xiàn)了在兩端快速添加(append)和彈出(pop)
ChainMap：類似字典的容器類，將多個映射集合到一個視圖里面

Counter

Counter是一個dict子類，主要是用來對你訪問的對象的頻率進(jìn)行計數(shù)。

>>> import collections
>>> # 統(tǒng)計字符出現(xiàn)的次數(shù)
... collections.Counter('hello world')
Counter({'l': 3, 'o': 2, 'h': 1, 'e': 1, ' ': 1, 'w': 1, 'r': 1, 'd': 1})
>>> # 統(tǒng)計單詞個數(shù)
... collections.Counter('hello world hello lucy'.split())
Counter({'hello': 2, 'world': 1, 'lucy': 1})

常用方法：

elements()：返回一個迭代器，每個元素重復(fù)計算的個數(shù)，如果一個元素的計數(shù)小于1,就會被忽略
most_common([n])：返回一個列表，提供n個訪問頻率最高的元素和計數(shù)
subtract([iterable-or-mapping])：從迭代對象中減去元素，輸入輸出可以是0或者負(fù)數(shù)
update([iterable-or-mapping])：從迭代對象計數(shù)元素或者從另一個映射對象 (或計數(shù)器) 添加

>>> c = collections.Counter('hello world hello lucy'.split())
>>> c
Counter({'hello': 2, 'world': 1, 'lucy': 1})
>>> # 獲取指定對象的訪問次數(shù)，也可以使用get方法
... c['hello']
2
>>> # 查看元素
... list(c.elements())
['hello', 'hello', 'world', 'lucy']
>>> c1 = collections.Counter('hello world'.split())
>>> c2 = collections.Counter('hello lucy'.split())
>>> c1
Counter({'hello': 1, 'world': 1})
>>> c2
Counter({'hello': 1, 'lucy': 1})
>>> # 追加對象，+或者c1.update(c2)
... c1+c2
Counter({'hello': 2, 'world': 1, 'lucy': 1})
>>> # 減少對象，-或者c1.subtract(c2)
... c1-c2
Counter({'world': 1})
>>> # 清除
... c.clear()
>>> c
Counter()

defaultdict

返回一個新的類似字典的對象。 defaultdict 是內(nèi)置 dict 類的子類。

class collections.defaultdict([default_factory[, ...]])
>>> d = collections.defaultdict()
>>> d
defaultdict(None, {})
>>> e = collections.defaultdict(str)
>>> e
defaultdict(<class 'str'>, {})

例子

defaultdict的一個典型用法是使用其中一種內(nèi)置類型（如str、int、list或dict等）作為默認(rèn)工廠，這些內(nèi)置類型在沒有參數(shù)調(diào)用時返回空類型。

>>> e = collections.defaultdict(str)
>>> e
defaultdict(<class 'str'>, {})
>>> e['hello']
''
>>> e
defaultdict(<class 'str'>, {'hello': ''})
>>> # 普通字典調(diào)用不存在的鍵時，報錯
... e1 = {}
>>> e1['hello']
Traceback (most recent call last):
 File "<stdin>", line 1, in <module>
KeyError: 'hello'

使用 int 作為 default_factory

>>> fruit = collections.defaultdict(int)
>>> fruit['apple'] = 2
>>> fruit
defaultdict(<class 'int'>, {'apple': 2})
>>> fruit['banana'] # 沒有對象時，返回0
0
>>> fruit
defaultdict(<class 'int'>, {'apple': 2, 'banana': 0})

使用 list 作為 default_factory

>>> s = [('yellow', 1), ('blue', 2), ('yellow', 3), ('blue', 4), ('red', 1)]
>>> d = collections.defaultdict(list)
>>> for k,v in s:
...   d[k].append(v)
...
>>> d
defaultdict(<class 'list'>, {'yellow': [1, 3], 'blue': [2, 4], 'red': [1]})
>>> d.items()
dict_items([('yellow', [1, 3]), ('blue', [2, 4]), ('red', [1])])
>>> sorted(d.items())
[('blue', [2, 4]), ('red', [1]), ('yellow', [1, 3])]

使用 dict 作為 default_factory

>>> nums = collections.defaultdict(dict)
>>> nums[1] = {'one':1}
>>> nums
defaultdict(<class 'dict'>, {1: {'one': 1}})
>>> nums[2]
{}
>>> nums
defaultdict(<class 'dict'>, {1: {'one': 1}, 2: {}})

使用 set 作為 default_factory

>>> types = collections.defaultdict(set)
>>> types['手機'].add('華為')
>>> types['手機'].add('小米')
>>> types['顯示器'].add('AOC')
>>> types
defaultdict(<class 'set'>, {'手機': {'華為', '小米'}, '顯示器': {'AOC'}})

OrderedDict

Python字典中的鍵的順序是任意的，它們不受添加的順序的控制。

collections.OrderedDict 類提供了保留他們添加順序的字典對象
>>> o = collections.OrderedDict()
>>> o['k1'] = 'v1'
>>> o['k3'] = 'v3'
>>> o['k2'] = 'v2'
>>> o
OrderedDict([('k1', 'v1'), ('k3', 'v3'), ('k2', 'v2')])

如果在已經(jīng)存在的 key 上添加新的值，將會保留原來的 key 的位置，然后覆蓋 value 值。

>>> o['k1'] = 666
>>> o
OrderedDict([('k1', 666), ('k3', 'v3'), ('k2', 'v2')])
>>> dict(o)
{'k1': 666, 'k3': 'v3', 'k2': 'v2'}

namedtuple

三種定義命名元組的方法：第一個參數(shù)是命名元組的構(gòu)造器（如下的：Person1，Person2，Person3）

>>> P1 = collections.namedtuple('Person1',['name','age','height'])
>>> P2 = collections.namedtuple('Person2','name,age,height')
>>> P3 = collections.namedtuple('Person3','name age height')

實例化命名元組

>>> lucy = P1('lucy',23,180)
>>> lucy
Person1(name='lucy', age=23, height=180)
>>> jack = P2('jack',20,190)
>>> jack
Person2(name='jack', age=20, height=190)
>>> lucy.name # 直接通過 實例名.屬性 來調(diào)用
'lucy'
>>> lucy.age
23

deque

collections.deque 返回一個新的雙向隊列對象，從左到右初始化（用方法 append()），從 iterable（迭代對象）數(shù)據(jù)創(chuàng)建。如果 iterable 沒有指定，新隊列為空。
collections.deque 隊列支持線程安全，對于從兩端添加（append）或者彈出（pop），復(fù)雜度O(1)。
雖然 list 對象也支持類似操作，但是這里優(yōu)化了定長操作（pop(0)、insert(0,v)）的開銷。
如果 maxlen 沒有指定或者是 None ，deque 可以增長到任意長度。否則，deque 就限定到指定最大長度。一旦限定長度的 deque 滿了，當(dāng)新項加入時，同樣數(shù)量的項就從另一端彈出。

支持的方法：

append(x)：添加x到右端
appendleft(x)：添加x到左端
clear()：清除所有元素，長度變?yōu)?
copy()：創(chuàng)建一份淺拷貝
count(x)：計算隊列中個數(shù)等于x的元素
extend(iterable)：在隊列右側(cè)添加iterable中的元素
extendleft(iterable)：在隊列左側(cè)添加iterable中的元素，注：在左側(cè)添加時，iterable參數(shù)的順序?qū)催^來添加
index(x[,start[,stop]])：返回第 x 個元素（從 start 開始計算，在 stop 之前）。返回第一個匹配，如果沒找到的話，升起 ValueError 。
insert(i,x)：在位置 i 插入 x 。注：如果插入會導(dǎo)致一個限長deque超出長度 maxlen 的話，就升起一個 IndexError 。
pop()：移除最右側(cè)的元素
popleft()：移除最左側(cè)的元素
remove(value)：移去找到的第一個 value。沒有拋出ValueError
reverse()：將deque逆序排列。返回 None 。
maxlen：隊列的最大長度，沒有限定則為None。

>>> d = collections.deque(maxlen=10)
>>> d
deque([], maxlen=10)
>>> d.extend('python')
>>> [i.upper() for i in d]
['P', 'Y', 'T', 'H', 'O', 'N']
>>> d.append('e')
>>> d.appendleft('f')
>>> d.appendleft('g')
>>> d.appendleft('h')
>>> d
deque(['h', 'g', 'f', 'p', 'y', 't', 'h', 'o', 'n', 'e'], maxlen=10)
>>> d.appendleft('i')
>>> d
deque(['i', 'h', 'g', 'f', 'p', 'y', 't', 'h', 'o', 'n'], maxlen=10)
>>> d.append('m')
>>> d
deque(['h', 'g', 'f', 'p', 'y', 't', 'h', 'o', 'n', 'm'], maxlen=10)

ChainMap

問題背景是我們有多個字典或者映射，想把它們合并成為一個單獨的映射，有人說可以用update進(jìn)行合并，這樣做的問題就是新建了一個數(shù)據(jù)結(jié)構(gòu)以致于當(dāng)我們對原來的字典進(jìn)行更改的時候不會同步。如果想建立一個同步的查詢方法，可以使用 ChainMap

可以用來合并兩個或者更多個字典，當(dāng)查詢的時候，從前往后依次查詢。簡單使用：

>>> d1 = {'apple':1,'banana':2}
>>> d2 = {'orange':2,'apple':3,'pike':1}
>>> combined1 = collections.ChainMap(d1,d2)
>>> combined2 = collections.ChainMap(d2,d1)
>>> combined1
ChainMap({'apple': 1, 'banana': 2}, {'orange': 2, 'apple': 3, 'pike': 1})
>>> combined2
ChainMap({'orange': 2, 'apple': 3, 'pike': 1}, {'apple': 1, 'banana': 2})
>>> for k,v in combined1.items():
...   print(k,v)
...
orange 2
apple 1
pike 1
banana 2
>>> for k,v in combined2.items():
...   print(k,v)
...
apple 3
banana 2
orange 2
pike 1

有一個注意點就是當(dāng)對ChainMap進(jìn)行修改的時候總是只會對第一個字典進(jìn)行修改，如果第一個字典不存在該鍵，會添加。

>>> d1 = {'apple':1,'banana':2}
>>> d2 = {'orange':2,'apple':3,'pike':1}
>>> c = collections.ChainMap(d1,d2)
>>> c
ChainMap({'apple': 1, 'banana': 2}, {'orange': 2, 'apple': 3, 'pike': 1})
>>> c['apple']
1
>>> c['apple'] = 2
>>> c
ChainMap({'apple': 2, 'banana': 2}, {'orange': 2, 'apple': 3, 'pike': 1})
>>> c['pike']
1
>>> c['pike'] = 3
>>> c
ChainMap({'apple': 2, 'banana': 2, 'pike': 3}, {'orange': 2, 'apple': 3, 'pike': 1})

從原理上面講，ChainMap 實際上是把放入的字典存儲在一個隊列中，當(dāng)進(jìn)行字典的增加刪除等操作只會在第一個字典上進(jìn)行，當(dāng)進(jìn)行查找的時候會依次查找，new_child() 方法實質(zhì)上是在列表的第一個元素前放入一個字典，默認(rèn)是{}，而 parents 是去掉了列表開頭的元素

>>> a = collections.ChainMap()
>>> a['x'] = 1
>>> a
ChainMap({'x': 1})
>>> b = a.new_child()
>>> b
ChainMap({}, {'x': 1})
>>> b['x'] = 2
>>> b
ChainMap({'x': 2}, {'x': 1})
>>> b['y'] = 3
>>> b
ChainMap({'x': 2, 'y': 3}, {'x': 1})
>>> a
ChainMap({'x': 1})
>>> c = a.new_child()
>>> c
ChainMap({}, {'x': 1})
>>> c['x'] = 1
>>> c['y'] = 1
>>> c
ChainMap({'x': 1, 'y': 1}, {'x': 1})
>>> d = c.parents
>>> d
ChainMap({'x': 1})
>>> d is a
False
>>> d == a
True

>>> a = {'x':1,'z':3}
>>> b = {'y':2,'z':4}
>>> c = collections.ChainMap(a,b)
>>> c
ChainMap({'x': 1, 'z': 3}, {'y': 2, 'z': 4})
>>> c.maps
[{'x': 1, 'z': 3}, {'y': 2, 'z': 4}]
>>> c.parents
ChainMap({'y': 2, 'z': 4})
>>> c.parents.maps
[{'y': 2, 'z': 4}]
>>> c.parents.parents
ChainMap({})
>>> c.parents.parents.parents
ChainMap({})

到此這篇關(guān)于Python collections模塊的使用方法的文章就介紹到這了,更多相關(guān)Python collections模塊內(nèi)容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關(guān)文章希望大家以后多多支持腳本之家！

您可能感興趣的文章: