accumulate()
itertools.accumulate(iterable)
Cette fonction fabrique un itérateur qui renvoie les résultats d’une fonction. Les fonctions peuvent être transmises de manière très similaire aux variables. La fonction accumulate() prend une fonction comme argument. Elle prend également un itérable. Elle renvoie les résultats accumulés. Les résultats sont eux-mêmes contenus dans un itérable. Tout cela peut sembler très déroutant. Je vous assure que, lorsque vous jouerez avec le code, cela aura du sens.
Code
data = result = itertools.accumulate(data, operator.mul)
for each in result:
print(each)
Sortie
1
2
6
24
120
L’opérateur.mul prend deux nombres et les multiplie.
operator.mul(1, 2)
2
operator.mul(2, 3)
6
operator.mul(6, 4)
24
operator.mul(24, 5)
120
Dans ce prochain exemple, nous utiliserons la fonction max.
Code
data = result = itertools.accumulate(data, max)
for each in result:
print(each)
Sortie
5
5
6
6
6
9
9
La fonction max renvoie le plus grand élément.
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
Passer une fonction est facultatif.
Code
data = result = itertools.accumulate(data)
for each in result:
print(each)
Sortie
5
7
13
17
22
31
32
Si aucune fonction n’est désignée, les éléments seront additionnés.
5
5 + 2 = 7
7 + 6 = 13
13 + 4 = 17
17 + 5 = 22
22 + 9 = 31
31 + 1 = 32
combinaisons()
itertools.combinations(iterable, r)
Cette fonction prend un itérable et un entier. Elle va créer toutes les combinaisons uniques qui ont r membres.
Code
shapes = result = itertools.combinations(shapes, 2)for each in result:
print(each)
Dans ce code, nous faisons toutes les combinaisons avec 2 membres.
Sortie
('circle', 'triangle')
('circle', 'square')
('triangle', 'square')
Code
shapes = result = itertools.combinations(shapes, 3)for each in result:
print(each)
Dans ce code, nous faisons tous les combos avec 3membres. C’est un peu moins excitant.
Sortie
('circle', 'triangle', 'square')
combinaisons_with_replacement()
itertools.combinations_with_replacement(iterable, r)
Ceci est comme la fonction combinations(), mais celle-ci permet de répéter des éléments individuels plusieurs fois.
Code
shapes = result = itertools.combinations_with_replacement(shapes, 2)
for each in result:
print(each)
Sortie
('circle', 'circle')
('circle', 'triangle')
('circle', 'square')
('triangle', 'triangle')
('triangle', 'square')
('square', 'square')
count()
itertools.count(start=0, step=1)
Fait un itérateur qui renvoie des valeurs régulièrement espacées en commençant par le nombre start.
Code
for i in itertools.count(10,3):
print(i)
if i > 20:
break
Dans le code ci-dessus, nous itérons ou bouclons sur une fonction. Nous disons à la fonction de commencer à 10 et de faire un pas de 3.
Sortie
10
13
16
19
22
Cette première itération a la valeur 10. À l’étape suivante, nous faisons un pas ou ajoutons 3, ce qui a la valeur de 13. Nous faisons la même chose pour l’itération suivante et obtenons une valeur de 16. Cela continuerait indéfiniment mais, nous avons ajouté une pause.
cycle()
itertools.cycle(iterable)
Cette fonction effectue un cycle dans un itérateur sans fin.
Code
colors = for color in itertools.cycle(colors):
print(color)
Dans le code ci-dessus, nous créons une liste. Ensuite, nous effectuons un cycle ou une boucle à travers cette liste sans fin. Normalement, une for boucle parcourt un itérable jusqu’à ce qu’elle atteigne la fin. Si une liste a 3 éléments, la boucle itérera 3 fois. Mais pas si nous utilisons la fonction cycle(). Avec cette fonction, lorsque nous atteignons la fin de l’itérable, nous recommençons depuis le début.
Sortie
red
orange
yellow
green
blue
indigo
violet
red
orange
yellow
green
...
J’ai tronqué la sortie sans fin ci-dessus avec des ellipses.
Chaîne()
itertools.chain(*iterables)
Cette fonction prend une série d’itérables et les renvoie comme un seul long itérable.
Code
colors =
shapes = result = itertools.chain(colors, shapes)
for each in result:
print(each)
Sortie
red
orange
yellow
green
blue
circle
triangle
square
pentagon
compresser()
itertools.compress(data, selectors)
Cette fonction filtre un itérable avec un autre.
Code
shapes =
selections = result = itertools.compress(shapes, selections)
for each in result:
print(each)
Sortie
circle
square
dropwhile()
itertools.dropwhile(predicate, iterable)
Faire un itérateur qui laisse tomber les éléments de l’itérable tant que le prédicat est vrai ; après, renvoie tous les éléments.
Code
data = result = itertools.dropwhile(lambda x: x<5, data)
for each in result:
print(each)
Sortie
5
6
7
8
9
10
1
Ok. Cela peut prêter à confusion. Le code dit de laisser tomber chaque élément tant que l’élément est inférieur à 5. Après avoir rencontré un élément qui n’est pas inférieur à 5, il renvoie le reste. C’est pourquoi ce dernier est renvoyé.
Code
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)
Cette fonction fabrique un itérateur qui filtre les éléments de l’itérable en renvoyant uniquement ceux pour lesquels le prédicat est False.
Code
data =
result = itertools.filterfalse(lambda x: x<5, data)
for each in result:
print(each)
Sortie
5
6
7
8
9
10
Code
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)
Simplement dit, cette fonction regroupe les choses ensemble. Ok. Celle-ci est compliquée. Et l’exemple est un peu long.
Code
robots = for key, group in itertools.groupby(bots, key=lambda x: x):
print(key)
print(list(group))
Sortie
autobot
decepticon
islice()
itertools.islice(iterable, start, stop)
Cette fonction ressemble beaucoup aux tranches. Cette fonction vous permet de découper un morceau d’un itérable.
Code
colors =
few_colors = itertools.islice(colors, 2)
for each in few_colors:
print(each)
Sortie
red
orange
permutations()
itertools.permutations(iterable, r=None)
Code
alpha_data = result = itertools.permutations(alpha_data)
for each in result:
print(each)
Sortie
('a', 'b', 'c')
('a', 'c', 'b')
('b', 'a', 'c')
('b', 'c', 'a')
('c', 'a', 'b')
('c', 'b', 'a')
produit()
Cette fonction crée les produits cartésiens à partir d’une série d’itérables.
Code
num_data =
alpha_data = result = itertools.product(num_data, alpha_data)
for each in result:
print(each)
Sortie
(1, 'a')
(1, 'b')
(1, 'c')
(2, 'a')
(2, 'b')
(2, 'c')
(3, 'a')
(3, 'b')
(3, 'c')
Imaginez un tableau comme celui-ci :
a b c
1 a1 b1 c1
2 a2 b2 c3
3 a3 b3 b3
repeat()
itertools.repeat(object)
Cette fonction va répéter un objet encore et encore. Sauf si, il y a un times argument.
Code
for i in itertools.repeat("spam"):
print(i)
Dans le code ci-dessus, nous créons une itérable qui ne fait que répéter spam encore et encore. Il le fera à l’infini. C’est ainsi que l’on fabrique des spam infinis.
Sortie
spam
spam
spam
spam
spam
spam
...
J’ai tronqué la sortie sans fin ci-dessus avec des ellipses.
Code
for i in itertools.repeat("spam", 3):
print(i)
Si nous utilisons l’argument times, nous pouvons limiter le nombre de répétitions.
Sortie
spam
spam
spam
Dans cet exemple, spam ne se répète que trois fois.
starmap()
itertools.starmap(function, iterable)
Cette fonction fabrique un itérateur qui calcule la fonction en utilisant les arguments obtenus de l’itérable. Jetons un coup d’œil.
Code
data =
result = itertools.starmap(operator.mul, data)
for each in result:
print(each)
Sortie
12
32
21
Etape par étape
operator.mul(2, 6)
12
operator.mul(8, 4)
32
operator.mul(7, 3)
21
takewhile()
itertools.takwwhile(predicate, iterable)
C’est un peu le contraire de dropwhile(). Cette fonction fabrique un itérateur et renvoie les éléments de l’itérable tant que le prédicat est vrai.
Code
data = result = itertools.takewhile(lambda x: x<5, data)
for each in result:
print(each)
Sortie
1
2
3
4
Code
data = result = itertools.takewhile(lambda x: x<5, data)
for each in result:
print(each)
Code
1
2
3
4
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)
Retourner n itérateurs indépendants à partir d’un seul itérable.
Code
colors =
alpha_colors, beta_colors = itertools.tee(colors)for each in alpha_colors:
print(each)print('..')for each in beta_colors:
print(each)
La valeur par défaut est 2, mais vous pouvez en faire autant que nécessaire.
Sortie
red
orange
yellow
green
blue
..
red
orange
yellow
green
blue
zip_longest()
itertools.zip_longest(*iterables, fillvalue=None)
Cette fonction fabrique un itérateur qui agrège les éléments de chacun des itérables. Si les itérables sont de longueur inégale, les valeurs manquantes sont remplies avec fillvalue. L’itération continue jusqu’à ce que l’itérable le plus long soit épuisé.
Code
colors =
data = for each in itertools.zip_longest(colors, data, fillvalue=None):
print(each)
Sortie
('red', 1)
('orange', 2)
('yellow', 3)
('green', 4)
('blue', 5)
(None, 6)
(None, 7)
(None, 8)
(None, 9)
(None, 10)
.