acumular()
itertools.accumulate(iterable)
Esta função faz um iterador que retorna os resultados de uma função. As funções podem ser passadas em torno de variáveis muito semelhantes. A função accumulate() assume uma função como um argumento. Também é necessária uma função iterável. Ela devolve os resultados acumulados. Os resultados são eles próprios contidos num iterável. Tudo isto pode parecer muito confuso. Asseguro-lhe que, quando brinca com o código fará sentido.
Código
data = result = itertools.accumulate(data, operator.mul)
for each in result:
print(each)
Output
1
2
6
24
120
O operador.mul pega em dois números e multiplica-os.
operator.mul(1, 2)
2
operator.mul(2, 3)
6
operator.mul(6, 4)
24
operator.mul(24, 5)
120
Neste próximo exemplo será utilizada a função max.
Código
data = result = itertools.accumulate(data, max)
for each in result:
print(each)
Eliminar
5
5
6
6
6
9
9
O max função retorna o maior item.
5
max(5, 2)
5
max(5, 6)
6
max(6, 4)
6
max(6, 5)
6
max(6, 9)
9
max(9, 1)
9
Passar uma função é opcional.
Código
data = result = itertools.accumulate(data)
for each in result:
print(each)
Eliminar
5
7
13
17
22
31
32
Se nenhuma função for designada, os itens serão somados.
5
5 + 2 = 7
7 + 6 = 13
13 + 4 = 17
17 + 5 = 22
22 + 9 = 31
31 + 1 = 32
combinações()
itertools.combinations(iterable, r)
Esta função leva um iterável e um número inteiro. Isto irá criar todas as combinações únicas que têm r membros.
Código
shapes = result = itertools.combinations(shapes, 2)for each in result:
print(each)
Neste código fazemos todos os combos com 2 membros.
P>Efecção
('circle', 'triangle')
('circle', 'square')
('triangle', 'square')
Código
shapes = result = itertools.combinations(shapes, 3)for each in result:
print(each)
Neste código fazemos todos os combos com 3membros. É um pouco menos excitante.
Empreendimento
('circle', 'triangle', 'square')
combinações_com_substituição()
itertools.combinations_with_replacement(iterable, r)
Este é igual à função combinations(), mas este permite que os elementos individuais sejam repetidos mais de uma vez.
c>Código
shapes = result = itertools.combinations_with_replacement(shapes, 2)
for each in result:
print(each)
Output
count()
itertools.count(start=0, step=1)
Faz um iterador que retorna valores uniformemente espaçados começando com o início do número.
Código
for i in itertools.count(10,3):
print(i)
if i > 20:
break
No código acima, iteramos ou fazemos um loop sobre uma função. Dizemos à função para começar em 10 e passo 3.
Output
10
13
16
19
22
Esta primeira iteração tem o valor 10. No passo seguinte, vamos dar o passo ou adicionar 3. Isto tem o valor 13. Fazemos a mesma coisa para a próxima iteração e obtemos um valor de 16. Isto continuaria para sempre mas, adicionámos uma pausa.
cycle()
itertools.cycle(iterable)
Esta função cicla infinitamente através de um iterador.
Código
colors = for color in itertools.cycle(colors):
print(color)
No código acima, criamos uma lista. Em seguida, fazemos um ciclo ou loop através desta lista infinitamente. Normalmente, um for passa por um iterável até chegar ao fim. Se uma lista tiver 3 itens, o laço irá iterar 3 vezes. Mas não se utilizarmos a função cycle(). Com esta função, quando chegamos ao fim do iterável recomeçamos do início.
Output
red
orange
yellow
green
blue
indigo
violet
red
orange
yellow
green
...
Tenho truncado a saída infinita acima com elipses.
chain()
itertools.chain(*iterables)
Esta função toma uma série de iterables e devolve-os como uma longa iterable.
Código
colors =
shapes = result = itertools.chain(colors, shapes)
for each in result:
print(each)
Eliminar
red
orange
yellow
green
blue
circle
triangle
square
pentagon
compress()
itertools.compress(data, selectors)
Esta função filtra uma iterável com outra.
c>código
shapes =
selections = result = itertools.compress(shapes, selections)
for each in result:
print(each)
Eliminar
circle
square
dropwhile()
itertools.dropwhile(predicate, iterable)
Faça um iterador que deixa cair elementos do iterável desde que o predicado seja verdadeiro; depois, devolve cada elemento.
c>Código
data = result = itertools.dropwhile(lambda x: x<5, data)
for each in result:
print(each)
Output
5
6
7
8
9
10
1
Ok. Isto pode ser confuso. O código diz para largar cada item enquanto o item for inferior a 5. Depois de encontrar um item que não seja inferior a 5, devolve o resto. É por isso que esse último é devolvido.
Step Through It
1 < 5: True, drop
2 < 5: True, drop
3 < 5: True, drop
4 < 5: True, drop
5 < 5: False, return surviving items
filterfalse()
itertools.filterfalse(predicate, iterable)
Esta função faz um iterador que filtra elementos de iterável devolvendo apenas aqueles para os quais o predicado é False.
c>Código
data =
result = itertools.filterfalse(lambda x: x<5, data)
for each in result:
print(each)
Eliminar
5
6
7
8
9
10
P>Passo Através dela
1 < 5: True, drop
2 < 5: True, drop
3 < 5: True, drop
4 < 5: True, drop
5 < 5: False, keep
6 < 5: False, keep
7 < 5: False, keep
8 < 5: False, keep
9 < 5: False, keep
10 < 5: False, keep
groupby()
itertools.groupby(iterable, key=None)
Simplesmente colocado, esta função agrupa as coisas. Ok. Esta é complicada. E o exemplo é um pouco longo.
Código
robots = for key, group in itertools.groupby(bots, key=lambda x: x):
print(key)
print(list(group))
Emprodução
autobot
decepticon
islice()
itertools.islice(iterable, start, stop)
Esta função é muito semelhante às fatias. Esta função permite recortar um pedaço de um iterável.
Código
colors =
few_colors = itertools.islice(colors, 2)
for each in few_colors:
print(each)
Eliminar
red
orange
permutações()
itertools.permutations(iterable, r=None)
Código
alpha_data = result = itertools.permutations(alpha_data)
for each in result:
print(each)
Output
('a', 'b', 'c')
('a', 'c', 'b')
('b', 'a', 'c')
('b', 'c', 'a')
('c', 'a', 'b')
('c', 'b', 'a')
produto()
Esta função cria os produtos cartesianos a partir de uma série de iterables.
Código
num_data =
alpha_data = result = itertools.product(num_data, alpha_data)
for each in result:
print(each)
Eliminar
(1, 'a')
(1, 'b')
(1, 'c')
(2, 'a')
(2, 'b')
(2, 'c')
(3, 'a')
(3, 'b')
(3, 'c')
Imagine uma tabela como esta:
a b c
1 a1 b1 c1
2 a2 b2 c3
3 a3 b3 b3
repeat()
itertools.repeat(object)
Esta função repetirá um objecto uma e outra vez. A menos que, haja um times argument.
Código
for i in itertools.repeat("spam"):
print(i)
No código acima, criamos um iterável que apenas repete spam vezes sem conta. Fá-lo-á infinitamente. É assim que infinito spam é feito.
Saída
spam
spam
spam
spam
spam
spam
...
trunquei a saída infinita acima com elipses.
c>Código
for i in itertools.repeat("spam", 3):
print(i)
Se utilizarmos o argumento times, podemos limitar o número de vezes que ele se repetirá.
Saída
spam
spam
spam
Neste exemplo spam só se repete três vezes.
starmap()
itertools.starmap(function, iterable)
Esta função faz um iterador que calcula a função usando argumentos obtidos a partir do iterável. Vamos dar uma vista de olhos.
Código
data =
result = itertools.starmap(operator.mul, data)
for each in result:
print(each)
Eliminar
12
32
21
P>Passo-a-passo
operator.mul(2, 6)
12
operator.mul(8, 4)
32
operator.mul(7, 3)
21
takewhile()
itertools.takwwhile(predicate, iterable)
Este é mais ou menos o oposto de dropwhile(). Esta função faz um iterador e devolve elementos do iterável, desde que o predicado seja verdadeiro.
Código
data = result = itertools.takewhile(lambda x: x<5, data)
for each in result:
print(each)
Eliminar
1
2
3
4
P>Passo Através dela
1 < 5: True, keep going
2 < 5: True, keep going
3 < 5: True, keep going
4 < 5: True, keep going
5 < 5: False, stop and drop
tee()
itertools.tee(iterable, n=2)
Retornar n iteradores independentes a partir de um único iterável.
Código
colors =
alpha_colors, beta_colors = itertools.tee(colors)for each in alpha_colors:
print(each)print('..')for each in beta_colors:
print(each)
O padrão é 2, mas pode fazer tantos quantos forem necessários.
P>Output
red
orange
yellow
green
blue
..
red
orange
yellow
green
blue
zip_longest()
itertools.zip_longest(*iterables, fillvalue=None)
Esta função faz um iterador que agrega elementos de cada um dos iterables. Se os iterables forem de comprimento desigual, os valores em falta são preenchidos com fillvalue. A iteração continua até se esgotar a iterabilidade mais longa.
Código
colors =
data = for each in itertools.zip_longest(colors, data, fillvalue=None):
print(each)
Saída
('red', 1)
('orange', 2)
('yellow', 3)
('green', 4)
('blue', 5)
(None, 6)
(None, 7)
(None, 8)
(None, 9)
(None, 10)