itertools操作迭代对象

count()无限迭代器

itertools.count(start=0, step=1)创建一个迭代器，生成从n开始的连续整数，如果忽略n，则从0开始计算（注意：此迭代器不支持长整数）

如果超出了sys.maxint，计数器将溢出并继续从-sys.maxint-1开始计算。

import itertools


natuals = itertools.count(1)  # 表示以1开始，可以以任何值（包含负数）开始
print(natuals)  # count(1)
for item in natuals:
    print(item)
'''
1
2
3
4
5
6
...
'''

因为count()会创建一个无限的迭代器，所以上述代码会打印出自然数序列，根本停不下来，只能按Ctrl+C退出。

cycle()无限迭代器

cycle()会把传入的一个序列无限重复下去

cs = itertools.cycle('ABC')  # 注意字符串也是序列的一种
print(cs)  # <itertools.cycle object at 0x000001F8DF068EE8>
for c in cs:
    print(c)
'''
A
B
C
A
B
C
A
...
'''

repeat()可指定循环次数

itertools.repeat(object[, times])创建一个迭代器，重复生成object，times（如果已提供）指定重复计数，如果未提供times，将无止尽返回该对象。

repeat()负责把一个元素无限重复下去，不过如果提供第二个参数就可以限定重复次数

ns = itertools.repeat('AB', 3)  # 3表示只循环3次，如果没有这个参数，会一直循环下去
for n in ns:
    print(n)
'''
AB
AB
AB
'''

takewhile()条件停止迭代

无限序列只有在for迭代时才会无限地迭代下去，如果只是创建了一个迭代对象，它不会事先把无限个元素生成出来，事实上也不可能在内存中创建无限多个元素。

无限序列虽然可以无限迭代下去，但是通常我们会通过takewhile()等函数根据条件判断来截取出一个有限的序列：

natuals = itertools.count(1)

ns = itertools.takewhile(lambda x: x <= 10, natuals)

print(ns)  # <itertools.takewhile object at 0x000001D329FA6808>
print(list(ns))  # [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

chain()串联迭代对象

chain()可以把多组迭代对象串联起来，形成一个更大的迭代器，就好像他们是来自于一个单一的序列。itertools.chain('ABC', 'XYZ', '123')多个可迭代对象也是可行的

for c in itertools.chain('ABC', 'XYZ'):
    print(c)
'''
A
B
C
X
Y
Z
'''

groupby()相邻重复元素组合

groupby()把迭代器中相邻的重复元素挑出来放在一起

for key, group in itertools.groupby('AAABBBCCAAA'):
    print(key, group)
'''
A <itertools._grouper object at 0x000001A5F13C9BA8>
B <itertools._grouper object at 0x000001A5F1461AC8>
C <itertools._grouper object at 0x000001A5F13C9BA8>
A <itertools._grouper object at 0x000001A5F1461A90>
'''

for key, group in itertools.groupby('AAABBBCCAAA'):
    print(key, list(group))
'''
A ['A', 'A', 'A']
B ['B', 'B', 'B']
C ['C', 'C']
A ['A', 'A', 'A']
'''

实际上挑选规则是通过函数完成的，只要作用于函数的两个元素返回的值相等，这两个元素就被认为是在一组的，而函数返回值作为组的key。如果我们要忽略大小写分组，就可以让元素'A'和'a'都返回相同的key：

for key, group in itertools.groupby('AaaBBbcCAAa', lambda c: c.upper()):
    print(key, list(group))
'''
A ['A', 'a', 'a']
B ['B', 'B', 'b']
C ['c', 'C']
A ['A', 'A', 'a']
'''

product()笛卡尔积

笛卡尔积：itertools.product(*iterables[, repeat])

直接对自身进行笛卡尔积：

for item in itertools.product('ABCD'):  # repeat默认为1
    print(item)
'''
('A',)
('B',)
('C',)
('D',)
'''
for item in itertools.product('ABCD', repeat=2):
    print(''.join(item), end=' ')
'''
AA AB AC AD BA BB BC BD CA CB CC CD DA DB DC DD
'''

总数量为len('ABCD') ** repeat等于4**2=16

两个元组进行笛卡尔积，product(list1, list2) 依次取出list1中的每1个元素，与list2中的每1个元素，组成元组，然后，将所有的元组组成一个列表，返回。

a = (1, 2, 3)
b = ('A', 'B', 'C')
c = itertools.product(a, b)
for item in c:
    print(item, end=' ')
    # (1, 'A') (1, 'B') (1, 'C') (2, 'A') (2, 'B') (2, 'C') (3, 'A') (3, 'B') (3, 'C')

permutations()排列

for item in itertools.permutations('ABCD', 2):  # 两个进行排列，不含自身重复
    print(''.join(item), end=' ')
    # AB AC AD BA BC BD CA CB CD DA DB DC

combinations()组合

for item in itertools.combinations('ABCD', 2):  # 两个进行排列，不含自身重复，不交换元素
    print(''.join(item), end=' ')
    # AB AC AD BC BD CD

combinations_with_replacement()组合包含自身重复

for item in itertools.combinations_with_replacement('ABCD', 2):
    print(''.join(item), end=' ')
    # AA AB AC AD BB BC BD CC CD DD