首页 > 代码库 > python collections模块-标准库

python collections模块-标准库

参考老顽童博客,他写的很详细,例子也很容易操作和理解.

1.模块简介

collections包含了一些特殊的容器,针对Python内置的容器,例如list、dict、set和tuple,提供了另一种选择;

namedtuple,可以创建包含名称的tuple;

deque,类似于list的容器,可以快速的在队列头部和尾部添加、删除元素;

Counter,dict的子类,计算可hash的对象;

OrderedDict,dict的子类,可以记住元素的添加顺序;

defaultdict,dict的子类,可以调用提供默认值的函数;

2.模块使用

2.1 Counter

counter可以支持方便、快速的计数,例如,

from collections import *

cnt = Counter()
wordList = ["a","b","c","c","a","a"]
for word in wordList:
    cnt[word] += 1
print cnt

控制台输出,

Counter({a: 3, c: 2, b: 1})

对可迭代的对象进行计数或者从另一个映射(counter)进行初始化,

>>> c = Counter()#一个新的,空的counter
>>> c
Counter()
>>> c = Counter("gallahad")#从可迭代的字符串初始化counter
>>> c
Counter({a: 3, l: 2, h: 1, g: 1, d: 1})
>>> c = Counter({red:4,blue:2})#从映射初始化counter
>>> c
Counter({red: 4, blue: 2})
>>> c = Counter(cats = 4,dogs = 8)#从args初始化counter
>>> c
Counter({dogs: 8, cats: 4})

Counter对象类似于字典,如果某个项缺失,会返回0,而不是报出KeyError;

>>> c = Counter([eggs,ham])
>>> c[bacon]#没有bacon
0
>>> c[eggs]#有eggs
1

将一个元素的数目设置为0,并不能将它从counter中删除,使用del可以将这个元素删除;

>>> c
Counter({eggs: 1, ham: 1})
>>> c[eggs] = 0
>>> c
Counter({ham: 1, eggs: 0})#eggs依然存在
>>> del c[eggs]
>>> c
Counter({ham: 1})#eggs不存在

Counter对象支持以下三个字典不支持的方法,elements(),most_common(),subtract();

element(),返回一个迭代器,每个元素重复的次数为它的数目,顺序是任意的顺序,如果一个元素的数目少于1,那么elements()就会忽略它;

>>> c = Counter(a=2,b=4,c=0,d=-2,e = 1)
>>> c
Counter({b: 4, a: 2, e: 1, c: 0, d: -2})
>>> list(c.elements())
[a, a, b, b, b, b, e]

most_common(),返回一个列表,包含counter中n个最大数目的元素
,如果忽略n或者为None,most_common()将会返回counter中的所有元素,元素有着相同数目的将会以任意顺序排列;

>>> Counter(abracadabra).most_common(3)
[(a, 5), (r, 2), (b, 2)]
>>> Counter(abracadabra).most_common()
[(a, 5), (r, 2), (b, 2), (c, 1), (d, 1)]
>>> Counter(abracadabra).most_common(None)
[(a, 5), (r, 2), (b, 2), (c, 1), (d, 1)]

subtract(),从一个可迭代对象中或者另一个映射(或counter)中,元素相减,类似于dict.update(),但是subtracts 数目而不是替换它们,输入和输出都有可能为0或者为负;

>>> 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, c: 3, b: 0, d: -6})

update(),从一个可迭代对象中或者另一个映射(或counter)中所有元素相加,类似于dict.upodate,是数目相加而非替换它们,另外,可迭代对象是一个元素序列,而非(key,value)对构成的序列;

>>> c
Counter({a: 4, b: 2, c: 0, d: -2})
>>> d
Counter({d: 4, b: 2, a: 1, c: -3})
>>> c.update(d)
>>> c
Counter({a: 5, b: 4, d: 2, c: -3})

Counter对象常见的操作,

