Itertools est un module Python courant, mais que savez-vous de lui ? Découvrez-le en explorant certaines des fonctions les plus utiles du module.

Itertools est l’un des modules les plus utiles de Python. Ses fonctions facilitent l’utilisation des listes et des tableaux. Que vous ayez besoin de toutes les permutations des valeurs d’un tableau ou que vous souhaitiez regrouper les caractères d’une chaîne, Itertools peut vous aider.

L’écriture du code pour ces cas courants peut être fastidieuse et source d’erreurs. C’est pourquoi les développeurs ont créé des bibliothèques qui font tout cela pour vous. Vous pouvez utiliser ces fonctions en important Itertools. Dans cet article, vous allez découvrir le module Itertools de Python et ses fonctions.

Qu’est-ce que le module Itertools ?

La documentation officielle de Python explique qu’Itertools contient du code pour construire des itérateurs. Ce module fournit des fonctions rapides et efficaces pour travailler avec des listes et des tableaux.

Avant d’utiliser ce module, vous devez l’importer en utilisant la syntaxe suivante :

import itertools

Il existe trois types d’itérateurs différents dans ce module.

Les itérateurs infinis
Itérateurs combinatoires
Itérateurs terminaux

Itérateurs infinis

Les itérateurs infinis peuvent exécuter une boucle à l’infini. Ces fonctions s’exécutent plus souvent à l’aide d’une boucle for. Il existe trois itérateurs infinis.

count(start, step)

La fonction count() prend deux paramètres : le début et le pas. La boucle commence à partir de la valeur de départ et renvoie des valeurs qui s’incrémentent par pas, qui est par défaut de 1. Prenons l’exemple ci-dessous : la boucle part de 2 et ajoute 2 à chaque fois. La boucle s’interrompt lorsque la valeur de i devient 10.

for i in itertools.count(2,2) :
si i == 10 :
break
autre :
print(i, end= » « )

Sortie :

2 4 6 8

repeat(nombre, timesToRepeat)

La fonction repeat() accepte deux paramètres. Le premier est une valeur que la fonction produit de manière répétée. Le second paramètre est le nombre de fois que le nombre doit être répété. Si vous ne spécifiez pas le second paramètre, la boucle se déroulera à l’infini.

for i in itertools.repeat(2,5) :
print(i, end= » « )

Sortie :

2 2 2 2 2

cycle(entrée)

La fonction cycle() itère à travers l’entrée et imprime les éléments individuels dans un ordre donné. Lorsqu’elle atteint la fin de son entrée, cycle recommence depuis le début.

c = 0
var = « 12345
for i in itertools.cycle(var) :
si c == 12 :
break
autre :
c = c + 1
print(i, end= » « )

Sortie :

1 2 3 4 5 1 2 3 4 5 1 2

Itérateurs combinatoires

Les itérateurs combinatoires fournissent des fonctions pour effectuer des permutations, des combinaisons et des produits cartésiens.

product(entrée)

La fonction product() calcule le produit cartésien de l’entrée spécifiée. Elle possède un paramètre de répétition qui calcule le produit cartésien d’un itérateur avec lui-même. Il s’agit d’un paramètre facultatif.

tableau = [1,2,3]
print(list(itertools.product(array, repeat=2)))
chaîne = « ABC
print(list(itertools.product(string, « XYZ »)))

Sortie :

Exemple 1 [(1, 1), (1, 2), (1, 3), (2, 1), (2, 2), (2, 3), (3, 1), (3, 2), (3, 3)]
Exemple 2 [(‘A’, ‘X’), (‘A’, ‘Y’), (‘A’, ‘Z’), (‘B’, ‘X’), (‘B’, ‘Y’), (‘B’, ‘Z’), (‘C’, ‘X’), (‘C’, ‘Y’), (‘C’, ‘Z’)]

permutations(entrée, taille)

Cette fonction retourne un tuple de toutes les permutations de l’itérable donné. Elle accepte deux paramètres : l’itérable et la taille du groupe. Si la taille du groupe n’est pas spécifiée, elle formera des groupes de la même longueur que l’itérable lui-même.

arr = [1,2,3,4]
print(list(itertools.permutations(arr, 2)))

Sortie :

[(1, 2), (1, 3), (1, 4), (2, 1), (2, 3), (2, 4), (3, 1), (3, 2), (3, 4), (4, 1), (4, 2), (4, 3)]

combinaisons(entrée, longueur)

La fonction combinations() permet de calculer les combinaisons de l’itérateur donné. Notez que cette fonction conserve l’ordre des éléments de son entrée. Alors que les permutations incluent des valeurs qui ne diffèrent que par l’ordre, les combinaisons produisent des valeurs uniques.

arr = [1,2,3,4]
print(list(itertools.combinations(arr, 3)))

Sortie :

[(1, 2, 3), (1, 2, 4), (1, 3, 4), (2, 3, 4)]

Itérateurs de terminaison

Les itérateurs de fin produisent une sortie basée sur les conditions données à l’entrée. Vous pouvez mieux le comprendre à partir de quelques exemples de fonctions.

accumuler(entrée, opérateur)

La fonction accumulate() accepte deux arguments : l’itérable et un opérateur. Elle produit un résultat en appliquant l’opérateur à un total cumulé et à chaque élément d’entrée tour à tour. L’opérateur est un argument facultatif. Si vous ne le passez pas, cette fonction effectuera une addition.

import operator
arr = [1,2,3,4]
print(list(itertools.accumulate(arr))
print(liste(itertools.accumulate(arr, operator.sub)))

Sortie :

[1, 3, 6, 10]
[1, -1, -4, -8]

starmap(fonction, entrée)

La fonction starmap() accepte une fonction et une liste de tuple comme arguments. Elle calcule les valeurs de retour en appliquant la fonction à chaque tuple de l’entrée. Dans l’exemple donné, cette fonction va calculer la valeur maximale de chaque tuple et la retourner dans un tableau.

arr = [(1,2,3), (4,5,6), (7,8,9)]
print(list(itertools.starmap(max, arr)))

Sortie :

[3, 6, 9]

filterfalse(fonction)

La fonction filterfalse() renvoie les valeurs qui ne remplissent pas la condition de la fonction passée. Le code donné ci-dessous supprime toutes les valeurs impaires.

arr = [1,2,3,4]
print(list(itertools.filterfalse(lambda x : x % 2 != 0, arr)))

Sortie :

[2, 4]

Continuez votre voyage de codage Python

Maintenant que vous avez appris à connaître le module Itertools, il est temps d’explorer d’autres modules Python. Python dispose de modules et de bibliothèques pour un large éventail de tâches. Ils comprennent des concepts avancés comme la transformation de Fourier et des applications AI/ML.

Certains modules sont plus compliqués que d’autres et leur apprentissage sera plus long. Le module Tkinter vous permet de construire des applications GUI complètes en Python.