La fonction zip() de Python expliquée avec des exemples simples

La fonction zip() en Python est un outil intéressant qui vous permet de combiner plusieurs listes ou autres itérables (comme des tuples, des ensembles ou même des chaînes) en un seul itérable de tuples. Pensez-y comme à une fermeture éclair sur une veste qui rassemble deux côtés.

Dans ce guide, nous explorerons les tenants et les aboutissants de la fonction zip() avec des exemples simples et pratiques qui vous aideront à comprendre comment l'utiliser efficacement.

Comment fonctionne la fonction zip() ?

La fonction zip() associe des éléments de plusieurs itérables, comme des listes, en fonction de leurs positions. Cela signifie que les premiers éléments de chaque liste seront appariés, puis le second, et ainsi de suite. Si les itérables n'ont pas la même longueur, zip() s'arrêtera à la fin de l'itérable le plus court.

La syntaxe de zip() est assez simple :

zip(*iterables)

Vous pouvez transmettre plusieurs itérables (listes, tuples, etc.), et il les combinera en tuples.

Exemple 1 : combinaison de deux listes

Commençons par un cas simple où nous avons deux listes et que nous souhaitons les combiner. Imaginez que vous ayez une liste de noms et une liste de scores correspondante, et que vous souhaitiez les associer.

# Two lists to combine
names = ["Alice", "Bob", "Charlie"]
scores = [85, 90, 88]

# Using zip() to combine them
zipped = zip(names, scores)

# Convert the result to a list so we can see it
zipped_list = list(zipped)
print(zipped_list)

Dans cet exemple, la fonction zip() prend les deux listes — names et scores — et les associe élément par élément. Le premier élément de names ("Alice") est associé au premier élément de scores (85), et ainsi de suite. Lorsque nous convertissons le résultat en liste, cela ressemble à ceci :

Résultat :

[('Alice', 85), ('Bob', 90), ('Charlie', 88)]

Cela facilite le travail avec des données associées de manière structurée.

Exemple 2 : Que se passe-t-il lorsque les listes sont inégales ?

Disons que vous avez des listes de différentes longueurs. Que se passe-t-il alors ? La fonction zip() est suffisamment intelligente pour s'arrêter dès qu'elle atteint la fin de la liste la plus courte.

# Lists of different lengths
fruits = ["apple", "banana"]
prices = [100, 200, 150]

# Zipping them together
result = list(zip(fruits, prices))
print(result)

Dans ce cas, la liste fruits comporte deux éléments et la liste prix en comporte trois. Mais zip() ne combinera que les deux premiers éléments, en ignorant la valeur supplémentaire dans les prix.

Résultat :

[('apple', 100), ('banana', 200)]

Remarquez comment la dernière valeur (150) dans la liste prix est ignorée car il n'y a pas de troisième fruit avec lequel l'associer. La fonction zip() garantit que vous n'obtiendrez pas d'erreurs lorsque vous travaillez avec des listes inégales, mais cela signifie également que vous risquez de perdre certaines données si vos listes ne sont pas équilibrées.

Exemple 3 : Décompresser un objet compressé

Que faire si vous souhaitez inverser l'opération zip() ? Par exemple, après avoir compressé deux listes ensemble, vous souhaiterez peut-être les diviser en listes individuelles. Vous pouvez le faire facilement en utilisant l'opérateur de déballage *.

# Zipped lists
cities = ["New York", "London", "Tokyo"]
populations = [8000000, 9000000, 14000000]

zipped = zip(cities, populations)

# Unzipping them
unzipped_cities, unzipped_populations = zip(*zipped)

print(unzipped_cities)
print(unzipped_populations)

Ici, nous compressons d'abord les listes de villes et de populations ensemble. Ensuite, en utilisant zip(*zipped), nous pouvons "décompresser" les tuples combinés en deux listes distinctes. L'opérateur * décompresse les tuples compressés dans leurs composants d'origine.

Résultat :

('New York', 'London', 'Tokyo')
(8000000, 9000000, 14000000)

