La fonction zip() en Python

En Python et dans tous les langages de programmation, nous pouvons utiliser les boucles for et while pour parcourir les tableaux. L’itération sur un seul tableau est très simple. Cependant, lorsqu’il s’agit d’itérer sur plusieurs tableaux ensemble, les choses commencent à devenir complexes. Si la taille de tous les tableaux est la même, alors c’est un travail simple. Mais si les tailles de tableau sont différentes, nous devons nous assurer que nous ne considérons que la longueur du plus petit tableau pour éviter les erreurs et les exceptions.

Python rend cette tâche beaucoup plus facile. Au lieu d’écrire manuellement la logique pour itérer sur des tableaux de différentes tailles, nous pouvons utiliser un utilitaire intégré, plus précisément une fonction, fournie par Python. Cette fonction est la fonction zip().

Cet article présentera la fonction zip() et comment l’utiliser.

La fonction zip() en Python

La fonction zip() accepte des objets itérables tels que des listes, des chaînes et des tuples comme arguments et renvoie un seul itérable.

L’objet itérable retourné a la longueur des plus petits itérables. Par exemple, si deux listes de taille 5 et 10 sont fournies à la fonction zip(), l’objet itérable retourné aura une longueur de 5. Cela signifie que seuls les premiers éléments 5 de la deuxième liste feront partie de l’objet itérable. Si un itérable vide ou aucun objet itérable est donné à cette fonction, elle renvoie également un itérable vide.

Maintenant que nous en avons fini avec la théorie, voyons comment utiliser cette fonction. Reportez-vous aux exemples suivants pour comprendre son utilisation.

Aucun objet itérable

Dans le code Python suivant, aucun objet itérable ne sera passé à la fonction zip().

result = zip()

for x in result:
    print(x)

Rien ne sera imprimé sur la console lorsque nous exécuterons le code ci-dessus. La raison derrière la même chose est simple; si aucun objet itérable n’était fourni, nous n’aurions rien à itérer. Par conséquent, un objet itérable vide est renvoyé.

Objets itérables de même longueur

Dans le code Python suivant, un tuple d’entiers, une liste de valeurs flottantes, une liste d’objets de classe et une chaîne de longueurs égales seront passés à la fonction zip().

class Number:
    def __init__(self, number):
        self.number = number

    def square(self):
        return number ** 2

    def __repr__(self):
        return f"Number({self.number})"


a = (11, 22, 33, 44, 55)
b = [1.1, 2.2, 3.3, 4.4, 5.5]
c = [Number(1), Number(23), Number(44.44), Number(0), Number(-9)]
d = "Hello"
result = zip(a, b, c, d)

for x in result:
    print(x)

Production :

(11, 1.1, Number(1), 'H')
(22, 2.2, Number(23), 'e')
(33, 3.3, Number(44.44), 'l')
(44, 4.4, Number(0), 'l')
(55, 5.5, Number(-9), 'o')

Comme nous pouvons le voir, la fonction zip() stocke les valeurs de tous les objets itérables ensemble dans des tuples. L’ordre des valeurs à l’intérieur des tuples est le même que l’ordre dans lequel leurs objets itérables ont été fournis à la fonction zip().

Nous pouvons déstructurer ou décompresser ces valeurs dans la boucle for pour un accès facile. Reportez-vous au code suivant pour la même chose.

class Number:
    def __init__(self, number):
        self.number = number

    def square(self):
        return number ** 2

    def __repr__(self):
        return f"Number({self.number})"


a = (11, 22, 33, 44, 55)
b = [1.1, 2.2, 3.3, 4.4, 5.5]
c = [Number(1), Number(23), Number(44.44), Number(0), Number(-9)]
d = "Hello"
result = zip(a, b, c, d)

for p, q, r, s in result:
    print("A:", p)
    print("B:", q)
    print("C:", r)
    print("D:", s)

Production :

A: 11
B: 1.1
C: Number(1)
D: H
A: 22
B: 2.2
C: Number(23)
D: e
A: 33
B: 3.3
C: Number(44.44)
D: l
A: 44
B: 4.4
C: Number(0)
D: l
A: 55
B: 5.5
C: Number(-9)
D: o

Au lieu d’utiliser des boucles for, nous pouvons également itérer sur un objet itérable en utilisant une boucle while. Avec les boucles while, nous aurions besoin de deux choses supplémentaires, la fonction next() et un bloc try-except. La fonction next() sera utilisée pour extraire les valeurs de l’objet itérable renvoyé par la fonction zip(), et le bloc try...except sera utilisé pour arrêter l’itération. Reportez-vous au code Python suivant pour la même chose.

class Number:
    def __init__(self, number):
        self.number = number

    def square(self):
        return number ** 2

    def __repr__(self):
        return f"Number({self.number})"


