itertools python 操作列表 python中itertools

Itertools模块官方描述：
Functional tools for creating and using iterators.即用于创建高效迭代器的函数。
itertools用于高效循环的迭代函数集合。

迭代器
迭代器（生成器） 在Python中是一种很常用也很好用的数据结构，比起列表(list)来说，迭代器最大的优势就是延迟计算，按需使用，从而提高开发体验和运行效率，以至于在Python 3中map,filter等操作返回的不再是列表而是迭代器。

话虽这么说但大家平时用到的迭代器大概只有range了，而通过iter函数把列表对象转化为迭代器对象又有点多此一举，这时候我们今天的主角itertools就该上场了。

迭代器的特点
惰性求值（Lazy evaluation），即只有当迭代至某个值时，它才会被计算，这个特点使得迭代器特别适合于遍历大文件或无限集合等，因为我们不用一次性将它们存储在内存中。

使用itertools
itertools中的函数大多是返回各种迭代器对象，其中很多函数的作用我们平时要写很多代码才能达到，而在运行效率上反而更低，毕竟人家是系统库。
什么是itertools
itertools 模块包含了一系列用来产生不同类型迭代器的函数或类，这些函数的返回都是一个迭代器，我们可以通过 for 循环来遍历取值，也可以使用 next() 来取值。

itertools的分类

itertools 模块提供的迭代器函数有以下几种类型：

• 无限迭代器：生成一个无限序列，比如自然数序列 1, 2, 3, 4, …；
• 有限迭代器：接收一个或多个序列（sequence）作为参数，进行组合、分组和过滤等；
• 组合生成器：序列的排列、组合，求序列的笛卡儿积等；

无限迭代器

itertools 模块提供了三个函数（事实上，它们是类）用于生成一个无限序列迭代器：

