标准库：一些最爱

集合、堆和双端队列

集合

集合Set类位于sets模块中。

>>> range(10)

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

>>> set(range(10))

set([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])

集合是由序列（或其他可迭代的对象)构建的。主要用于检查成员资格，因此，副本是被忽略的：

>>> range(10)*2

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

>>> set(range(10)*2)

set([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])

和字典一样，集合元素的顺序是随意的，因此不应该以元素的顺序作为依据进行编程：

>>> set([‘b‘,‘a‘,‘c‘])

set([‘a‘, ‘c‘, ‘b‘])

除了检查成员资格外，还可以使用标准的集合操作，如求并集和交集，可以使用方法，也可以对整数进行位操作时使用的操作。

如想找出两个集合的并集，可以使用其中一个集合的union方法或者使用按位与（OR）运算符”|”：

>>> a=set(range(5))

>>> a

set([0, 1, 2, 3, 4])

>>> b=set(range(1,8,2))

>>> b

set([1, 3, 5, 7])

>>> a.union(b)

set([0, 1, 2, 3, 4, 5, 7])

>>> a|b

set([0, 1, 2, 3, 4, 5, 7])

其他方法和运算符

交集

>>> c=a&b

>>> c

set([1, 3])

>>> c.issubset(a)

True

>>> c.issubset(b)

True

>>> c<=a

True

>>> c>=a

False

>>> c<=b

True

>>> c>=b

False

>>> a.intersection(b)

set([1, 3])

>>> a&b

set([1, 3])

差

>>> a.difference(b)

set([0, 2, 4])

>>> a-b

set([0, 2, 4])

>>> b-a

set([5, 7])

>>> b.difference(a)

set([5, 7])

对称差

>>> a.symmetric_difference(b)

set([0, 2, 4, 5, 7])

>>> a^b

set([0, 2, 4, 5, 7])

拷贝

>>> a.copy()

set([0, 1, 2, 3, 4])

>>> a.copy() is a

False

还有些原地运算符和对应的方法，以及基本方法add和remove。

集合是可变的，所以不能用做字典中的键。

另外一个问题是集合本身只能包含不可变（可散列的）值，所以也就不能包含其他集合。

实际当中，集合的集合是很常用的，所以这就是个问题：

幸好有个frozenset类型，用于代表不可变（可散列）的集合：

>>> a=set()

>>> b=set()

>>> a.add(b)

Traceback (most recent call last):

  File "<pyshell#33>", line 1, in <module>

    a.add(b)

TypeError: unhashable type: ‘set‘

>>> a.add(frozenset(b))

Frozenset构造函数创建给定集合的副本，不管是集合作为其他集合还是字典的键，frozenset都很有用。

堆

堆（heap）是优先队列的一种。使用优先队列能够以任意顺序增加对象，并且能在任何时间（可能在增加对象的同时）找到（也可能是移除）最小的元素，也就是说比用于列表的min方法要有效率得多。

事实上，python并没有独立的堆类型——只有一个包含一些堆操作函数的模块，这个模块叫做heapq（q是queue的缩写）。

Heapq模块中重要的函数

heappush函数用于增加堆的项。注意，不能将它用于任何之前讲述的列表中——它只能用于通过各种堆函数创建的列表中。原因是元素的顺序很重要。

>>> from heapq import *

>>> from random import shuffle

>>> data=range(10)

>>> shuffle(data)

>>> heap=[]

>>> for n in data:

heappush(heap,n)

>>> heap

[0, 1, 5, 3, 2, 6, 7, 9, 8, 4]

>>> heappush(heap,0.5)

>>> heap

[0, 0.5, 5, 3, 1, 6, 7, 9, 8, 4, 2]

元素的顺序并不像看起来那么随意。虽然不是严格排序的，但也是有规则的：位于i位置上的元素总比i/2位置处的元素大（反过来说就是i位置处的元素总比2*i以及2*i+1位置处的元素小）。这是底层堆算法的基础，而这个特性称为堆属性。

heappop函数弹出最小的元素——一般来说都是在索引0处的元素，并且会确保剩余元素中最小的那个占据这个位置（保持刚才提到的堆属性）。一般来说，尽管弹出列表的第一个元素并不是很有效率，但在这里不是问题，因为heappop在“幕后”会做一些精巧的移位操作：

>>> heappop(heap)

0

>>> heappop(heap)

0.5

>>> heappop(heap)

1

>>> heap

[2, 3, 5, 8, 4, 6, 7, 9]

heapify函数使任意列表作为参数，并通过尽可能少的移位操作，将其转换为合法的堆。如果没有用heappush建立堆，那么在使用heappush和heappop前应该使用这个函数。

>>> heap=[5,8,0,3,6,7,9,1,4,2]

>>> heap

[5, 8, 0, 3, 6, 7, 9, 1, 4, 2]

>>> heapify(heap)

>>> heap

[0, 1, 5, 3, 2, 7, 9, 8, 4, 6]

heapreplace函数并不像其他函数那么常用。它弹出堆的最小元素，并且将新元素推入，这样做比调用heappop之后再调用heappush更高效。

>>> heapreplace(heap,0.5)

0

>>> heap

[0.5, 1, 5, 3, 2, 7, 9, 8, 4, 6]

>>> heapreplace(heap,10)

0.5

>>> heap

[1, 2, 5, 3, 6, 7, 9, 8, 4, 10]

heapq模块中剩下的两个函数nlargest(n,iter)和nsmallest(n,iter)分别用来寻找任何可迭代对象iter中第n大或第n小的元素。可以使用排序和分片来完成这个工作，但堆算法更快而且更有效地使用内存，也更易用。

双端队列

双端队列（Double-ended queue，或称deque）在需要按照元素增加的顺序来移除元素时非常有用。

双端队列通过可迭代对象（比如集合）创建，而且有些非常有用的方法。

>>> from collections import deque

>>> q=deque(range(5))

>>> q.append(5)

>>> q.appendleft(6)

>>> q

deque([6, 0, 1, 2, 3, 4, 5])

>>> q.pop()

5

>>> q.popleft()

6

>>> q

deque([0, 1, 2, 3, 4])

>>> q.rotate(-1)

>>> q

deque([1, 2, 3, 4, 0])

>>> q.rotate(3)

>>> q

deque([3, 4, 0, 1, 2])

双端队列好用的原因是它能够有效地在开头（左侧）增加和弹出元素，这是列表中无法实现的。除此之外，使用双端队列的好处还有：能够有效地旋转（rotate）元素（也就是将它们左移或右移，使头尾相连）。双端队列对象还有extend和extendleft方法。extend和列表的extend方法差不多，extendleft则类似于appendleft。注意，extendleft使用的可迭代对象中的元素会反序出现在双端队列中。

原文：http://blog.csdn.net/signjing/article/details/36201499