a = (11, 22, 33, 44, 55)
b = [1.1, 2.2, 3.3, 4.4, 5.5]
c = [Number(1), Number(23), Number(44.44), Number(0), Number(-9)]
d = "Hello"
result = zip(a, b, c, d)

while True:
    try:
        p, q, r, s = next(result)
        print("A:", p)
        print("B:", q)
        print("C:", r)
        print("D:", s)
    except StopIteration:
        break

Production :

A: 11
B: 1.1
C: Number(1)
D: H
A: 22
B: 2.2
C: Number(23)
D: e
A: 33
B: 3.3
C: Number(44.44)
D: l
A: 44
B: 4.4
C: Number(0)
D: l
A: 55
B: 5.5
C: Number(-9)
D: o

Lorsqu’aucune valeur n’est disponible à l’intérieur d’un itérateur, il lève une exception StopIteration. En utilisant un bloc try-except, nous attrapons cette exception et sortons de la boucle infinie while.

Objets itérables de différentes longueurs

Dans le code Python suivant, un tuple d’entiers, une liste de valeurs flottantes, une liste d’objets de classe et une chaîne de différentes longueurs seront passés à la fonction zip().

class Number:
    def __init__(self, number):
        self.number = number

    def square(self):
        return number ** 2

    def __repr__(self):
        return f"Number({self.number})"


a = (11, 22, 33)
b = [1.1, 2.2, 3.3, 4.4]
c = [Number(1), Number(23), Number(44.44), Number(0), Number(-9)]
d = "HelloWorld"
result = zip(a, b, c, d)

for p, q, r, s in result:
    print("A:", p)
    print("B:", q)
    print("C:", r)
    print("D:", s)

Production :

A: 11
B: 1.1
C: Number(1)
D: H
A: 22
B: 2.2
C: Number(23)
D: e
A: 33
B: 3.3
C: Number(44.44)
D: l

Tous les objets itérables ont des longueurs différentes. Le premier objet itérable ou le tuple d’entiers a la plus petite longueur, 3. Par conséquent, la sortie n’imprime que les premières valeurs 3 de tous les objets itérables.

Création d’un dictionnaire

Nous pouvons créer un dictionnaire de paires clé-valeur à l’aide de la fonction zip(). L’idée est de créer un itérateur de deux tableaux de mêmes longueurs, contenant des clés et leurs valeurs respectives, et de les mapper l’un à l’autre dans un dictionnaire tout en itérant sur l’objet itérable renvoyé. Reportez-vous au code suivant pour la même chose.

import json

a = ["W", "O", "R", "L", "D"]
b = [1.1, True, "Hello", None, 5]
result = zip(a, b)
mapping = {x: y for x, y in result}
print(json.dumps(mapping, indent=4))

Production :

{
    "W": 1.1,
    "O": true,
    "R": "Hello",
    "L": null,
    "D": 5
}

Le code ci-dessus utilise uniquement le module json pour embellir la sortie du dictionnaire. Notez que son utilisation est entièrement facultative.

Utiliser la fonction zip() avec la fonction enumerate()

La fonction enumerate() est utilisée pour obtenir l’index et la valeur en même temps lors de l’itération sur un objet itérable. Comme la fonction zip() retourne un itérateur, on peut regrouper les deux fonctions et avoir accès aux index et aux valeurs. Reportez-vous au code Python suivant pour la même chose.

class Number:
    def __init__(self, number):
        self.number = number

    def square(self):
        return number ** 2

    def __repr__(self):
        return f"Number({self.number})"


a = (11, 22, 33)
b = [1.1, 2.2, 3.3, 4.4]
c = [Number(1), Number(23), Number(44.44), Number(0), Number(-9)]
d = "HelloWorld"
result = zip(a, b, c, d)

for i, (p, q, r, s) in enumerate(result):
    print(f"A{i + 1}:", p)
    print(f"B{i + 1}:", q)
    print(f"C{i + 1}:", r)
    print(f"D{i + 1}:", s)

Production :

A1: 11
B1: 1.1
C1: Number(1)
D1: H
A2: 22
B2: 2.2
C2: Number(23)
D2: e
A3: 33
B3: 3.3
C3: Number(44.44)
D3: l

Dans le code Python ci-dessus, à l’intérieur de la boucle for, i, (p, q, r, s) décompressez les valeurs renvoyées par la fonction enumerate(), et (p, q, r, s) décompresser les valeurs renvoyées par la fonction zip().

Les valeurs retournées par la fonction enumerate() sont au format suivant.

(0, (11, 1.1, Number(1), "H"))
(1, (22, 2.2, Number(23), "e"))
(2, (33, 3.3, Number(44.44), "l"))

Il clarifie pourquoi i, (p, q, r, s) a été utilisé pour décompresser toutes les valeurs.