目录
1. namedtuple(typename, field_names[, verbose=False][, rename=False])
2. deque([iterable[, maxlen]])
3. Counter([iterable-or-mapping])
5. defaultdict([default_factory[, ...]])
简介
collections 是 python 的内置模块，提供了对dict , list , set , 和 tuple 容器类的功能扩展或替代。合理使用此模块，有助于提高代码的性能和可读性。
- namedtuple()：创建命名元组子类的工厂函数
- deque：创建一个可在两头操作的队列，类似列表(list)的容器，实现了在两端快速添加(append)和弹出(pop)
- Counter：字典的子类，提供了可哈希对象的计数功能
- OrderedDict：字典的子类，保存了他们被添加的顺序。普通的dict类，添加的数据会根据key值自动排序。如果使用print或遍历等方法，列印出来的顺序与添加的顺序不一定相同。
- defaultdict：字典的子类，提供了一个工厂函数，为字典查询提供一个默认值
https://docs.python.org/zh-cn/2.7/library/collections.html#collections.defaultdict1. namedtuple(typename, field_names[, verbose=False][, rename=False])
它会返回一个新的元组的子类，即其作用是创建一个tuple的子类，不过tuple中的各个元素添加了个名字。本质还是个tuple。
所以其返回值是个类。所以要想使用，就还需要用这个子类初始化才能得到数据对象。以下这些help中的案例，对其使用演示的比较清晰。
>>> Point = namedtuple('Point', ['x', 'y'])
>>> Point.__doc__ # docstring for the new class
'Point(x, y)'
>>> p = Point(11, y=22) # instantiate with positional args or keywords
>>> p[0] + p[1] # indexable like a plain tuple
33
>>> x, y = p # unpack like a regular tuple
>>> x, y
(11, 22)
>>> p.x + p.y # fields also accessable by name
33
>>> d = p._asdict() # convert to a dictionary
>>> d['x']
11
>>> Point(**d) # convert from a dictionary
Point(x=11, y=22)
>>> p._replace(x=100) # _replace() is like str.replace() but targets named fields
Point(x=100, y=22)
命名元组尤其有用于赋值 csv sqlite3 模块返回的元组
EmployeeRecord = namedtuple('EmployeeRecord', 'name, age, title, department, paygrade')
import csv
for emp in map(EmployeeRecord._make, csv.reader(open("employees.csv", "rb"))):
print emp.name, emp.title
import sqlite3
conn = sqlite3.connect('/companydata')
cursor = conn.cursor()
cursor.execute('SELECT name, age, title, department, paygrade FROM employees')
for emp in map(EmployeeRecord._make, cursor.fetchall()):
print emp.name, emp.title_make()和_asdict()是namedtuple所创建子类的两个好方法：
_make()可直接从tuple或者list数据生成子类对象。
_asdict()可将子类对象直接转化为字典数据。
>>> User = namedtuple("User",["name", "age", "weight"])
>>>
>>> userdata = ["root",18,50]
>>> user_root = User._make(userdata)
>>> user_root
User(name='root', age=18, weight=50)
>>> user_root._asdict()
OrderedDict([('name', 'root'), ('age', 18), ('weight', 50)])
>>>
>>> userdata = ["admin",20,70]
>>> user_admin = User._make(userdata)
>>> user_admin
User(name='admin', age=20, weight=70)
>>> user_admin._asdict()
OrderedDict([('name', 'admin'), ('age', 20), ('weight', 70)])2. deque([iterable[, maxlen]])
返回一个新的双向队列对象，从左到右初始化(用方法 append()) ，从 iterable （迭代对象) 数据创建。如果 iterable 没有指定，新队列为空。
Deque队列是由栈或者queue队列生成的（发音是 “deck”，”double-ended queue”的简称）。
Deque 支持线程安全，内存高效添加(append)和弹出(pop)，从两端都可以。
虽然 list 对象也支持类似操作，不过这里优化了定长操作和 pop(0) 和 insert(0, v) 的开销。
如果 maxlen 没有指定或者是
None，deques 可以增长到任意长度。否则，deque就限定到指定最大长度。一旦限定长度的deque满了，当新项加入时，同样数量的项就从另一端弹出。限定长度deque提供类似Unix filtertail的功能。它们同样可以用与追踪最近的交换和其他数据池活动。
双向队列deque的对象的常用方法：
| 属性maxlen | Deque的最大尺寸，如果没有限定的话就是 None 。 |
| append(x) | 添加 x 到 队列的右端。 |
| appendleft(x) | 添加 x 到 队列的左端 |
| clear() | 移除所有元素，使其长度为0. |
| count(x) | 计算queue中元素等于x的个数。 |
| extend(iterable) | 扩展deque的右侧，通过添加iterable参数中的元素。 |
| extendleft(iterable) | 扩展deque的左侧，通过添加iterable参数中的元素。 注意，左添加时，在结果中iterable参数中的顺序将被反过来添加。 |
| pop() | 移去并且返回一个元素，deque 最右侧的那一个。 如果没有元素的话，就引发一个 IndexError。 |
| popleft() | 移去并且返回一个元素，deque 最左侧的那一个。 如果没有元素的话，就引发 IndexError。 |
| remove(value) | 移除找到的第一个 value。 如果没有的话就引发 ValueError。 |
| reverse() | 将deque逆序排列。返回 None 。 |
| rotate(n=1) | 向右循环移动 n 步。 如果 n 是负数，就向左循环。 如果deque不是空的，向右循环移动一步就等价于 |
deque示例：
>>> from collections import deque
>>> d = deque('ghi') # make a new deque with three items
>>> for elem in d: # iterate over the deque's elements
... print elem.upper()
G
H
I
>>> d.append('j') # add a new entry to the right side
>>> d.appendleft('f') # add a new entry to the left side
>>> d # show the representation of the deque
deque(['f', 'g', 'h', 'i', 'j'])
>>> d.pop() # return and remove the rightmost item
'j'
>>> d.popleft() # return and remove the leftmost item
'f'
>>> list(d) # list the contents of the deque
['g', 'h', 'i']
>>> d[0] # peek at leftmost item
'g'
>>> d[-1] # peek at rightmost item
'i'
>>> list(reversed(d)) # list the contents of a deque in reverse
['i', 'h', 'g']
>>> 'h' in d # search the deque
True
>>> d.extend('jkl') # add multiple elements at once
>>> d
deque(['g', 'h', 'i', 'j', 'k', 'l'])
>>> d.rotate(1) # right rotation
>>> d
deque(['l', 'g', 'h', 'i', 'j', 'k'])
>>> d.rotate(-1) # left rotation
>>> d
deque(['g', 'h', 'i', 'j', 'k', 'l'])
>>> deque(reversed(d)) # make a new deque in reverse order
deque(['l', 'k', 'j', 'i', 'h', 'g'])
>>> d.clear() # empty the deque
>>> d.pop() # cannot pop from an empty deque
Traceback (most recent call last):
File "<pyshell#6>", line 1, in -toplevel-
d.pop()
IndexError: pop from an empty deque
>>> d.extendleft('abc') # extendleft() reverses the input order
>>> d
deque(['c', 'b', 'a'])3. Counter([iterable-or-mapping])
它是dict的subclass，用于统计计数。结果的元素，按照字典的key/value成对排序的。
或者说，对于可迭代对象比如string, list或dict等，Counter()可统计每个元素出现的次数。
>>> # Tally occurrences of words in a list
>>> from collections import *
>>>
>>> colors = ['red', 'blue', 'red', 'green', 'blue', 'blue']
>>> Counter(colors)
Counter({'blue': 3, 'red': 2, 'green': 1})
>>> # Find the ten most common words in Hamlet
>>> import re
>>> words = re.findall(r'\w+', open('hamlet.txt').read().lower())
>>> Counter(words).most_common(10)
[('the', 1143), ('and', 966), ('to', 762), ('of', 669), ('i', 631),
('you', 554), ('a', 546), ('my', 514), ('hamlet', 471), ('in', 451)]
>>> Counter('gallahad')
Counter({'a': 3, 'l': 2, 'h': 1, 'g': 1, 'd': 1})
# elements(), 返回一个迭代器，每个元素重复计数的个数。元素顺序是任意的。
>>> c = Counter(a=4, b=2, c=0, d=-2, e=1)
>>> del c['e']
>>> list(c.elements())
['a', 'a', 'a', 'a', 'b', 'b']
# most_common([n]), Return a list of the n most common elements
>>> Counter('abracadabra').most_common(3)
[('a', 5), ('r', 2), ('b', 2)]
# subtract([iterable-or-mapping]), 从 迭代对象 或 映射对象 减去元素。
>>> c = Counter(a=4, b=2, c=0, d=-2)
>>> d = Counter(a=1, b=2, c=3, d=4)
>>> c.subtract(d)
>>> c
Counter({'a': 3, 'b': 0, 'c': -3, 'd': -6})
# Counter 对象的常用案例
>>> sum(c.values()) # total of all counts
>>> c.clear() # reset all counts
>>> list(c) # list unique elements
>>> set(c) # convert to a set
>>> dict(c) # convert to a regular dictionary
>>> c.items() # convert to a list of (elem, cnt) pairs
>>> Counter(dict(list_of_pairs)) # convert from a list of (elem, cnt) pairs
>>> c.most_common()[:-n-1:-1] # n least common elements
>>> c += Counter() # remove zero and negative counts
# 提供了几个数学操作
>>> c = Counter(a=3, b=1)
>>> d = Counter(a=1, b=2)
>>> c + d # add two counters together: c[x] + d[x]
Counter({'a': 4, 'b': 3})
>>> c - d # subtract (keeping only positive counts)
Counter({'a': 2})
>>> c & d # intersection: min(c[x], d[x])
Counter({'a': 1, 'b': 1})
>>> c | d # union: max(c[x], d[x])
Counter({'a': 3, 'b': 2})
4. OrderedDict
OrderedDict 是字典的子类，但与普通的dict不同的是，它会记录并保持元素的插入顺序。它可以与排序结合使用来创建一个已排序的字典。其属性及方法，在py2上，与dict没有什么差异。
>>> from collections import OrderedDict
# regular unsorted dictionary
>>> d = {'banana': 3, 'apple': 4, 'pear': 1, 'orange': 2}
# dictionary sorted by key
>>> OrderedDict(sorted(d.items(), key=lambda t: t[0]))
OrderedDict([('apple', 4), ('banana', 3), ('orange', 2), ('pear', 1)])
# dictionary sorted by value
>>> OrderedDict(sorted(d.items(), key=lambda t: t[1]))
OrderedDict([('pear', 1), ('orange', 2), ('banana', 3), ('apple', 4)])
# dictionary sorted by length of the key string
>>> OrderedDict(sorted(d.items(), key=lambda t: len(t[0])))
OrderedDict([('pear', 1), ('apple', 4), ('orange', 2), ('banana', 3)])
# usually usage
>>> d = OrderedDict()
>>> d['name']='root'
>>> d['age']=5
>>> d['grade']=2
>>> d['class']=10
5. defaultdict([default_factory[, ...]])
返回一个新的类似字典的对象。它实现了当 key 不存在时返回默认值的功能。 defaultdict 是内置 dict 类的子类。它重载了一个方法并添加了一个可写的实例变量。其余的功能与 dict 类相同。
参数default_factory必须是可操作的，比如 python 内置类型，或者无参的可调用的函数。
>>> from collections import *
# 以list作为default_factory
# it is easy to group a sequence of key-value pairs into a dictionary of lists
>>> s = [('yellow', 1), ('blue', 2), ('yellow', 3), ('blue', 4), ('red', 1)]
>>> d = defaultdict(list)
>>> for k, v in s:
... d[k].append(v)
...
>>> d.items()
[('blue', [2, 4]), ('red', [1]), ('yellow', [1, 3])]
# or to a new dict object
>>> d = {}
>>> for k, v in s:
... d.setdefault(k, []).append(v)
...
>>> d.items()
[('blue', [2, 4]), ('red', [1]), ('yellow', [1, 3])]
# Setting the default_factory to int makes the defaultdict useful for counting
>>> s = 'mississippi'
>>> d = defaultdict(int)
>>> for k in s:
... d[k] += 1
...
>>> d.items()
[('i', 4), ('p', 2), ('s', 4), ('m', 1)]
# Setting the default_factory to set makes the defaultdict useful for building a dictionary of sets:
>>> s = [('red', 1), ('blue', 2), ('red', 3), ('blue', 4), ('red', 1), ('blue', 4)]
>>> d = defaultdict(set)
>>> for k, v in s:
... d[k].add(v)
...
>>> d.items()
[('blue', set([2, 4])), ('red', set([1, 3]))]
# 无参函数作为default_factory
>>> def StudentInfo():
... return {
... "name":"root",
... "age":10
... }
...
>>> dd = defaultdict(StudentInfo)
>>> s = dd['student'] # 此处等同于运行 s = StudentInfo()
>>> print s
{'age': 10, 'name': 'root'}
>>> s['age']=20
>>> print s
{'age': 20, 'name': 'root'}
扫一扫
863
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
