collections模块

collections模块

collections模块是数据类型的扩展模块，一些非常重要但平常又不经常使用的数据类型都放在该模块

(一)、单端队列

单端队列的特点：

• 先进先出：一边进另一边出，必须严格按照顺序进行
  • 导入模块：import queue
  • 实例化单端队列对象：q = queue.Queue()
  • 往队列中放入值：q.put(值)
  • 查看当前队列的大小：print(q.qsize())
  • 获取最先放进去的值：print(q.get())

import queue
q = queue.Queue()
q.put(1)
# put()放入值
print('大小%s' % q.qsize())
q.put('a')
print('大小%s' % q.qsize())
q.put((1,2,3))
print('大小%s' % q.qsize())
q.put({'k1': 'k2'})
print('大小%s' % q.qsize())
print(q)
# <Queue.Queue instance at 0x10b13c098>
print(q.get())
# 获取到的是最先放进去的值：1

'''
结果是：
大小1
大小2
大小3
大小4
<Queue.Queue instance at 0x101f8e0e0>
1

'''

• 队列外部是看不到内部的排列顺序的，单端队列非常的严格。

(二)、双端队列(deque)

• 双端队列两端都是可以进，也可以出，基于这样一个原理，越是先进去的越在双端队列的中间，出去的越晚。
• deque对象的基本操作：
  • 导入模块：from collections import deque
  • 创建双端队列对象：dq = deque()
  • 给队列加值：append()右侧添加， appendleft()左侧添加， insert()往指定的位置加值
  • 删除队列中的值：pop()删除末尾的值，popleft()删除左边的值，remove()删除指定的值
• deque对象格式是一个类似于列表类型，拥有列表的删除、增加的功能，但是两者之间存在区别：
  • 在insert、remove的时候，deque的平均效率要远远高于列表。
  • 列表在根据索引查看某个值的速度要高于deque
  • append和pop对于对于列表的速度和效率没有什么影响，如果从开头或者中间去操作，效率影响会很大，所以，实际的工作中列表操作很少会用到insert()和remove()。

from collections import deque
dq = deque()
# 创建双端队列对象
dq.append(1)
dq.append({'k1':'k2'})
# 往队列中添加数据
dq.append(23456)
dq.appendleft('123245')
dq.appendleft((1,2,3,4,5))
print(dq)
# 输出的数据为列表形式 
dq.pop()
print(dq)
dq.pop()
print(dq)
dq.remove('123245')
print(dq)
dq.popleft()
print(dq)
dq.insert(1, 1)
print(dq)

'''
deque([(1, 2, 3, 4, 5), '123245', 1, {'k1': 'k2'}, 23456])
deque([(1, 2, 3, 4, 5), '123245', 1, {'k1': 'k2'}])
deque([(1, 2, 3, 4, 5), '123245', 1])
deque([(1, 2, 3, 4, 5), 1])
deque([1])
deque([1, 1])
'''

(三)、创建新的数据类型：namedtuple

namedtuple创建新的数据类型，基本的步骤为：

• 导入包：from collections import namedtuple
• 创建新的类：类名 = namedtuple(‘对类的描述‘, [类的参数1, 类的参数2,...])
• 实例化类，创建类对象
• 通过对象.属性调用数据，因为是元组类型，也可以通过下标索引来调用

from collections import namedtuple
Rectagle = namedtuple('Ractangle_class', ['length', 'width'])
# 类名 = namedtuple('对类的描述', [类的参数名1， 参数名2...])
# 这个类实际上相当于创建了一个新的数据类型
r = Rectagle(100, 50)
# 实例化类           
print(r.length)
print(r.width)
# 实例化对象是一个元组，可以通过属性来访问
print(r)
print(r[1])
print(r[0])
# 也可以通过下标索引来访问

'''
100
50
Ractangle_class(length=100, width=50)
50
100

'''

(四)、defaultdict

正常的字典，当调用一个字典中没有的key时程序会报错，但是当通过defaultdict创建的字典如果调用没有字典中没有的key的时候不会报错，会返回一个默认值。
具体步骤：

• 导入包：from collections import defaultdict
• 创建字典: d = defaultdict(工厂, k1=‘v1‘, k2=‘v2‘,...)，这里的参数不能加引号
• 调用字典：d[‘k1‘], d[‘k2‘], d[‘k3‘]...
• 当调用到字典中不存在的key时，会返回工厂的默认返回值，并且把默认值和查询的key作为key、value添加到字典中去。
• 工厂的类型：
  • python已经定义好的数据类型
  • 自定义函数，函数不能有参数，直接时return 返回值

'''python定义好的数据类型'''
from collections import defaultdict
d = defaultdict(int, name='alex', age=19)
print(d['name'])
print(d['age'])
print(d['gender'])

'''
alex
19
0
'''

'''自定义函数作为工厂'''
from collections import defaultdict

def func():
    return 'dict'
    # 函数不能有参数

d = defaultdict(func, name='alex', age=100)
print(d['name'])
print(d['age'])
print(d['gender'])

'''
alex
100
dict
'''

(五)、计数器Counter

通过计数器可以获取对象中每一个元素出现的次数，并以字典的格式来返回， key为元素， value为该元素出现的次数。
具体用法：

• 导入包：from collections import Counter
• 创建计数器对象：c = Counter(需要被计数对象)
• 计数器对象是一个由参数和出现次数作为key、value的字典对象
• 查看出现次数最多的几个参数：c.most_common(num)， num表示要查看的前几个参数
• 删除字典对象的最后一位：c.popitem()

from collections import Counter

c = Counter([1,2,3,4,5,634,23,44,2,4,25,2,52,6,2,3,2,4,2,4,6,7])
print(c.most_common(4))
print(c)
print(c.popitem())
print(c)

'''
[(2, 6), (4, 4), (3, 2), (6, 2)]
Counter({2: 6, 4: 4, 3: 2, 6: 2, 1: 1, 5: 1, 634: 1, 23: 1, 44: 1, 25: 1, 52: 1, 7: 1})
(7, 1)
Counter({2: 6, 4: 4, 3: 2, 6: 2, 1: 1, 5: 1, 634: 1, 23: 1, 44: 1, 25: 1, 52: 1})
'''

注意：放入计数器中的对象必须是可哈希的，即可以迭代的对象

collections模块

原文：https://www.cnblogs.com/ddzc/p/12317722.html