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

(一)、单端队列

单端队列的特点：

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

      print(q.get())

      获取到的是最先放进去的值：1

‘’’ 结果是： 大小1 大小2 大小3 大小4

1

‘’’

  2. - 队列外部是看不到内部的排列顺序的，单端队列非常的严格。
  3. <a name="ycpue"></a>
  4. ### (二)、双端队列(deque)
  6. - 双端队列两端都是可以进，也可以出，基于这样一个原理，越是先进去的越在双端队列的中间，出去的越晚。
  7. - deque对象的基本操作：
  8.    - 导入模块：from collections import deque
  9.    - 创建双端队列对象：dq = deque()
  10.    - 给队列加值：append()右侧添加， appendleft()左侧添加， insert()往指定的位置加值
  11.    - 删除队列中的值：pop()删除末尾的值，popleft()删除左边的值，remove()删除指定的值
  12. - deque对象格式是一个类似于列表类型，拥有列表的删除、增加的功能，但是两者之间存在区别：
  13.    - 在insert、remove的时候，deque的平均效率要远远高于列表。
  14.    - 列表在根据索引查看某个值的速度要高于deque
  15.    - append和pop对于对于列表的速度和效率没有什么影响，如果从开头或者中间去操作，效率影响会很大，所以，实际的工作中列表操作很少会用到insert()和remove()。
  16. ```python
  17. from collections import deque
  18. dq = deque()
  19. # 创建双端队列对象
  20. dq.append(1)
  21. dq.append({'k1':'k2'})
  22. # 往队列中添加数据
  23. dq.append(23456)
  24. dq.appendleft('123245')
  25. dq.appendleft((1,2,3,4,5))
  26. print(dq)
  27. # 输出的数据为列表形式 
  28. dq.pop()
  29. print(dq)
  30. dq.pop()
  31. print(dq)
  32. dq.remove('123245')
  33. print(dq)
  34. dq.popleft()
  35. print(dq)
  36. dq.insert(1, 1)
  37. print(dq)
  39. '''
  40. deque([(1, 2, 3, 4, 5), '123245', 1, {'k1': 'k2'}, 23456])
  41. deque([(1, 2, 3, 4, 5), '123245', 1, {'k1': 'k2'}])
  42. deque([(1, 2, 3, 4, 5), '123245', 1])
  43. deque([(1, 2, 3, 4, 5), 1])
  44. deque([1])
  45. deque([1, 1])
  46. '''

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

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

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

‘’’

  2. <a name="95oGm"></a>
  3. ### (四)、defaultdict
  4. 正常的字典，当调用一个字典中没有的key时程序会报错，但是当通过defaultdict创建的字典如果调用没有字典中没有的key的时候不会报错，会返回一个默认值。<br />具体步骤：
  6. - 导入包：from collections import defaultdict
  7. - 创建字典: d = defaultdict(工厂, k1='v1', k2='v2',...)，这里的参数不能加引号
  8. - 调用字典：d['k1'], d['k2'], d['k3']...
  9. - 当调用到字典中不存在的key时，会返回工厂的默认返回值，并且把默认值和查询的key作为key、value添加到字典中去。
  10. - 工厂的类型：
  11.    - python已经定义好的数据类型
  12.    - 自定义函数，函数不能有参数，直接时return 返回值
  13. ```python
  14. '''python定义好的数据类型'''
  15. from collections import defaultdict
  16. d = defaultdict(int, name='alex', age=19)
  17. print(d['name'])
  18. print(d['age'])
  19. print(d['gender'])
  21. '''
  22. alex
  23. 19
  24. 0
  25. '''
  1. '''自定义函数作为工厂'''
  2. from collections import defaultdict
  4. def func():
  5.     return 'dict'
  6.     # 函数不能有参数
  8. d = defaultdict(func, name='alex', age=100)
  9. print(d['name'])
  10. print(d['age'])
  11. print(d['gender'])
  13. '''
  14. alex
  15. 100
  16. dict
  17. '''

(五)、计数器Counter

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

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

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