Python - Librería Itertools
#39 Ejemplos en Python usando la librería itertools.
#1. Combinaciones de una lista de elementos:
import itertools
lista = [1, 2, 3]
combinaciones = itertools.combinations(lista, 2)
print(list(combinaciones)) # Salida: [(1, 2), (1, 3), (2, 3)]
#2. Permutaciones de una lista de elementos:
import itertools
lista = [1, 2, 3]
permutaciones = itertools.permutations(lista)
print(list(permutaciones))
# Salida: [(1, 2, 3), (1, 3, 2), (2, 1, 3), (2, 3, 1), (3, 1, 2), (3, 2, 1)]
#3. Productos cartesianos de dos listas:
import itertools
lista1 = [1, 2]
lista2 = ['a', 'b']
productos = itertools.product(lista1, lista2)
print(list(productos))
# Salida: [(1, 'a'), (1, 'b'), (2, 'a'), (2, 'b')]
#4. Combinaciones con repetición de una lista de elementos:
import itertools
lista = [1, 2, 3]
combinaciones = itertools.combinations_with_replacement(lista, 2)
print(list(combinaciones))
# Salida: [(1, 1), (1, 2), (1, 3), (2, 2), (2, 3), (3, 3)]
#5. Cadenas de elementos repetidos:
import itertools
cadena = itertools.repeat('Hola', 3)
print(list(cadena))
# Salida: ['Hola', 'Hola', 'Hola']
#6. Elementos de una lista agrupados en tuplas de tamaño fijo:
import itertools
lista = [1, 2, 3, 4, 5, 6]
grupos = itertools.zip_longest(*[iter(lista)]*3)
print(list(grupos))
# Salida: [(1, 2, 3), (4, 5, 6)]
#7. Elementos de una lista agrupados en tuplas de tamaño variable:
import itertools
lista = [1, 2, 3, 4, 5, 6]
grupos = itertools.zip_longest(*[iter(lista)]*2, fillvalue=None)
print(list(grupos))
# Salida: [(1, 2), (3, 4), (5, 6)]
#8. Elementos de una lista agrupados en sublistas de tamaño fijo:
import itertools
lista = [1, 2, 3, 4, 5, 6]
grupos = [list(g) for g in itertools.zip_longest(*[iter(lista)]*3, fillvalue=None)]
print(grupos)
# Salida: [[1, 2, 3], [4, 5, 6]]
#9. Elementos de una lista agrupados en sublistas de tamaño variable:
import itertools
lista = [1, 2, 3, 4, 5, 6]
grupos = [list(g) for g in itertools.zip_longest(*[iter(lista)]*2, fillvalue=None)]
print(grupos)
# Salida: [[1, 2], [3, 4], [5, 6]]
#10. Elementos de una lista agrupados en sublistas
#de tamaño variable con una condición:
import itertools
lista = [1, 2, 3, 4, 5, 6]
grupos = [list(g) for k, g in itertools.groupby(lista, lambda x: x % 2 == 0) if not k]
print(grupos)
# Salida: [[1], [3], [5]]
#11. Elementos de una lista agrupados en sublistas
#de tamaño variable con una función de agrupación:
import itertools
lista = [1, 2, 3, 4, 5, 6]
grupos = [list(g) for k, g in itertools.groupby(lista, lambda x: x < 4)]
print(grupos)
# Salida: [[1, 2, 3], [4, 5, 6]]
#12. Elementos de una lista agrupados en sublistas de tamaño variable
#con una función de agrupación y ordenados:
import itertools
lista = [1, 2, 3, 4, 5, 6]
grupos = [list(g) for k, g in itertools.groupby(sorted(lista), lambda x: x < 4)]
print(grupos)
# Salida: [[1, 2, 3], [4, 5, 6]]
#13. Elementos de una lista agrupados en sublistas
#de tamaño variable con una función de agrupación y ordenados inversamente:
import itertools
lista = [1, 2, 3, 4, 5, 6]
grupos = [list(g) for k, g in itertools.groupby(sorted(lista, reverse=True), lambda x: x > 3)]
print(grupos)
# Salida: [[6, 5, 4], [3, 2, 1]]
#14. Elementos de una lista agrupados en sublistas
#de tamaño variable con una función de agrupación y ordenados por longitud:
import itertools
lista = [[1, 2], [3, 4, 5], [6, 7, 8, 9], [10, 11]]
grupos = [list(g) for k, g in itertools.groupby(sorted(lista, key=len), lambda x: len(x) < 4)]
print(grupos)
# Salida: [[[1, 2], [10, 11], [3, 4, 5]], [[6, 7, 8, 9]]]
#15. Elementos de una lista agrupados en sublistas
#de tamaño variable con una función de agrupación
#y ordenados por la suma de sus elementos:
import itertools
lista = [[1, 2], [3, 4, 5], [6, 7, 8, 9], [10, 11]]
grupos = [list(g) for k, g in itertools.groupby(sorted(lista, key=sum), lambda x: sum(x) < 15)]
print(grupos)
# Salida: [[[1, 2], [3, 4, 5]], [[10, 11], [6, 7, 8, 9]]]
#16. Elementos de una lista agrupados en sublistas
#de tamaño variable con una función de agrupación
#y ordenados por la media de sus elementos:
import itertools
lista = [[1, 2], [3, 4, 5], [6, 7, 8, 9], [10, 11]]
grupos = [list(g) for k, g in itertools.groupby(sorted(lista, key=lambda x: sum(x)/len(x)), lambda x: sum(x)/len(x) < 6)]
print(grupos)
# Salida: [[[1, 2], [3, 4, 5]], [[6, 7, 8, 9], [10, 11]]]
#17. Combinaciones de elementos:
from itertools import combinations
lista = ['a', 'b', 'c']
combinaciones = list(combinations(lista, 2))
print(combinaciones)
# Salida: [('a', 'b'), ('a', 'c'), ('b', 'c')]
#18. Permutaciones de elementos:
from itertools import permutations
lista = ['a', 'b', 'c']
permutaciones = list(permutations(lista))
print(permutaciones)
# Salida: [('a', 'b', 'c'), ('a', 'c', 'b'), ('b', 'a', 'c'), ('b', 'c', 'a'), ('c', 'a', 'b'), ('c', 'b', 'a')]
#19. Productos cartesianos:
from itertools import product
lista1 = ['a', 'b']
lista2 = [1, 2]
productos = list(product(lista1, lista2))
print(productos)
# Salida: [('a', 1), ('a', 2), ('b', 1), ('b', 2)]
#20. Combinaciones con repetición:
from itertools import combinations_with_replacement
lista = ['a', 'b']
combinaciones = list(combinations_with_replacement(lista, 3))
print(combinaciones)
# Salida: [('a', 'a', 'a'), ('a', 'a', 'b'), ('a', 'b', 'b'), ('b', 'b', 'b')]
#21. Agrupación de elementos:
from itertools import zip_longest
lista1 = ['a', 'b', 'c']
lista2 = [1, 2]
agrupacion = list(zip_longest(lista1, lista2))
print(agrupacion)
# Salida: [('a', 1), ('b', 2), ('c', None)]
#22. accumulate: devuelve una lista acumulativa de los elementos en una secuencia.
import itertools
seq = [1, 2, 3, 4, 5]
result = itertools.accumulate(seq)
print(list(result))
# Salida: [1, 3, 6, 10, 15]
#23. chain: combina varias secuencias en una sola secuencia.
import itertools
seq1 = [1, 2, 3]
seq2 = [4, 5, 6]
result = itertools.chain(seq1, seq2)
print(list(result))
# Salida: [1, 2, 3, 4, 5, 6]
#24. compress: filtra los elementos de una secuencia según otra secuencia booleana.
import itertools
seq = ['a', 'b', 'c', 'd', 'e']
selector = [True, False, True, False, True]
result = itertools.compress(seq, selector)
print(list(result))
# Salida: ['a', 'c', 'e']
#25. count: devuelve un iterador que produce valores consecutivos empezando por un número dado.
import itertools
result = itertools.count(10)
print(next(result)) # Salida: 10
print(next(result)) # Salida: 11
x = itertools.count(start=0, step=2)
print(next(x)) # Salida: 0
print(next(x)) # Salida: 2
print(next(x)) # Salida: 4
#26. cycle: devuelve un iterador que repite indefinidamente los elementos de una secuencia.
import itertools
seq = ['a', 'b', 'c']
result = itertools.cycle(seq)
print(next(result)) # Salida: 'a'
print(next(result)) # Salida: 'b'
print(next(result)) # Salida: 'c'
print(next(result)) # Salida: 'a'
x = [1, 2, 3]
y = itertools.cycle(x)
print(next(y)) # Salida: 1
print(next(y)) # Salida: 2
print(next(y)) # Salida: 3
print(next(y)) # Salida: 1
#27. dropwhile: devuelve los elementos de una secuencia después de que una función dada sea falsa para el primer elemento.
import itertools
seq = [1, 3, 5, 7, 4, 6]
result = itertools.dropwhile(lambda x: x % 2 != 0, seq)
print(list(result))
# Salida: [4, 6]
x = [1, 3, 5, 7, 9, 2, 4, 6, 8, 10]
y = itertools.dropwhile(lambda i: i < 5, x)
print(list(y))
# Salida: [5, 7, 9, 2, 4, 6, 8, 10]
#28. filterfalse: devuelve los elementos de una secuencia para los cuales una función dada devuelve False.
import itertools
seq = [1, 2, 3, 4, 5]
result = itertools.filterfalse(lambda x: x % 2 == 0, seq)
print(list(result))
# Salida: [1, 3, 5]
x = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
y = itertools.filterfalse(lambda i: i % 2 == 0, x)
print(list(y))
# Salida: [1, 3, 5, 7, 9]
#29. islice: devuelve un iterador que produce una selección de elementos de una secuencia.
import itertools
seq = [1, 2, 3, 4, 5]
result = itertools.islice(seq, 1, None)
print(list(result))
# Salida: [2, 3, 4, 5]
x = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
y = itertools.islice(x, 2, 7, 2)
print(list(y))
# Salida: [3, 5, 7]
#30. starmap: aplica una función a cada elemento de una secuencia de tuplas.
import itertools
seq = [(1,2), (3,4), (5,6)]
result = itertools.starmap(lambda x,y: x+y, seq)
print(list(result))
# Salida: [3, 7, 11]
x = [(1, 2), (3, 4), (5, 6)]
y = itertools.starmap(lambda x, y: x + y, x)
print(list(y))
# Salida: [3, 7, 11]
#31. takewhile: devuelve los elementos de una secuencia hasta que una función dada sea falsa para un elemento.
import itertools
seq = [1, 3, 5, 7, 4, 6]
result = itertools.takewhile(lambda x: x % 2 != 0, seq)
print(list(result))
# Salida: [1, 3, 5, 7]
x = [1, 3, 5, 7, 9, 2, 4, 6, 8, 10]
y = itertools.takewhile(lambda i: i < 5, x)
print(list(y))
# Salida: [1, 3]
#32. tee: devuelve varios iteradores independientes que producen los mismos valores.
#import itertools
#seq = [1, 2, 3, 4, 5]
#result1, result2 = itertools.tee(seq)
#print(list(result1))
## Salida: [1, 2, 3, 4, 5]
#print(list(result2))
## Salida: [1, 2, 3, 4, 5]
#33. Elementos de una lista agrupados en sublistas
#de tamaño variable con una función de agrupación
#y ordenados por la desviación estándar de sus elementos:
#import itertools
#import statistics
#lista = [[1, 2], [3, 4, 5], [6, 7, 8, 9], [10, 11]]
#grupos = [list(g) for k, g in itertools.groupby(sorted(lista, key=lambda x: statistics.stdev(x)), lambda x: statistics.stdev(x) < 3)]
#print(grupos)
#34. Elementos de una lista agrupados en sublistas de tamaño variable
#con una función de agrupación y ordenados por la mediana de sus elementos:
#import itertools
#import statistics
#lista = [[1, 2], [3, 4, 5], [6, 7, 8, 9], [10, 11]]
#grupos = [list(g) for k, g in itertools.groupby(sorted(lista, key=lambda x: statistics.median(x)), lambda x: statistics.median(x) < 6)]
#print(grupos)
#35. Elementos de una lista agrupados en sublistas de tamaño variable
#con una función de agrupación y ordenados por la moda de sus elementos:
#import itertools
#import statistics
#lista = [[1, 2], [3, 4, 5], [6, 7, 8, 9], [10, 11]]
#grupos = [list(g) for k, g in itertools.groupby(sorted(lista, key=lambda x: statistics.mode(x)), lambda x: statistics.mode(x) < 6)]
#print(grupos)
#36. Elementos de una lista agrupados en sublistas de tamaño variable
#con una función de agrupación y ordenados por la varianza de sus elementos:
#import itertools
#import statistics
#lista = [[1, 2], [3, 4, 5], [6, 7, 8, 9], [10, 11]]
#grupos = [list(g) for k, g in itertools.groupby(sorted(lista, key=lambda x: statistics.variance(x)), lambda x: statistics.variance(x) < 10)]
#print(grupos)
#37. Usando los dígitos 0-9 sin ninguna repetición para rellena las casillas y crear dos prismas rectangulares con el mismo volumen
import itertools
a=itertools.permutations([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
for x in a:
val = x[0] * (x[1]*10 +x[2]) * (x[3]*10 +x[4])
val2 = x[5] * (x[6]*10 +x[7]) * (x[8]*10 +x[9])
if val == val2 and x[1] != 0 and x[3] != 0 and x[6] != 0 and x[8] != 0:
print(x)
#38. Conjunto Potencia con Números
import itertools
def powerset(iterable):
return itertools.chain.from_iterable(itertools.combinations(iterable, i)
for i in range(len(iterable) + 1))
list(ConjuntoPotencia(range(3)))
#39. Conjunto Potencia con Letras
import itertools
def ConjuntoPotencia(secuencia):
for tamano in range(len(secuencia) + 1):
yield from itertools.combinations(secuencia, tamano)
for resultado in ConjuntoPotencia('abc'):
print(resultado)