Que sont les fonctions Python Itertools ?

Selon la documentation de Python, Itertools est un module Python qui fournit un ensemble d'outils rapides et économes en mémoire pour travailler avec les itérateurs Python. Ces outils peuvent être utilisés seuls ou en combinaison, et ils permettent de créer et de travailler de manière succincte et efficace avec des itérateurs de manière rapide et économe en mémoire.

Le module Itertools contient des fonctions qui facilitent le travail avec les itérateurs, en particulier lors de la manipulation de grands ensembles de données. Les fonctions Itertools peuvent fonctionner sur des itérateurs existants pour créer des itérateurs Python encore plus complexes.

De plus, Itertools peut aider les développeurs à réduire les erreurs lorsqu'ils travaillent avec des itérateurs et à écrire un code plus propre, lisible et maintenable.

Types of Iterators in Python Itertools

En fonction des fonctionnalités fournies par les itérateurs du module Itertools, ils peuvent être classés dans les types suivants :

# 1. Itérateurs infinis

Ce sont des itérateurs qui vous permettent de travailler avec des séquences infinies et d'exécuter une boucle à l'infini s'il n'y a pas de condition pour sortir de la boucle. De tels itérateurs sont utiles lors de la simulation de boucles infinies ou de la génération d'une séquence illimitée. Itertools a trois itérateurs infinis, qui incluent compter(), cycle(), et répéter().

# 2. Itérateurs combinatoires

Les itérateurs combinatoires comprennent des fonctions qui peuvent être utilisées pour travailler sur des produits cartésiens et effectuer des combinaisons et des permutations d'éléments contenus dans un itérable. Ce sont les fonctions incontournables lorsque vous essayez de trouver toutes les manières possibles d'organiser ou de combiner des éléments dans un itérable. Itertools dispose de quatre itérateurs combinatoires. Ceux-ci sont produit(), permutations(), combinaisons() et combinaisons_avec_remplacement().

# 3. Itérateurs se terminant sur la séquence d'entrée la plus courte

Ce sont des itérateurs de terminaison qui sont utilisés sur des séquences finies et génèrent une sortie basée sur le type de fonction utilisée. Voici des exemples de ces itérateurs de fin : accumulate(), chain(), chain.from_iterable(), compress(), dropwhile(), filterfalse(), groupby(), islice(), pairwise(), starmap(), takewhile(), tee()et au zip_longest().

Voyons comment fonctionnent les différentes fonctions d'Itertools selon leur type :

Infinite Iterators

Les trois itérateurs infinis incluent :

# 1. count ()

La fonction count(start, step) génère une séquence infinie de nombres à partir de la valeur de départ. La fonction prend deux arguments optionnels : Commencez et étape. L'argument Commencez définit où la séquence de nombres doit commencer. Par défaut, il commence à 0 si aucune valeur de départ n'est fournie. étape définit la différence entre chaque nombre consécutif. La valeur de pas par défaut est 1.

import itertools
# count starting at 4, making steps of 2  
for i in itertools.count(4, 2):
    # condition to end the loop avoiding infinite looping
    if i == 14:
        break
    else:
        print(i) # output - 4, 6, 8, 10, 12

Sortie

4
6
8
10
12

# 2. faire du vélo()

La fonction cycle(itérable) prend un itérable comme argument, puis parcourt l'itérable permettant l'accès aux éléments de l'itérable dans l'ordre dans lequel ils apparaissent.

Par exemple, si on passe de ["rouge", "vert", "jaune"] à faire du vélo(), au premier cycle, nous aurons accès au « rouge » ; au deuxième cycle nous aurons accès au « vert », puis au « jaune ». Au quatrième cycle, puisque tous les éléments ont été épuisés dans l'itérable, on recommencera à « red » puis on continuera indéfiniment.

Lorsque vous appelez cycle(), vous stockez son résultat dans une variable pour créer un itérateur qui maintient son état. Cela garantit que le cycle ne recommence pas à chaque fois, vous donnant accès uniquement au premier élément.

