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