Python-collections模块-58

模块的导入和使用

模块的导入应该在程序开始的地方

更多相关内容 http://www.cnblogs.com/Eva-J/articles/7292109.html

常用模块　　

collections模块

在内置数据类型（dict、list、set、tuple）的基础上，collections模块还提供了几个额外的数据类型：Counter、deque、defaultdict、namedtuple和OrderedDict等。

1.namedtuple: 生成可以使用名字来访问元素内容的tuple

2.deque: 双端队列，可以快速的从另外一侧追加和推出对象

3.Counter: 计数器，主要用来计数

4.OrderedDict: 有序字典

5.defaultdict: 带有默认值的字典


collections模块：Python中的扩展数据类型

#列表、元祖
#字典
#集合、frozenset
#字符串
#堆栈 : 先进后出
#队列 ：先进先出 FIFO

namedtuple

我们知道tuple可以表示不变集合，例如，一个点的二维坐标就可以表示成：

>>> p = (1, 2)

但是，看到(1, 2)，很难看出这个tuple是用来表示一个坐标的。

这时，namedtuple就派上了用场：

from collections import namedtuple
Point = namedtuple('point',['x','y','z'])
p1 = Point(1,2,3)
p2 = Point(3,2,1)
print(p1.x)
print(p1.y)
print(p1,p2)

#扑克牌花色和数字
Card = namedtuple('card',['suits','number'])
c1 = Card('红桃',2)
print(c1)
print(c1.number)
print(c1.suits)

类似的，如果要用坐标和半径表示一个圆，也可以用namedtuple定义：

#namedtuple('名称', [属性list]):
Circle = namedtuple('Circle', ['x', 'y', 'r'])

deque

使用list存储数据时，按索引访问元素很快，但是插入和删除元素就很慢了，因为list是线性存储，数据量大的时候，插入和删除效率很低。

deque是为了高效实现插入和删除操作的双向列表，适合用于队列和栈：

#队列
import queue
q = queue.Queue()
q.put([1,2,3])
q.put(5)
q.put(6)
print(q)
print(q.get())
print(q.get())
print(q.get())
print(q.get())   # 阻塞
print(q.qsize())  #判断大小

双端队列：

from collections import deque
dq = deque([1,2])
dq.append('a')   # 从后面放数据  [1,2,'a']
dq.appendleft('b') # 从前面放数据 ['b',1,2,'a']
dq.insert(2,3)    #['b',1,3,2,'a']
print(dq.pop())      # 从后面取数据
print(dq.pop())      # 从后面取数据
print(dq.popleft())  # 从前面取数据
print(dq)

OrderedDict

使用dict时，Key是无序的。在对dict做迭代时，我们无法确定Key的顺序。

如果要保持Key的顺序，可以用OrderedDict：

>>> from collections import OrderedDict
>>> d = dict([('a', 1), ('b', 2), ('c', 3)])
>>> d # dict的Key是无序的
{'a': 1, 'c': 3, 'b': 2}
>>> od = OrderedDict([('a', 1), ('b', 2), ('c', 3)])
>>> od # OrderedDict的Key是有序的
OrderedDict([('a', 1), ('b', 2), ('c', 3)])

注意，OrderedDict的Key会按照插入的顺序排列，不是Key本身排序：

>>> od = OrderedDict()
>>> od['z'] = 1
>>> od['y'] = 2
>>> od['x'] = 3
>>> od.keys() # 按照插入的Key的顺序返回
['z', 'y', 'x']

3.6开始字典变得有序了？

#有序字典
from collections import  OrderedDict
od = OrderedDict([('a', 1), ('b', 2), ('c', 3)])
print(od) # OrderedDict的Key是有序的
print(od['a'])
for k in od:
    print(k)

'''
OrderedDict([('a', 1), ('b', 2), ('c', 3)])
1
a
b
c
'''

defaultdict

有如下值集合 [11,22,33,44,55,66,77,88,99,90...]，将所有大于 66 的值保存至字典的第一个key中，将小于 66 的值保存至第二个key的值中。

即： { 'k1' : 大于 66 , 'k2' : 小于 66 }

values = [11, 22, 33,44,55,66,77,88,99,90]

my_dict = {}

for value in  values:
    if value>66:
        if my_dict.has_key('k1'):
            my_dict['k1'].append(value)
        else:
            my_dict['k1'] = [value]
    else:
        if my_dict.has_key('k2'):
            my_dict['k2'].append(value)
        else:
            my_dict['k2'] = [value]

from collections import defaultdict

values = [11, 22, 33,44,55,66,77,88,99,90]

my_dict = defaultdict(list)

for value in  values:
    if value>66:
        my_dict['k1'].append(value)
    else:
        my_dict['k2'].append(value)

使用dict时，如果引用的Key不存在，就会抛出KeyError。如果希望key不存在时，返回一个默认值，就可以用defaultdict：

>>> from collections import defaultdict
>>> dd = defaultdict(lambda: 'N/A')
>>> dd['key1'] = 'abc'
>>> dd['key1'] # key1存在
'abc'
>>> dd['key2'] # key2不存在，返回默认值
'N/A'

from collections import defaultdict
d = defaultdict(list)
print(d['k']) # []
d = defaultdict(lambda : 5) # defaultdict() 里面必须是一个可调用的类型 # 给字典
print(d['k']) # 5

Python 可调用对象

除了用户定义的函数，调用运算符（即 ()）还可以应用到其他对象上。如果想判断对象
能否调用，可以使用内置的 callable() 函数。Python 数据模型文档列出了 7 种可调用对
象。
(1)用户定义的函数
　　使用 def 语句或 lambda 表达式创建。

(2)内置函数
　　使用 C 语言（CPython）实现的函数，如 len 或 time.strftime。

(3)内置方法
　　使用 C 语言实现的方法，如 dict.get。

(4)方法
　　在类的定义体中定义的函数。

(5)类
　　调用类时会运行类的 __new__ 方法创建一个实例，然后运行 __init__ 方法，初始
化实例，最后把实例返回给调用方。因为 Python 没有 new 运算符，所以调用类相当于调
用函数。（通常，调用类会创建那个类的实例，不过覆盖 __new__ 方法的话，也可能出
现其他行为。）

(6)类的实例
如果类定义了 __call__ 方法，那么它的实例可以作为函数调用。

(7)使用 yield 关键字的函数或方法。

调用生成器函数返回的是生成器对象。

Counter

Counter类的目的是用来跟踪值出现的次数。它是一个无序的容器类型，以字典的键值对形式存储，其中元素作为key，其计数作为value。计数值可以是任意的Interger（包括0和负数）。Counter类和其他语言的bags或multisets很相似。