import itertools

colors = ["red", "green", "yellow"]
# pass in colors into cycle()
color_cycle = itertools.cycle(colors)
print(color_cycle)

# range used to stop the infinite loop once we've printed 7 times
# next() used to return the next item from the iterator
for i in range(7):
    print(next(color_cycle))

Sortie :

red
green
yellow
red
green
yellow
red

# 3. répéter()

repeat(elem,n) prend deux arguments, un élément à répéter (douleur), et le nombre de fois que vous souhaitez répéter l'élément (n). L'élément que vous souhaitez répéter peut être une valeur unique ou un itérable. Si vous ne passez pas, n, l'élément sera répété à l'infini.

import itertools
   
for i in itertools.repeat(10, 3):
    print(i)

Sortie :

10 
10
10

Combinatoric Iterators

Les itérateurs combinatoires incluent :

# 1. produit()

product() est une fonction utilisée pour calculer le produit cartésien de l'itérable qui lui est passé. Si nous avons deux itérables ou ensembles, par exemple, x = {7,8} et y = {1,2,3}, le produit cartésien de x et y contiendra toutes les combinaisons possibles d'éléments de x et y, où le le premier élément vient de x et le second de y. Le produit cartésien de x et y dans ce cas est [(7, 1), (7, 2), (7, 3), (8, 1), (8, 2), (8, 3)].

product() prend un paramètre optionnel appelé répéter qui est utilisé pour calculer le produit cartésien d'un itérable avec lui-même. répéter spécifie le nombre de répétitions pour chaque élément à partir des itérables d'entrée lors du calcul du produit cartésien.

Par exemple, appeler product('ABCD', repeat=2) donne des combinaisons telles que ('A', 'A'), ('A', 'B'), ('A', 'C'), etc. sur. Si la répétition était définie sur 3, la fonction produirait des combinaisons telles que ('A', 'A', 'A'), ('A', 'A', 'B'), ('A', 'A' , 'C'), ('A', 'A', 'D') et ainsi de suite.

from itertools import product
# product() with the optional repeat argument
print("product() with the optional repeat argument ")
print(list(product('ABC', repeat = 2)))

# product with no repeat
print("product() WITHOUT an optional repeat argument")
print(list(product([7,8], [1,2,3])))

Sortie

product() with the optional repeat argument 
[('A', 'A'), ('A', 'B'), ('A', 'C'), ('B', 'A'), ('B', 'B'), ('B', 'C'), ('C', 'A'), ('C', 'B'), ('C', 'C')]
product() WITHOUT an optional repeat argument
[(7, 1), (7, 2), (7, 3), (8, 1), (8, 2), (8, 3)]

# 2. permutations()

permutations(iterable, group_size) renvoie toutes les permutations possibles de l'itérable qui lui est passé. Une permutation représente le nombre de façons dont les éléments d'un ensemble peuvent être ordonnés. permutations() prend un argument optionnel Taille de groupe. Si Taille de groupe n'est pas spécifié, les permutations générées auront la même taille que la longueur de l'itérable passé à la fonction

import itertools
numbers = [1, 2, 3]
sized_permutations = list(itertools.permutations(numbers,2))
unsized_permuatations = list(itertools.permutations(numbers))

print("Permutations with a size of 2")
print(sized_permutations)
print("Permutations with NO size argument")
print(unsized_permuatations)

Sortie

Permutations with a group size of 2
[(1, 2), (1, 3), (2, 1), (2, 3), (3, 1), (3, 2)]
Permutations with NO size argument
[(1, 2, 3), (1, 3, 2), (2, 1, 3), (2, 3, 1), (3, 1, 2), (3, 2, 1)]

# 3. combinaisons ()

combinations(iterable, size) renvoie toutes les combinaisons possibles d'un itérable d'une longueur donnée à partir des éléments de l'itérable transmis à la fonction. Le taille L'argument spécifie la taille de chaque combinaison.

