python常用模块之collections模块

collections模块

官方文档参考地址

目录:

• namedtuple
• deque
• OrderdDict
• defaultdict
• Counter

 

1. namedtuple()

　　格式：collections.namedtuple(typename, field_names, *, rename=False, defaults=None, module=None)

　　参数:   typename: 元组名称， field_names: 元组中每个参数的名字， rename: 元素名字含有Python关键字必须设为True

　　·　　  剩下的参数python3.5,3.6.3.7都有区别，默认None就好

　　功能：就如其名，命名元组，类似于给元组中的每个变量添加一个名字，然后可以通过名字访问元素

 

用法：直接通过列表添加元素名字

>>> from collections import namedtuple
>>> Point = namedtuple('Point', ['x', 'y'])  # 元组名称为Point
>>> p = Point(3, 4)     # 直接按照位置创建对象
>>> p.x, p.y               # 直接根据名字取值
(3, 4)
>>> p   # 根据__repr__方法打印出元组名+元素名和值
Point(x=3, y=4)
>>> p = Point(x=3,y=5.5)    # 命名参数创建对象
>>> p
Point(x=3, y=5.5)
>>> a, b = p     # 类似元组可以直接解包
>>> a, b
(3, 5.5)
>>> p[0] + p[1]   # 直接按照下标取值
8.5

还可以通过字符串添加名字

>>> Student = namedtuple('Student', 'id, name, age')  # 还可以通过字符串设置元素名，字符串要可以通过空格和逗号分隔
>>> s = Student()
>>> s = Student(1, 'xiaoming', 12)
>>> s
Student(id=1, name='xiaoming', age=12)
>>> Student = namedtuple('Student', 'id name age')
>>> s = Student(2, 'xiaohong', 14)
>>> s
Student(id=2, name='xiaohong', age=14)

 当元素名称有关键字或重复时，python自动将该名称命名为_+下标， 此时rename参数也要设置为True

>>> test = namedtuple('test', ['def', 'name', 'for', 'name'], rename=True)
>>> t = test('def', 'test', 'for', 'test')      
>>> t._0
'def'
>>> t._2
'for'
>>> t._3
'test'
>>> t.name
'test'

namedtuple对象方法：

_make(iterable): 用一个可迭代对象赋值

>>> p1 = [1, 2]
>>> Point(p1)
>>> Point._make(p1)
Point(x=1, y=2)

_asdict(): 返回一个元素名与值的OrderedDict字典

>>> p._asdict()
OrderedDict([('x', 1), ('y', 2)])

_replace(**kwargs)： 修改元素值，并返回一个新的实例对象

>>> p._replace(x=3)
Point(x=3, y=2)

_fields：参看元素名称

>>> p._fields
('x', 'y')

 2. deque

　　格式: class collections.deque([iterable[, maxlen]])

　   参数：iterable: 从iterable对象依次取值赋给deque, 不传则为空队列 maxlen: 队列的最大长度，默认长度不限

　　功能: double ended queue 创建一个双端队列, 是线程安全的，性能也高，从任意一端取值或添加值得效率接近o(1)

 

用法：

创建deque对象:

>>> d = deque('abc')
>>> d
deque(['a', 'b', 'c'])
>>> d = deque()  # 创建一个空队列
>>> d
deque([])

deque对象方法: 

append(x):  向队列尾端添加一个元素

>>> d = deque('abc')
>>> d
deque(['a', 'b', 'c'])
>>> d.append('d')
>>> d
deque(['a', 'b', 'c', 'd'])

appendleft(x):  向队列左边添加一个元素

>>> d.appendleft('e')
>>> d
deque(['e', 'a', 'b', 'c', 'd'])

clear(): 清空队列元素

>>> d.clear()
>>> d
deque([])

copy():   返回一个浅拷贝deque对象

>>> a = [1, 2, 3, 4]
>>> d = deque()
>>> d.append(a)
>>> d
deque([[1, 2, 3, 4]])
>>> d2 = d.copy()  # 浅拷贝: d和d2是两个对象，但是子对象指向同一对象
>>> d2
deque([[1, 2, 3, 4]])
>>> a.append(5)  # a改变了，d和d2都改变了
>>> d
deque([[1, 2, 3, 4, 5]])
>>> d2
deque([[1, 2, 3, 4, 5]])

count(x):  返回元素个数

>>> d = deque('abcaaa')
>>> d
deque(['a', 'b', 'c', 'a', 'a', 'a'])
>>> d.count('a')
4

extend(iterable):  通过append方法把可迭代对象的每一个元素添加到队列尾端

>>> d = deque('a')
>>> d
deque(['a'])
>>> d.extend('bcd')
>>> d
deque(['a', 'b', 'c', 'd'])

extendleft(iterable):  通过appendleft方法把可迭代对象的每一个元素添加到队列左边

>>> d = deque('a')
>>> d
deque(['a'])
>>> d.extendleft('bcd')
>>> d
deque(['d', 'c', 'b', 'a'])

index(x[, start[, stop]]):  返回元素在队列第一次匹配的位置，位置stop>index>=start， 没有找到就报错

>>> d
deque(['d', 'c', 'b', 'a', 'a', 'b', 'c'])
>>> d.index('a')
3
>>> d.index('a', 4, 7)
4
>>> d.index('z')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: 'z' is not in deque

