collections模块的数据结构简介

爱被打了一巴掌 2021-09-29 13:40 368阅读 0赞

# 要点概论： #

### 1.  defaultdict 对象 ###

### 2. OrderedDict 对象 ###

### 3. ChainMap 对象 ###

### 4. Counter 对象 ###

### 5. namedtuple 对象 ###

### 6. UserDict ，UserList ， UserString 对象 ###

## ##

## 1. defaultdict 对象 ##

collections.defaultdict(function\_factory) 用于构建类似 dict 的对象。

与 dict 的区别是，创建 defaultdict 对象时，可以使用构造函数参数 function\_factory，指定其键 / 值对中值得类型。

其中，可选参数 function\_factory 为字典键 / 值对中值的类型；其他可选参数同 dict 构造函数。

defaultdict 实现了 \_\_missing(key) ，即键不存在时，返回值的类型（function\_factory）对应的默认值，例如，数值为 0 ，字符串为 '' ，list  为 \[ \] 等。

**defaultdict 对象示例：**

![ContractedBlock.gif][] ![ExpandedBlockStart.gif][]

from collections import defaultdict
    
    s = [('r',1),('g',2),('b',3)]
    
    dd = defaultdict(int,s)
    print(dd)       # defaultdict(<class 'int'>, {'g': 2, 'b': 3, 'r': 1})
    print(dd['b'])  # 3
    print(dd['w'])  # 不存在时，返回默认值 0

创建对象并索引

![ContractedBlock.gif][] ![ExpandedBlockStart.gif][]

from collections import defaultdict
    
    s1 = [('r',1),('g',2),('b',3),('r',4),('b',5)]
    
    dd1 = defaultdict(list)    # 指定值的类型为列表，即可以 .append 添加值
    for k,v in s1:
        print(dd1)
        dd1[k].append(v)
    
    print(list(dd1.items()))    # [('b', [3, 5]), ('g', [2]), ('r', [1, 4])] 每次结果是无序的

设置值的类型

## 2. OrderedDict 对象 ##

collections.OrderedDict 是 dict 的子类，能够记录字典元素插入的顺序（有序字典）。其构造函数为：

**collections.OrderedDict(\[items\])　　\#构造函数**

**　　**OrderedDict 对象的元素保持插入的顺序，更新键的值时，不改变顺序；删除项，然后再插入与删除项相同的键 / 值对时，则置于末尾。

除了继承 dict 的方法， OrderedDict 对象包括以下两个方法。

**　1）popitem(last=True) ：弹出最后一个元素（LIFO）；如果 last=False ，则袒护第一个元素（FIFO）。**

**　　　　2）move\_to\_end(key,last=True)：移动 key 到最后；如果 last=False，则移动到最前面。**

注意，两个 OrderedDict 对象的相等比较运算（==）与元素的位置顺序有关。OrderedDict 对象支持反向迭代，使用 reversed() 反转列表中元素。

**OrderedDict对象示例**

![ContractedBlock.gif][] ![ExpandedBlockStart.gif][]

from collections import OrderedDict
    
    d = {
         'banana':3,'apple':4,'pear':1,'orange':2}
    
    print(d.items())    # dict_items([('pear', 1), ('apple', 4), ('orange', 2), ('banana', 3)])
    print(sorted(d.items()))    # [('apple', 4), ('banana', 3), ('orange', 2), ('pear', 1)]
    
    od = OrderedDict(sorted(d.items()))
    print(od)   # OrderedDict([('apple', 4), ('banana', 3), ('orange', 2), ('pear', 1)])
    print(od.popitem()) # ('pear', 1)
    
    
    od.move_to_end('apple')     # 把 'apple' 键 / 值对移动到最后
    print(od)   # OrderedDict([('banana', 3), ('orange', 2), ('apple', 4)])
    # collections.OrderedDict([items])  构造函数

创建OrderedDict对象和使用方法

![ContractedBlock.gif][] ![ExpandedBlockStart.gif][]

from collections import OrderedDict
    
    dd = {
         'banana': 3, 'apple':4, 'pear': 1, 'orange': 2}
    kd = OrderedDict(sorted(dd.items(), key=lambda t: t[0]))    #按key排序
    print(kd)
    
    vd = OrderedDict(sorted(dd.items(),key=lambda t:t[1]))      #按照value排序
    print(vd)
    
    # 程序运行结果如下：
    OrderedDict([('apple', 4), ('banana', 3), ('orange', 2), ('pear', 1)])
    OrderedDict([('pear', 1), ('orange', 2), ('banana', 3), ('apple', 4)])

分别按照key或value排序

## 3. ChainMap 对象 ##

collections.ChainMap 对象用于连接多个 map ，其构造函数为：

**ChainMap(\*maps)　　\# 构造函数**