Les résultats sont ordonnés. La combinaison diffère légèrement des permutations. Avec la permutation, l'ordre compte, mais avec la combinaison, l'ordre n'a pas d'importance. Par exemple, dans [A, B, C] il y a 6 permutations : AB, AC, BA, BC, CA, CB mais seulement 3 combinaisons AB, AC, BC.

import itertools
numbers = [1, 2, 3,4]
size2_combination = list(itertools.combinations(numbers,2))
size3_combination = list(itertools.combinations(numbers, 3))

print("Combinations with a size of 2")
print(size2_combination)
print("Combinations with a size of 3")
print(size3_combination)

Sortie :

Combinations with a size of 2
[(1, 2), (1, 3), (1, 4), (2, 3), (2, 4), (3, 4)]
Combinations with a size of 3
[(1, 2, 3), (1, 2, 4), (1, 3, 4), (2, 3, 4)]

# 4. combinaisons_avec_remplacement()

combinations_with_replacement(iterable, size) génère toutes les combinaisons possibles d'un itérable d'une longueur donnée à partir de l'itérable transmis à la fonction et autorise les éléments répétés dans les combinaisons de sortie. Le taille détermine la taille des combinaisons générées.

Cette fonction diffère de combinaisons () en ce qu' il donne des combinaisons où un élément peut être répété plus d'une fois. Par exemple, vous pouvez obtenir une combinaison telle que (1,1) que vous ne pouvez pas obtenir avec combinaison().

import itertools
numbers = [1, 2, 3,4]

size2_combination = list(itertools.combinations_with_replacement(numbers,2))
print("Combinations_with_replacement => size 2")
print(size2_combination)

Sortie

Combinations_with_replacement => size 2
[(1, 1), (1, 2), (1, 3), (1, 4), (2, 2), (2, 3), (2, 4), (3, 3), (3, 4), (4, 4)]

Terminating iterators

Cela inclut des itérateurs tels que :

# 1. accumuler()

accumulate(itérable, fonction) prend un itérable et un deuxième argument optionnel qui est une fonction. Il renvoie ensuite le résultat cumulé de l'application de la fonction à chaque itération sur les éléments de l'itérable. Si aucune fonction n'est transmise, l'addition est effectuée et les résultats cumulés sont renvoyés.

import itertools
import operator
numbers = [1, 2, 3, 4, 5]

# Accumulate the sum of numbers
accumulated_val = itertools.accumulate(numbers)
accumulated_mul = itertools.accumulate(numbers, operator.mul)
print("Accumulate with no function")
print(list(accumulated_val))
print("Accumulate with multiplication")
print(list(accumulated_mul))

Sortie :

Accumulate with no function
[1, 3, 6, 10, 15]
Accumulate with multiplication
[1, 2, 6, 24, 120]

# 2. chaîne()

chain(iterable_1, iterable_2, …) prend plusieurs itérables et les enchaîne en produisant un seul itérable contenant les valeurs des itérables passés à la fonction chain()

import itertools

letters = ['A', 'B', 'C', 'D']
numbers = [1, 2, 3]
colors = ['red', 'green', 'yellow']

# Chain letters and numbers together
chained_iterable = list(itertools.chain(letters, numbers, colors))
print(chained_iterable)

Sortie :

['A', 'B', 'C', 'D', 1, 2, 3, 'red', 'green', 'yellow']

# 3. chain.from_iterable()

chain.from_iterable(iterable) cette fonction est similaire à chain(). Cependant, il diffère de la chaîne en ce qu'il ne prend qu'un seul itérable contenant des sous-itérables et les enchaîne.

import itertools

letters = ['A', 'B', 'C', 'D']
numbers = [1, 2, 3]
colors = ['red', 'green', 'yellow']

iterable = ['hello',colors, letters, numbers]
chain = list(itertools.chain.from_iterable(iterable))
print(chain)

Sortie :

['h', 'e', 'l', 'l', 'o', 'red', 'green', 'yellow', 'A', 'B', 'C', 'D', 1, 2, 3]

# 4. compresse()