>>> c
Counter({a: 5, b: 4, d: 2, c: -3})
>>> sum(c.values())# 统计所有的数目
8
>>> list(c)# 列出所有唯一的元素
[a, c, b, d]
>>> set(c)# 转换为set
set([a, c, b, d])
>>> dict(c)# 转换为常规的dict
{a: 5, c: -3, b: 4, d: 2}
>>> c.items()# 转换为(elem,cnt)对构成的列表
[(a, 5), (c, -3), (b, 4), (d, 2)]
>>> c.most_common()[:-4:-1]# 输出n个数目最小元素
[(c, -3), (d, 2), (b, 4)]
>>> c += Counter()# 删除数目为0和为负的元素
>>> c
Counter({a: 5, b: 4, d: 2})
>>> Counter(dict(c.items()))# 从(elem,cnt)对构成的列表转换为counter
Counter({a: 5, b: 4, d: 2})
>>> c.clear()# 清空counter
>>> c
Counter()

在Counter对象进行数学操作,得多集合(counter中元素数目大于0)加法和减法操作,是相加或者相减对应元素的数目;交集和并集返回对应数目的最小值和最大值;每个操作均接受暑促是有符号的数目,但是输出并不包含数目为0或者为负的元素;

>>> c = Counter(a=3,b=1,c=-2)
>>> d = Counter(a=1,b=2,c=4)
>>> c+d#求和
Counter({a: 4, b: 3, c: 2})
>>> c-d#求差
Counter({a: 2})
>>> c & d#求交集
Counter({a: 1, b: 1})
>>> c | d#求并集
Counter({c: 4, a: 3, b: 2})

2.2 deque

deque是栈和队列的一种广义实现,deque是"double-end queue"的简称;deque支持线程安全、有效内存地以近似O(1)的性能在deque的两端插入和删除元素,尽管list也支持相似的操作,但是它主要在固定长度操作上的优化,从而在pop(0)和insert(0,v)(会改变数据的位置和大小)上有O(n)的时间复杂度。

deque支持如下方法,

append(x), 将x添加到deque的右侧;

appendleft(x), 将x添加到deque的左侧;

clear(), 将deque中的元素全部删除,最后长度为0;

count(x), 返回deque中元素等于x的个数;

extend(iterable), 将可迭代变量iterable中的元素添加至deque的右侧;

extendleft(iterable), 将变量iterable中的元素添加至deque的左侧,往左侧添加序列的顺序与可迭代变量iterable中的元素相反;

pop(), 移除和返回deque中最右侧的元素,如果没有元素,将会报出IndexError;

popleft(), 移除和返回deque中最左侧的元素,如果没有元素,将会报出IndexError;

remove(value), 移除第一次出现的value,如果没有找到,报出ValueError;

reverse(), 反转deque中的元素,并返回None;

rotate(n), 从右侧反转n步,如果n为负数,则从左侧反转,d.rotate(1)等于d.appendleft(d.pop());

maxlen, 只读的属性,deque的最大长度,如果无解,就返回None;

除了以上的方法之外,deque还支持迭代、序列化、len(d)、reversed(d)、copy.copy(d)、copy.deepcopy(d),通过in操作符进行成员测试和下标索引,索引的时间复杂度是在两端是O(1),在中间是O(n),为了快速获取,可以使用list代替。

>>> from collections import deque
>>> d = deque(ghi)# 新建一个deque,有三个元素
>>> for ele in d:# 遍历deque
...     print ele.upper()
...     
... 
G
H
I
>>> d.append(j)# deque右侧添加一个元素
>>> d.appendleft(f)# deque左侧添加一个元素
>>> d# 打印deque
deque([f, g, h, i, j])
>>> d.pop()# 返回和移除最右侧元素
j
>>> d.popleft()# 返回和移除最左侧元素
f
>>> list(d)# 以列表形式展示出deque的内容
[g, h, i]
>>> d[0]# 获取最左侧的元素
g
>>> d[-1]# 获取最右侧的元素
i
>>> list(reversed(d))# 以列表形式展示出倒序的deque的内容
[i, h, g]
>>> h in d# 在deque中搜索
True
>>> d.extend(jkl)# 一次添加多个元素
>>> d
deque([g, h, i, j, k, l])
>>> d.rotate(1)# 往右侧翻转
>>> d
deque([l, g, h, i, j, k])
>>> d.rotate(-1)# 往左侧翻转
>>> d
deque([g, h, i, j, k, l])
>>> deque(reversed(d))# 以逆序新建一个deque
deque([l, k, j, i, h, g])
>>> d.clear()# 清空deque
>>> d.pop()# 不能在空的deque上pop
Traceback (most recent call last):
  File "<input>", line 1, in <module>
