¿Qué son las funciones Itertools de Python?

Según la documentación de Python, Itertools es un módulo de Python que proporciona un conjunto de herramientas rápidas y eficientes en memoria para trabajar con iteradores de Python. Estas herramientas pueden utilizarse solas o combinadas, y permiten crear y trabajar con iteradores de forma sucinta y eficaz, rápida y eficiente en memoria.

El módulo Itertools contiene funciones que facilitan el trabajo con iteradores, sobre todo cuando se manejan grandes conjuntos de datos. Las funciones Itertools pueden trabajar sobre iteradores existentes para crear iteradores Python aún más complejos.

Además, Itertools puede ayudar a los desarrolladores a reducir los errores al trabajar con iteradores y a escribir un código más limpio, legible y fácil de mantener.

Tipos de iteradores en Python Itertools

Basándose en la funcionalidad que proporcionan los iteradores del módulo Itertools, se pueden clasificar en los siguientes tipos:

#1. Iteradores infinitos

Estos son iteradores que le permiten trabajar con secuencias infinitas y ejecutar un bucle infinitamente si no se pone ninguna condición para salir del bucle. Estos iteradores son útiles cuando se simulan bucles infinitos o se genera una secuencia sin límites. Itertools tiene tres iteradores infinitos, que incluyen count(), cycle() y repeat().

#2. Iteradores combinatorios

Los iteradores combinatorios comprenden funciones que pueden utilizarse para trabajar con productos cartesianos y realizar combinaciones y permutaciones de elementos contenidos en un iterable. Son las funciones a las que hay que recurrir cuando se trata de encontrar todas las formas posibles de ordenar o combinar elementos en un iterable. Itertools dispone de cuatro iteradores combinatorios. Estos son producto(), permutaciones(), combinaciones() y combinaciones_con_reemplazo().

#3. Iteradores que terminan en la secuencia de entrada más corta

Se trata de iteradores de terminación que se utilizan sobre secuencias finitas y generan una salida basada en el tipo de función utilizada. Algunos ejemplos de estos iteradores de terminación son: accumulate(), chain(), chain.from_iterable(), compress(), dropwhile(), filterfalse(), groupby(), islice(), pairwise(), starmap(), takewhile(), tee(), y zip_longest().

Veamos cómo funcionan las distintas funciones de Itertools según su tipo:

Iteradores infinitos

Los tres iteradores infinitos son

#1. count()

La función count(start, step) genera una secuencia infinita de números a partir del valor inicial. La función toma dos argumentos opcionales: inicio y paso. El argumento inicio establece dónde debe comenzar la secuencia de números. Por defecto, comienza en 0 si no se proporciona un valor de inicio. step establece la diferencia entre cada número consecutivo. El valor de paso por defecto es 1.

import itertools
# cuenta empezando en 4, haciendo pasos de 2 
for i in itertools.count(4, 2):
   # condición para finalizar el bucle evitando bucles infinitos
 if i == 14:
 break
 else:
 print(i) # output - 4, 6, 8, 10, 12

Salida

4
6
8
10
12

#2. ciclo()

la función cycle(iterable) toma un iterable como argumento y luego realiza un ciclo a través del iterable permitiendo el acceso a los elementos del iterable en el orden en que aparecen.

Por ejemplo, si pasamos [“rojo”, “verde”, “amarillo”] a cycle( ), en el primer ciclo tendremos acceso a “rojo”; en el segundo ciclo tendremos acceso a “verde”, luego a “amarillo”. En el cuarto ciclo, dado que se han agotado todos los elementos en el iterable, volveremos a empezar en “rojo” y seguiremos infinitamente.

Al llamar a cycle() se almacena su resultado en una variable para crear un iterador que mantenga su estado. Esto asegura que el ciclo no comience de nuevo cada vez, dándole acceso sólo al primer elemento.

import itertools

colors = ["rojo", "verde", "amarillo"]
# pase los colores a cycle()
color_cycle = itertools.cycle(colors)
print(color_cycle)

# range se utiliza para detener el bucle infinito una vez que hemos impreso 7 veces
# next() se utiliza para devolver el siguiente elemento del iterador
for i in range(7):
 print(next(color_cycle))

Salida:

rojo
verde
amarillo
rojo
verde
amarillo
rojo

#3. repetir()

repeat(elem,n) toma dos argumentos, un elemento a repetir(elem), y el número de veces que desea repetir el elemento(n). El elemento que desea repetir puede ser un único valor o un iterable. Si no pasa n, el elemento se repetirá infinitamente.

import itertools
   
for i in itertools.repeat(10, 3):
 print(i)

Salida:

10 
10
10

Iteradores combinatorios

Los iteradores combinatorios incluyen:

#1. product()

