[游戏开发]itertools --- 为高效循环而创建迭代器的函数

资料来源：https://www.cnblogs.com/dwithy/p/11653164.html
https://segmentfault.com/a/1190000008590958
https://blog.csdn.net/qq_43401035/article/details/119253871

无穷迭代器

itertools.count(start=0, step=1)

• 创建一个迭代器，它从start 值开始，返回均匀间隔的值。常用于map() 中的实参来生成连续的数据点。
• 此外，还用于zip() 来添加序列号

import itertools

# 输出0-9的奇数
for i in itertools.count(1, 2):
    print(i)
    if i == 9:
        break
"""
1
3
5
7
9
"""

itertools.cycle(iterable)

• 创建一个迭代器，返回iterable 中所有元素并保存一个副本。当取完iterable 中所有元素，返回副本中的所有元素。无限重复

import itertools

j = 0

# 循环输出'abc'中的字母
for i in itertools.cycle('abc'):
    print(i)

    # 第5步结束循环
    j += 1
    if j == 5:
        break
"""
a
b
c
a
b
"""

itertools.repeat(object[, times ])

• 生成一个重复times次object的迭代器，若times=None则无限次重复。

import itertools

for i in itertools.repeat('练习', 3):
    print(i)
"""
练习
练习
练习
"""

根据最短输入序列长度停止的迭代器

itertools.accumulate(iterable[, func, *, initial=None ])

• 返回累积汇总值或其他双目运算函数的累积结果值（通过可选的func 参数指定）
• 参考一个类似函数functools.reduce() ，它只返回一个最终累积值。

import itertools
import operator

data = [3, 4, 6, 2, 1, 9, 0, 7, 5, 8]
print(list(itertools.accumulate(data, operator.mul)))
print(list(itertools.accumulate(data, max)))
"""
[3, 12, 72, 144, 144, 1296, 0, 0, 0, 0]
[3, 4, 6, 6, 6, 9, 9, 9, 9, 9]
"""

itertools.chain(*iterables)

• *iterables：可以传入多个迭代器作为参数。
• 说明： 把传入的多个iterable拼接成一个迭代器，并且按传入顺序迭代。

import itertools

print('单独的迭代器拼接')
for i in itertools.chain('abc', [1, 2, 3]):
    print(i)

print('用iterable的元素拼接，iterable的元素必须为可迭代：')
for i in itertools.chain.from_iterable(['abc', [1, 2, 3]]):
    print(i)
"""
单独的迭代器拼接
a
b
c
1
2
3
用iterable的元素拼接，iterable的元素必须为可迭代：
a
b
c
1
2
3
"""

itertools.compress(data, selectors)

• 按照真值表筛选元素

import itertools

# data长度为5，selector长度为3
for i in itertools.compress([1, 2, 3, 4, 5, 6], [1, 0, 1]):
    print(i)
x = itertools.compress(range(5), (True, False, True, True, False))
print(list(x))
"""
1
3
[0, 2, 3]
"""

itertools.dropwhile(predicate, iterable)

• 说明：将iterable中的元素传入predicate中作为predicate的参数，若predicate返回True则去除，若predicate返回Flase则保留，最后生成一个迭代器。

import itertools

# 去除小于3的数
for i in itertools.dropwhile(lambda x: x < 3, [1, 2, 3, 4, 5]):
    print(i)
"""
3
4
5
"""

itertools.filterfalse(predicate, iterable)

• 保留对应真值为False的元素

import itertools

x = itertools.filterfalse(lambda e: e < 5, (1, 5, 3, 6, 9, 4))
print(list(x))
"""
[5, 6, 9]
"""

itertools.groupby(iterable, key=None)

• 按照分组函数的值对元素进行分组

import itertools

x = itertools.groupby(range(10), lambda x: x < 5 or x > 8)
for condition, numbers in x:
    print(condition, list(numbers))

# 将字符串元素转换为大写后，相邻字符相同的组成一组
for i, j in itertools.groupby('AaBbA', lambda x: x.upper()):  # i是lambda匿名函数返回的结果，j是函数处理之后的同组元素迭代器
    print('%s:%s' % (i, list(j)))
"""
True [0, 1, 2, 3, 4]
False [5, 6, 7, 8]
True [9]
A:['A', 'a']
B:['B', 'b']
A:['A']
"""

