Python Itertools|极客笔记

Python Itertools

Itertools是Python 3中最令人惊奇的标准库之一。这个库有非常酷的函数，毫不夸张地说，它是Python编程语言的宝石。Python提供了Itertools的出色文档，但在本教程中，我们将讨论一些重要且有用的函数或迭代器。

Itertools最重要的一点是，这个库的函数用于创建内存高效且精确的代码。

在学习Python Itertools之前，您应该了解Python的迭代器和生成器。在本文中，我们将为初学者和专业人士描述Itertools。

介绍

根据Itertools的官方定义，“ 该模块实现了一些受APL、Haskell和SML构造启发的迭代器构建模块 。” 简单来说，这些迭代器可以组合在一起创建“迭代器代数”，使得完成复杂任务成为可能。Itertools中的函数用于生成更复杂的迭代器。让我们举个示例：Python内置的zip()函数接受任意数量的可迭代参数。它迭代元组并返回它们对应的元素。

a = [1,2,3]
b= ['a', 'b', 'c']
c = zip(a,b)
print(c)

输出：

[(1, 'a'), (2, 'b'), (3, 'c')]

在上面的代码中，我们将两个列表[1,2,3]和[‘a’,’b’,’c’]作为可迭代的参数传递给函数。这些列表每次返回一个元素。在Python中，实现了<.iter()>或<.getitem()>方法的元素被称为可迭代的。

用于调用可迭代对象并返回可迭代器对象。

a = iter('Hello')
print(a)

输出:

<str_iterator object at 0x01505FA0>

Python的zip()函数调用每个参数的iter()函数，然后通过将结果组合成元组来调用next()函数。

注意：如果你正在使用zip()函数和map()函数，那么你已经在使用itertools。你不需要单独导入它。

迭代器的类型

itertools模块中有各种类型的迭代器。下面是列表：

无限迭代器
组合迭代器
终止迭代器

无限迭代器

在Python中，任何可以实现for循环的对象都被称为迭代器。列表、元组、集合、字典、字符串都是迭代器的示例，但迭代器还可以是无限的，这种类型的迭代器称为无限迭代器。

迭代器	参数	结果
count(start,step)	start, [step]	start, start+step, step+2*step
cycle()	P	p0,p1,….plast
repeat()	elem [,n]	elem, elem, elem,….无限重复或达到n次

count(start, stop) ：它从起始值打印到无限大。步长参数是可选的，如果提供了step**的值，那么将跳过步骤的数量。考虑以下示例：

import itertools

for i in itertools.count(10,5):
    if i == 50:
        break
    else:
        print(i,end=" ")

输出：

10 15 20 25 30 35 40 45

cycle(iterable) : 这个迭代器从传递的参数中按顺序打印出所有的值。它以循环的方式打印这些值。考虑以下示例：

import itertools
temp = 0
for i in itertools.cycle("123"):
    if temp > 7:
        break
    else:
        print(i,end=' ')
        temp = temp+1

输出：

    1 2 3 1 2 3 1 2 3 1 2

示例 2：使用 next() 函数

import itertools

val = ['Java', 'T', 'Point']

iter = itertools.cycle(val)

for i in range(6):
    # Using next function
    print(next(iter), end = " ")

输出:

Java T Point Java T Point

repeat(val,num) ：顾名思义，它无限次地重复打印传递的值。 num 参数是可选的。考虑以下示例：

 import itertools
 print("Printing the number repeadtly:")
 print(list(itertools.repeat(40,15)))

输出:

[40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40]

组合迭代器： 通过递归生成器简化了复杂的组合结构。排列、组合和笛卡尔积是组合结构的示例。

在Python中，有四种类型的组合迭代器：

Product() – 用于计算输入可迭代对象的笛卡尔积。在此函数中，我们使用可选的 repeat 关键字参数来计算与自身的可迭代对象的乘积。关键字 repeat 表示重复的次数。它以排序元组的形式返回输出。考虑以下示例：

from itertools import product

print("We are computing cartesian product using repeat Keyword Argument:")
print(list(product([1, 2], repeat=2)))
print()

print("We are computing cartesian product of the containers:")
print(list(product(['Java', 'T', 'point'], '5')))
print()

print("We are computing product of the containers:")
print(list(product('CD', [4, 5])))

输出:

Computing cartesian product using repeat Keyword Argument:
[(1, 1), (1, 2), (2, 1), (2, 2)]