compress(data, selectors) prend deux arguments, données qui est un itérable, et sélecteurs qui est un itérable contenant les valeurs booléennes true et false. 1, 0 peuvent également être utilisés comme alternatives aux valeurs booléennes true et false. compress() puis filtre le passé données en utilisant les éléments correspondants passés dans le sélecteur.

Valeurs dans données qui correspondent à la valeur véritable or 1 dans le sélecteur sont sélectionnés, tandis que le reste qui correspond à faux or 0 sont ignorés. Si vous passez moins de booléens dans sélecteurs que le nombre d'éléments dans données tous les éléments au-delà des booléens passés dans sélecteurs sont ignorés

import itertools

# data has 10 items
data = ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J']
# passing in 9 selector items
selectors = [True, False, 1, False, 0, 1, True, False, 1]

# Select elements from data based on selectors
filtered_data = list(itertools.compress(data, selectors))
print(filtered_data)

Sortie :

['A', 'C', 'F', 'G', 'I']

# 5. laisser tomber()

dropwhile(fonction, séquence) prend une fonction avec la condition qui renvoie vrai ou faux et une séquence de valeurs. Il supprime ensuite toutes les valeurs jusqu'à ce que la condition transmise renvoie False. Une fois que la condition renvoie false, les autres éléments sont inclus dans ses résultats, qu'ils renvoient True ou False.

import itertools

numbers = [1, 2, 3, 4, 5, 1, 6, 7, 2, 1, 8, 9, 0, 7]

# Drop elements until the passed condition is False
filtered_numbers = list(itertools.dropwhile(lambda x: x < 5, numbers))
print(filtered_numbers)

Sortie :

[5, 1, 6, 7, 2, 1, 8, 9, 0, 7]

# 6. filtrefaux()

filterfalse(fonction, séquence) prend une fonction, avec une condition qui évalue vrai ou faux et une séquence. Il renvoie ensuite les valeurs de la séquence qui ne satisfont pas la condition de la fonction. 

import itertools

numbers = [1, 2, 3, 4, 2, 3 5, 6, 5, 8, 1, 2, 3, 6, 2, 7, 4, 3]

# Filter elements for which condition is False
filtered_numbers = list(itertools.filterfalse(lambda x: x < 4, numbers))
print(filtered_numbers)

Sortie :

[4, 5, 6, 5, 8, 6, 7, 4]

# 7. par groupe()

groupby(iterable, key) prend un itérable et une clé, puis crée un itérateur qui renvoie des clés et des groupes consécutifs. Pour que cela fonctionne, l'itérable qui lui est transmis doit être trié sur la même fonction clé. La fonction clé computer une valeur clé pour chaque élément de l'itérable.

import itertools

input_list = [("Domestic", "Cow"), ("Domestic", "Dog"), ("Domestic", "Cat"),("Wild", "Lion"), ("Wild", "Zebra"), ("Wild", "Elephant")]
classification = itertools.groupby(input_list,lambda x: x[0])
for key,value in classification:
  print(key,":",list(value))

Sortie :

Domestic : [('Domestic', 'Cow'), ('Domestic', 'Dog'), ('Domestic', 'Cat')]
Wild : [('Wild', 'Lion'), ('Wild', 'Zebra'), ('Wild', 'Elephant')]

# 8. tranche()

islice(iterable, start, stop, step) vous permet de trancher un itérable en utilisant la commencer arrêter, et étape valeurs passées. L'argument étape est facultatif. Le comptage commence à partir de 0 et l'élément sur le Arrêtez le numéro n'est pas inclus.

import itertools

numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18]

# Select elements within a range
selected_numbers = list(itertools.islice(numbers, 2, 10))
selected_numbers_step= list(itertools.islice(numbers, 2, 10,2))
print("islice without setting a step value")
print(selected_numbers)
print("islice with a step value of 2")
print(selected_numbers_step)

Sortie :

islice without setting a step value
[3, 4, 5, 6, 7, 8, 9, 10]
islice with a step value of 2
[3, 5, 7, 9]