IndexError: pop from an empty deque
>>> d.extendleft(abc)# 以输入的逆序向左扩展
>>> d
deque([c, b, a])

其他的应用:

1.限定长度的deque提供了Unix中tail命令相似的功能;

from collections import deque

def tail(filename,n = 10):
    "Return the last n lines of a file"
    return deque(open(filename),n)

print tail("temp.txt",10)

2.使用deque维护一个序列(右侧添加元素,左侧删除元素)中窗口的平均值;

from collections import deque
import itertools

def moving_average(iterable,n = 3):
    it = iter(iterable)
    d = deque(itertools.islice(it,n-1))
    # 第一次只有两个元素,再右移的过程中,需要先删除最左端的元素,因此现在最左端加入0
    d.appendleft(0)
    s = sum(d)
    for ele in it:
        # 删除最左端的元素,再加上新元素
        s += ele - d.popleft()
        # 右端添加新元素
        d.append(ele)
        yield s / float(n)

array = [40,30,50,46,39,44]
for ele in moving_average(array,n=3):
    print ele

3.rotate()方法提供了一种实现deque切片和删除的方式,例如,del d[n]依赖于rotate方法的纯Python实现,如下,

from collections import deque

def delete_nth(d,n):
    # 将前n个元素翻转到右侧
    d.rotate(-n)
    # 删除第n个元素
    d.popleft()
    # 再将后n个元素翻转到左侧
    d.rotate(n)

d = deque("abcdefg")
delete_nth(d,n = 3)
print d

4.slice依赖于rotate方法的纯Python实现,如下,

from collections import deque

def slice(d,m,n):
    # 先将前面m个元素翻转到右侧
    d.rotate(-m)
    i = m
    sliceList = []
    # 依次将[m,n]区间内的元素出栈
    while i < n:
        item = d.popleft()
        sliceList.append(item)
        i+=1
    # 再将出栈的元素扩展到deque右侧
    d.extend(sliceList)
    # 再将后面n个元素翻转到左侧
    d.rotate(n)
    return sliceList

d = deque("abcdefg")
print slice(d,1,5)

2.3 defaultdict

defaultdict是内置数据类型dict的一个子类,基本功能与dict一样,只是重写了一个方法__missing__(key)和增加了一个可写的对象变量default_factory。

>>> dir(defaultdict)
[__class__, __cmp__, __contains__, __copy__, __delattr__, __delitem__, __doc__, __eq__, __format__, __ge__, __getattribute__, __getitem__
, __gt__, __hash__, __init__, __iter__, __le__, __len__, __lt__,__missing__, __ne__, __new__, __reduce__, __reduce_ex__, __repr__, __setattr__, __setitem__, __sizeof__, __str__, __subclasshook__, clear
, copy, default_factory, fromkeys, get, has_key, items, iteritems, iterkeys, itervalues, keys, pop, popitem, setdefault, update, v
alues, viewitems, viewkeys, viewvalues]
>>> dir(dict)
[__class__, __cmp__, __contains__, __delattr__, __delitem__, __doc__
, __eq__, __format__, __ge__, __getattribute__, __getitem__, __gt__,
 __hash__, __init__, __iter__, __le__, __len__, __lt__, __ne__, _
_new__, __reduce__, __reduce_ex__, __repr__, __setattr__, __setitem__, __sizeof__, __str__, __subclasshook__, clear, copy, fromkeys, get, has_key, items, iteritems, iterkeys, itervalues, keys, pop, po
pitem, setdefault, update, values, viewitems, viewkeys, viewvalues]

