O Módulo Itertools
O módulo itertools é uma coleção de ferramentas para lidar com iteradores e objetos iteráveis eficazmente. Ele oferece uma variedade de funcionalidades para trabalhar com iteráveis de forma concisa e eficiente em termos de memória.
Na prática, o itertools conta com um conjunto de funções que operam sobre iteradores para produzir iteradores mais complexos. Com isso, ele suporta uma “álgebra iteradora” que permite a criação de ferramentas especializadas eficientemente em Python puro.
O itertools é particularmente útil para criar loops e iterações, combinar e manipular iteráveis e gerar sequências e combinações complexas. Ele oferece várias funções que permitem que os desenvolvedores executem operações comuns em iteradores de forma rápida e com códigos mais claros. A seguir, conheça algumas das principais funções do itertools e aprenda a usá-las.
Iteradores infinitos
count()
Gera uma sequência infinita de inteiros, começando a partir de um determinado número e incrementando por um passo especificado. A sintaxe básica é:
count(start, step)
onde start se refere ao ponto de início da contagem e step é o passo do incremento. Veja um exemplo simples de como usar essa função.
from itertools import count
counter = count(start=1, step=1)
# Imprime apenas os primeiros 5 elementos
for _ in range(5):
print(next(counter))
# resultados:
# 1
# 2
# 3
# 4
# 5
Nesse exemplo, a contagem foi iniciada em 1 com passo para incremento de 1 também. Usamos um for loop para imprimir os primeiros 5 valores calculados.
cycle()
Cria um iterador infinito que repete os elementos de um iterável indefinidamente. Veja um exemplo ilustrativo:
from itertools import cycle
cores = ['vermelho', 'verde', 'azul']
cores_cycle = cycle(cores)
# Imprime apenas os primeiros 10 elementos
for i in range(10):
print(next(cores_cycle))
# resultados:
# vermelho
# verde
# azul
# vermelho
# verde
# azul
# vermelho
# verde
# azul
# vermelho
No exemplo acima, usamos um for loop para imprimir apenas os 10 primeiros resultados. Como cycle() cria um iterador infinito, é crucial ter uma condição ou uma instrução break para sair do loop quando necessário para evitar loops infinitos.
Iteradores Combinatórios
permutations()
Gera todas as permutações possíveis de um iterável.
from itertools import permutations
minha_lista = [1, 2, 3, 4, 5]
# Gera todas as permutações possíveis com 2 elementos do iterável minha_lista
lista_permutada = list(permutations(minha_lista, 2))
# Imprime as permutações
for permuta in lista_permutada:
print(permuta)
# resultados:
# (1, 2)
# (1, 3)
# (1, 4)
# (1, 5)
# (2, 1)
# (2, 3)
# (2, 4)
# (2, 5)
# (3, 1)
# (3, 2)
# (3, 4)
# (3, 5)
# (4, 1)
# (4, 2)
# (4, 3)
# (4, 5)
# (5, 1)
# (5, 2)
# (5, 3)
# (5, 4)
Neste exemplo, partimos de uma lista chamada minha_lista contendo elementos de 1 a 5. Usamos a função permutations() para gerar todas as permutações de comprimento 2 da lista. Essa função recebe o iterável como o primeiro argumento e o comprimento das permutações como o segundo argumento. Em seguida, convertemos as permutações iteráveis em uma lista usando a função list e a armazenamos na variável lista_permutada. Finalmente, usamos um loop for para iterar sobre a lista obtida e imprimir cada permutação.
combinations()
Produz todas as combinações possíveis de um comprimento especificado a partir de um iterável.
from itertools import combinations
minha_lista = ['A', 'B', 'C']
# Gera todas as combinações possíveis com 2 elementos do iterável minha_lista
lista_combinacoes = list(combinations(minha_lista, 2))
# Imprime os resultados
for combinacao in lista_combinacoes:
print(combinacao)
# resultados:
# ('A', 'B')
# ('A', 'C')
# ('B', 'C')
No código acima, a função combinations() recebe o iterável como o primeiro argumento e o comprimento das combinações como o segundo argumento. Em seguida, convertemos as combinações iteráveis em uma lista usando a função list e a armazenamos na variável lista_combinacoes. Finalmente, usamos um loop para imprimir cada combinação. Como resultado, obtemos todas as combinações possíveis de comprimento 2 da lista, sem repetições.
Iteradores Terminadores (Terminating Iterators)
chain()
Recebe vários iteráveis como argumentos e retorna um único iterável. Chain() itera através de cada entrada iterável, produzindo seus elementos um a um. Uma vez que um iterável é esgotado, ele passa para o próximo.
A função chain() não cria cópias das iteráveis de entrada. Em vez disso, ela aponta para as iteráveis originais, o que é mais eficiente em termos de memória para grandes conjuntos de dados. Veja um pequeno exemplo dessa função abaixo:
from itertools import chain
lista1 = [1, 2, 3]
lista2 = ['A', 'B', 'C']
lista3 = ['4D', '5E', '6F']
# encadeia as listas juntas
lista_final = list(chain(lista1, lista2, lista3))
print(lista_final)
# resultado: [1, 2, 3, 'A', 'B', 'C', '4D', '5E', '6F']
Groupby()
Agrupa elementos consecutivos em uma iteração com base em uma função chave. Sua sintaxe básica é:
itertools.groupby(iteravel, key=None)
Nessa sintaxe, o iterável é a sequência de entrada ou iterável que você deseja agrupar. O termo key é um parâmetro opcional que especifica uma função para gerar uma chave para cada elemento. Por padrão, ele usa o próprio elemento como a chave.
A função groupby retorna um iterador que produz pares (key, group), onde key é o valor de chave comum e group é um iterador que contém todos os elementos consecutivos da entrada iterável que compartilham essa chave. Veja um exemplo simples para ilustrar o uso dessa função:
from itertools import groupby
lista = ['Trabalhador1', 'Trabalhador2', 'Trabalhador2', 'Trabalhador3', 'Trabalhador3', 'Trabalhador3']
grupos = groupby(lista)
for key, group in grupos:
print(f"Key: {key}, Grupo: {list(group)}")
# resultados:
# Key: Trabalhador1, Grupo: ['Trabalhador1']
# Key: Trabalhador2, Grupo: ['Trabalhador2', 'Trabalhador2']
# Key: Trabalhador3, Grupo: ['Trabalhador3', 'Trabalhador3', 'Trabalhador3']
Veja também:
Encontrou algum erro ou quer fazer uma sugestão? Por favor, entre em contato usando nosso formulário de contatos.
