Python collections模块

collections模块

Python的collections模块包含了许多实用的集合类。

namedtuple

namedtuple可以定义一个简单的类，比直接定义一个类更简单，且减少了初始化类的很多初始化方法，所以速度更快。

from colletions import namedtuple
User = namedtuple('User',['name','age','height'])
user = User('tsir',18,60.5)
print(user.name, user.age, user.height)

>>> tsir 18 60.5

namedtuple继承于tuple，所以也拥有tuple的性质

name, age, height = user
print(name, age, height)

>>> tsir 18 60.5

namedtuple还可以使用类方法_make方法来传入可迭代的对象创建类

t_list = ['bob', 20, 70]
t_tuple = ('jean', 30, 80 )
user1 = User._make(t_list)
user2 = User._make(t_tuple)
print(user1, user2)

>>> User(name='bob', age=20, height=70) User(name='jean', age=30, height=80)

namedtuple还可以使用_asdict方法将namedtutple对象转化成字典

user_dict = user._asdict()
print(user_dict)

# OrderedDict是另一种集合类，继承于dict
>>> OrderedDict([('name', 'tsir'), ('age', 18), ('height', 60.5)])

tuple与list相比，tuple会作为常量在编译时确定，所以速度会比list快很多；tuple是线程安全的；tuple可作为dict的key；tuple具有拆包特性。

defaultdict

defaultdict继承于dict，可以为value赋默认值。

给定一个list，要统计出其中每个元素重复出现的次数。若用dict来做的话

list = ['a','b','c','b','a','d']
d_dict = {}
for ch in list:
    if ch not in dict:
        d_dict[ch] = 1
    else:
        d_dict[ch] += 1
print(d_dict)

>>> {'a': 2, 'b': 2, 'c': 1, 'd': 1}

若使用defaultdict的话

from collections import defaultdict
list = ['a','b','c','b','a','d']
# defaultdict传入int则默认赋值0，传入list则默认赋值[]
df_dcit = defaultdict(int)
for ch in list:
    # 若ch不存在与df_dict中，defaultdict会自动让df_dcit[ch] = 0
    df_dcit[ch] += 1
print(df_dcit)

>>> defaultdict(<class 'int'>, {'a': 2, 'b': 2, 'c': 1, 'd': 1})

defaultdict不可以直接传入字典进行默认赋值，但可传入引用对象，就可以通过传入函数来达到对字典赋默认值的效果

def defineDict():
    return {
        'name': '',
        'age'L 0
    }
df_dict = defaultdict(defineDict)
print(df_dict['dc1'])

>>> {'name': '', 'age': 0}

deque

deque是双端队列,所以可以在两端进行操作

from collections import deque
user_deque = deque(['math','code','music'])
# 在头部添加元素
user_deque.appendleft('left')
# 在尾部添加元素
user_deque.append('end')
print(user_deque)

>>> deque(['left', 'math', 'code', 'music', 'end'])

deque可以合并

add_deque = deque([1,2,3])
user_deque.extend(add_deque)
print(user_deque)

>>> deque(['left', 'math', 'code', 'music', 'end', 1, 2, 3])

deque浅拷贝,即只复制元素和引用，所以修改引用的内容也会修改原deque的内容

user_deque2 = deque([[1,2,3], 'hello', 'python'])
user_deque3 = user_deque2.copy()
user_deque3[0][0] = 3
print(user_deque2, user_deque3)

>>> deque([[3,2,3], 'hello' ,'python']) deque([[3,2,3], 'hello' ,'python'])

若要完全复制一个不一样的deque需要采用copy模块中的深拷贝

import copy
user_deque4 = copu.deepcopy(user_deque3)
user_deque4[0][0] = 4
print(user_deque3, user_deque4)

>>> deque([[3,2,3], 'hello' ,'python']) deque([[4,2,3], 'hello' ,'python'])

deque与list相似，但不是继承于list。而queue队列其实是继承deque实现的。deque是线程安全的，是通过GIL保护的，而list是线程不安全的。

Counter

Counter模块用于统计，非常实用

from collections import Counter
c_list = ['k1','k2','k3','k2','k3','k3']
c_tuple = (1,1,2,2,3,3,3,4)
c_string = "acadsadaaf"
print(Counter(c_list), Counter(c_tuple), Counter(c_string))

>>> Counter({'k3': 3, 'k2': 2, 'k1': 1}) Counter({3: 3, 1: 2, 2: 2, 4: 1}) Counter({'a': 5, 'd': 2, 'c': 1, 's': 1, 'f': 1})

Counter还实用update方法可根据上一次结果继续统计,update()方法可传递任何可迭代的参数

count = Counter(c_string)
print(count)
count.update('ddassc')
print(count)

>>> Counter({'a': 5, 'd': 2, 'c': 1, 's': 1, 'f': 1})
    Counter({'a': 6, 'd': 4, 's': 3, 'c': 2, 'f': 1})

Counter模块还可以实用most_common函数找出出现次数top n的参数

# 打印出现次数最多的两个参数及次数
print(count.most_common(2))

>>> [('a',6), ('d',4)]

OrderedDict

OrderedDict 继承于dict，它拥有有序性，按照添加的顺序排列

exp_odict = OrderedDict()
exp_odict['b'] = 'b'
exp_odict['a'] = 'a'
exp_odict['c'] = 'c'
print(exp_odict)

>>> OrderedDict([('b', 'b'), ('a', 'a'), ('c', 'c')])

OrderedDict也可移除key

exp_odict.pop('c')
print(exp_odict)

>>> OrderedDict([('b', 'b'), ('a', 'a')])

OrderedDict可通过move_to_end()方法移动指定key到最后

exp_odict.move_to_end('b')
print(exp_odict)

>>> OrderedDict([('a', 'a'), ('b', 'b')])

Tips: 在python3.6之前dict是无序的，而在python3.6之后dict是有序的。

ChainMap

ChainMap可以用来将多个字典组合到一起

dict1 = {'a': 1, 'd': 2}
dict2 = {'c': 3, 'd': 4}
cha_dict = ChainMap(dict1, dict2)
# 以列表形式展示出来，maps是指向dict而不是copy
print(cha_dict.maps)
for k, v in cha_dict.items():
    # 若key相同，前面的key覆盖后面的key
    print(k, v)

>>> [{'a': 1, 'd': 2}, {'c': 3, 'd': 4}]
    d 2
    a 1
    c 3