ChainMap 对象内部包含多个 map 列表，map 属性返回这个列表。第一个 map 为子 map ，其他 map 为父 map。

查询时，首先查询第一个 map ，如果没有查到，则一次查询其他 map 。 ChainMap 对象只允许更新第一个 map。

ChainMap 对象 cmap 除了支持字典映射的属性和方法外，还包含下列属性和方法。

**1）cmap.maps：【属性】。返回 cmap 对象内部包含的 map 的列表。**

**　　2）cmap.parents：【属性】。返回包含其父 map 的新的 ChainMap 对象，即 ChainMap(\*d,maps\[1:\])。**

**　　3）cmap.new\_child()：【方法】。返回新的 ChainMap 对象，即 ChainMap(\{\},\*d.maps)。**

**ChainMap 对象示例：**

![ContractedBlock.gif][] ![ExpandedBlockStart.gif][]

from collections import ChainMap
    
    m1 = {
         'a':1,'b':2}
    m2 = {
         'a':2,'x':3,'y':4}
    m = ChainMap(m1,m2)
    
    print(m.maps)           # [{'b': 2, 'a': 1}, {'x': 3, 'y': 4, 'a': 2}]
    print(m.parents)        # ChainMap({'y': 4, 'a': 2, 'x': 3})
    
    print(m.new_child())    # ChainMap({}, {'b': 2, 'a': 1}, {'a': 2, 'x': 3, 'y': 4})
    
    print(m['a'])           # 1
    print(m['x'])           # 3
    m['a'] = 99             # 更新 'a' 的值为99
    m['x'] = 10             # 更新键 'x' 的值，因为父 map 不能更新，故实际上再子 map 中插入键 / 值对
    print(m)                # ChainMap({'a': 99, 'x': 10, 'b': 2}, {'a': 2, 'x': 3, 'y': 4})

ChainMap 对象示例

**ChainMap 对象应用示例：**

【程序中参数值可以为默认值 map1，环境变量 map2 ，命令行参数 map3 ，优先顺序为 map3 > map2 > map1 。使用 ChainMap(map3,map2,map1)，可以保证有限使用命令行指定的参数。】

![ContractedBlock.gif][] ![ExpandedBlockStart.gif][]

import os,argparse
    from collections import ChainMap
    
    defaults = {
         'color':'red','user':'guest'}
    parser = argparse.ArgumentParser()
    parser.add_argument('-u','--user')
    parser.add_argument('-c','--color')
    namespace = parser.parse_args()
    command_line_args = {k:v for k,v in vars(namespace).items() if v}
    combined = ChainMap(command_line_args,os.environ,defaults)
    
    print(combined['color'])
    print(combined['user'])
    
    # 程序运行结果如下：
    # red
    # guest

ChainMap.py