# 9. par paire()

pairwise(iterable) renvoie des paires superposées successives extraites de l'itérable qui lui est transmis dans l'ordre dans lequel elles apparaissent dans l'itérable. Si l'itérable qui lui est passé a moins de deux valeurs, le résultat de pairwise() sera vide.

from itertools import pairwise

numbers = [1, 2, 3, 4, 5, 6, 7, 8]
word = 'WORLD'
single = ['A']

print(list(pairwise(numbers)))
print(list(pairwise(word)))
print(list(pairwise(single)))

Sortie :

[(1, 2), (2, 3), (3, 4), (4, 5), (5, 6), (6, 7), (7, 8)]
[('W', 'O'), ('O', 'R'), ('R', 'L'), ('L', 'D')]
[]

# 10. carte des étoiles()

starmap(fonction, itérable) est une fonction utilisée à la place de map() lorsque les paramètres d'argument sont déjà regroupés en tuples. startmap() applique une fonction aux éléments de l'itérable qui lui sont passés. L'itérable doit avoir des éléments regroupés en tuples.

import itertools

iter_starmap = [(123, 63, 13), (5, 6, 52), (824, 51, 9), (26, 24, 16), (14, 15, 11)]
print (list(itertools.starmap(min, iter_starmap)))

Sortie :

[13, 5, 9, 16, 11]

# 11. prendre du temps()

takewhile(function, iterable) fonctionne à l'opposé de laisser tomber(). takewhile() prend une fonction avec une condition à évaluer et un itérable. Il inclut ensuite tous les éléments de l'itérable qui satisfont la condition dans la fonction jusqu'à ce que False soit renvoyé. Une fois que False est renvoyé, tous les éléments suivants de l'itérable sont ignorés.

import itertools

numbers = [1, 2, 3, 4, 5, 1, 6, 7, 2, 1, 8, 9, 0, 7]

# Drop elements until the passed condition is False
filtered_numbers = list(itertools.takewhile(lambda x: x < 5, numbers))
print(filtered_numbers)

Sortie :

[1, 2, 3, 4]

# 12. tee()

tee(itérable, n) prend un itérable et renvoie plusieurs itérateurs indépendants. Le nombre d'itérateurs à renvoyer est défini par n, qui par défaut est 2.

import itertools

numbers = [1, 2, 3, 4, 5]

# Create two independent iterators from numbers
iter1, iter2 = itertools.tee(numbers, 2)
print(list(iter1))
print(list(iter2))

Sortie :

[1, 2, 3, 4, 5]
[1, 2, 3, 4, 5]

# 13. zip_longest()

zip_longest(iterables, fillvalue) accepte plusieurs itérateurs et une valeur de remplissage. Il renvoie ensuite un itérateur qui agrège les éléments de chacun des itérateurs qui lui sont passés. Si les itérateurs ne sont pas de la même longueur, les valeurs manquantes sont remplacées par les valeur de remplissage passé à la fonction jusqu'à épuisement de l'itérable le plus long.

import itertools

names = ['John', 'mathew', 'mary', 'Alice', 'Bob', 'Charlie', 'Fury']
ages = [25, 30, 12, 13, 42]

# Combine name and ages, filling in missing ages with a dash
combined = itertools.zip_longest(names, ages, fillvalue="-")

for name, age in combined:
    print(name, age)

Sortie :

John 25
mathew 30
mary 12
Alice 13
Bob 42
Charlie -
Fury -

Conclusion

Les itertools Python sont un ensemble d'outils important pour un développeur Python. Les itertools Python sont largement utilisés dans programmation fonctionnelle, le traitement et la transformation des données, le filtrage et la sélection des données, le regroupement et l'agrégation, la combinaison d'itérables, la combinatoire et le travail avec des séquences infinies.

En tant que développeur Python, vous bénéficierez grandement de l'apprentissage des itertools, alors assurez-vous d'utiliser cet article pour vous familiariser avec Python Itertools.