Cela montre comment vous pouvez inverser le processus de compression pour récupérer les données d'origine.

Exemple 4 : compresser plus de deux listes

Vous n'êtes pas limité à seulement deux listes avec zip(). Vous pouvez compresser autant d’itérables que vous le souhaitez. Voici un exemple avec trois listes.

# Three lists to zip
subjects = ["Math", "English", "Science"]
grades = [88, 79, 92]
teachers = ["Mr. Smith", "Ms. Johnson", "Mrs. Lee"]

# Zipping three lists together
zipped_info = zip(subjects, grades, teachers)

# Convert to a list to see the result
print(list(zipped_info))

Dans cet exemple, nous compressons trois listes : sujets, notes et enseignants. Le premier élément de chaque liste est regroupé, puis le deuxième, et ainsi de suite.

Résultat :

[('Math', 88, 'Mr. Smith'), ('English', 79, 'Ms. Johnson'), ('Science', 92, 'Mrs. Lee')]

De cette façon, vous pouvez combiner plusieurs informations liées dans des tuples faciles à gérer.

Exemple 5 : compression de chaînes

Les chaînes sont également itérables en Python, vous pouvez donc les compresser comme vous le feriez avec des listes. Essayons de combiner deux chaînes.

# Zipping two strings
str1 = "ABC"
str2 = "123"

# Zipping the characters together
zipped_strings = list(zip(str1, str2))
print(zipped_strings)

Ici, le premier caractère de str1 est combiné avec le premier caractère de str2, et ainsi de suite.

Résultat :

[('A', '1'), ('B', '2'), ('C', '3')]

Ceci est particulièrement utile si vous devez traiter ou associer des caractères de plusieurs chaînes.

Exemple 6 : compresser des dictionnaires

Bien que les dictionnaires soient légèrement différents des listes, vous pouvez toujours utiliser zip() pour les combiner. Par défaut, zip() compressera uniquement les clés du dictionnaire. Regardons un exemple :

# Two dictionaries
dict1 = {"name": "Alice", "age": 25"}
dict2 = {"name": "Bob", "age": 30"}

# Zipping dictionary keys
zipped_keys = list(zip(dict1, dict2))
print(zipped_keys)

Ici, zip() associe les clés des deux dictionnaires.

Résultat :

[('name', 'name'), ('age', 'age')]

Si vous souhaitez compresser les valeurs des dictionnaires, vous pouvez le faire en utilisant la méthode .values() :

zipped_values = list(zip(dict1.values(), dict2.values()))
print(zipped_values)

Résultat :

[('Alice', 'Bob'), (25, 30)]

Vous pouvez désormais facilement combiner les valeurs des deux dictionnaires.

Exemple 7 : Utilisation de zip() dans des boucles

L'une des utilisations les plus courantes de zip() concerne les boucles lorsque vous souhaitez traiter plusieurs listes en même temps. Voici un exemple :

# Lists of names and scores
names = ["Alice", "Bob", "Charlie"]
scores = [85, 90, 88]

# Using zip() in a loop
for name, score in zip(names, scores):
    print(f"{name} scored {score}")

Cette boucle parcourt simultanément les listes names et scores, associant chaque nom à son score correspondant.

Résultat :

Alice scored 85
Bob scored 90
Charlie scored 88

L'utilisation de zip() dans des boucles comme celle-ci rend votre code plus propre et plus facile à lire lorsque vous travaillez avec des données associées.

Conclusion

La fonction zip() est un outil pratique en Python qui vous permet de combiner plusieurs itérables en tuples, facilitant ainsi le travail avec des données associées. Que vous associiez des éléments de listes, de tuples ou de chaînes, zip() simplifie votre code et peut être particulièrement utile dans les boucles.

Avec les exemples de cet article, vous devriez maintenant bien comprendre comment utiliser zip() dans divers scénarios.

Si vous avez trouvé cette explication de la fonction zip() de Python utile, vous pourrez également profiter des didacticiels de programmation plus approfondis et des concepts que j'aborde sur mon blog.

Bon codage !