De acordo com a documentação do Python, Itertools é um módulo Python que fornece um conjunto de ferramentas rápidas e com eficiência de memória para trabalhar com iteradores Python. Essas ferramentas podem ser usadas sozinhas ou em combinação e possibilitam criar e trabalhar com iteradores de forma sucinta e eficiente, de maneira rápida e eficiente em termos de memória.
O módulo Itertools contém funções que facilitam o trabalho com iteradores, principalmente ao lidar com grandes conjuntos de dados. As funções do Itertools podem funcionar em iteradores existentes para criar iteradores Python ainda mais complexos.
Além disso, o Itertools pode ajudar os desenvolvedores a reduzir erros ao trabalhar com iteradores e escrever código mais limpo, legível e de fácil manutenção.
Com base na funcionalidade que os iteradores no módulo Itertools fornecem, eles podem ser classificados nos seguintes tipos:
últimas postagens
#1. Iteradores Infinitos
Esses são iteradores que permitem que você trabalhe com sequências infinitas e execute um loop infinitamente se não houver nenhuma condição para sair do loop. Esses iteradores são úteis ao simular loops infinitos ou gerar uma sequência ilimitada. Itertools tem três iteradores infinitos, que incluem count(), cycle() e repeat().
#2. Iteradores Combinatórios
Iteradores combinatórios compreendem funções que podem ser usadas para trabalhar em produtos cartesianos e realizar combinações e permutações de elementos contidos em um iterável. Essas são as funções essenciais ao tentar encontrar todas as maneiras possíveis de organizar ou combinar elementos em um iterável. Itertools tem quatro iteradores combinatórios. Estes são product(), permutations(), combinações() e combinações_com_reposição().
#3. Iteradores terminando na sequência de entrada mais curta
Estes são iteradores de terminação que são usados em sequências finitas e geram uma saída com base no tipo de função usada. Exemplos desses iteradores de terminação incluem: acumula(), chain(), chain.from_iterable(), compress(), dropwhile(), filterfalse(), groupby(), islice(), pairwise(), starmap(), takewhile (), tee() e zip_longest().
Vejamos como diferentes funções do Itertools funcionam de acordo com seu tipo:
Iteradores Infinitos
Os três iteradores infinitos incluem:
#1. contar()
A função count(start, step) gera uma sequência infinita de números a partir do valor inicial. A função recebe dois argumentos opcionais: start e step. O argumento start define onde a sequência de números deve começar. Por padrão, ele começa em 0 se um valor inicial não for fornecido. step define a diferença entre cada número consecutivo. O valor padrão da etapa é 1.
import itertools
# count starting at 4, making steps of 2
for i in itertools.count(4, 2):
# condition to end the loop avoiding infinite looping
if i == 14:
break
else:
print(i) # output - 4, 6, 8, 10, 12
Saída
4 6 8 10 12
#2. ciclo()
A função cycle(iterable) usa um iterável como um argumento e, em seguida, percorre o iterável, permitindo o acesso aos itens no iterável na ordem em que aparecem.
Por exemplo, se passarmos em [“red”, “green”, “yellow”] em cycle(), no primeiro ciclo, teremos acesso a “red”; no segundo ciclo teremos acesso ao “verde”, depois ao “amarelo”. No quarto ciclo, uma vez que todos os elementos foram esgotados no iterável, vamos recomeçar no “vermelho” e continuar infinitamente.
Ao chamar cycle() você armazena seu resultado em uma variável para criar um iterador que mantém seu estado. Isso garante que o ciclo não recomece todas as vezes, dando a você acesso apenas ao primeiro elemento.
import itertools
colors = ["red", "green", "yellow"]
# pass in colors into cycle()
color_cycle = itertools.cycle(colors)
print(color_cycle)
# range used to stop the infinite loop once we've printed 7 times
# next() used to return the next item from the iterator
for i in range(7):
print(next(color_cycle))
Saída:
red green yellow red green yellow red
#3. repita()
repeat(elem,n) leva dois argumentos, um elemento para repetir (elem) e o número de vezes que você deseja repetir o elemento(n). O elemento que você deseja repetir pode ser um valor único ou iterável. Se você não passar, n, o elemento será repetido infinitamente.
import itertools
for i in itertools.repeat(10, 3):
print(i)
Saída:
10 10 10
Iteradores Combinatórios
Os iteradores combinatórios incluem:
#1. produtos()
product() é uma função usada para calcular o produto cartesiano do iterável passado para ela. Se tivermos dois iteráveis ou conjuntos, por exemplo, x = {7,8} e y = {1,2,3}, o produto cartesiano de x e y conterá todas as combinações possíveis de elementos de x e y, onde o primeiro elemento é de x e o segundo de y. O produto cartesiano de x e y neste caso é [(7, 1), (7, 2), (7, 3), (8, 1), (8, 2), (8, 3)].
product() recebe um parâmetro opcional chamado repeat que é usado para calcular o produto cartesiano de um iterável consigo mesmo. repeat especifica o número de repetições para cada elemento dos iteráveis de entrada ao calcular o produto cartesiano.
Por exemplo, chamar product(‘ABCD’, repeat=2) produz combinações como (‘A’, ‘A’), (‘A’, ‘B’), (‘A’, ‘C’) e assim sobre. Se a repetição fosse definida como 3, a função produziria combinações como (‘A’, ‘A’, ‘A’), (‘A’, ‘A’, ‘B’), (‘A’, ‘A’ , ‘C’), (‘A’, ‘A’, ‘D’) e assim por diante.
from itertools import product
# product() with the optional repeat argument
print("product() with the optional repeat argument ")
print(list(product('ABC', repeat = 2)))
# product with no repeat
print("product() WITHOUT an optional repeat argument")
print(list(product([7,8], [1,2,3])))
Saída
product() with the optional repeat argument
[('A', 'A'), ('A', 'B'), ('A', 'C'), ('B', 'A'), ('B', 'B'), ('B', 'C'), ('C', 'A'), ('C', 'B'), ('C', 'C')]
product() WITHOUT an optional repeat argument
[(7, 1), (7, 2), (7, 3), (8, 1), (8, 2), (8, 3)]
#2. permutações()
permutations(iterable, group_size) retorna todas as permutações possíveis do iterável passado para ele. Uma permutação representa o número de maneiras pelas quais os elementos de um conjunto podem ser ordenados. permutations() recebe um argumento opcional group_size. Se group_size não for especificado, as permutações geradas serão do mesmo tamanho que o comprimento do iterável passado para a função
import itertools
numbers = [1, 2, 3]
sized_permutations = list(itertools.permutations(numbers,2))
unsized_permuatations = list(itertools.permutations(numbers))
print("Permutations with a size of 2")
print(sized_permutations)
print("Permutations with NO size argument")
print(unsized_permuatations)
Saída
Permutations with a group size of 2 [(1, 2), (1, 3), (2, 1), (2, 3), (3, 1), (3, 2)] Permutations with NO size argument [(1, 2, 3), (1, 3, 2), (2, 1, 3), (2, 3, 1), (3, 1, 2), (3, 2, 1)]
#3. combinações()
combinações(iterável, tamanho) retorna todas as combinações possíveis de um iterável de um determinado comprimento dos elementos no iterável passado para a função. O argumento size especifica o tamanho de cada combinação.
Os resultados são ordenados. A combinação difere ligeiramente das permutações. Com permutação, a ordem importa, mas com combinação, a ordem não importa. Por exemplo, em [A, B, C] existem 6 permutações: AB, AC, BA, BC, CA, CB, mas apenas 3 combinações AB, AC, BC.
import itertools
numbers = [1, 2, 3,4]
size2_combination = list(itertools.combinations(numbers,2))
size3_combination = list(itertools.combinations(numbers, 3))
print("Combinations with a size of 2")
print(size2_combination)
print("Combinations with a size of 3")
print(size3_combination)
Saída:
Combinations with a size of 2 [(1, 2), (1, 3), (1, 4), (2, 3), (2, 4), (3, 4)] Combinations with a size of 3 [(1, 2, 3), (1, 2, 4), (1, 3, 4), (2, 3, 4)]
#4. combinações_com_reposição()
combinações_with_replacement(iterável, tamanho) gera todas as combinações possíveis de um iterável de um determinado comprimento do iterável passado para a função e permite elementos repetidos nas combinações de saída. O tamanho determina o tamanho das combinações geradas.
Esta função difere de combinações() porque fornece combinações em que um elemento pode ser repetido mais de uma vez. Por exemplo, você pode obter uma combinação como (1,1) que não pode com a combinação ().
import itertools
numbers = [1, 2, 3,4]
size2_combination = list(itertools.combinations_with_replacement(numbers,2))
print("Combinations_with_replacement => size 2")
print(size2_combination)
Saída
Combinations_with_replacement => size 2 [(1, 1), (1, 2), (1, 3), (1, 4), (2, 2), (2, 3), (2, 4), (3, 3), (3, 4), (4, 4)]
Terminando iteradores
Isso inclui iteradores como:
#1. acumular()
acumule(iterable, function) recebe um iterável e um segundo argumento opcional que é uma função. Em seguida, ele retorna o resultado acumulado da aplicação da função em cada iteração nos elementos do iterável. Se nenhuma função for passada, a adição é feita e os resultados acumulados são retornados.
import itertools
import operator
numbers = [1, 2, 3, 4, 5]
# Accumulate the sum of numbers
accumulated_val = itertools.accumulate(numbers)
accumulated_mul = itertools.accumulate(numbers, operator.mul)
print("Accumulate with no function")
print(list(accumulated_val))
print("Accumulate with multiplication")
print(list(accumulated_mul))
Saída:
Accumulate with no function [1, 3, 6, 10, 15] Accumulate with multiplication [1, 2, 6, 24, 120]
#2. corrente()
chain(iterable_1, iterable_2, …) pega vários iteráveis e os encadeia, produzindo um único iterável contendo valores dos iteráveis passados para a função chain()
import itertools letters = ['A', 'B', 'C', 'D'] numbers = [1, 2, 3] colors = ['red', 'green', 'yellow'] # Chain letters and numbers together chained_iterable = list(itertools.chain(letters, numbers, colors)) print(chained_iterable)
Saída:
['A', 'B', 'C', 'D', 1, 2, 3, 'red', 'green', 'yellow']
#3. chain.from_iterable()
chain.from_iterable(iterable) esta função é semelhante a chain(). No entanto, difere da cadeia porque leva apenas um único iterável contendo sub-iteráveis e os encadeia.
import itertools letters = ['A', 'B', 'C', 'D'] numbers = [1, 2, 3] colors = ['red', 'green', 'yellow'] iterable = ['hello',colors, letters, numbers] chain = list(itertools.chain.from_iterable(iterable)) print(chain)
Saída:
['h', 'e', 'l', 'l', 'o', 'red', 'green', 'yellow', 'A', 'B', 'C', 'D', 1, 2, 3]
#4. comprimir()
compress(data, selectors) aceita dois argumentos, data que é um iterável e seletores que é um iterável contendo valores booleanos true e false. 1, 0 também podem ser usados como alternativas aos valores booleanos true e false. compress() então filtra os dados passados usando os elementos correspondentes passados no seletor.
Os valores nos dados que correspondem ao valor true ou 1 no seletor são selecionados, enquanto os demais que correspondem a false ou 0 são ignorados. Se você passar menos booleanos nos seletores do que o número de itens nos dados, todos os elementos além dos booleanos passados nos seletores serão ignorados
import itertools # data has 10 items data = ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J'] # passing in 9 selector items selectors = [True, False, 1, False, 0, 1, True, False, 1] # Select elements from data based on selectors filtered_data = list(itertools.compress(data, selectors)) print(filtered_data)
Saída:
['A', 'C', 'F', 'G', 'I']
#5. dropwhile()
dropwhile(function, sequence) recebe uma função com a condição que retorna true ou false e uma sequência de valores. Em seguida, descarta todos os valores até que a condição passada retorne False. Uma vez que a condição retorna false, o resto dos elementos são incluídos em seus resultados independentemente de retornarem True ou False.
import itertools numbers = [1, 2, 3, 4, 5, 1, 6, 7, 2, 1, 8, 9, 0, 7] # Drop elements until the passed condition is False filtered_numbers = list(itertools.dropwhile(lambda x: x < 5, numbers)) print(filtered_numbers)
Saída:
[5, 1, 6, 7, 2, 1, 8, 9, 0, 7]
#6. filtrofalso()
filterfalse(function, sequence) recebe uma função, com uma condição que avalia como true ou false e uma sequência. Em seguida, ele retorna valores da sequência que não satisfazem a condição da função.
import itertools numbers = [1, 2, 3, 4, 2, 3 5, 6, 5, 8, 1, 2, 3, 6, 2, 7, 4, 3] # Filter elements for which condition is False filtered_numbers = list(itertools.filterfalse(lambda x: x < 4, numbers)) print(filtered_numbers)
Saída:
[4, 5, 6, 5, 8, 6, 7, 4]
#7. groupby()
groupby(iterable, key) recebe um iterável e uma chave e, em seguida, cria um iterador que retorna chaves e grupos consecutivos. Para que funcione, o iterável passado para ele precisa ser classificado na mesma função chave. A função de chave calcula um valor de chave para cada elemento no iterável.
import itertools
input_list = [("Domestic", "Cow"), ("Domestic", "Dog"), ("Domestic", "Cat"),("Wild", "Lion"), ("Wild", "Zebra"), ("Wild", "Elephant")]
classification = itertools.groupby(input_list,lambda x: x[0])
for key,value in classification:
print(key,":",list(value))
Saída:
Domestic : [('Domestic', 'Cow'), ('Domestic', 'Dog'), ('Domestic', 'Cat')]
Wild : [('Wild', 'Lion'), ('Wild', 'Zebra'), ('Wild', 'Elephant')]
#8. islice()
islice(iterable, start, stop, step) permite dividir um iterável usando os valores start, stop e step passados. O argumento da etapa é opcional. A contagem começa em 0 e o item no número de parada não é incluído.
import itertools
numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18]
# Select elements within a range
selected_numbers = list(itertools.islice(numbers, 2, 10))
selected_numbers_step= list(itertools.islice(numbers, 2, 10,2))
print("islice without setting a step value")
print(selected_numbers)
print("islice with a step value of 2")
print(selected_numbers_step)
Saída:
islice without setting a step value [3, 4, 5, 6, 7, 8, 9, 10] islice with a step value of 2 [3, 5, 7, 9]
#9. emparelhados()
pairwise(iterable) retorna pares sobrepostos sucessivos retirados do iterável passado para ele na ordem em que aparecem no iterável. Se o iterável passado para ele tiver menos de dois valores, o resultado de pairwise() ficará vazio.
from itertools import pairwise numbers = [1, 2, 3, 4, 5, 6, 7, 8] word = 'WORLD' single = ['A'] print(list(pairwise(numbers))) print(list(pairwise(word))) print(list(pairwise(single)))
Saída:
[(1, 2), (2, 3), (3, 4), (4, 5), (5, 6), (6, 7), (7, 8)]
[('W', 'O'), ('O', 'R'), ('R', 'L'), ('L', 'D')]
[]
#10. mapa estelar()
starmap(function, iterable) é uma função usada em vez de map() quando os parâmetros do argumento já estão agrupados em tuplas. startmap() aplica uma função aos elementos do iterável passado para ela. O iterável deve ter elementos agrupados em tuplas.
import itertools iter_starmap = [(123, 63, 13), (5, 6, 52), (824, 51, 9), (26, 24, 16), (14, 15, 11)] print (list(itertools.starmap(min, iter_starmap)))
Saída:
[13, 5, 9, 16, 11]
#11. demora()
takewhile(function, iterable) funciona de maneira oposta a dropwhile(). takewhile() recebe uma função com uma condição a ser avaliada e iterável. Em seguida, inclui todos os elementos no iterável que satisfazem a condição na função até que False seja retornado. Depois que False for retornado, todos os elementos a seguir no iterável serão ignorados.
import itertools numbers = [1, 2, 3, 4, 5, 1, 6, 7, 2, 1, 8, 9, 0, 7] # Drop elements until the passed condition is False filtered_numbers = list(itertools.takewhile(lambda x: x < 5, numbers)) print(filtered_numbers)
Saída:
[1, 2, 3, 4]
#12. camiseta()
tee(iterável, n) recebe um iterável e retorna vários iteradores independentes. O número de iteradores a serem retornados é definido por n, que por padrão é 2.
import itertools numbers = [1, 2, 3, 4, 5] # Create two independent iterators from numbers iter1, iter2 = itertools.tee(numbers, 2) print(list(iter1)) print(list(iter2))
Saída:
[1, 2, 3, 4, 5] [1, 2, 3, 4, 5]
#13. zip_longest()
zip_longest(iterables, fillvalue) aceita vários iteradores e um fillvalue. Em seguida, ele retorna um iterador que agrega elementos de cada um dos iteradores passados para ele. Se os iteradores não tiverem o mesmo comprimento, os valores ausentes serão substituídos pelo fillvalue passado para a função até que o iterável mais longo seja esgotado.
import itertools
names = ['John', 'mathew', 'mary', 'Alice', 'Bob', 'Charlie', 'Fury']
ages = [25, 30, 12, 13, 42]
# Combine name and ages, filling in missing ages with a dash
combined = itertools.zip_longest(names, ages, fillvalue="-")
for name, age in combined:
print(name, age)
Saída:
John 25 mathew 30 mary 12 Alice 13 Bob 42 Charlie - Fury -
Conclusão
As itertools do Python são um conjunto de ferramentas importante para um desenvolvedor Python. As itertools do Python são usadas extensivamente em programação funcional, processamento e transformação de dados, filtragem e seleção de dados, agrupamento e agregação, combinação de iteráveis, combinatória e ao trabalhar com sequências infinitas.
Como desenvolvedor Python, você se beneficiará muito ao aprender sobre itertools, portanto, certifique-se de usar este artigo para se familiarizar com Python Itertools.