160 lines
3.7 KiB
Python
Executable File
160 lines
3.7 KiB
Python
Executable File
"""
|
|
El módulo itertools es un conjunto de herramientas para manejar iteradores.
|
|
Los iteradores son un tipo de dato que usar para iterar, ejm. en un loop for.
|
|
|
|
Un iterator es un objeto sobre el cual se puede iterar, es decir, se pueden
|
|
recorrer todos sus valores.
|
|
|
|
Un iterador es un objeto que contiene un número contable de valores
|
|
|
|
En python un iterador es un obj. que implementa el protocolo iterator, que
|
|
consiste en los métodos __iter__() y __next__().
|
|
|
|
Listas, tuplas, diccionarios y sets, son objetos iterables. De los cuales se
|
|
puede obtener un iterador, metodo iter()
|
|
|
|
Algunas herramientas de los iteradores son:
|
|
product, permutations, combinations, accumulate, groupby, infite iterators
|
|
"""
|
|
|
|
# product
|
|
from itertools import product
|
|
|
|
a = [1, 2]
|
|
b = [3, 4]
|
|
prod = product(a, b) # <itertools.product object at ...>
|
|
list(prod)
|
|
# [(1, 3), (1, 4),
|
|
# (2, 3), (2, 4)]
|
|
|
|
a = [1, 2]
|
|
b = [3]
|
|
prod = product(a, b, repeat=2) # <itertools.product object at ...>
|
|
list(prod)
|
|
# [(1, 3, 1, 3), (1, 3, 2, 3),
|
|
# (2, 3, 1, 3), (2, 3, 2, 3)]
|
|
|
|
|
|
# permutations: todos los posibles ordenes de una entrada
|
|
from itertools import permutations
|
|
|
|
a = [1,2,3]
|
|
perm = permutations(a)
|
|
list(perm)
|
|
# [(1, 2, 3), (1, 3, 2),
|
|
# (2, 1, 3), (2, 3, 1),
|
|
# (3, 1, 2), (3, 2, 1)]
|
|
|
|
# especificar largo de permutaciones
|
|
perm = permutations(a, 2)
|
|
list(perm)
|
|
# [(1, 2), (1, 3),
|
|
# (2, 1), (2, 3),
|
|
# (3, 1), (3, 2)]
|
|
|
|
|
|
# combinations: realiza todas las posibles combinaciones, según
|
|
# largo pasado como 2do argumento (no repite elementos)
|
|
from itertools import (combinations,
|
|
combinations_with_replacement,
|
|
accumulate)
|
|
|
|
a = [1,2,3,4]
|
|
comb = combinations(a, 2)
|
|
list(comb)
|
|
# [(1, 2), (1, 3),
|
|
# (1, 4), (2, 3),
|
|
# (2, 4), (3, 4)]
|
|
|
|
# combinations_with_replacement: igual que el anterior pero repite elementos
|
|
comb_wr = combinations_with_replacement(a, 2)
|
|
list(comb_wr)
|
|
# [(1, 1), (1, 2), (1, 3), (1, 4), (2, 2),
|
|
# (2, 3), (2, 4), (3, 3), (3, 4), (4, 4)]
|
|
|
|
# accumulate: acumula(suma o concatena) elemementos (del mismo tipo)
|
|
accum = accumulate(a)
|
|
list(accum) # [1,3,6,10]
|
|
|
|
b = ['a', 'b', 'cedario']
|
|
accum2 = accumulate(b)
|
|
list(accum2) # ['a', 'ab', 'abcedario']
|
|
|
|
# accumulate, multiplicación
|
|
import operator
|
|
accum_mult = accumulate(a, func=operator.mul)
|
|
list(accum_mult) # [1, 2, 6, 24]
|
|
|
|
# accumulate, max
|
|
c = [1, 2, 5, 3, 4]
|
|
accm_max = accumulate(c, func=max)
|
|
list(accm_max) # [1, 2, 5, 5, 5]
|
|
|
|
|
|
# groupby: crea un iterador que retorna keys y groups de un elemento iterable
|
|
from itertools import groupby
|
|
|
|
#def menor_q_3(x):
|
|
# return x < 3
|
|
# reemplazado por funcion lambda
|
|
|
|
a = [1, 2, 3, 4]
|
|
group_obj = groupby(a, key=lambda x: x<3)
|
|
for key, value in group_obj:
|
|
print(key, list(value))
|
|
# True [1, 2]
|
|
# False [3, 4]
|
|
|
|
personas = [{'nombre': 'Zerafio', 'edad': 26},
|
|
{'nombre': 'Raber', 'edad': 26},
|
|
{'nombre': 'Estor', 'edad': 58},
|
|
{'nombre': 'Gunter', 'edad': 26}]
|
|
|
|
group_obj = groupby(personas, key=lambda x: x['edad'])
|
|
for key, value in group_obj:
|
|
print(key, list(value))
|
|
# agrupa solo si los elementos son consecutivos?
|
|
# 26 [{'nombre': 'Zerafio', 'edad': 26}, {'nombre': 'Raber', 'edad': 26}]
|
|
# 58 [{'nombre': 'Estor', 'edad': 58}]
|
|
# 26 [{'nombre': 'Gunter', 'edad': 26}]
|
|
|
|
|
|
# infite iterators
|
|
from itertools import count, cycle, repeat
|
|
|
|
# count, itera infinitamente desde un numero
|
|
for i in count(10):
|
|
print(i)
|
|
if i == 15:
|
|
break
|
|
# 10
|
|
# 11
|
|
# 12
|
|
# 13
|
|
# 14
|
|
# 15
|
|
|
|
# cycle, itera infinitamente un iterable
|
|
a = [1, 2, 3]
|
|
cont = 0
|
|
for i in cycle(a):
|
|
print(i)
|
|
cont += 1
|
|
if cont > 8:
|
|
break
|
|
# 1
|
|
# 2
|
|
# 3
|
|
# 1
|
|
# 2
|
|
# 3
|
|
|
|
# repeat, repite el argumento pasado infinitamente,
|
|
# o hasta el valor pasado como segundo argumento
|
|
for i in repeat(1, 4):
|
|
print(i)
|
|
# 1
|
|
# 1
|
|
# 1
|
|
# 1
|