Computing cartesian product of the containers:
[('Java', '5'), ('T', '5'), ('point', '5')]

Computing product of the containers:
[('C', 4), ('C', 5), ('D', 4), ('D', 5)]

Permutations() ：用于生成可迭代对象的所有可能排列。每个元素的唯一性取决于它们的位置而不是值。它接受两个参数 iterable 和 group_size 。如果group_size的值为 none 或未指定，则group_size变为可迭代对象的长度。

from itertools import permutations

print("Computing all permutation of the following list")
print(list(permutations([3,"Python"],2)))
print()

print("Permutations of following string")
print(list(permutations('AB')))
print()

print("Permutation of the given container is:")
print(list(permutations(range(4),2)))

输出：

Computing all permutation of the following list
[(3, 'Python'), ('Python', 3)]

Permutations of following string
[('A', 'B'), ('B', 'A')]

Permutation of the given container is:
[(0, 1), (0, 2), (0, 3), (1, 0), (1, 2), (1, 3), (2, 0), (2, 1), (2, 3), (3, 0), (3, 1), (3, 2)]

Combinations() : 它用于按照指定的组大小打印传递的容器的所有可能组合（不重复），并按排序顺序显示。

from itertools import combinations
print("Combination of list in sorted order(without replacement)",list(combinations(['B',3],2)))
print()

print("Combination of string in sorted order",list(combinations("ZX",2)))
print()

print("Combination of list in sorted order",list(combinations(range(20),1)))

输出：

Combination of list in sorted order(without replacement) [('B', 3)]
Combination of string in sorted order [('Z', 'X')]
Combination of list in sorted order [(0,), (1,), (2,), (3,), (4,), (5,), (6,), (7,), (8,), (9,)]

Combination_with_replacement() ：它接受两个参数，第一个参数是长度为r的元组，第二个参数是重复次数。它从可迭代对象的元素中返回长度为n的子序列，并重复相同的过程。在 combination_with_replacement() 中，元素可以重复出现。

from itertools import combinations_with_replacement

print("Combination of string in sorted order(with replacement) is:")
print(list(combinations_with_replacement("XY", 3)))
print()

print("Combination of list in sorted order(with replacement) is:")
print(list(combinations_with_replacement([4, 2], 3)))
print()

print("Combination of container in sorted order(with replacement) is:")
print(list(combinations_with_replacement(range(3), 2)))

输出：

Combination of string in sorted order(with replacement) is:
[('X', 'X', 'X'), ('X', 'X', 'Y'), ('X', 'Y', 'Y'), ('Y', 'Y', 'Y')]

Combination of list in sorted order(with replacement) is:
[(4, 4, 4), (4, 4, 2), (4, 2, 2), (2, 2, 2)]

Combination of container in sorted order(with replacement) is:
[(0, 0), (0, 1), (0, 2), (1, 1), (1, 2), (2, 2)]

终止迭代器

终止迭代器通常用于处理小型输入序列，并且根据迭代器中使用的方法的功能生成输出。

有不同类型的终止迭代器：

accumulate(iter, func) ：它接受两个参数，第一个参数是可迭代的对象，第二个参数是在可迭代对象的每个值迭代时将执行的函数。如果未在accumulate()迭代器中定义该函数，则默认进行加法运算。输出的可迭代对象取决于输入的可迭代对象；如果输入的可迭代对象不包含任何值，则输出的可迭代对象也将为空。

import itertools
import operator

# initializing list 1
list1 = [1, 4, 5, 7, 9, 11]

# using accumulate() that will prints the successive summation of elements
print("The sum is : ", end="")
print(list(itertools.accumulate(list1)))

# using accumulate() that will prints the successive multiplication of elements
print("The product is : ", end="")
print(list(itertools.accumulate(list1, operator.mul)))


# using accumulate() that will prints the successive summation of elements
print("The sum is : ", end="")
print(list(itertools.accumulate(list1)))

# using accumulate() that will prints the successive multiplication of elements
print("The product is : ", end="")
print(list(itertools.accumulate(list1, operator.mul)))

输出：

The sum is : [1, 5, 10, 17, 26, 37]
The product is : [1, 4, 20, 140, 1260, 13860]
The sum is : [1, 5, 10, 17, 26, 37]
The product is : [1, 4, 20, 140, 1260, 13860]