函数	说明
count(firstval=0, step=1)	创建一个从 firstval (默认值为 0) 开始，以 step (默认值为 1) 为步长的的无限整数迭代器
cycle(iterable)	对 iterable 中的元素反复执行循环，返回迭代器
repeat(object [,times]	反复生成 object，如果给定 times，则重复次数为 times，否则为无限

详解

1、itertools.count

就是一个计数器,可以指定起始位置和步长

##(1)参数不指定
# x= itertools.count()
# for i in x:
#     if i > 6:
#          break
#     print(i)

## (2)指定开始值和步长
# x= itertools.count(2, 3)
# for i in x:
#     if i > 6:
#          break
#     print(i)

##(3)也可用于切片操作：
# islice(iterable, [start, ] stop [, step])
# x = itertools.count(start=20, step=-1)
# print(list(itertools.islice(x, 0, 10, 1)))

2、itertools.cycle

循环指定的列表和迭代器,用于对 iterable 中的元素反复执行循环.

##(1)循环语句
cycle_strings = itertools.cycle('ABC')
i = 1
for string in cycle_strings:
     if i == 10:
         break
     print(i, string)
     i += 1

##(2)也可用于切片操作
x = itertools.cycle('ABC')
print(list(itertools.islice(x, 0, 10, 1)))

3、itertools.repeat

简单的生成一个拥有指定数目元素的迭代器

##(1)
x = itertools.repeat(3, 6)
print(list(x))

##(2)
for item in itertools.repeat('hello world', 3):
    print(item)

有限迭代器

itertools 模块提供了多个函数（类），接收一个或多个迭代对象作为参数，对它们进行组合、分组和过滤等：

序号	函数	语法	说明
1	chain()	chain(iterable1, iterable2, iterable3, …)	连接多个列表或者迭代器,作为一个新的迭代器返回。
2	compress()	compress(data, selectors)	用于对数据进行筛选,当 selectors 的某个元素为 true 时，则保留 data 对应位置的元素，否则去除.
3	dropwhile()	dropwhile(predicate, iterable)	按照真值函数丢弃掉列表和迭代器前面的元素,iterable 中的元素，如果 predicate(item) 为 true，则丢弃该元素，否则返回该项及所有后续项。
4	groupby()	groupby(iterable[, keyfunc])	iterable 是一个可迭代对象， keyfunc 是分组函数，用于对 iterable 的连续项进行分组，如果不指定，则默认对 iterable 中的连续相同项进行分组，返回一个 (key, sub-iterator) 的迭代器。
5	islice()	islice(iterable, [start,] stop [, step])	切片选择,iterable 是可迭代对象，start 是开始索引，stop 是结束索引，step 是步长，start 和 step 可选。
6	tee()	tee(iterable [,n])	用于从 iterable 创建 n 个独立的迭代器，以元组的形式返回，n 的默认值是 2。
7	takewhile()	takewhile(predicate, iterable)	predicate(item) 为 true，则保留该元素，只要 predicate(item) 为 false，则立即停止迭代。

详解

1、itertools.chain

连接多个列表或者迭代器。
chain使用形式：

chain(iterable1, iterable2, iterable3, ...)

chain 接收多个可迭代对象作为参数，将它们【连接】起来，作为一个新的迭代器返回。

##(1)
x = itertools.chain(range(3), range(4), [3, 2, 4])
print(list(x))

##(2)
for item in itertools.chain([1, 2, 3], ['a', 'b', 'c']):
    print(item)

2、itertools.compress

按照真值表筛选元素。
语法：compress(data, selectors) 当 selectors 的某个元素为 true 时，则保留 data 对应位置的元素，否则去除。

x = itertools.compress(range(5), (True, False, True, True, False))
print(list(x))

x1 = list(itertools.compress('ABCDEF', [1, 1, 0, 1, 0, 1]))
print(x1)

x2 = list(itertools.compress('ABCDEF', [1, 1, 0, 1]))
print(x2)

x3 = list(itertools.compress('ABCDEF', [True, False, True]))
print(x3)

3、itertools.dropwhile

按照真值函数丢弃掉列表和迭代器前面的元素
语法：dropwhile(predicate, iterable) predicate 是函数，iterable 是可迭代对象。对于 iterable 中的元素，如果 predicate(item) 为 true，则丢弃该元素，否则返回该项及所有后续项。

x = itertools.dropwhile(lambda e: e < 5, range(10))
print(list(x))

x1 = list(itertools.dropwhile(lambda x: x < 5, [1, 3, 6, 2, 1]))
print(x1)

x2 = list(itertools.dropwhile(lambda x2: x2 > 3, [2, 1, 6, 5, 4]))
print(x2)
---->
[5, 6, 7, 8, 9]
[6, 2, 1]
[2, 1, 6, 5, 4]

4、groupby

用于对序列进行分组。
语法：groupby(iterable[, keyfunc]) 其中，iterable 是一个可迭代对象， keyfunc 是分组函数，用于对 iterable 的连续项进行分组，如果不指定，则默认对 iterable 中的连续相同项进行分组，返回一个 (key, sub-iterator) 的迭代器。

#(1)不指定分组
for key, value_iter in itertools.groupby('aaabbbaaccd'):
    print(key, ":", list(value_iter))

#(2)指定分组--使用 len 函数作为分组函数,连续项不相同
data = ['a', 'bb', 'ccc', 'dd', 'eee', 'f']
for key, value_iter in itertools.groupby(data, len):
    print(key, ":", list(value_iter))

#(3)指定分组--使用 len 函数作为分组函数，连续项相同
data = ['a', 'bb', 'cc', 'ddd', 'eee', 'f']
for key, value_iter in itertools.groupby(data, len):
    print(key, ";", list(value_iter))

5、islice

切片选择
语法：islice(iterable, [start,] stop [, step]) iterable 是可迭代对象，start 是开始索引，stop 是结束索引，step 是步长，start 和 step 可选。

x = list(itertools.islice([10, 6, 2, 8, 1, 3, 9], 5))
print(x)

x1 = list(itertools.islice(itertools.count(), 6))
print(x1)

x2 = list(itertools.islice(itertools.count(), 3, 10))
print(x2)

x3 = list(itertools.islice(itertools.count(), 3, 10, 2))
print(x3)
---->
[10, 6, 2, 8, 1]
[0, 1, 2, 3, 4, 5]
[3, 4, 5, 6, 7, 8, 9]
[3, 5, 7, 9]

6、tee

生成指定数目的迭代器。
语法：tee(iterable [,n]) tee 用于从 iterable 创建 n 个独立的迭代器，以元组的形式返回，n 的默认值是 2。

#(1)n 默认为 2，创建2个独立的迭代器
x = itertools.tee('abcd')
print(x)

#(2)
x1, x2 = itertools.tee('abcde')
print(list(x1))
print(list(x2))

#(3)创建3个独立的迭代器
x3 = itertools.tee('abc', 3)
print(x3)
---->
(<itertools._tee object at 0x000001ABBD283108>, <itertools._tee object at 0x000001ABBD283148>)
['a', 'b', 'c', 'd', 'e']
['a', 'b', 'c', 'd', 'e']
(<itertools._tee object at 0x000001ABBD2832C8>, <itertools._tee object at 0x000001ABBD283308>, <itertools._tee object at 0x000001ABBD283348>)

(4)
x4 = itertools.tee(range(10), 3)
for num in x4:
    print(list(num))
---->
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

7、takewhile

语法：takewhile(predicate, iterable) predicate 是函数，iterable 是可迭代对象。如果 predicate(item) 为 true，则保留该元素，只要 predicate(item) 为 false，则立即停止迭代。

x = list(itertools.takewhile(lambda x: x < 5, [1, 3, 6, 2, 1]))
print(x)
x1 = list(itertools.takewhile(lambda x: x > 3, [2, 1, 6, 5, 4]))
print(x1)
---->
[1, 3]
[]

组合生成器

itertools 组合生成器函数，用于求序列的排列、组合等：

序号	函数	语法	说明
1	product	product(iter1, iter2, … iterN, [repeat=1])	用于求多个可迭代对象的笛卡尔积，它跟嵌套的 for 循环等价。repeat 是一个关键字参数，用于指定重复生成序列的次数。
2	permutations	permutations(iterable[, r])	用于生成一个排列，r 指定生成排列的元素的长度，如果不指定，则默认为可迭代对象的元素长度。
3	combinations	combinations(iterable, r)	用于求序列的组合，r 指定生成组合的元素的长度。
4	combinations_with_replacement	combinations_with_replacement(iterable, r)	和 combinations 类似，但它生成的组合包含自身元素。

详解

1、product

product 用于求多个可迭代对象的笛卡尔积，它跟嵌套的 for 循环等价。
语法：product(iter1, iter2, ... iterN, [repeat=1])repeat是一个关键字参数，用于指定重复生成序列的次数，

for item in itertools.product('ABCD', 'xy'):
    print(item)

x = list(itertools.product('ab', range(3)))
print(x)

x1 = list(itertools.product((0, 1), (0, 1), (0, 1)))
print(x1)

x2 = list(itertools.product('ABC', repeat=2))
print(x2)

2、permutations

permutations 用于生成一个排列。
语法：permutations(iterable[, r]) r 指定生成排列的元素的长度，如果不指定，则默认为可迭代对象的元素长度。

x1 = list(itertools.permutations('ABC', 2))
print(x1)

x2 = list(itertools.permutations('ABC'))
print(x2)
---->
[('A', 'B'), ('A', 'C'), ('B', 'A'), ('B', 'C'), ('C', 'A'), ('C', 'B')]
[('A', 'B', 'C'), ('A', 'C', 'B'), ('B', 'A', 'C'), ('B', 'C', 'A'), ('C', 'A', 'B'), ('C', 'B', 'A')]

3、combinations 用于求序列的组合

语法：combinations(iterable, r) 其中，r 指定生成组合的元素的长度。

x = list(itertools.combinations('ABC', 2))
print(x)
---->
[('A', 'B'), ('A', 'C'), ('B', 'C')]

4、combinations_with_replacement

和 combinations 类似，但它生成的组合包含自身元素。

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

小结

itertools模块提供了很多用于产生多种类型迭代器的函数，它们的返回值不是 list，而是迭代器。