Python中好用的模块-collections

深藏阁楼爱情的钟 2022-11-04 05:56 196阅读 0赞

Python中好用的collections模块

### 文章目录 ###

*   *   *   *  1. Counter
             *  2. defaultdict
             *  3. OrderedDict
             *  4. namedtuple
             *  5. deque
             *  6. ChainMap

这个模块实现了特定目标的容器，以提供Python标准内建容器 dict、list、set、tuple 的替代选择。

*  Counter：字典的子类，提供了可哈希对象的计数功能
 *  defaultdict：字典的子类，提供了一个工厂函数，为字典查询提供了默认值
 *  OrderedDict：字典的子类，保留了他们被添加的顺序
 *  namedtuple：创建命名元组子类的工厂函数
 *  deque：类似列表容器，实现了在两端快速添加(append)和弹出(pop)
 *  ChainMap：类似字典的容器类，将多个映射集合到一个视图里面

#### 1. Counter ####

Counter是一个dict子类，主要是用来对你访问的对象的频率进行计数。  
常用方法：

*  elements()：返回一个迭代器，每个元素重复计算的个数，如果一个元素的计数小于1,就会被忽略。
 *  most\_common(\[n\])：返回一个列表，提供n个访问频率最高的元素和计数
 *  subtract(\[iterable-or-mapping\])：从迭代对象中减去元素，输入输出可以是0或者负数
 *  update(\[iterable-or-mapping\])：从迭代对象计数元素或者从另一个 映射对象 (或计数器) 添加。

import collections
    
    # 统计字符出现的次数
    print(collections.Counter('hello world'))  # Counter({'l': 3, 'o': 2, 'h': 1, 'e': 1, ' ': 1, 'w': 1, 'r': 1, 'd': 1})
    # 统计单词个数
    print(collections.Counter('hello world hello lucy'.split()))  # Counter({'hello': 2, 'world': 1, 'lucy': 1})
    # 获取指定对象的访问次数，也可以使用get方法
    c = collections.Counter('hello world hello lucy'.split())
    print(c.get('hello'))  # 2
    # 查看元素
    print(list(c.elements()))  # ['hello', 'hello', 'world', 'lucy']
    # 清除
    c.clear()
    
    c1 = collections.Counter('hello world'.split())
    c2 = collections.Counter('hello lucy'.split())
    print(c1+c2)  # 追加对象，+或者c1.update(c2) 输出：Counter({'hello': 2, 'world': 1, 'lucy': 1})
    print(c1-c2)  # 减少对象，-或者c1.subtract(c2) 输出：Counter({'world': 1})

#### 2. defaultdict ####

`collections.defaultdict(default_factory)` 为字典的没有的key提供一个默认的值。参数应该是一个函数，当没有参数调用时返回默认值。如果没有传递任何内容，则默认为None。

import collections
    
    d = collections.defaultdict()
    d['hello'] = 'zhan'
    print(d)  # defaultdict(None, {'hello': 'zhan'})
    e = collections.defaultdict(str)
    e['hello11'] = 'zhan11'
    print(e)  # defaultdict(<class 'str'>, {'hello11': 'zhan11'})
    fruit = collections.defaultdict(int)
    print(fruit)  # defaultdict(<class 'int'>, {})
    s = [('NC', 'Raleigh'), ('VA', 'Richmond'), ('WA', 'Seattle'), ('NC', 'Asheville')]
    d = collections.defaultdict(list)
    for k, v in s:
        d[k].append(v)
    print(d)  # defaultdict(<class 'list'>, {'NC': ['Raleigh', 'Asheville'], 'VA': ['Richmond'], 'WA': ['Seattle']})

#### 3. OrderedDict ####

Python字典中的键的顺序是任意的:它们不受添加的顺序的控制。  
`collections.OrderedDict` 类提供了保留他们添加顺序的字典对象。

import collections
    
    o = collections.OrderedDict()
    o['key1'] = 'value1'
    o['key2'] = 'value2'
    o['key3'] = 'value3'
    # 如果在已经存在的key上添加新的值，将会保留原来的key的位置，然后覆盖value值。
    o['key1'] = 'value5'
    print(o)  # OrderedDict([('key1', 'value5'), ('key2', 'value2'), ('key3', 'value3')])

#### 4. namedtuple ####

三种定义命名元组的方法：第一个参数是命名元组的构造器（如下的：Person，Human）

import collections
    
    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)
    jack = P2('jack', 20, 190)
    rose = P3('rose', 29, 340)
    print(lucy)
    print(jack)
    print(rose)

#### 5. deque ####

collections.deque返回一个新的双向队列对象，从左到右初始化(用方法 append()) ，从 iterable （迭代对象) 数据创建。如果 iterable 没有指定，新队列为空。  
collections.deque队列支持线程安全，对于从两端添加(append)或者弹出(pop)，复杂度O(1)。  
虽然list对象也支持类似操作，但是这里优化了定长操作（pop(0)、insert(0,v)）的开销。  
如果 maxlen 没有指定或者是 None ，deques 可以增长到任意长度。否则，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。

import collections
    
    dd = collections.deque(maxlen=10)
    print(dd)
    dd.extend('python')
    print([i.upper() for i in dd])
    dd.append('e')
    print(dd)
    dd.appendleft('f')
    print(dd)

#### 6. ChainMap ####

一个 ChainMap 将多个字典或者其他映射组合在一起，创建一个单独的可更新的视图。 如果没有 maps 被指定，就提供一个默认的空字典 。ChainMap是管理嵌套上下文和覆盖的有用工具。

import collections
    
    d1 = { 'apple': 1, 'banana': 2}
    d2 = { 'orange': 2, 'apple': 3, 'pike': 1}
    combined_d = collections.ChainMap(d1, d2)
    print(combined_d)  # ChainMap({'apple': 1, 'banana': 2}, {'orange': 2, 'apple': 3, 'pike': 1})
    for k, v in combined_d.items():
        print(k, v)
    
    reverse_combind_d = collections.ChainMap(d2, d1)
    print(reverse_combind_d)  # ChainMap({'orange': 2, 'apple': 3, 'pike': 1}, {'apple': 1, 'banana': 2})
    for k, v in reverse_combind_d.items():
        print(k, v)