missing(key)

  1. 如果default_factory属性为None,就报出以key作为遍历的KeyError异常;
  2. 如果default_factory不为None,就会向给定的key提供一个默认值,这个值插入到词典中,并返回;
  3. 如果调用default_factory报出异常,这个异常在传播时不会改变;
  4. 这个方法是当要求的key不存在时,dict类中的__getitem()__方法所调用,无论它返回或者报出什么,最终返回或报出给__getitem()__;
  5. 只有__getitem__()才能调用__missing__(),这意味着,如果get()起作用,如普通的词典,将会返回None作为默认值,而不是使用default_factory;

default_factory, 这个属性用于__missing__()方法,使用构造器中的第一个参数初始化;

使用list作为default_factory,很容易将一个key-value的序列转换为一个关于list的词典;

>>> from collections import *
>>> s = [(yellow,1),(blue,2),(yellow,3),(blue,4),(red,5)]
>>> d = defaultdict(list)
>>> for k,v in s: d[k].append(v)
... 
>>> d.items()
[(blue, [2, 4]), (red, [5]), (yellow, [1, 3])]

当每一个key第一次遇到时,还没有准备映射,首先会使用default_factory函数自动创建一个空的list,list.append()操作将value添加至新的list中,当key再次遇到时,通过查表,返回对应这个key的list,list.append()会将新的value添加至list,这个技术要比dict.setdefault()要简单和快速。

>>> e = {}
>>> for k,v in s: e.setdefault(k,[]).append(v)
... 
>>> e.items()
[(blue, [2, 4]), (red, [5]), (yellow, [1, 3])]

设置default_factory为int,使得defaultdict可以用于计数,

>>> s = "mississippi"
>>> d = defaultdict(int)
>>> for k in s: d[k]+=1
... 
>>> d.items()
[(i, 4), (p, 2), (s, 4), (m, 1)]

当一个字母第一次遇到,默认从default_factory中调用int()用于提供一个默认为0的计数,递增操作会增加每个字母的计数。

函数int()经常返回0,是常量函数的一种特例。一种更快和更灵活的创建常量函数的方式是使用itertools.repeat(),可以提供任意常量值(不仅仅是0),

>>> import itertools
>>> def constant_factory(value):
...     return itertools.repeat(value).next
... 
>>> d = defaultdict(constant_factory(<missing>))
>>> d.update(name = "John",action = "ran")
>>> "%(name)s %(action)s to %(object)s"%d
John ran to <missing>

将default_factory设置为set,使得defaultdict可以建立一个关于set的词典,

>>> 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]))]

2.4 namedtuple

命名的元组,意味给元组中的每个位置赋予含义,意味着代码可读性更强,namedtuple可以在任何常规元素使用的地方使用,而且它可以通过名称来获取字段信息而不仅仅是通过位置索引。

>>> from collections import *
>>> Point = namedtuple(Point,[x,y],verbose = True)
class Point(tuple):
    Point(x, y)

    __slots__ = ()

    _fields = (x, y)

    def __new__(_cls, x, y):
        Create new instance of Point(x, y)
        return _tuple.__new__(_cls, (x, y))

    @classmethod
    def _make(cls, iterable, new=tuple.__new__, len=len):
        Make a new Point object from a sequence or iterable
        result = new(cls, iterable)
        if len(result) != 2:
            raise TypeError(Expected 2 arguments, got %d % len(result))
        return result

    def __repr__(self):
        Return a nicely formatted representation string
        return Point(x=%r, y=%r) % self

    def _asdict(self):
        Return a new OrderedDict which maps field names to their values
        return OrderedDict(zip(self._fields, self))

    def _replace(_self, **kwds):
        Return a new Point object replacing specified fields with new values
        result = _self._make(map(kwds.pop, (x, y), _self))
        if kwds:
            raise ValueError(Got unexpected field names: %r % kwds.keys())
        return result

    def __getnewargs__(self):
        Return self as a plain tuple.  Used by copy and pickle.
        return tuple(self)

    __dict__ = _property(_asdict)

    def __getstate__(self):
        Exclude the OrderedDict from pickling
        pass

    x = _property(_itemgetter(0), doc=Alias for field number 0)

    y = _property(_itemgetter(1), doc=Alias for field number 1)