insert(i, x):  向指定位置添加一个元素，如果元素位置不存在则默认向尾部添加元素，如果插入操作会导致元素个数超过最大值，则会报异常

>>> d = deque('abc')
>>> d
deque(['a', 'b', 'c'])
>>> d.insert(1, 'd')
>>> d
deque(['a', 'd', 'b', 'c'])
>>> d.insert(6, 'g')
>>> d
deque(['a', 'd', 'b', 'c', 'g'])
>>> d.insert(-1, 'g')
>>> d
deque(['a', 'd', 'b', 'c', 'g', 'g'])

pop()： 从队列右边抛出一个元素并返回，如果队列为空，会抛出一个IndexError异常

deque(['a', 'b', 'c'])
>>> d.pop()
'c'
>>> d
deque(['a', 'b'])

popleft()： 从队列左边抛出一个元素并返回，如果队列为空，会抛出一个IndexError异常

>>> d = deque('abc')
>>> d
deque(['a', 'b', 'c'])
>>> d.popleft()
'a'
>>> d
deque(['b', 'c'])

remove(value)： 移除第一个找到的元素， 不存在则报异常

>>> d = deque('abcabc')
>>> d
deque(['a', 'b', 'c', 'a', 'b', 'c'])
>>> d.remove('b')
>>> d
deque(['a', 'c', 'a', 'b', 'c'])

reverse():  反转队列的元素，无返回值

>>> d = deque('abc')
>>> d
deque(['a', 'b', 'c'])
>>> d.reverse()
>>> d
deque(['c', 'b', 'a'])

rotate(n=1): 如果n>0 相当于将右边的n个元素依次移到左边，如果n<0 相当于将左边的n个元素依次移到右边

>>> d = deque([1, 2, 3, 4, 5, 6, 7])
>>> d
deque([1, 2, 3, 4, 5, 6, 7])
>>> d.rotate(2)
>>> d
deque([6, 7, 1, 2, 3, 4, 5])
>>> d.rotate(-2)
>>> d
deque([1, 2, 3, 4, 5, 6, 7])

 3. OrderedDict

　　格式: class collections.OrderedDict([items])

　   功能:  建立一个有序的字典，顺序是按照key插入的顺序排的，其他大都同字典类似

 

用法:

 

>>> from collections import OrderedDict
>>> dic = OrderedDict([('1',1), ('2', 2), (3,'3')])
>>> dic
OrderedDict([('1', 1), ('2', 2), (3, '3')])
>>> dic.popitem()  # 默认将最后一个键值对抛出
(3, '3')
>>> dic['4'] = 4
>>> dic
OrderedDict([('1', 1), ('2', 2), ('4', 4)])
>>> dic['1'] = 5
>>> dic
OrderedDict([('1', 5), ('2', 2), ('4', 4)])
>>> dic.move_to_end('1')  # 将第一个元素移动至最后一个
>>> dic
OrderedDict([('2', 2), ('4', 4), ('1', 5)])

 

4. defaultdict 

　　格式: defaultdict([default_factory[, ...]])

　　参数: default_factory: 为None时同字典一样，不为None时要是一个可调用的(Callable)对象，并作为一个key的默认值返回。

　　功能: 返回一个类似字典的带有默认值得字典，方法基本与字典一样

用法:

 1) 默认为列表可以省去判断key不存在的步骤

>>> from collections import defaultdict
>>> d = defaultdict(list)  # 默认是一个列表
>>> s = [('alpha', 'a'), ('digit', 1), ('alpha', 'b'), ('alpha', 'c'), ('digit', 5)]
>>> for k, v in s:
...     d[k].append(v)
... 
>>> d
defaultdict(<class 'list'>, {'alpha': ['a', 'b', 'c'], 'digit': [1, 5]})

2) 用来统计数目

>>> s = 'abcadfdfaklcmlfdfa'
>>> d = defaultdict(int)
>>> for k in s:
...     d[k] += 1
... 
>>> sorted(d.items(), key=lambda item: item[1])  # 按数目大小排序
[('b', 1), ('k', 1), ('m', 1), ('c', 2), ('l', 2), ('d', 3), ('f', 4), ('a', 4)]

3) 设置默认值为不可调用对象(用lambda函数)

>>> d = defaultdict(lambda: 0)
>>> d[5]
0

 

5. Counter

　　格式: Counter([iterable-or-mapping])

　　参数: 可迭代对象或是映射对象

　　功能: 它是一个类字典对象, 统计值出现的次数，value保存出现次数

用法: 

>>> from collections import Counter
>>> s = "abcabcabcdddda"  # 统计字符出现的次数
>>> c = Counter(s)
>>> c
Counter({'d': 4, 'a': 4, 'c': 3, 'b': 3})

>>> c = Counter(a=2, b=4)  # 用命名参数初始化
>>> c
Counter({'b': 4, 'a': 2})  
>>> d = Counter(c=3, a=5)
>>> d
Counter({'a': 5, 'c': 3})  
>>> c - d
Counter({'b': 4})  # 把key值相等的相减，只保留值为正的key
>>> c + d
Counter({'a': 7, 'b': 4, 'c': 3})  # 求并集，并把key值相等的相加
>>> c.subtract(d) 
>>> c
Counter({'b': 4, 'c': -3, 'a': -3})