product() es una función utilizada para calcular el producto cartesiano del iterable que se le pasa. Si tenemos dos iterables o conjuntos, por ejemplo, x = {7,8} e y = {1,2,3}, el producto cartesiano de x e y contendrá todas las combinaciones posibles de elementos de x e y, donde el primer elemento es de x y el segundo de y. El producto cartesiano de x e y en este caso es [(7, 1), (7, 2), (7, 3), (8, 1), (8, 2), (8, 3)].

product() toma un parámetro opcional llamado repeat que se utiliza para calcular el producto cartesiano de un iterable consigo mismo. repeat especifica el número de repeticiones de cada elemento de los iterables de entrada al calcular el producto cartesiano.

Por ejemplo, al llamar a product(‘ABCD’, repeat=2) se obtienen combinaciones como (‘A’, ‘A’), (‘A’, ‘B’), (‘A’, ‘C’), y así sucesivamente. Si la repetición se fijara en 3, la función produciría combinaciones como (‘A’, ‘A’, ‘A’), (‘A’, ‘A’, ‘B’), (‘A’, ‘A’, ‘C’), (‘A’, ‘A’, ‘D’), etc.

from itertools import product
# producto() con el argumento de repetición opcional
print("producto() con el argumento de repetición opcional ")
print(list(producto('ABC', repetición = 2)))

# producto sin repetición
print("producto() SIN argumento de repetición opcional")
print(list(producto([7,8], [1,2,3])))

Salida

product() con el argumento de repetición opcional 
[('A', 'A'), ('A', 'B'), ('A', 'C'), ('B', 'A'), ('B', 'B'), ('B', 'C'), ('C', 'A'), ('C', 'B'), ('C', 'C')]
product() SIN un argumento opcional de repetición
[(7, 1), (7, 2), (7, 3), (8, 1), (8, 2), (8, 3)]

#2. permutaciones()

permutaciones(iterable, tamaño_grupo) devuelve todas las permutaciones posibles del iterable que se le ha pasado. Una permutación representa el número de formas en que pueden ordenarse los elementos de un conjunto. permutations() toma un argumento opcional group_size. Si tamaño_grupo no se especifica, las permutaciones generadas tendrán el mismo tamaño que la longitud del iterable pasado a la función

import itertools
numbers = [1, 2, 3]
sized_permutations = list(itertools.permutations(numbers,2))
unsized_permuatations = list(itertools.permutations(numbers))

print("Permutaciones con un tamaño de 2")
print(sized_permutations)
print("Permutaciones SIN argumento de tamaño")
print(unsized_permuatations)

Salida

Permutaciones con un tamaño de grupo de 2
[(1, 2), (1, 3), (2, 1), (2, 3), (3, 1), (3, 2)]
Permutaciones SIN argumento de tamaño
[(1, 2, 3), (1, 3, 2), (2, 1, 3), (2, 3, 1), (3, 1, 2), (3, 2, 1)]

#3. combinaciones()

combinaciones(iterable, tamaño) devuelve todas las combinaciones posibles de un iterable de una longitud dada a partir de los elementos del iterable pasados a la función. El argumento tamaño especifica el tamaño de cada combinación.

Los resultados se ordenan. La combinación difiere ligeramente de la permutación. Con la permutación, el orden importa, pero con la combinación, el orden no importa. Por ejemplo, en [A, B, C] hay 6 permutaciones: AB, AC, BA, BC, CA, CB pero sólo 3 combinaciones 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("Combinaciones con un tamaño de 2")
print(size2_combination)
print("Combinaciones con un tamaño de 3")
print(size3_combination)

Salida:

Combinaciones con un tamaño de 2
[(1, 2), (1, 3), (1, 4), (2, 3), (2, 4), (3, 4)]
Combinaciones con un tamaño de 3
[(1, 2, 3), (1, 2, 4), (1, 3, 4), (2, 3, 4)]

#4. combinaciones_con_reemplazo()

combinaciones_con_reemplazo(iterable, tamaño) genera todas las combinaciones posibles de un iterable de una longitud dada a partir del iterable pasado a la función y permite elementos repetidos en las combinaciones de salida. El tamaño determina el tamaño de las combinaciones generadas.

Esta función difiere de combinations() en que da combinaciones en las que un elemento puede repetirse más de una vez. Por ejemplo, puede obtener una combinación como (1,1) que no puede con combination().

import itertools
numbers = [1, 2, 3,4]

combinacion_tamaño2 = list(itertools.combinaciones_con_reemplazo(numbers,2))
print("Combinaciones_con_reemplazo => tamaño 2")
print(combinacion_tamaño2)

Salida

Combinaciones_con_reemplazo => tamaño 2
[(1, 1), (1, 2), (1, 3), (1, 4), (2, 2), (2, 3), (2, 4), (3, 3), (3, 4), (4, 4)]

