python基础=== itertools介绍（转载）
原文链接：http://python.jobbole.com/85321/
Python提供了一个非常棒的模块用于创建自定义的迭代器，这个模块就是 itertools。itertools 提供的工具相当高效且节省内存。使用这些工具，你将能够创建自己定制的迭代器用于高效率的循环。这一章，我们将一起看一看这些工具的应用实例以便理解并应用到自己的编程中去。
让我们先从几个无限迭代器的例子开始吧！
无限迭代器
itertools 包自带了三个可以无限迭代的迭代器。这意味着，当你使用他们时，你要知道你需要的到底是最终会停止的迭代器，还是需要无限地迭代下去。
这些无限迭代器在生成数字或者在长度未知的可迭代对象（iterables）中循环时相当有用。下面我们开始认识这些有趣的可迭代对象！
count(初值=0, 步长=1)
count 迭代器会返回从传入的起始参数开始的均匀间隔的数值。count 也可以接收指定的步长参数。我们来看一个简单的例子：
>>> for i in count(10):
... if i > 20:
... break
... else:
... print(i)
...
10
11
12
13
14
15
16
17
18
19
20
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
|
>>> from itertools import count
>>> for i in count(10):
... if i > 20:
... break
... else:
... print(i)
...
10
11
12
13
14
15
16
17
18
19
20
|
这里我们先从 itertools 导入 count，然后创建一个 for 循环。循环中加入了条件检查，当迭代器值大于 20 时跳出循环，否则将打印出迭代器的当前值。你应该注意到了，输出结果从 10 开始，与我们传入 count 的起始值是一致的。
另一种控制无限迭代器输出的方式是使用 itertools 的子模块 islice。使用方法如下：
>>> for i in islice(count(10), 5):
... print(i)
...
10
11
12
13
14
|
1
2
3
4
5
6
7
8
9
|
>>> from itertools import islice
>>> for i in islice(count(10), 5):
... print(i)
...
10
11
12
13
14
|
这里，我们先导入了 islice，然后遍历 count，从 10 开始，输出 5 个元素后结束。你大概猜到了，islice 的第二个参数控制何时停止迭代。但其含义并不是”达到数字 5 时停止“，而是”当迭代了 5 次之后停止“。
cycle(可迭代对象)
itertools 中的 cycle 迭代器允许你创建一个能在一组值间无限循环的迭代器。下面我们传入一个 3 个字母的字符串，看看将会发生什么：
>>> count = 0
>>> for item in cycle('XYZ'):
... if count > 7:
... break
... print(item)
... count += 1
...
X
Y
Z
X
Y
Z
X
Y
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
|
>>> from itertools import cycle
>>> count = 0
>>> for item in cycle('XYZ'):
... if count > 7:
... break
... print(item)
... count += 1
...
X
Y
Z
X
Y
Z
X
Y
|
这里我们创建了一个 for 循环，使其在三个字母 XYZ 间无限循环。当然，我们并不真地想要永远循环下去，所以我们添加了一个简单的计数器来跳出循环。
你也可以用 Python 内建的 next 函数对 itertools 创建的迭代器进行循环：
>>> iterator = cycle(polys)
>>> next(iterator)
'triangle'
>>> next(iterator)
'square'
>>> next(iterator)
'pentagon'
>>> next(iterator)
'rectangle'
>>> next(iterator)
'triangle'
>>> next(iterator)
'square'
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
>>> polys = ['triangle', 'square', 'pentagon', 'rectangle']
>>> iterator = cycle(polys)
>>> next(iterator)
'triangle'
>>> next(iterator)
'square'
>>> next(iterator)
'pentagon'
>>> next(iterator)
'rectangle'
>>> next(iterator)
'triangle'
>>> next(iterator)
'square'
|
上面的代码中，我们创建一个简单的多边形组成的列表，然后传入 cycle。我们用一个变量存储新建的迭代器，然后将这个变量传入 next 函数。每一次调用 next 都将返回迭代器中的下一个值。由于迭代器是无限的，我们可以一直调用 next 而永远不会到尽头。
repeat(对象[, 次数])
repeat 迭代器会一遍遍地返回传入的对象直至永远，除非你设定了 times 参数。这与 cycle 非常相像，除了一点，repeat 不会在多个值之间循环。我们看一个简单的例子：
>>> repeat(5, 5)
repeat(5, 5)
>>> iterator = repeat(5, 5)
>>> next(iterator)
5
>>> next(iterator)
5
>>> next(iterator)
5
>>> next(iterator)
5
>>> next(iterator)
5
>>> next(iterator)
Traceback (most recent call last):
Python Shell, prompt 21, line 1
builtins.StopIteration:
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
|
>>> from itertools import repeat
>>> repeat(5, 5)
repeat(5, 5)
>>> iterator = repeat(5, 5)
>>> next(iterator)
5
>>> next(iterator)
5
>>> next(iterator)
5
>>> next(iterator)
5
>>> next(iterator)
5
>>> next(iterator)
Traceback (most recent call last):
Python Shell, prompt 21, line 1
builtins.StopIteration:
|
这里，我们先导入 repeat，然后设定其重复五次数字 5。接着，我们连续六次调用 next 函数，观察它是否工作正常。当运行这段代码，将引发 StopIteration，因为最后一次调用 next 函数，迭代器中的值已经全部返回了。
可终止的迭代器
多数用 itertools 创建的迭代器并不是无限的。这一节，我们将了解 itertools 中的有限迭代器。为了对于输出的可读的结果，我们将使用 Python 内建列表存储。 如果不使用列表，你将只能打印出 itertools 对象。
accumulate(可迭代对象[, 函数])
accumulate 迭代器将返回累计求和结果，或者传入两个参数的话，由传入的函数累积计算的结果。默认设定为相加，我们赶快试一试吧：
>>> list(accumulate(range(10)))
[0, 1, 3, 6, 10, 15, 21, 28, 36, 45]
|
1
2
3
|
>> from itertools import accumulate
>>> list(accumulate(range(10)))
[0, 1, 3, 6, 10, 15, 21, 28, 36, 45]
|
这里，我们 导入了 accumulate，然后传入 10 个数字，0-9。迭代器将传入数字依次累加，所以第一个是 0 ，第二个是 0+1， 第三个是 1+2，如此下去。现在我们导入 operator 模块，然后添加进去：
>>> list(accumulate(range(1, 5), operator.mul))
[1, 2, 6, 24]
|
1
2
3
|
>>> import operator
>>> list(accumulate(range(1, 5), operator.mul))
[1, 2, 6, 24]
|
这里我们传入了数字 1-4 到 accumulate 迭代器中。我们还传入了一个函数：operator.mul，这个函数将接收的参数相乘。所以每一次迭代，迭代器将以乘法代替除法（1×1=1, 1×2=2, 2×3=6, 以此类推）。
accumulate 的文档中给出了其他一些有趣的例子，例如贷款分期偿还，混沌递推关系等。这绝对值得你花时间去看一看。
chain(*可迭代对象)
chain 迭代器能够将多个可迭代对象合并成一个更长的可迭代对象。实际上，我参与的一个项目中最近就需要这一功能。我有一个列表，里面已经包含一些元素，接着想把另外两个列表添加到最初那个列表中。注意，我们想添加的是两个列表的元素。最初，我是这样做的：
>>> numbers = list(range(5))
>>> cmd = ['ls', '/some/dir']
>>> my_list.extend(cmd, numbers)
>>> my_list
['foo', 'bar', ['ls', '/some/dir'], [0, 1, 2, 3, 4]]
|
1
2
3
4
5
6
|
>>> my_list = ['foo', 'bar']
>>> numbers = list(range(5))
>>> cmd = ['ls', '/some/dir']
>>> my_list.extend(cmd, numbers)
>>> my_list
['foo', 'bar', ['ls', '/some/dir'], [0, 1, 2, 3, 4]]
|
这并不是我想要的。itertools 模块提供一个优雅得多的方法用chain 来合并这些列表：
>>> my_list = list(chain(['foo', 'bar'], cmd, numbers))
>>> my_list
['foo', 'bar', 'ls', '/some/dir', 0, 1, 2, 3, 4]
|
1
2
3
4
|
>>> from itertools import chain
>>> my_list = list(chain(['foo', 'bar'], cmd, numbers))
>>> my_list
['foo', 'bar', 'ls', '/some/dir', 0, 1, 2, 3, 4]
|
许多聪明的读者可能想到了，实际上不使用 itertools，也有其他方法能够实现这一要求。你可以这样做：
>>> my_list += cmd + numbers
>>> my_list
['foo', 'bar', 'ls', '/some/dir', 0, 1, 2, 3, 4]
|
1
2
3
4
|
>>> my_list = ['foo', 'bar']
>>> my_list += cmd + numbers
>>> my_list
['foo', 'bar', 'ls', '/some/dir', 0, 1, 2, 3, 4]
|
这些方法当然都是可行的。在我知道 chain 之前，我可能会这样做，但我个人认为这个例子中， chain 更为优雅，也更容易理解。
chain.from_iterable(可迭代对象)
你也可以用 chain 的一个方法，叫做 from_iterable。这个方法与直接用 chain 有些细微的差别。不同于直接传入一系列可迭代对象，你必须传入一个嵌套的列表。我们这就来看一看：
>>> numbers = list(range(5))
>>> cmd = ['ls', '/some/dir']
>>> chain.from_iterable(cmd, numbers)
Traceback (most recent call last):
Python Shell, prompt 66, line 1
builtins.TypeError: from_iterable() takes exactly one argument (2 given)
>>> list(chain.from_iterable([cmd, numbers]))
['ls', '/some/dir', 0, 1, 2, 3, 4]
|
1
2
3
4
5
6
7
8
9
|
>>> from itertools import chain
>>> numbers = list(range(5))
>>> cmd = ['ls', '/some/dir']
>>> chain.from_iterable(cmd, numbers)
Traceback (most recent call last):
Python Shell, prompt 66, line 1
builtins.TypeError: from_iterable() takes exactly one argument (2 given)
>>> list(chain.from_iterable([cmd, numbers]))
['ls', '/some/dir', 0, 1, 2, 3, 4]
|
这里我们跟之前一样先导入 chain。我们尝试传入两个列表，但却出现了 TypeError！为了修正这个错误，我们将 cmd 和 numbers 放入一个列表中，将这个嵌套的列表传入 from_iterable。虽然有点细微差别，但也是很方便使用的。
compress(数据, 选择器)
子模块 compress 在用一个可迭代对象过滤另一个可迭代对象时十分有用。这是通过将作为选择器的可迭代对象取为布尔值列表来实现的。下面是它的实现方式：
>>> letters = 'ABCDEFG'
>>> bools = [True, False, True, True, False]
>>> list(compress(letters, bools))
['A', 'C', 'D']
|
1
2
3
4
5
|
>>> from itertools import compress
>>> letters = 'ABCDEFG'
>>> bools = [True, False, True, True, False]
>>> list(compress(letters, bools))
['A', 'C', 'D']
|
这个例子中，我们有七个字母和五个布尔值构成的列表。我们它们传入 compress 函数。compress 函数将交替查看两个可迭代对象。先检查第一个可迭代对象，然后是第二个，如果第二个的元素为 True，则保留第一个对应元素，如果为 False，则丢弃第一个对应元素。据此，再看看上面的例子，你会发现第一、第三和第四个位置元素为 True，对应的与第一个对象中的 A, C 和 D。
dropwhile(断言, 可迭代对象)
itertools 还提供了一个小清新的迭代器 dropwhile。只要过滤器判定是 True，dropwhile 迭代器就会排除这些元素。因此，在出现断言为 False 之前，你不会看到任何输出结果。这可能导致启动时间非常长，这点应当注意。
我们看一个来自于 Python 文档的例子：
>>> list(dropwhile(lambda x: x<5, [1,4,6,4,1]))
[6, 4, 1]
|
1
2
3
|
>>> from itertools import dropwhile
>>> list(dropwhile(lambda x: x<5, [1,4,6,4,1]))
[6, 4, 1]
|
这里，我们先导入 dropwhile，然后传入一个简单的 lambda 声明的函数，如果 x 小于5，lambda 将返回 True ，否则返回 False。dropwhile 将遍历整个列表，然后将每个元素传入 lambda。如果 lambda 返回 True 则舍弃该值。一旦遇到了数字 6，lambda 将返回 False，因此，我们将保留数字 6 以及之后余下的元素。
当我了解更多之后发现，用一般的函数比 lambda 函数更为有用。所以我们尝试创建一个函数，如果参数大于 5，函数返回 True。
>>> def greater_than_five(x):
... return x > 5
...
>>> list(dropwhile(greater_than_five, [6, 7, 8, 9, 1, 2, 3, 10]))
[1, 2, 3, 10]
|
1
2
3
4
5
6
|
>>> from itertools import dropwhile
>>> def greater_than_five(x):
... return x > 5
...
>>> list(dropwhile(greater_than_five, [6, 7, 8, 9, 1, 2, 3, 10]))
[1, 2, 3, 10]
|
这里，我们在 Python 解释器中创建了一个简单的函数作为断言或过滤器。如果我们传入的值为 True，这些值都会被舍弃。一旦我们遇到了一个小于 5 的值，那么该值，包括其后余下的全部值都将被保留，正如你在例子中看到的。
filterfalse(断言, 可迭代对象)
itertools 中的 filterfalse 函数与 dropwhile 非常类似。只是，filterfalse 返回断言为 False 的那些值，而不是舍弃断言为 True 的值。以我们上一节创建的函数为例来阐释：
>>> def greater_than_five(x):
... return x > 5
...
>>> list(filterfalse(greater_than_five, [6, 7, 8, 9, 1, 2, 3, 10]))
[1, 2, 3]
|
1
2
3
4
5
6
|
>>> from itertools import filterfalse
>>> def greater_than_five(x):
... return x > 5
...
>>> list(filterfalse(greater_than_five, [6, 7, 8, 9, 1, 2, 3, 10]))
[1, 2, 3]
|
这里，我们向 filter 传入了我们创建的函数和一个整数元素的列表。如果整数值小于 5，这个整数将保留下来，否则将被舍弃。注意到，这里的结果仅有 1, 2 和 3。与 dropwhile 不同，filterfalse将对全部的值进行条件判断。
groupby(可迭代对象, 键=None)
groupby 迭代器会从传入的可迭代对象返回连续的键和组。不借助例子可能很难理解这一点，所以我们还是看例子。将下面的代码输入解释器或者存为一个文件：
vehicles = [('Ford', 'Taurus'), ('Dodge', 'Durango'),
('Chevrolet', 'Cobalt'), ('Ford', 'F150'),
('Dodge', 'Charger'), ('Ford', 'GT')]
sorted_vehicles = sorted(vehicles)
for key, group in groupby(sorted_vehicles, lambda make: make[0]):
for make, model in group:
print('{model} is made by {make}'.format(model=model,
make=make))
print ("**** END OF GROUP ***n")
|
1
2
3
4
5
6
7
8
9
10
11
12
13
|
from itertools import groupby
vehicles = [('Ford', 'Taurus'), ('Dodge', 'Durango'),
('Chevrolet', 'Cobalt'), ('Ford', 'F150'),
('Dodge', 'Charger'), ('Ford', 'GT')]
sorted_vehicles = sorted(vehicles)
for key, group in groupby(sorted_vehicles, lambda make: make[0]):
for make, model in group:
print('{model} is made by {make}'.format(model=model,
make=make))
print ("**** END OF GROUP ***n")
|
这里，我们先导入 groupby，然后创建一个元组构成的列表。接着，我们试图对数据排序使其输出时更有意义，这也让 groubby 能够正确地对元素分组。下一步，我们遍历 groupby 返回的含有键和组的迭代器。接着我们遍历组，并且打印出它的内容。如果你运行这段代码，你应该会看到下面的结果。
**** END OF GROUP ***
Charger is made by Dodge
Durango is made by Dodge
**** END OF GROUP ***
F150 is made by Ford
GT is made by Ford
Taurus is made by Ford
**** END OF GROUP ***
|
1
2
3
4
5
6
7
8
9
10
11
|
Cobalt is made by Chevrolet
**** END OF GROUP ***
Charger is made by Dodge
Durango is made by Dodge
**** END OF GROUP ***
F150 is made by Ford
GT is made by Ford
Taurus is made by Ford
**** END OF GROUP ***
|
试试改动一下上面的代码，将传入的 sorted_vehicles 替换成 vehicles。你很快就会明白为什么你要在传入 groupby 前对数据排序。
islice(可迭代变量, 起始值, 终止值[, 步长])
我们实际上在 count 一节的时候已经提到了 islice，这里我们将更深入地探讨这一函数。islice 是一个返回可迭代对象选定元素的迭代器。这种表述有点模糊。简而言之，islice 所做的是利用可迭代对象的索引实现切片，然后以迭代器的形式返回所选元素。实际上 islice 有两种实现方式，一种是 itertools.islice(iterable, stop)，还有一种更符合 Python 惯例的形式：islice(iterable, start, stop[, step])。
我们来看看第一种形式，观察它是如何工作的：
>>> iterator = islice('123456', 4)
>>> next(iterator)
'1'
>>> next(iterator)
'2'
>>> next(iterator)
'3'
>>> next(iterator)
'4'
>>> next(iterator)
Traceback (most recent call last):
Python Shell, prompt 15, line 1
builtins.StopIteration:
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
>>> from itertools import islice
>>> iterator = islice('123456', 4)
>>> next(iterator)
'1'
>>> next(iterator)
'2'
>>> next(iterator)
'3'
>>> next(iterator)
'4'
>>> next(iterator)
Traceback (most recent call last):
Python Shell, prompt 15, line 1
builtins.StopIteration:
|
在以上的代码中，我们传入了一个 6 个字符组成的字符串以及终止参数 4 给 isilce。这表示 islice 返回的迭代器将包含传入字符串的前 4 个字符。为了验证，我们连续四次调用 next 函数。Python 能够智能地识别是否只有 2 个传入参数，若是，则第二个参数就取为终止参数。
我们再试试传入三个参数来验证是否可以同时传入起始值和终止值。count 工具可以帮助我们解释这一概念：
>>> from itertools import count
>>> for i in islice(count(), 3, 15):
... print(i)
...
3
4
5
6
7
8
9
10
11
12
13
14
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
|
>>> from itertools import islice
>>> from itertools import count
>>> for i in islice(count(), 3, 15):
... print(i)
...
3
4
5
6
7
8
9
10
11
12
13
14
|
这里我们调用了 count，并指定 islice 从 3 开始，到 15 时结束。这跟我们用 slice 效果是一样的，不同之处在于传入的是迭代器，返回的是新的迭代器。
starmap(函数, 可迭代对象)
starmap 工具能够创建一个用传入的函数和可迭代对象计算的迭代器。如文档中所言，“map() 和 starmap() 的区别正如 function(a,b) 和 function(*c) 的区别。”
下面来看一个简单的例子：
>>> def add(a, b):
... return a+b
...
>>> for item in starmap(add, [(2,3), (4,5)]):
... print(item)
...
5
9
|
1
2
3
4
5
6
7
8
9
|
>>> from itertools import starmap
>>> def add(a, b):
... return a+b
...
>>> for item in starmap(add, [(2,3), (4,5)]):
... print(item)
...
5
9
|
这里，我们先创建了一个接受两个参数的求和函数。接下来我们创建了一个 for 循环，并调用 starmap 函数，starmap 函数的第一个传入参数是我们创建的求和函数，第二个传入参数是元组构成的列表。starmap 函数接着会将每一个元组传入求和函数，然后将结果返回到迭代器，正如我们打印出的那样。
takewhile(断言, 可迭代对象)
takewhile 模块与我们之前介绍的 dropwhile 迭代器刚好相反。takewhile 所创建的迭代器，一旦可迭代对象的断言或过滤器结果为 True 就返回元素。试一试下面的例子，看看它是如何工作的：
>>> list(takewhile(lambda x: x<5, [1,4,6,4,1]))
[1, 4]
|
1
2
3
|
>>> from itertools import takewhile
>>> list(takewhile(lambda x: x<5, [1,4,6,4,1]))
[1, 4]
|
这里，运行 takewhile 时传入了一个 lambda 函数和一个列表。输出的仅是可迭代对象的前两个整数元素。因为 1 和 4 都小于 5，而 6 大于5，一旦 takewhile 遇到 6， 判定条件结果将是 False，可迭代对象余下的元素将会被忽略。
tee(可迭代对象, n=2)
tee 工具能够从一个可迭代对象创建 n 个迭代器。这意味着你能够用一个可迭代对象创建多个迭代器。下面这段代码能大体解释它是如何工作的：
>>> data = 'ABCDE'
>>> iter1, iter2 = tee(data)
>>> for item in iter1:
... print(item)
...
A
B
C
D
E
>>> for item in iter2:
... print(item)
...
A
B
C
D
E
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
|
>>> from itertools import tee
>>> data = 'ABCDE'
>>> iter1, iter2 = tee(data)
>>> for item in iter1:
... print(item)
...
A
B
C
D
E
>>> for item in iter2:
... print(item)
...
A
B
C
D
E
|
这里我们创建了一个 5 个字母组成的字符串，然后传入 tee。由于 tee 的默认参数是 2，我们用两个变量接收 tee 返回的两个迭代器。最后，我们分别遍历了这两个迭代器，并打印出它们的内容。正如你所见的，它们的内容是相同的。
zip_longest(*可迭代对象, 填充值=None)
zip_longest 迭代器可以用于将两个可迭代对象配对。如果可迭代对象的长度不同，也可以传入填充值。我们来看一个来自该函数文档的一个很初级的例子：
>>> for item in zip_longest('ABCD', 'xy', fillvalue='BLANK'):
... print (item)
...
('A', 'x')
('B', 'y')
('C', 'BLANK')
('D', 'BLANK')
|
1
2
3
4
5
6
7
8
|
>>> from itertools import zip_longest
>>> for item in zip_longest('ABCD', 'xy', fillvalue='BLANK'):
... print (item)
...
('A', 'x')
('B', 'y')
('C', 'BLANK')
('D', 'BLANK')
|
这段代码里，我们先导入 zip_longest，然后传入两个需要配对的字符串。你会发现，第一个字符串有 4 个字符，而第二个只有 2 个字符。我们还传入了填充值”BLANK“。当遍历并打印的时候，会看到返回的是元组。前两个元组是分别来自两个字符串第一个和第二个字母的组合。后两个则插入了填充值。
需要注意的是，如果传入 zip_longest 的可迭代对象是无限的，那么你应该用类似 islice 的工具在外部处理函数，以便控制调用的次数。
组合生成器
itertools 库提供了四个可用于生成数据排列和组合的迭代器。这一章将介绍这些有趣的迭代器。
combinations(可迭代对象, r)
如果你需要生成数据的组合，Python 已经为你准备了 itertools.combinations。combinations 能够让你通过有一定长度的可迭代对象创建一个迭代器。请看：
>>>list(combinations('WXYZ', 2))
[('W', 'X'), ('W', 'Y'), ('W', 'Z'), ('X', 'Y'), ('X', 'Z'), ('Y', 'Z')]
|
1
2
3
|
>>>from itertools import combinations
>>>list(combinations('WXYZ', 2))
[('W', 'X'), ('W', 'Y'), ('W', 'Z'), ('X', 'Y'), ('X', 'Z'), ('Y', 'Z')]
|
当你运行这段代码时会发现，combinations 返回组合是元组。为了使输出结果更具可读性，可以遍历迭代器将元组组合成字符串：
... print(''.join(item))
...
WX
WY
WZ
XY
XZ
YZ
|
1
2
3
4
5
6
7
8
9
|
>>> for item in combinations('WXYZ', 2):
... print(''.join(item))
...
WX
WY
WZ
XY
XZ
YZ
|
现在容易看到全部的组合结果。注意，combinations 函数得到的组合是依循词典顺序的，因而如果传入的可迭代对象已经排序，那么你得到的组合元组也将是按序的。还有一点值得注意的是，combinations 函数不会将每个单独的元素自己跟自己组合。
combinations_with_replacement(可迭代对象, r)
combinationa_with_replacement 迭代器与 combinations 非常类似。唯一的区别是，它会创建元素自己与自己的组合。我们还是用上一节的例子来阐释：
>>> for item in combinations_with_replacement('WXYZ', 2):
... print(''.join(item))
...
WW
WX
WY
WZ
XX
XY
XZ
YY
YZ
ZZ
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
>>> from itertools import combinations_with_replacement
>>> for item in combinations_with_replacement('WXYZ', 2):
... print(''.join(item))
...
WW
WX
WY
WZ
XX
XY
XZ
YY
YZ
ZZ
|
正如你所见，我们这里多了四个输出：WW, XX, YY 和 ZZ。
product(*可迭代对象, 重复=1)
itertools 包还提供一个小清新的函数用于根据一系列输入的可迭代对象计算笛卡尔积。没错，这就是 product 函数。我们来瞧瞧它是如何工作的！
>>> arrays = [(-1,1), (-3,3), (-5,5)]
>>> cp = list(product(*arrays))
>>> cp
[(-1, -3, -5),
(-1, -3, 5),
(-1, 3, -5),
(-1, 3, 5),
(1, -3, -5),
(1, -3, 5),
(1, 3, -5),
(1, 3, 5)]
|
1
2
3
4
5
6
7
8
9
10
11
12
|
>>> from itertools import product
>>> arrays = [(-1,1), (-3,3), (-5,5)]
>>> cp = list(product(*arrays))
>>> cp
[(-1, -3, -5),
(-1, -3, 5),
(-1, 3, -5),
(-1, 3, 5),
(1, -3, -5),
(1, -3, 5),
(1, 3, -5),
(1, 3, 5)]
|
这里，我们先导入 product，然后创建一个元组构成的列表，用变量 arrays 储存。接下来，我们将这些数组传入 product 函数，然后调用。你应该注意到了，我们调用时使用了 *arrays。这会使传入的列表被拆解，依次应用于 product 函数。这意味着你传入的将是三个变量而不是一个。如果有兴趣，你可以试试调用带星号的 arrays，看看会发生什么。
permutations(可迭代变量, r)
itertools 的子模块 permutation 能够返回由传入的可迭代对象的元素构成的长度为 r 的排列。与 combination 函数类似，permutation 将以词典序输出。请看：
>>> for item in permutations('WXYZ', 2):
... print(''.join(item))
...
WX
WY
WZ
XW
XY
XZ
YW
YX
YZ
ZW
ZX
ZY
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
|
>>> from itertools import permutations
>>> for item in permutations('WXYZ', 2):
... print(''.join(item))
...
WX
WY
WZ
XW
XY
XZ
YW
YX
YZ
ZW
ZX
ZY
|
容易发现，输出结果比 combinations 的输出结果长一些。当使用时，permutation 函数将遍历字符串的所有排列，但当输入元素是唯一的时候，不会让这个元素自己和自己排列。
总结
itertools 是创建迭代器时十分通用的工具集。你可以用这些单独用这些工具，也可以组合起来使用来创建自定义的迭代器。Python 官方文档提供了许多很棒的实例，你可以参考这些例子发掘这个有用的库的其他用法。
python基础=== itertools介绍（转载）的更多相关文章
- Day1 - Python基础1 介绍、基本语法、流程控制
Python之路,Day1 - Python基础1 本节内容 Python介绍 发展史 Python 2 or 3? 安装 Hello World程序 变量 用户输入 模块初识 .pyc是个什么鬼 ...
- [python] 基础工具介绍好文推荐
Github上有个哥们写的,还不错,mark一下: https://github.com/lijin-THU/notes-python/blob/master/index.ipynb 相对全面的介绍了 ...
- Python学习笔记—Python基础1 介绍、发展史、安装、基本语法
第一周学习笔记: 一.Python介绍 1.Python的创始人为吉多·范罗苏姆.1989年的圣诞节期间,吉多·范罗苏姆为了在阿姆斯特丹打发时间,决心开发一个新的脚本解释程序,作为ABC语言 ...
- week1 - Python基础1 介绍、基本语法、流程控制
知识内容: 1.python介绍 2.变量及输入输出 3.分支结构 4.循环结构 一.python介绍 Python主要应用领域: 云计算: 云计算最火的语言, 典型应用OpenStack WEB开发 ...
- python基础初识介绍以及安装
python介绍 Python的创始人为Guido van Rossum.1989年圣诞节期间,在阿姆斯特丹,Guido为了打发圣诞节的无趣,决心开发一个新的脚本解释程序,做为ABC 语言的一种继承. ...
- Python基础1 介绍、基本语法
---恢复内容开始--- 本节内容 Python介绍 发展史 Python 2 or 3? 安装 Hello World程序 变量 用户输入 模块初识 .pyc是个什么鬼? 数据类型初识 数据运算 表 ...
- Python基础1 介绍、基本语法 、 流程控制-DAY1
本节内容 Python介绍 发展史 Python 2 or 3? 安装 Hello World程序 变量 用户输入 模块初识 .pyc是个什么鬼? 数据类型初识 数据运算 表达式if ...else语 ...
- Python之路,Day1 - Python基础1 介绍、基本语法、流程控制
本节内容 1.python介绍 2.发展史 3.python 2.x or python 3.x ? 4.python 安装 5.第一个程序 Hello World 程序 6.变量 7.用户输入 8. ...
- Python基础 列表介绍、使用
第3章 学习目标: 列表是什么以及如何使用列表元素.列表让你能够在一个地方存储成组的信息,其中可以只包含几个元素,也可以包含数百万个元素.列表是新手可直接使用的最强大的Python功能之一,它融合了众 ...
随机推荐
- html页面导入文件 使用include后多出一空白行的解决
用include引入的footer和header文件都在上面多出一空白行,是Unicode签名(bom)引起的. “标题/编码”,把 包括unicode签名(bom) 的勾取消就好了.
- hdu 3030 Increasing Speed Limits (离散化+树状数组+DP思想)
Increasing Speed Limits Time Limit: 2000/10000 MS (Java/Others) Memory Limit: 32768/32768 K (Java ...
- POJ2079：Triangle——题解
http://poj.org/problem?id=2079 题目大意:求最大面积的三角形. —————————————————— 可以知道,最大面积的三角形的顶点一定是最大凸包的顶点. 接下来就是O ...
- [学习笔记]分治FFT
一般的分治FFT是指: https://www.luogu.org/problemnew/show/P4721 考虑后面的f和前面的f有关系,但是贡献可以分着计算,逐一累计上去. 考虑cdq分治.算出 ...
- 20181015 考试记录&数论
题目传送门 W神爷的题解 数论 小 M 的算式 [问题描述] 小 M 在做数学作业的时候遇到了一个有趣的问题:有一个长度为 n 的数字 串 S,小 M 需要在数字之间填入若干个“+”和恰好一个“=”, ...
- Codeforces Round #340 (Div. 2) A
A. Elephant time limit per test 1 second memory limit per test 256 megabytes input standard input ou ...
- bzoj 2095 [Poi2010]Bridges 判断欧拉维护，最大流+二分
[Poi2010]Bridges Time Limit: 10 Sec Memory Limit: 259 MBSubmit: 1448 Solved: 510[Submit][Status][D ...
- git版本回退与撤销操作
场景1:当你改乱了工作区某个文件的内容,想直接丢弃工作区的修改时,用命令git checkout -- file. 场景2:当你不但改乱了工作区某个文件的内容,还添加到了暂存区时,想丢弃修改,分两步, ...
- 疯狂java学习笔记
面向对象: 从现实世界中客观存在的事物(对象)出发构造软件系统,并在软件系统构造中运用人类的自然思维方式,强调直接以现实世界中的事物为中心来思考,认识问题,并根据这些事务的本质特点,将他们抽象为系统中 ...
- 深度解析Java多线程的内存模型
内部java内存模型 硬件层面的内存模型 Java内存模型和硬件内存模型的联系 共享对象的可见性 资源竞速 Java内存模型很好的说明了JVM是如何在内存里工作的,JVM可以理解为java执行的一个操 ...