前言：

collections是實現了特定目標的容器，以提供python標準內建容器dict,list,set和tuple的替代選擇。

Counter

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

import collections

#統計字符出現的次數

test1 = collections.Counter('hello world')

#統計單詞出現的次數

test2 = collections.Counter('hello world'.split())

print(test1)

'''Counter({'l': 3, 'o': 2, 'h': 1, 'e': 1, ' ': 1, 'w': 1, 'r': 1, 'd': 1})'''

print(test2)

'''Counter({'hello': 1, 'world': 1})'''

常用方法：

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

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

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

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

import collections

a = collections.Counter('hello world'.split())

print(a)

#獲取指定對象的訪問次數，也可以用get獲取

print(a.get('hello'))

print(a['hello'])

#查看元素

print(list(a.elements()))

b = collections.Counter('你好 世界'.split())

#追加對象,也可以使用a.update(b)

print(a+b)

#減少對象,也可以使用a.subtract(b)

print(a-b)

#清除

print(a.clear())

defaultdict

返回一個新的類似字典的對象，defaultdict是內置dict類的子類

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

import collections

#使用str

a = collections.defaultdict(str)

print(a)

'''defaultdict(, {})'''

print(a['hello'])

''' '''

print(a)

'''defaultdict(, {'hello': ''})'''

#使用int

fruit = collections.defaultdict(int)

fruit['apple'] = 2

print(fruit)

'''defaultdict(, {'apple': 2})'''

#沒有對象時返回0

print(fruit['banana'])

'''0'''

#使用list

b = [('yellow',1),('red',2),('green',3)]

c = collections.defaultdict(list)

for k,v in b:

c[k].append(v)

print(c)

'''defaultdict(, {'yellow': [1], 'red': [2], 'green': [3]})'''

print(c.items())

'''dict_items([('yellow', [1]), ('red', [2]), ('green', [3])])'''

#使用dict

d = collections.defaultdict(dict)

d[1] = {'one',1}

print(d)

'''defaultdict(, {1: {1, 'one'}})'''

#使用set

phone = collections.defaultdict(set)

phone['品牌'].add('小米')

phone['品牌'].add('蘋果')

phone['處理器'].add('聯發科')

print(phone)

'''defaultdict(, {'品牌': {'蘋果', '小米'}, '處理器': {'聯發科'}})'''

OrderdDict

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

colletions.OrderdDict類提供了保留他們添加順序的字典對象

import collections

ot = collections.OrderedDict()

ot['k1'] = ''

ot['k3'] = ''

ot['k2'] = ''

print(ot)

'''OrderedDict([('k1', ''), ('k3', ''), ('k2', '')])'''

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

ot['k1'] = 666

print(ot)

'''OrderedDict([('k1', 666), ('k3', ''), ('k2', '')])'''

print(dict(ot))

'''{'k1': 666, 'k3': '', 'k2': ''}'''

namedtuple

三種定義命名元組的方法，第一個參數是命名元組的構造器(如下所示：Person1,Person2,Person3)

import collections

p1 = collections.namedtuple('Person1',['name','sex','age'])

p2 = collections.namedtuple('Person2','name,sex,age')

p3 = collections.namedtuple('Person3','name sex age')

#實例化命名元組

zhangsan = p1('張三','男',28)

print(zhangsan)

'''Person1(name='張三', sex='男', age=28)'''

lisi = p2('李四','女',24)

print(lisi)

'''Person2(name='李四', sex='女', age=24)'''

print(lisi.name)

'''李四'''

deque

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

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

如果長度沒有指定或者是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超出最大長度的話，就拋出InderErrory異常錯誤】

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

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

remove(value)：移去找到的第一個value，沒有拋出ValueError異常錯誤

reverse()：將deque逆序排列。返回None

maxlen()：隊列的最大長度，沒有限定則為None

import collections

x = collections.deque(maxlen=10)

print(x)

'''deque([], maxlen=10)'''

x.extend('Python')

print(x)

'''deque(['P', 'y', 't', 'h', 'o', 'n'], maxlen=10)'''

x.append('a')

x.appendleft('H')

x.appendleft('P')

x.appendleft('P')

print(x)

'''deque(['P', 'P', 'H', 'P', 'y', 't', 'h', 'o', 'n', 'a'], maxlen=10)'''

x.appendleft('P')

print(x)

'''deque(['P', 'P', 'P', 'H', 'P', 'y', 't', 'h', 'o', 'n'], maxlen=10)'''

ChainMap

我們有多個字典或者映射，想把他們合并成為一個單獨的映射，有人說是可以用update進行合并，這樣做的問題就是新建了一個數據結構以致于當我們對原來的字典更改的時候不會同步。如果想建立一個同步的查詢方法，可以使用ChainMap。可以用來合并兩個或者多個字典。當查詢的時候，從前往后依次查詢，簡單使用。

import collections

test1 = {'apple':1,'banana':2}

test2 = {'orange':2,'apple':3,'pike':1}

comb1 = collections.ChainMap(test1,test2)

comb2 = collections.ChainMap(test2,test1)

print(comb1)

'''ChainMap({'apple': 1, 'banana': 2}, {'orange': 2, 'apple': 3, 'pike': 1})'''

print(comb2)

'''ChainMap({'orange': 2, 'apple': 3, 'pike': 1}, {'apple': 1, 'banana': 2})'''

for k,v in comb1.items():

print(k,v)

'''

orange 2

apple 1

pike 1

banana 2

'''

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

print(comb1['apple'])

'''1'''

comb1['apple'] = 2

print(comb1)

'''ChainMap({'apple': 2, 'banana': 2}, {'orange': 2, 'apple': 3, 'pike': 1})'''

print(comb1['pike'])

'''1'''

comb1['pike'] = 3

print(comb1)

'''ChainMap({'apple': 2, 'banana': 2, 'pike': 3}, {'orange': 2, 'apple': 3, 'pike': 1})'''

從原理上講，ChainMap實際上是把放入的字典存儲在一個隊列里，當進行字典的增刪等操作只會在第一個字典中進行。當進行查詢的時候會依次查找，new_child()方法實質上是在列表的第一個元素前放入一個字典，默認是{}，而parents是去掉列表開頭的元素

import collections

a = collections.ChainMap()

a['x'] = 1

print(a)

'''ChainMap({'x': 1})'''

b = a.new_child()

print(b)

'''ChainMap({}, {'x': 1})'''

b['x'] = 2

print(b)

'''ChainMap({'x': 2}, {'x': 1})'''

c = a.new_child()

c['y'] = 2

print(c)

'''ChainMap({'y': 2}, {'x': 1})'''

d = c.parents

print(d)

'''ChainMap({'x': 1})'''

總結

以上是生活随笔為你收集整理的python collections模块_Python 的collections模块的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。