itertools.islice(iterable, start, stop[, step ])

• 对iterable进行切片，参考函数slice。

import itertools

x = itertools.islice(range(10), 0, 9, 2)
print(list(x)) # [0, 2, 4, 6, 8]

itertools.pairwise(iterable)

• 创建一个迭代器，返回从 iterable 获取的连续重叠对。

import itertools

print(itertools.pairwise('ABCDEFG')) # AB BC CD DE EF FG
pairwise('A')  # (Empty)

itertools.starmap(function, iterable)

• 对iterable进行映射操作，参考map函数。两者区别在于func有多个参数时，startmap为func(*arg)用的是可变参数，map为func(arg1,arg2)用的是位置参数

import itertools

# 生成迭代器，其元素为原来元素之和的映射
for i in itertools.starmap(lambda x, y: x + y, [(1, 1), (2, 2), (3, 3)]):
    print(i)
"""
2
4
6
"""

itertools.takewhile(predicate, iterable)

• 与dropwhile相反，保留元素直至真值函数值为假。

import itertools

x = itertools.takewhile(lambda e: e < 5, range(10))
print(list(x))  # [0, 1, 2, 3, 4]

itertools.tee(iterable, n=2)

• 对iterable进行复制，生成n的相同的iterable。

import itertools
#复制迭代器
i,j,k=itertools.tee(iter('abc'),3)
print(list(i))
print(list(j))
print(list(k))
'''
结果：
['a', 'b', 'c']
['a', 'b', 'c']
['a', 'b', 'c']
'''

itertools.zip_longest(*iterables, fillvalue=None)

• 类似于zip，不过以较长的列表和迭代器的长度为准

import itertools

x = itertools.zip_longest(range(3), range(5))
y = zip(range(3), range(5))
print(list(x))  # [(0, 0), (1, 1), (2, 2), (None, 3), (None, 4)]
print(list(y))  # [(0, 0), (1, 1), (2, 2)]

排列组合迭代器

itertools.product(*iterables, repeat=1)

• 创建一个迭代器，返回可迭代对象输入的笛卡儿积。

product('AB', range(3))  # ('A',0) ('A',1) ('A',2) ('B',0) ('B',1) ('B',2)
product(range(2), repeat=3)  # (0,0) (0,1) (1,0) (1,1)

itertools.permutations(iterable, r=None)

• 创建一个迭代器，连续返回由 iterable 元素生成长度为 r 的排列。如果 r 未指定或为 None ，r 默认设置为 iterable 的长度，这种情况下，生成所有全长排列。

permutations(range(3))  # (0,1,2) (0,2,1) (1,0,2) (1,2,0) (2,0,1) (2,1,0)
permutations('ABC')  # ('A','B','C') ('A','C','B') ('B','A','C') ('B','C','A') ('C','A','B') ('C','B','A')
permutations('ABC', 2)  # ('A','B') ('A','C') ('B','A') ('B','C') ('C','A') ('C','B')

itertools.combinations(iterable, r)

• 取tierable对象中r个元素进行组合。

import itertools

x = "ABC"
combin_1 = itertools.combinations(x, 1)  # 取1个数进行组合，生成的时一个迭代器
combin_2 = itertools.combinations(x, 2)  # 取2个数进行组合，生成的是一个迭代器
print('combin_1:', list(combin_1))  # 将迭代器转为列表并打印
print('\ncombin_1、combin_2的数据类型：', type(combin_1))
print('\n输出迭代器每次迭代内容:')
for i in combin_2:
    print(i)

x = itertools.combinations(range(4), 3)
print(list(x))
"""
combin_1: [('A',), ('B',), ('C',)]
combin_1、combin_2的数据类型： <class 'itertools.combinations'>
输出迭代器每次迭代内容:
('A', 'B')
('A', 'C')
('B', 'C')
[(0, 1, 2), (0, 1, 3), (0, 2, 3), (1, 2, 3)]
"""

itertools.combinations_with_replacement(iterable, r)

• 允许重复元素的组合

import itertools

x = itertools.combinations_with_replacement('ABC', 2)
print(list(x))
"""
[('A', 'A'), ('A', 'B'), ('A', 'C'), ('B', 'B'), ('B', 'C'), ('C', 'C')]
"""