>>> p = Point(11,y = 22)# 实例化一个对象,可以使用位置或者关键字
>>> p[0] + p[1]# 通过索引访问元组中的元素
33
>>> x,y = p# 分开,类似于常规的元组
>>> x,y
(11, 22)
>>> p.x + p.y# 通过名称访问元素
33
>>> p# 可读的__repr__,通过name = value风格
Point(x=11, y=22)
namedtuple在给csv或者sqlite3返回的元组附上名称特别有用,
from collections import *
import csv

EmployeeRecord = namedtuple(EmployeeRecord,name, age, title, department, paygrade)
for emp in map(EmployeeRecord._make,csv.reader(open("employee.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

控制台输出,

Jim RD
Tom Manager

除了从tuples继承的方法之外,namedtuple还支持三种方法和一个属性,为了避免和名称冲突,这些方法和属性以下划线开始。

**somenamedtuple._make(),** 从已有的序列或者可迭代的对象中创建一个新的对象;

>>> Point = namedtuple(Point, [x, y])
>>> t = [33,44]
>>> Point._make(t)
Point(x=33, y=44)

**somenamedtuple._asdict(),** 返回一个OrderDict,由名称到对应值建立的映射;

>>> p = Point(x = 11,y = 22)
>>> p
Point(x=11, y=22)
>>> pDict = p._asdict()
>>> pDict
OrderedDict([(x, 11), (y, 22)])

**somenamedtuple._replace(),** 返回一个新的namedtuple对象,用新值替换指定名称中的值;

>>> p2 = p._replace(x = 33)
>>> p2
Point(x=33, y=22)

**somenamedtuple._fields,** 以字符串构成的元组的形式返回namedtuple中的名称,在自省或者基于一个已经存在的namedtuple中创建新的namedtuple时,非常有用;

>>> p._fields
(x, y)
>>> Color = namedtuple(Color,"red green blu")
>>> Pixel = namedtuple(Pixel,Point._fields + Color._fields)
>>> Pixel(11,22,128,255,0)
Pixel(x=11, y=22, red=128, green=255, blu=0)

当名称存储在字符串中,可以使用getattr()函数进行检索,

>>> getattr(p,x)
11

使用**操作符,可以将一个字典转换成namedtuple,

>>> d  = {x:11,y:22}
>>> Point(**d)
Point(x=11, y=22)

由于namedtuple也是Python中的一个类,因此再子类中,它很容易添加或者修改一些功能,如下是添加一个可计算名称和固定长度的输出格式;子类中的__slots__是一个空的元组,可以通过避免词典实例的创建来节约内存开销;

class Point(namedtuple(Point,x y)):
    __slots__ = ()
    @property
    def hypot(self):
        return (self.x ** 2 + self.y**2) ** 0.5
    def __str__(self):
        return "Point:x = %6.3f  y = %6.3f  hypot = %6.3f" %(self.x,self.y,self.hypot)

for p in Point(3,4),Point(14,5/7.):
    print p

控制台输出,

Point:x =  3.000  y =  4.000  hypot =  5.000
Point:x = 14.000  y =  0.714  hypot = 14.018

子类在增加、存储名称时,并不是非常有用,相反,可以容易地通过_fields属性来创建一个新的namedtuple;

>>> Point3D = namedtuple("Point3D",Point._fields + (z,))
>>> Point3D._fields
(x, y, z)

默认值可以通过_replace()来实现,以便于标准化一个原型实例;

>>> Account = namedtuple(Account,owner balance transaction_count)
>>> default_account = Account(<owner name>,0.0,0)
>>> johns_account = default_account._replace(owner = "John")
>>> johns_account
Account(owner=John, balance=0.0, transaction_count=0)

枚举类型常量可以通过namedtuple来实现,更简单和有效的方式是通过意见简单的类声明;

Status = namedtuple(Status,open pending closed)._make(range(3))
print Status

class Status:
open, pending, closed = range(3)

print Status.open
print Status.pending
print Status.closed

控制台输出,

Status(open=0, pending=1, closed=2)
0
1
2

2.5 OrderedDict

OrderedDict类似于正常的词典,只是它记住了元素插入的顺序,当在有序的词典上迭代时,返回的元素就是它们第一次添加的顺序。

class collections.OrderedDict,返回已给dict的子类,支持常规的dict的方法,OrderedDict是一个记住元素首次插入顺序的词典,如果一个元素重写已经存在的元素,那么原始的插入位置保持不变,如果删除一个元素再重新插入,那么它就在末尾。

OrderedDict.popitem(last=True),popitem方法返回和删除一个(key,value)对,如果last=True,就以LIFO方式执行,否则以FIFO方式执行。

OrderedDict也支持反向迭代,例如reversed()。

OrderedDict对象之间的相等测试,例如,list(od1.items()) == list(od2.items()),是对顺序敏感的;OrderedDict和其他的映射对象(例如常规的词典)之间的相等测试是顺序不敏感的,这就允许OrderedDict对象可以在使用常规词典的地方替换掉常规词典。

OrderedDict构造器和update()方法可以接受关键字变量,但是它们丢失了顺序,因为Python的函数调用机制是将一个无序的词典传入关键字变量。

一个有序的词典记住它的成员插入的顺序,可以使用排序函数,将其变为排序的词典,

>>> d = {"banana":3,"apple":2,"pear":1,"orange":4}
>>> # dict sorted by key
>>> OrderedDict(sorted(d.items(),key = lambda t:t[0]))
OrderedDict([(apple, 2), (banana, 3), (orange, 4), (pear, 1)])
>>> # dict sorted by value
>>> OrderedDict(sorted(d.items(),key = lambda t:t[1]))
OrderedDict([(pear, 1), (apple, 2), (banana, 3), (orange, 4)])
>>> # dict sorted by length of key string
>>>a =  OrderedDict(sorted(d.items(),key = lambda t:len(t[0])))
>>>a
OrderedDict([(pear, 1), (apple, 2), (orange, 4), (banana, 3)])
>>> del a[apple]
>>> a
OrderedDict([(pear, 1), (orange, 4), (banana, 3)])
>>> a["apple"] = 2
>>> a
OrderedDict([(pear, 1), (orange, 4), (banana, 3), (apple, 2)])

当元素删除时,排好序的词典保持着排序的顺序;但是当新元素添加时,就会被添加到末尾,就不能保持已排序。

创建一个有序的词典,可以记住最后插入的key的顺序,如果一个新的元素要重写已经存在的元素,那么原始的插入位置就会改变成末尾,

>>> class LastUpdatedOrderedDict(OrderedDict):
...     def __setitem__(self,key,value):
...         if key in self:
...             del self[key]
...         OrderedDict.__setitem__(self, key, value)
... 
>>> obj = LastUpdatedOrderedDict()
>>> obj["apple"] = 2
>>> obj["windows"] = 3
>>> obj
LastUpdatedOrderedDict([(apple, 2), (windows, 3)])
>>> obj["apple"] = 1
>>> obj
LastUpdatedOrderedDict([(windows, 3), (apple, 1)])

一个有序的词典可以和Counter类一起使用,counter对象就可以记住元素首次出现的顺序;

class OrderedCounter(Counter,OrderedDict):
    def __repr__(self):
        return "%s(%r)"%(self.__class__.__name__,OrderedDict(self))

    def __reduce__(self):
        return self.__class__,(OrderedDict(self))

#和OrderDict一起使用的Counter对象
obj = OrderedCounter()
wordList = ["b","a","c","a","c","a"]
for word in wordList:
    obj[word] += 1
print obj

# 普通的Counter对象
cnt = Counter()
wordList = ["b","a","c","a","c","a"]
for word in wordList:
    cnt[word] += 1
print cnt

控制台输出,

OrderedCounter(OrderedDict([(b, 1), (a, 3), (c, 2)]))
Counter({a: 3, c: 2, b: 1})

3.Reference

8.3. collections — High-performance container datatypes

python collections模块-标准库