** argparse 模块介绍：[http://blog.csdn.net/lis\_12/article/details/54618868][http_blog.csdn.net_lis_12_article_details_54618868]**

## 4. Counter 对象 ##

collections.Counter 对象（计数器）用于统计各元素的计数，结果为 map ，其构造函数为：

**Couner(\[iterable-or-mapping\])　　\# 构造函数**

可选参数为系列或字典 map。

**创建 Counter 对象示例：**

from collections import Counter
    
    c1 = Counter()                      # 创建空的 Counter 对象
    c2 = Counter('banana')             # 基于系列创建 Counter 对象
    c3 = Counter({
        'red':4,'blue':2})  # 基于字典映射创建 Counter 对象
    c4 = Counter(cats = 4,dogs = 8)    # 基于命名参数创建 Counter 对象
    
    print(c1);print(c2);print(c3);print(c4)
    
    # 程序运行结果如下
    # Counter()
    # Counter({'a': 3, 'n': 2, 'b': 1})
    # Counter({'red': 4, 'blue': 2})
    # Counter({'dogs': 8, 'cats': 4})

PS：查询时，如果键不存在，不会报错，而是返回值 0 。

Counter 对象 c 还包含下列属性和方法：

**1）c.elements()：返回元素列表，各元素重复的次数为其计数**

**　　　　2）c.most\_common(\[n\])：返回计数值最大的 n 个元素的元组（元素，计数）列表**

**　　　　3）c.subtract(\[iterable-or-mapping\])：元素的计数值减去系列或字典中对应元素的计数。**

**Counter 对象方法示例：**

![ContractedBlock.gif][] ![ExpandedBlockStart.gif][]

from collections import Counter
    
    c = Counter({
         'r':3,'g':2,'b':1,'y':4,'w':3})
    
    print(c.elements())         # <itertools.chain object at 0x0000024F5A6A8E10>
    print(list(c.elements()))   # ['g', 'g', 'r', 'r', 'r', 'y', 'y', 'y', 'y', 'b', 'w', 'w', 'w']
    print(c.most_common(3))     # [('y', 4), ('w', 3), ('r', 3)]
    
    c.subtract('r');c           # 待补充

方法示例

**Counter 对象应用示例【统计文本文件中单词频率，输出最高频率的 5 个单词】：**

![ContractedBlock.gif][] ![ExpandedBlockStart.gif][]

import collections,re
    
    with open('test_Counter',encoding='utf-8') as f:
        words = re.findall(r'\w+',f.read().lower())
        c = collections.Counter(words)
        print(c.most_common(5))
    
    # 程序运行结果如下
    # [('i', 6), ('to', 5), ('very', 5), ('can', 4), ('but', 3)]

统计文件单词频率

**附录【上例中读取的文本文件内容】：**

![ContractedBlock.gif][] ![ExpandedBlockStart.gif][]

don't know what I do now is right, those are wrong, and when I finally Laosi when I know these. So I can do now is to try to do well in everything,
    and then wait to die a natural death.Sometimes I can be very happy to talk to everyone, can be very presumptuous, but no one knows,
    it is but very deliberatelycamouflage, camouflage; I can make him very happy very happy, but couldn't find the source of happiness,
    just giggle.
    
    【中文：我不知道我现在做的哪些是对的,那些是错的,而当我终于老死的时候我才知道这些.所以我现在所能做的就是尽力做好每一件事,然后等待着老死.
    有时候我可以很开心的和每个人说话,可以很放肆的,可是却没有人知道,那不外是伪装,很刻意的伪装；我可以让自己很快乐很快乐,可是却找不到快乐的源头,
    只是傻笑.】

test\_Counter

## 5. namedtuple 对象 ##

元组（tuple）时常用的数据类型，但只能通过索引访问其元素，如果 tuple 中的元素很多时，操作起来就比较麻烦，且容易出错。

使用 namdtuple 的构造函数，可以定义一个 tuple 的子类命名元组。namedtuple 对象既可以使用元素名称访问其元素，也可使用索引访问。其构造函数为：

namedtuple(typename, field\_names, verbose=False, rename=False)　　　　\# 构造函数

其中，typename 是返回 tuple 的子类的类名；field\_names 是命名元组元素的名称，必须为合法的标识符；

verbose 为 True 时，创建命名元组后会打印类定义信息；rename 为 True 时，field\_names 中如果包含保留关键字，则自动命名为 \_1，\_2，......。

创建的命名元组的类可以通过其 \_source 和 \_fields 返回其代码和字段属性。

**somenamedtuple.\_source：类的代码。**

**　　　　somenamedtuple.\_dields：类的字段属性。**

**namedtuple 对象示例：**

from collections import namedtuple
    
    p = namedtuple('Point',['x','y'])
    print(p._source)    # 打印类的代码
    print(p._fields)    # 打印类的字段属性。输出：('x', 'y')
    p.x = 11;p.y = 22
    print(p.x + p.y)      # 使用元素名称访问命名元组的元素。输出：33

namedtuple 创建的类继承与 tuple ，包含以下三个额外的方法。

s**omenamedtuple.\_make(iterable)：从指定系列 iterable 构建命名元组对象。**

**　　　　somenamedtuple.\_asdict()：把命名元组对象转换为 OrderedDict 对象。**

**　　　　somenamedtuple.replace(kwargs)：创建新的命名元组对象，替换指定字段。**

**namedtuple 对象方法示例：**

![ContractedBlock.gif][] ![ExpandedBlockStart.gif][]

from collections import namedtuple
    
    p = namedtuple('Point',['x','y'])
    t = [3,4]
    p1 = p._make(t)
    print(p1)                   # Point(x=3, y=4)
    print(p1._asdict())         # OrderedDict([('x', 3), ('y', 4)])
    print(p1._replace(x=30))    # Point(x=30, y=4)

namedtuple 对象应用示例（**待补充**）

## 6. UserDict ，UserList ， UserString 对象 ##

collections.6.UserDict ，UserList ， UserString 对象分别时 dict，list 和 str 的子类，一般用于创建其派生类。其构造函数如下：

**UserDict(\[initialdata\])　　　　\# 构造函数**

**　　　　UserLiist(\[list\])　　　　　　   \# 构造函数**

**　　　　UserString(\[sequence\])　　  \# 构造函数**

虽然可以直接基于 dict，list 和 str 创建派生类，但 UserDict ， UserList ，UserString 包括一个属性成员：data ，用于存放内容，因而可以更方便地实现。

**UserString 对象示例：**

from collections import *
    
    us = UserString('abc')
    print(us.data)              # abc

转载于:https://www.cnblogs.com/HZY258/p/8537812.html

[ContractedBlock.gif]: https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif
[ExpandedBlockStart.gif]: /images/20210725/1489f1d6d2fe4413841fecea7c107c27.png
[http_blog.csdn.net_lis_12_article_details_54618868]: http://blog.csdn.net/lis_12/article/details/54618868