nt
@functools.total_ordering
class Point:
def __init__(self, x, y):
self.x = x
self.y = y
def __repr__(self):
return '({}, {})'.format(self.x, self.y)
def __eq__(self, other):
return (self.x, self.y) == (other.x, other.y)
def __gt__(self, other):
return (self.x, self.y) > (other.x, other.y)
# 生成Point实例的数据集
data = list(map(Point, [1, 2, 3, 1, 2], range(5)))
print('Data:')
pprint.pprint(data, width=35)
print()
# 对无序的data基于属性x聚合
print('聚合, 无序data:')
for k, g in groupby(data, operator.attrgetter('x')):
print(k, list(g))
print()
# 对data排序
data.sort()
print('排序后:')
pprint.pprint(data, width=35)
print()
# 对排序后的data基于属性X聚合
print('聚合, 有序data:')
for k, g in groupby(data, operator.attrgetter('x')):
print(k, list(g))
输入序列需要根据键值进行排序处理后才输出预期的聚合结果。
# OutPut
Data:
[(1, 0),
(2, 1),
(3, 2),
(1, 3),
(2, 4)]
聚合, 无序data:
1 [(1, 0)]
2 [(2, 1)]
3 [(3, 2)]
1 [(1, 3)]
2 [(2, 4)]
排序后:
[(1, 0),
(1, 3),
(2, 1),
(2, 4),
(3, 2)]
聚合, 有序data:
1 [(1, 0), (1, 3)]
2 [(2, 1), (2, 4)]
3 [(3, 2)]
6.组合
accumulate() 函数的作用是:处理可迭代的输入，将第n和n+1项传递给目标函数，生成返回值，而不是直接返回输入。默认函数功能是将两个值相加，因此可以使用 accumulate() 来生成一系列数值输入的累积和。
from itertools import accumulate
print(list(accumulate(range(5))))
print(list(accumulate('abcde')))
如果输入序列是非整数值时，结果取决于将两个项“相加”在一起的含义。比如上面例子中的第二项 accumulate() 接收的是一个字符串，返回则是将字符串逐个拼接在一起。
# OutPut
[0, 1, 3, 6, 10]
['a', 'ab', 'abc', 'abcd', 'abcde']
同时 accumulate() 也接受自定义的带有两个输入项的函数。
from itertools import accumulate
def f(a, b):
print(a, b)
return b + a
print(list(accumulate('abcde', f)))
# OutPut
a b
ba c
cba d
dcba e
['a', 'ba', 'cba', 'dcba', 'edcba']
如果嵌套for循环遍历多个序列可以使用 product() ，它会生成一个迭代器，其值是该组输入值的笛卡尔乘积。
from itertools import product
char = ['a', 'b', 'c']
integer = [1, 2, 3]
for each in product(char, integer):
print(each)
由 product() 产生的值是元组，由每个迭代中取出的成员按照它们传递的顺序作为参数传入。
# OutPut
('a', 1)
('a', 2)
('a', 3)
('b', 1)
('b', 2)
('b', 3)
('c', 1)
('c', 2)
('c', 3)
如果要计算序列与其本身的笛卡尔积，则需要指定 repeat 参数。
from itertools import product
char = ['a', 'b']
for each in product(char, repeat=2):
print(each)
for each in product(char, repeat=2):
print(each)
# OutPut
('a', 'a', 'a')
('a', 'a', 'b')
('a', 'b', 'a')
('a', 'b', 'b')
('b', 'a', 'a')
('b', 'a', 'b')
('b', 'b', 'a')
('b', 'b', 'b')
permutation() 函数从输入的迭代的组合中生成指定长度的排列。它默认生成所有排列的完整集合。
from itertools import permutations
for each in permutations('abc'):
print(each)
print()
for each in permutations('abc', r=2):
print(each)
使用 r 参数来限制返回的单个排列的长度。
# OutPut
('a', 'b', 'c')
('a', 'c', 'b')
('b', 'a', 'c')
('b', 'c', 'a')
('c', 'a', 'b')
('c', 'b', 'a')
('a', 'b')
('a', 'c')
('b', 'a')
('b', 'c')
('c', 'a')
('c', 'b')
如果输出要保证唯一, 即需要组合而不是排列，请使用 combination() 。只要输入的成员是唯一的，输出就不会包含任何重复的值。
from itertools import combinations
for each in combinations('abc', r=2):
print(each)
与 permutations() 不同的是, combination() 必须传入 r 参数。
# OutPut
('a', 'b')
('a', 'c')
('b', 'c')
因为 combination() 不重复单个输入元素，但考虑有时需要包含重复元素的组合。对于这些情况，可以使用 combinations_with_replacement() 。
from itertools import combinations_with_replacement
for each in combinations_with_replacement('abc', r=2):
print(each)
在此输出中，每个输入项都与其自身以及输入序列的所有其他成员组合。
('a', 'a')
('a', 'b')
('a', 'c')
('b', 'b')
('b', 'c')
('c', 'c')
转载请注明来源: Python标准库笔记(10) — itertools模块