chain(iter1, iter2) - 用于按照以 chain 形式传递的可迭代对象的顺序打印所有的值，并在参数中声明。考虑以下示例：

import itertools

# declaring list 1
list1 = [1, 2, 3, 4]

# declaring list 2
list2 = [1, 5, 6, 8]

# declaring list 3
list3 = [9, 10, 11, 12]

# using chain() function that will to print all elements of lists
print("The output is : ", end="")
print(list(itertools.chain(list1, list2, list3)))

输出：

The output is: [1, 2, 3, 4, 1, 5, 6, 8, 9, 10, 11, 12]

dropwhile(func, seq) - 只有在 func 之后开始打印字符。考虑以下参数：

import itertools
# initializing list
list1 = [2, 4, 5, 7, 8]
# using dropwhile() iterator that will print start displaying after condition is false
print("The output is : ", end="")
print(list(itertools.dropwhile(lambda x: x % 2 == 0, list1)))

输出：

The output is  : [5, 7, 8]

filterfalse(func,seq) - 通过名称可以知道，此迭代器仅打印对传递的函数返回false的值。考虑以下示例：

import itertools

# declaring list
list1 = [12, 14, 15, 27, 28]

# using filterfalse() iterator that will print false values
print("The Output is: ", end="")
print(list(itertools.filterfalse(lambda x: x % 2 == 0, list1)))

输出：

The Output is : [15, 27]

islice（iterable，start，stop，step） - 它根据给定的位置对给定的可迭代对象进行分割。它依次接受四个参数，分别是可迭代对象、容器、起始位置、结束位置和步长（可选）。

import itertools
# Declaring list
list1 = [12, 34, 65, 73, 80, 19, 20]
# using islice() iterator that will slice the list acc. to given argument
# starts printing from 3nd index till 8th skipping 2
print("The sliced list values are : ", end="")
print(list(itertools.islice(list1, 2, 8, 2)))

输出:

The sliced list values are : [34, 73, 19]

starmap(func, tuple list) - 它接受两个参数；第一个参数是函数，第二个参数是一个由元组形式的元素组成的列表。考虑以下示例。

import itertools

# Declaring list that contain tuple as element
list1 = [(10, 20, 15), (18, 40, 19), (53, 42, 90), (16, 12, 27)]

# using starmap() iterator for selection value acc. to function
# selects max of all tuple values
print("The values acc. to function are : ", end="")
print(list(itertools.starmap(max, list1)))

输出：

The values acc. to function are : [20, 40, 90, 27]

takewhile(func, iterable) - 它是dropwhile()的逆操作。它会打印值，直到返回false条件。考虑以下示例：

import itertools

# Defining a list
list1 = [20, 42, 64, 77, 8, 10, 20]

# takewhile() iterator is used  to print values till condition return false.
print("Print until 1st false value returned : ", end="")
print(list(itertools.takewhile(lambda x: x % 2 == 0, list1)))

输出：

The list values until false value return : [20, 42, 64]

tee(iterator, count) - 它将容器分割成指定数目的迭代器。考虑以下示例：

import itertools

# Declaring list
li = [1, 2, 3, 4, 5, 6, 7]

# storing list in iterator
iti = iter(li)
# using tee() iterator to create a list of iterators
# Creating list of 3 iterators having similar values.
it = itertools.tee(iti, 3)
# It will print object of iterator
print(it)
print("The iterators are : ")
for i in range(0, 2):
    print(list(it[i]))

输出：

(<itertools._tee object at 0x01B88D88>, <itertools._tee object at 0x01B88DA8>, <itertools._tee object at 0x01B88BA8>)
The iterators are : 
[1, 2, 3, 4, 5, 6, 7]
[1, 2, 3, 4, 5, 6, 7]

zip_longest(iterable1, iterable2, fillval) - 它按照顺序交替打印可迭代对象的值。如果其中一个可迭代对象打印完所有值，则剩余的值将由分配给填充值的值填充。

import itertools
print(" The combined value of iterrables is :")
print(*(itertools.zip_longest('Java', 'Tpoint', fillvalue='_')))

输出：

The combined value of iterables is :
('J', 'T') ('a', 'p') ('v', 'o') ('a', 'i') ('_', 'n') ('_', 't')

在本教程中，我们讨论了一些有用的迭代器，以及itertools。

Python Itertools