accumulate()
itertools.accumulate(iterable)
Questa funzione crea un iteratore che restituisce i risultati di una funzione. Le funzioni possono essere passate molto simili alle variabili. La funzione accumulate() prende una funzione come argomento. Prende anche un iterabile. Restituisce i risultati accumulati. I risultati sono essi stessi contenuti in un iterabile. Tutto questo può sembrare molto confuso. Vi assicuro che quando giocherete con il codice avrà senso.
Codice
data = result = itertools.accumulate(data, operator.mul)
for each in result:
print(each)
Output
1
2
6
24
120
L’operator.mul prende due numeri e li moltiplica.
operator.mul(1, 2)
2
operator.mul(2, 3)
6
operator.mul(6, 4)
24
operator.mul(24, 5)
120
In questo prossimo esempio useremo la funzione max.
Codice
data = result = itertools.accumulate(data, max)
for each in result:
print(each)
Output
5
5
6
6
6
9
9
La funzione max ritorna l’elemento più grande.
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
Il passaggio di una funzione è opzionale.
Codice
data = result = itertools.accumulate(data)
for each in result:
print(each)
Output
5
7
13
17
22
31
32
Se non viene designata alcuna funzione gli elementi saranno sommati.
5
5 + 2 = 7
7 + 6 = 13
13 + 4 = 17
17 + 5 = 22
22 + 9 = 31
31 + 1 = 32
combinations()
itertools.combinations(iterable, r)
Questa funzione prende un iterabile e un intero. Questo creerà tutte le combinazioni uniche che hanno r membri.
Codice
shapes = result = itertools.combinations(shapes, 2)for each in result:
print(each)
In questo codice facciamo tutte le combo con 2 membri.
Output
('circle', 'triangle')
('circle', 'square')
('triangle', 'square')
Codice
shapes = result = itertools.combinations(shapes, 3)for each in result:
print(each)
In questo codice facciamo tutte le combo con 3 membri. È un po’ meno eccitante.
Output
('circle', 'triangle', 'square')
combinations_with_replacement()
itertools.combinations_with_replacement(iterable, r)
Questa è proprio come la funzione combinations(), ma questa permette ai singoli elementi di essere ripetuti più di una volta.
Codice
shapes = result = itertools.combinations_with_replacement(shapes, 2)
for each in result:
print(each)
Output
('circle', 'circle')
('circle', 'triangle')
('circle', 'square')
('triangle', 'triangle')
('triangle', 'square')
('square', 'square')
count()
itertools.count(start=0, step=1)
Fa un iteratore che restituisce valori uniformemente spaziati a partire dal numero iniziale.
Codice
for i in itertools.count(10,3):
print(i)
if i > 20:
break
Nel codice precedente, iteriamo o facciamo un loop su una funzione. Diciamo alla funzione di iniziare da 10 e fare il passo 3.
Output
10
13
16
19
22
Questa prima iterazione ha il valore 10. Nel passo successivo facciamo un passo o aggiungiamo 3. Questo ha il valore di 13. Facciamo la stessa cosa per la prossima iterazione e otteniamo un valore di 16. Questo continuerebbe all’infinito ma, abbiamo aggiunto una pausa.
cycle()
itertools.cycle(iterable)
Questa funzione fa un ciclo attraverso un iteratore all’infinito.
Codice
colors = for color in itertools.cycle(colors):
print(color)
Nel codice precedente, creiamo una lista. Poi facciamo un ciclo o un loop attraverso questa lista all’infinito. Normalmente, un for ciclo passa attraverso un iterabile fino alla fine. Se una lista ha 3 elementi, il ciclo itererà 3 volte. Ma non se usiamo la funzione cycle(). Con questa funzione, quando raggiungiamo la fine dell’iterabile ricominciamo dall’inizio.
Output
red
orange
yellow
green
blue
indigo
violet
red
orange
yellow
green
...
Ho troncato l’output infinito sopra con delle ellissi.
catena()
itertools.chain(*iterables)
Questa funzione prende una serie di iterabili e li restituisce come un iterabile lungo.
Codice
colors =
shapes = result = itertools.chain(colors, shapes)
for each in result:
print(each)
Output
red
orange
yellow
green
blue
circle
triangle
square
pentagon
compress()
itertools.compress(data, selectors)
Questa funzione filtra un iterabile con un altro.
Codice
shapes =
selections = result = itertools.compress(shapes, selections)
for each in result:
print(each)
Output
circle
square
dropwhile()
itertools.dropwhile(predicate, iterable)
Crea un iteratore che lascia cadere elementi dall’iterabile finché il predicato è vero; dopo, restituisce ogni elemento.
Codice
data = result = itertools.dropwhile(lambda x: x<5, data)
for each in result:
print(each)
Output
5
6
7
8
9
10
1
Ok. Questo può confondere. Il codice dice di far cadere ogni elemento mentre l’elemento è inferiore a 5. Dopo che incontra un elemento che non è inferiore a 5, restituisce il resto. Ecco perché viene restituito l’ultimo.
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)
Questa funzione crea un iteratore che filtra gli elementi dall’iterabile restituendo solo quelli per cui il predicato è False.
Codice
data =
result = itertools.filterfalse(lambda x: x<5, data)
for each in result:
print(each)
Output
5
6
7
8
9
10
Step Through It
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)
In poche parole, questa funzione raggruppa le cose. Ok. Questo è complicato. E l’esempio è un po’ lungo.
Codice
robots = for key, group in itertools.groupby(bots, key=lambda x: x):
print(key)
print(list(group))
Output
autobot
decepticon
islice()
itertools.islice(iterable, start, stop)
Questa funzione è molto simile a slices. Questa funzione vi permette di tagliare un pezzo di un iterabile.
Codice
colors =
few_colors = itertools.islice(colors, 2)
for each in few_colors:
print(each)
Output
red
orange
permutazioni()
itertools.permutations(iterable, r=None)
Codice
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')
prodotto()
Questa funzione crea i prodotti cartesiani da una serie di iterabili.
Codice
num_data =
alpha_data = result = itertools.product(num_data, alpha_data)
for each in result:
print(each)
Output
(1, 'a')
(1, 'b')
(1, 'c')
(2, 'a')
(2, 'b')
(2, 'c')
(3, 'a')
(3, 'b')
(3, 'c')
Immaginate una tabella come questa:
a b c
1 a1 b1 c1
2 a2 b2 c3
3 a3 b3 b3
repeat()
itertools.repeat(object)
Questa funzione ripeterà un oggetto più e più volte. A meno che non ci sia un argomento times.
Codice
for i in itertools.repeat("spam"):
print(i)
Nel codice sopra, creiamo un iterable che ripete semplicemente spam più e più volte. Lo farà all’infinito. Ecco come si crea un spam infinito.
Output
spam
spam
spam
spam
spam
spam
...
Ho troncato l’output infinito sopra con delle ellissi.
Codice
for i in itertools.repeat("spam", 3):
print(i)
Se usiamo l’argomento times, possiamo limitare il numero di volte che si ripeterà.
Output
spam
spam
spam
In questo esempio spam ripete solo tre volte.
starmap()
itertools.starmap(function, iterable)
Questa funzione crea un iteratore che calcola la funzione utilizzando gli argomenti ottenuti dall’iterabile. Diamo un’occhiata.
Codice
data =
result = itertools.starmap(operator.mul, data)
for each in result:
print(each)
Output
12
32
21
Step Through
operator.mul(2, 6)
12
operator.mul(8, 4)
32
operator.mul(7, 3)
21
takewhile()
itertools.takwwhile(predicate, iterable)
Questo è un po’ il contrario di dropwhile(). Questa funzione crea un iteratore e restituisce elementi dall’iterabile se il predicato è vero.
Codice
data = result = itertools.takewhile(lambda x: x<5, data)
for each in result:
print(each)
Output
1
2
3
4
Step Through It
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)
Ritorna n iteratori indipendenti da un singolo iterabile.
Codice
colors =
alpha_colors, beta_colors = itertools.tee(colors)for each in alpha_colors:
print(each)print('..')for each in beta_colors:
print(each)
Il valore predefinito è 2, ma potete crearne quanti ne volete.
Output
red
orange
yellow
green
blue
..
red
orange
yellow
green
blue
zip_longest()
itertools.zip_longest(*iterables, fillvalue=None)
Questa funzione crea un iteratore che aggrega elementi da ciascuna delle iterabili. Se le iterabili sono di lunghezza disuguale, i valori mancanti sono riempiti con fillvalue. L’iterazione continua fino ad esaurire l’iterabile più lungo.
Codice
colors =
data = for each in itertools.zip_longest(colors, data, fillvalue=None):
print(each)
Output
('red', 1)
('orange', 2)
('yellow', 3)
('green', 4)
('blue', 5)
(None, 6)
(None, 7)
(None, 8)
(None, 9)
(None, 10)