亚洲综合国产精品,蜜桃麻豆av在线,色哟哟精品丝袜一区二区

主頁 > 知識庫 > Python的collections模塊真的很好用

Python的collections模塊真的很好用

collections是實現了特定目標的容器，以提供Python標準內建容器 dict , list , set , 和 tuple 的替代選擇。為了讓大家更好的認識，本文詳細總結collections的相關知識，一起來學習吧！

collections模塊：實現了特定目標的容器，以提供Python標準內建容器 dict、list、set、tuple 的替代選擇。

Counter：字典的子類，提供了可哈希對象的計數功能。

defaultdict：字典的子類，提供了一個工廠函數，為字典查詢提供了默認值。

OrderedDict：字典的子類，保留了他們被添加的順序。

namedtuple：創建命名元組子類的工廠函數。

deque：類似列表容器，實現了在兩端快速添加(append)和彈出(pop)。

ChainMap：類似字典的容器類，將多個映射集合到一個視圖里面。

Counter

Counter是一個dict子類，主要是用來對你訪問的對象的頻率進行計數。

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

常用方法：

elements()：返回一個迭代器，每個元素重復計算的個數，如果一個元素的計數小于1,就會被忽略。

most_common([n])：返回一個列表，提供n個訪問頻率最高的元素和計數

subtract([iterable-or-mapping])：從迭代對象中減去元素，輸入輸出可以是0或者負數

update([iterable-or-mapping])：從迭代對象計數元素或者從另一個映射對象 (或計數器) 添加。

>>> c = collections.Counter('hello world hello lucy'.split())
>>> c
Counter({'hello': 2, 'world': 1, 'lucy': 1})
>>> # 獲取指定對象的訪問次數，也可以使用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 是內置 dict 類的子類。

class collections.defaultdict([default_factory[, ...]])

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

例子

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

>>> e = collections.defaultdict(str)
>>> e
defaultdict(class 'str'>, {})
>>> e['hello']
''
>>> e
defaultdict(class 'str'>, {'hello': ''})
>>> # 普通字典調用不存在的鍵時，報錯
... 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

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

使用 set 作為 default_factory

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

## OrderedDict

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

collections.OrderedDict 類提供了保留他們添加順序的字典對象。

```python
>>> o = collections.OrderedDict()
>>> o['k1'] = 'v1'
>>> o['k3'] = 'v3'
>>> o['k2'] = 'v2'
>>> o
OrderedDict([('k1', 'v1'), ('k3', 'v3'), ('k2', 'v2')])

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

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

## namedtuple

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

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

實例化命名元組

```python
>>> 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 # 直接通過 實例名.屬性 來調用
'lucy'
>>> lucy.age
23

deque

collections.deque 返回一個新的雙向隊列對象，從左到右初始化（用方法 append()），從 iterable（迭代對象）數據創建。如果 iterable 沒有指定，新隊列為空。

collections.deque 隊列支持線程安全，對于從兩端添加（append）或者彈出（pop），復雜度O(1)。

雖然 list 對象也支持類似操作，但是這里優化了定長操作（pop(0)、insert(0,v)）的開銷。

如果 maxlen 沒有指定或者是 None ，deque 可以增長到任意長度。否則，deque 就限定到指定最大長度。一旦限定長度的 deque 滿了，當新項加入時，同樣數量的項就從另一端彈出。

支持的方法：

append(x)：添加x到右端。

appendleft(x)：添加x到左端。

clear()：清除所有元素，長度變為0。

copy()：創建一份淺拷貝。

count(x)：計算隊列中個數等于x的元素。

extend(iterable)：在隊列右側添加iterable中的元素。

extendleft(iterable)：在隊列左側添加iterable中的元素，注：在左側添加時，iterable參數的順序將會反過來添加。

index(x[,start[,stop]])：返回第 x 個元素（從 start 開始計算，在 stop 之前）。返回第一個匹配，如果沒找到的話，拋出 ValueError 。

insert(i,x)：在位置 i 插入 x 。注：如果插入會導致一個限長deque超出長度 maxlen 的話，就拋出一個 IndexError 。

pop()：移除最右側的元素。

popleft()：移除最左側的元素。

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進行合并，這樣做的問題就是新建了一個數據結構以致于當我們對原來的字典進行更改的時候不會同步。如果想建立一個同步的查詢方法，可以使用 ChainMap。

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

```python
>>> 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
/code>/pre>

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

pre>code class="language-python line-numbers">>>> 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 實際上是把放入的字典存儲在一個隊列中，當進行字典的增加刪除等操作只會在第一個字典上進行，當進行查找的時候會依次查找，new_child() 方法實質上是在列表的第一個元素前放入一個字典，默認是{}，而 parents 是去掉了列表開頭的元素。

```python
>>> 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({})

到此這篇關于Python的collections模塊真的很好用的文章就介紹到這了,更多相關Python的collections模塊內容請搜索腳本之家以前的文章或繼續瀏覽下面的相關文章希望大家以后多多支持腳本之家！

您可能感興趣的文章: