python自带intertool模块找不到_Python：itertools模块使用说明

In [1]: from itertools import *

#用xrange创建长度10000，元素均为0的列表

In [2]: timeit [0 for i in xrange(10000)]

1000 loops, best of 3: 404 us per loop

#用itertools创建长度10000，元素均为0的列表,性能明显提高。原因是迭代器创建列表对象是一次性分配完内存

In [3]: timeit list(repeat(0,10000))

10000 loops, best of 3: 75.8 us per loop

#连接两个列表

In [4]: it=chain(xrange(5),"abc")

In [5]: list(it)

Out[5]: [0, 1, 2, 3, 4, 'a', 'b', 'c']

#对列表进行排序组合，无序

In [6]:list(combinations("abcd",2))

Out[6]: [('a', 'b'), ('a', 'c'), ('a', 'd'), ('b', 'c'), ('b', 'd'), ('c', 'd')]

#对列表进行排序组合，有序

In [7]:list(permutations("abcd",2))

Out[7]: [('a', 'b'), ('a', 'c'), ('a', 'd'), ('b', 'a'), ('b', 'c'), ('b', 'd'), ('c', 'a'), ('c', 'b'), ('c', 'd'), ('d', 'a'), ('d', 'b'), ('d', 'c')]

#对列表进行排序组合，包括同一元素自身的组合

In [8]: it=combinations_with_replacement("abcd",2)

In [9]: list(it)

Out[9]: [('a', 'a'),

('a', 'b'),

('a', 'c'),

('a', 'd'),

('b', 'b'),

('b', 'c'),

('b', 'd'),

('c', 'c'),

('c', 'd'),

('d', 'd')]

#按条件过滤迭代器

In [10]: it=compress("abcde",[True,False,True])

In [11]: list(it)

Out[11]: ['a', 'c']

#ifilter(predicate, iterable) 创建一个迭代器，仅生成 iterable 中 predicate(item)为 True 的项，如果 predicate 为 None，将返回 iterable 中所有计算为 True 的项。

In [18]: list(ifilter(lambda x: x%2, range(10)))

Out[18]: [1, 3, 5, 7, 9]

#ifilterfalse(predicate, iterable):创建一个迭代器，仅生成 iterable 中 predicate(item)为 False 的项，如果 predicate 为 None，则返回 iterable 中所有计算为 False 的项。

In [19]: list(ifilterfalse(lambda x: x%2, range(10)))

Out[19]: [0, 2, 4, 6, 8]

#dropwhile(predicate, iterable):

#创建一个迭代器，只要函数 predicate(item)为 True，就丢弃 iterable 中的项，如果 predicate 返回 False，就会生成 iterable 中的项和所有后续项。

In [20]: list(dropwhile(lambda x: x<5, [1,4,6,4,1]))

Out[20]: [6, 4, 1]

#takewhile(predicate [, iterable]):

#创建一个迭代器，生成 iterable 中 predicate(item)为 True 的项，只要 predicate 计算为 False，迭代就会立即停止。

In [21]: list(takewhile(lambda x: x<5, [1,4,6,4,1]))

Out[21]: [1, 4]

#chain.from_iterable(iterables):

#一个备用链构造函数，其中的 iterables 是一个迭代变量，生成迭代序列，此操作的结果与以下生成器代码片段生成的结果相同：

In [22]: test = chain.from_iterable('ABCDEF')

In [23]: test.next()

Out[23]: 'A'

In [24]: test.next()

Out[24]: 'B'

#count([n]):

#创建一个迭代器，生成从 n 开始的连续整数，如果忽略 n，则从 0 开始计算（注意：此迭代器不支持长整数），如果超出了 sys.maxint，计数器将溢出并继续从-sys.maxint-1 开始计算。

In [30]: test=count(10000)

In [31]: test.next()

Out[31]: 10000

In [32]: test.next()

Out[32]: 10001

In [33]: test.next()

Out[33]: 10002

In [34]: test.next()

Out[34]: 10003

#cycle(iterable):

#创建一个迭代器，对 iterable 中的元素反复执行循环操作，内部会生成 iterable 中的元素的一个副本，此副本用于返回循环中的重复项。

In [49]: test=cycle(range(3))

In [50]: test.next()

Out[50]: 0

In [51]: test.next()

Out[51]: 1

In [52]: test.next()

Out[52]: 2

In [53]: test.next()

Out[53]: 0

In [54]: test.next()

Out[54]: 1

#islice(iterable, [start, ] stop [, step]):

#创建一个迭代器，生成项的方式类似于切片返回值： iterable[start : stop : step]，将跳过前 start 个项，迭代在 stop 所指定的位置停止，step 指定用于跳过项的步幅。与切片不同，负值不会用于任何 start，stop 和 step，如果省略了 start，迭代将从 0 开始，如果省略了 step，步幅将采用 1.

In [1]: from itertools import *

In [2]: list(islice('ABCDEFG', 2))

Out[2]: ['A', 'B']

In [3]: list(islice('ABCDEFG', 2, 4))

Out[3]: ['C', 'D']

In [4]: list(islice('ABCDEFG', 2, None))

Out[4]: ['C', 'D', 'E', 'F', 'G']

In [5]: list(islice('ABCDEFG', 2, None,2))

Out[5]: ['C', 'E', 'G']

#izip(iter1, iter2, ... iterN):

#创建一个迭代器，生成元组(i1, i2, ... iN)，其中 i1，i2 ... iN 分别来自迭代器 iter1，iter2 ... iterN，只要提供的某个迭代器不再生成值，迭代就会停止，此函数生成的值与内置的 zip()函数相同。

In [7]: list(izip('ABCD', 'xy'))

Out[7]: [('A', 'x'), ('B', 'y')]

#izip_longest(iter1, iter2, ... iterN, [fillvalue=None]):

#与 izip()相同，但是迭代过程会持续到所有输入迭代变量 iter1,iter2 等都耗尽为止，如果没有使用 fillvalue 关键字参数指定不同的值，则使用 None 来填充已经使用的迭代变量的值。

In [8]: list(izip_longest('ABCD', 'xy', fillvalue='-'))

Out[8]: [('A', 'x'), ('B', 'y'), ('C', '-'), ('D', '-')]

#product(iter1, iter2, ... iterN, [repeat=1]):

#创建一个迭代器，生成表示 item1，item2 等中的项目的笛卡尔积的元组，repeat 是一个关键字参数，指定重复生成序列的次数

In [11]: list(product('ABCD', 'xy'))

Out[11]:

[('A', 'x'),

('A', 'y'),

('B', 'x'),

('B', 'y'),

('C', 'x'),

('C', 'y'),

('D', 'x'),

('D', 'y')]

In [13]: list(product(range(2), repeat=3))

Out[13]:

[(0, 0, 0),

(0, 0, 1),

(0, 1, 0),

(0, 1, 1),

(1, 0, 0),

(1, 0, 1),

(1, 1, 0),

(1, 1, 1)]