Iteradores de terminación

Esto incluye iteradores como

#1. accumulate()

accumulate(iterable, function) toma un iterable y un segundo argumento opcional que es una función. Entonces devuelve el resultado acumulado de aplicar la función en cada iteración sobre los elementos del iterable. Si no se pasa ninguna función, se realiza la suma y se devuelven los resultados acumulados.

import itertools
import operator
numbers = [1, 2, 3, 4, 5]

# Acumula la suma de números
accumulated_val = itertools.accumulate(numbers)
accumulated_mul = itertools.accumulate(numbers, operator.mul)
print("Acumular sin función")
print(list(accumulated_val))
print("Acumular con multiplicación")
print(list(accumulated_mul))

Salida:

Acumular sin función
[1, 3, 6, 10, 15]
Acumular con multiplicación
[1, 2, 6, 24, 120]

#2. encadenar()

chain(iterable_1, iterable_2, …) toma múltiples iterables y los encadena produciendo un único iterable que contiene valores de los iterables pasados a la función chain()

import itertools

letras = ['A', 'B', 'C', 'D']
números = [1, 2, 3]
colores = ['rojo', 'verde', 'amarillo']

# Encadene letras y números
encadenado_iterable = list(itertools.chain(letras, números, colores))
print(encadenado_iterable)

Salida:

['A', 'B', 'C', 'D', 1, 2, 3, 'rojo', 'verde', 'amarillo']

#3. cadena.from_iterable()

chain.from_iterable(iterable) esta función es similar a chain(). Sin embargo, difiere de la cadena en que sólo toma un único iterable que contiene subiterables y los encadena.

import itertools

letras = ['A', 'B', 'C', 'D']
números = [1, 2, 3]
colores = ['rojo', 'verde', 'amarillo']

iterable = ['hola',colores, letras, números]
cadena = list(itertools.cadena.from_iterable(iterable))
print(cadena)

Salida:

['h', 'e', 'l', 'l', 'o', 'rojo', 'verde', 'amarillo', 'A', 'B', 'C', 'D', 1, 2, 3]

#4. comprimir()

compress(data, selectors) toma dos argumentos, data que es un iterable, y selectors que es un iterable que contiene valores booleanos true, y false. también se pueden utilizar 1, 0 como alternativas a los valores booleanos true y false. compress() filtra entonces los datos pasados utilizando los elementos correspondientes pasados en el selector .

Los valores de los datos que corresponden al valor verdadero o 1 en el selector se seleccionan, mientras que el resto que corresponden a falso o 0 se ignoran. Si se pasan menos booleanos en los selectores que el número de elementos en los datos se ignoran todos los elementos más allá de los booleanos pasados en los selectores

import itertools

# los datos tienen 10 elementos
datos = ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J']
# pasar 9 elementos en los selectores
selectores = [Verdadero, Falso, 1, Falso, 0, 1, Verdadero, Falso, 1]

# Seleccionar elementos de los datos basándose en los selectores
datos_filtrados = list(itertools.compress(data, selectors))
print(filtered_data)

Salida:

['A', 'C', 'F', 'G', 'I']

#5. dropwhile()

dropwhile(function, sequence) toma una función con la condición que devuelve verdadero o falso y una secuencia de valores. A continuación, deja caer todos los valores hasta que la condición pasada devuelva False. Una vez que la condición devuelve falso, el resto de los elementos se incluyen en sus resultados independientemente de si devolverían Verdadero o Falso.

import itertools

numbers = [1, 2, 3, 4, 5, 1, 6, 7, 2, 1, 8, 9, 0, 7]

# Arroja elementos hasta que la condición pasada es False
filtered_numbers = list(itertools.dropwhile(lambda x: x < 5, numbers))
print(filtered_numbers)

Salida:

[5, 1, 6, 7, 2, 1, 8, 9, 0, 7]

#6. filterfalse()

filterfalse(function, sequence) toma una función, con una condición que evalúa a verdadero o falso y una secuencia. A continuación, devuelve los valores de la secuencia que no satisfacen la condición de la función.

import itertools

numbers = [1, 2, 3, 4, 2, 3 5, 6, 5, 8, 1, 2, 3, 6, 2, 7, 4, 3]

# Filtre los elementos cuya condición sea False
filtered_numbers = list(itertools.filterfalse(lambda x: x < 4, numbers))
print(filtered_numbers)

Salida:

[4, 5, 6, 5, 8, 6, 7, 4]

#7. groupby()

groupby(iterable, clave) toma un iterable y una clave, luego hace un iterador que devuelve claves y grupos consecutivos. Para que funcione, el iterable que se le pasa debe estar ordenado en la misma función clave. La función clave computa un valor clave para cada elemento del iterable.

