Le dépaquetage désigne l'action d'extraire les éléments d'une collection, comme une list, un tuple ou un dict, en utilisant l'itération.
Les valeurs dépaquetées peuvent ensuite être affectées à des variables dans la même instruction, ce que l'on appelle communément l'affectation multiple.
Les opérateurs spéciaux * et ** sont souvent utilisés dans des contextes de dépaquetage et avec l'affectation multiple.
Il ne faut pas confondre *<variable_name> et **<variable_name> avec * et **. Alors que * et ** servent respectivement à la multiplication et à l'exponentiation, *<variable_name> et **<variable_name> servent d'opérateurs d'empaquetage et de dépaquetage.
Affectation multiple
Dans une affectation multiple, le nombre de variables à gauche de l'opérateur d'affectation (=) doit correspondre au nombre de valeurs à droite.
Pour séparer les valeurs, utilise une virgule , :
>>> a, b = 1, 2
>>> a
1
Si l'affectation multiple reçoit un nombre incorrect de variables pour les valeurs données, une ValueError sera levée :
>>> x, y, z = 1, 2
ValueError: too many values to unpack (expected 3, got 2)
L'affectation multiple n'est pas limitée à un seul type de données :
>>> x, y, z = 1, "Hello", True
>>> x
1
>>> y
'Hello'
>>> z
True
L'affectation multiple permet d'échanger des éléments dans des lists.
Cette pratique est assez courante dans les algorithmes de tri.
Par exemple :
>>> numbers = [1, 2]
>>> numbers[0], numbers[1] = numbers[1], numbers[0]
>>> numbers
[2, 1]
Comme les tuples sont immuables, tu ne peux pas échanger d'éléments dans un tuple.
Dépaquetage
Les exemples ci-dessous utilisent des lists, mais les mêmes concepts s'appliquent aux tuples.
En Python, il est possible de dépaqueter les éléments d'une list, d'un tuple ou d'un dictionary dans des variables distinctes.
Comme les valeurs apparaissent dans les lists/tuples dans un ordre précis, elles sont dépaquetées dans les variables dans le même ordre :
>>> fruits = ["apple", "banana", "cherry"]
>>> x, y, z = fruits
>>> x
"apple"
Si certaines valeurs ne sont pas nécessaires, tu peux utiliser _ pour les signaler :
>>> fruits = ["apple", "banana", "cherry"]
>>> _, _, z = fruits
>>> z
"cherry"
Dépaquetage profond
Dépaqueter et affecter des valeurs provenant d'une list/d'un tuple imbriqué dans une list ou un tuple (aussi appelés listes/tuples imbriqués) fonctionne de la même manière qu'un dépaquetage superficiel, mais nécessite souvent des qualificatifs pour clarifier le contexte ou la position :
>>> fruits_vegetables = [["apple", "banana"], ["carrot", "potato"]]
>>> [[a, b], [c, d]] = fruits_vegetables
>>> a
"apple"
>>> d
"potato"
Tu peux aussi dépaqueter en profondeur seulement une partie d'une list/d'un tuple imbriqué :
>>> fruits_vegetables = [["apple", "banana"], ["carrot", "potato"]]
>>> [a, [c, d]] = fruits_vegetables
>>> a
["apple", "banana"]
>>> c
"carrot"
Si le dépaquetage comporte des variables mal placées ou un nombre incorrect de valeurs, tu obtiendras une ValueError :
>>> fruits_vegetables = [["apple", "banana"], ["carrot", "potato"]]
>>> [[a, b], [d]] = fruits_vegetables
ValueError: too many values to unpack (expected 1)
Dépaquetage d'une liste/d'un tuple avec *
Quand tu dépaquettes une list/un tuple, tu peux utiliser l'opérateur * pour capturer les valeurs « restantes ».
C'est plus clair qu'un découpage de la list/du tuple (qui, dans certaines situations, est moins lisible).
Par exemple, on peut extraire le premier élément, puis placer les valeurs restantes dans une nouvelle list sans le premier élément :
>>> fruits = ["apple", "banana", "cherry", "orange", "kiwi", "melon", "mango"]
>>> x, *last = fruits
>>> x
"apple"
>>> last
["banana", "cherry", "orange", "kiwi", "melon", "mango"]
On peut aussi extraire les valeurs du début et de la fin de la list tout en regroupant toutes les valeurs du milieu :
>>> fruits = ["apple", "banana", "cherry", "orange", "kiwi", "melon", "mango"]
>>> x, *middle, y, z = fruits
>>> y
"melon"
>>> middle
["banana", "cherry", "orange", "kiwi"]
On peut également utiliser * dans un dépaquetage profond :
>>> fruits_vegetables = [["apple", "banana", "melon"], ["carrot", "potato", "tomato"]]
>>> [[a, *rest], b] = fruits_vegetables
>>> a
"apple"
>>> rest
["banana", "melon"]
Dépaquetage d'un dictionnaire
Le dépaquetage d'un dictionnaire est un peu différent du dépaquetage d'une list/d'un tuple.
L'itération sur les dictionnaires porte par défaut sur les clés.
Donc, quand tu dépaquettes un dict, tu ne peux dépaqueter que les clés, et pas les valeurs :
>>> fruits_inventory = {"apple": 6, "banana": 2, "cherry": 3}
>>> x, y, z = fruits_inventory
>>> x
"apple"
Si tu veux dépaqueter les valeurs, tu peux utiliser la méthode <dict>.values() :
>>> fruits_inventory = {"apple": 6, "banana": 2, "cherry": 3}
>>> x, y, z = fruits_inventory.values()
>>> x
6
Si tu as besoin à la fois des clés et des valeurs, utilise la méthode <dict>.items().
<dict>.items() génère une vue itérable contenant des paires clé-valeur.
Celles-ci peuvent être dépaquetées dans un tuple :
>>> fruits_inventory = {"apple": 6, "banana": 2, "cherry": 3}
>>> x, y, z = fruits_inventory.items()
>>> x
("apple", 6)
Empaquetage
L'empaquetage est la capacité de regrouper plusieurs valeurs dans une seule list affectée à une variable.
C'est utile quand tu veux dépaqueter des valeurs, les modifier, puis empaqueter à nouveau le résultat dans une variable.
Cela permet également d'effectuer des fusions entre 2 lists/tuples/dicts ou plus.
Empaquetage d'une liste/d'un tuple avec *
L'empaquetage d'une list/d'un tuple se fait avec l'opérateur *.
Cela empaquette toutes les valeurs dans une list/un tuple.
>>> fruits = ("apple", "banana", "cherry")
>>> more_fruits = ["orange", "kiwi", "melon", "mango"]
# fruits and more_fruits are unpacked and then their elements are packed into combined_fruits
>>> combined_fruits = *fruits, *more_fruits
# If there is no * on to the left of the "=" the result is a tuple
>>> combined_fruits
("apple", "banana", "cherry", "orange", "kiwi", "melon", "mango")
# If the * operator is used on the left side of "=" the result is a list.
# Note the trailing comma.
>>> *combined_fruits_too, = *fruits, *more_fruits
>>> combined_fruits_too
['apple', 'banana', 'cherry', 'orange', 'kiwi', 'melon', 'mango']
Pour en savoir plus sur l'utilisation de * du côté gauche, consulte la PEP 3132.
Empaquetage d'un dictionnaire avec **
L'empaquetage d'un dictionnaire se fait avec l'opérateur **.
Cela empaquette toutes les paires clé-valeur d'un dictionnaire dans un autre dictionnaire, ou combine deux dictionnaires entre eux.
>>> fruits_inventory = {"apple": 6, "banana": 2, "cherry": 3}
>>> more_fruits_inventory = {"orange": 4, "kiwi": 1, "melon": 2, "mango": 3}
# fruits_inventory and more_fruits_inventory are unpacked into key-values pairs and combined.
>>> combined_fruits_inventory = {**fruits_inventory, **more_fruits_inventory}
# then the pairs are packed into combined_fruits_inventory
>>> combined_fruits_inventory
{"apple": 6, "banana": 2, "cherry": 3, "orange": 4, "kiwi": 1, "melon": 2, "mango": 3}
Utilisation de * et ** avec les fonctions
Empaquetage avec les paramètres d'une fonction
Quand tu crées une fonction qui accepte un nombre arbitraire d'arguments, tu peux utiliser *args ou **kwargs dans la définition de la fonction.
*args sert à empaqueter un nombre arbitraire d'arguments positionnels (non nommés) dans un tuple, et
**kwargs sert à empaqueter un nombre arbitraire d'arguments nommés dans un dictionnaire.
Utilisation de *args :
# This function is defined to take any number of positional arguments
>>> def my_function(*args):
... print(args)
# Arguments given to the function are packed into a tuple
>>> my_function(1, 2, 3)
(1, 2, 3)
>>> my_function("Hello")
("Hello")
>>> my_function(1, 2, 3, "Hello", "Mars")
(1, 2, 3, "Hello", "Mars")
Utilisation de **kwargs :
# This function is defined to take any number of keyword arguments
>>> def my_function(**kwargs):
... print(kwargs)
# Arguments given to the function are packed into a dictionary
>>> my_function(a=1, b=2, c=3)
{"a": 1, "b": 2, "c": 3}
*args et **kwargs peuvent aussi être utilisés en combinaison l'un avec l'autre :
>>> def my_function(*args, **kwargs):
... print(sum(args))
... for key, value in kwargs.items():
... print(str(key) + " = " + str(value))
>>> my_function(1, 2, 3, a=1, b=2, c=3)
6
a = 1
b = 2
c = 3
Tu peux aussi écrire des paramètres avant *args pour permettre des arguments positionnels précis.
Les arguments nommés individuels doivent alors apparaître avant **kwargs.
Les arguments doivent être structurés comme ceci :
def my_function(<positional_args>, *args, <key-word_args>, **kwargs)
Si tu ne respectes pas cet ordre, tu obtiendras une erreur.
>>> def my_function(a, b, *args):
... print(a)
... print(b)
... print(args)
>>> my_function(1, 2, 3, 4, 5)
1
2
(3, 4, 5)
Écrire les arguments dans un ordre incorrect provoquera une erreur :
>>>def my_function(*args, a, b):
... print(args)
>>>my_function(1, 2, 3, 4, 5)
Traceback (most recent call last):
File "c:\something.py", line 3, in <module>
my_function(1, 2, 3, 4, 5)
TypeError: my_function() missing 2 required keyword-only arguments: 'a' and 'b'
Dépaquetage dans les appels de fonction
Tu peux utiliser * pour dépaqueter une list/un tuple d'arguments dans un appel de fonction.
C'est très utile pour les fonctions qui n'acceptent pas d'iterable :
>>> def my_function(a, b, c):
... print(c)
... print(b)
... print(a)
numbers = [1, 2, 3]
>>> my_function(*numbers)
3
2
1
Utiliser le dépaquetage avec * et la fonction native zip() est un autre cas d'usage courant.
La fonction zip() prend plusieurs itérables et renvoie une list de tuples regroupant les valeurs de chaque iterable :
>>> values = (['x', 'y', 'z'], [1, 2, 3], [True, False, True])
>>> a, *rest = zip(*values)
>>> rest
[('y', 2, False), ('z', 3, True)]
Exercice d'apprentissage