import itertools

input_list = [("Doméstico", "Vaca"), ("Doméstico", "Perro"), ("Doméstico", "Gato"),("Salvaje", "León"), ("Salvaje", "Cebra"), ("Salvaje", "Elefante")]
classification = itertools.groupby(lista_entrada,lambda x: x[0])
para clave,valor en clasificación:
 print(clave,":",lista(valor))

Salida:

Doméstico : [('Doméstico', 'Vaca'), ('Doméstico', 'Perro'), ('Doméstico', 'Gato')]
Salvaje : [('Salvaje', 'León'), ('Salvaje', 'Cebra'), ('Salvaje', 'Elefante')]

#8. islice()

islice(iterable, start, stop, step) le permite trocear un iterable utilizando los valores start, stop y step pasados. El argumento paso es opcional. El recuento comienza en 0 y no se incluye el elemento del número de parada.

import itertools

numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18]

# Seleccionar elementos dentro de un rango
selected_numbers = list(itertools.islice(numbers, 2, 10))
selected_numbers_step= list(itertools.islice(numbers, 2, 10,2))
print("islice sin establecer un valor de paso")
print(selected_numbers)
print("islice con un valor de paso de 2")
print(selected_numbers_step)

Salida:

islice sin fijar un valor de paso
[3, 4, 5, 6, 7, 8, 9, 10]
islice con un valor de paso de 2
[3, 5, 7, 9]

#9. pairwise()

pairwise(iterable) devuelve pares sucesivos superpuestos tomados del iterable que se le ha pasado en el orden en que aparecen en el iterable. Si el iterable que se le pasa tiene menos de dos valores, el resultado de pairwise() estará vacío.

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))

Salida:

[(1, 2), (2, 3), (3, 4), (4, 5), (5, 6), (6, 7), (7, 8)]
[('W', 'O'), ('O', 'R'), ('R', 'L'), ('L', 'D')]
[]

#10. starmap()

starmap(function, iterable) es una función que se utiliza en lugar de map() cuando los parámetros del argumento ya están agrupados en tuplas. startmap() aplica una función a los elementos del iterable que se le pasa. El iterable debe tener los elementos agrupados en 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)))

Salida:

[13, 5, 9, 16, 11]

#11. takewhile()

takewhile(function, iterable) funciona de forma opuesta a dropwhile(). takewhile() toma una función con una condición a evaluar y un iterable. A continuación, incluye todos los elementos del iterable que satisfacen la condición de la función hasta que se devuelve False. Una vez devuelto False, se ignoran todos los elementos siguientes del iterable.

import itertools

numbers = [1, 2, 3, 4, 5, 1, 6, 7, 2, 1, 8, 9, 0, 7]

# Descarta los elementos hasta que la condición pasada sea False
filtered_numbers = list(itertools.takewhile(lambda x: x < 5, numbers))
print(filtered_numbers)

Salida:

[1, 2, 3, 4]

#12. tee()

tee(iterable, n) toma un iterable y devuelve múltiples iteradores independientes. El número de iteradores a devolver se establece mediante n, que por defecto es 2.

import itertools

numbers = [1, 2, 3, 4, 5]

# Crea dos iteradores independientes a partir de numbers
iter1, iter2 = itertools.tee(numbers, 2)
print(list(iter1))
print(list(iter2))

Salida:

[1, 2, 3, 4, 5]
[1, 2, 3, 4, 5]

#13. zip_longest()

zip_longest(iterables, fillvalue) recibe varios iteradores y un fillvalue. A continuación devuelve un iterador que agrega elementos de cada uno de los iteradores que se le han pasado. Si los iteradores no tienen la misma longitud, los valores que faltan se sustituyen por el fillvalue pasado a la función hasta agotar el iterable más largo.

import itertools

names = ['John', 'mathew', 'mary', 'Alice', 'Bob', 'Charlie', 'Fury']
ages = [25, 30, 12, 13, 42]

# Combine el nombre y las edades, rellenando las edades que falten con un guión
combined = itertools.zip_longest(names, ages, fillvalue="-")

for name, age in combined:
 print(name, age)

Salida:

John 25
mathew 30
mary 12
Alice 13
Bob 42
Charlie -
Fury -

Conclusión

Las itertools de Python son un importante conjunto de herramientas para un desarrollador de Python. Las itertools de Python se utilizan mucho en programación funcional, procesamiento y transformación de datos, filtrado y selección de datos, agrupación y agregación, combinación de iterables, combinatoria y cuando se trabaja con secuencias infinitas.

Como desarrollador de Python, se beneficiará enormemente aprendiendo sobre las itertools, así que asegúrese de utilizar este artículo para familiarizarse con las itertools de Python.