Python Language
Déstructurer la liste (aka emballage et déballage)

Affectation de destruction

Dans les affectations, vous pouvez diviser une Iterable en valeurs en utilisant la syntaxe "unpacking":

Destructuration en tant que valeurs

a, b = (1, 2)
print(a)
# Prints: 1
print(b)
# Prints: 2

Si vous essayez de décompresser plus que la longueur de l'itérable, vous obtenez une erreur:

a, b, c = [1]
# Raises: ValueError: not enough values to unpack (expected 3, got 1)

head, *tail = [1, 2, 3, 4, 5]

print(head)
# Prints: 1
print(tail)
# Prints: [2, 3, 4, 5]

l = [1, 2, 3, 4, 5]
head = l[0]
tail = l[1:]

a, b, *other, z = [1, 2, 3, 4, 5]
print(a, b, z, other)
# Prints: 1 2 5 [3, 4]

Ignorer les valeurs dans les affectations de déstructuration

Si vous êtes seulement intéressé par une valeur donnée, vous pouvez utiliser _ pour indiquer que vous n'êtes pas intéressé. Remarque: ceci sera toujours défini _ , la plupart des gens ne l'utilisent pas comme variable.

a, _ = [1, 2]
print(a)
# Prints: 1
a, _, c = (1, 2, 3)
print(a)
# Prints: 1
print(c)
# Prints: 3

a, *_ = [1, 2, 3, 4, 5]
print(a)
# Prints: 1

 a, *_, b = [1, 2, 3, 4, 5]
 print(a, b)
 # Prints: 1 5

 a, _, b, _, c, *_ = [1, 2, 3, 4, 5, 6]
 print(a, b, c)
 # Prints: 1 3 5

Arguments de la fonction d'emballage

Dans les fonctions, vous pouvez définir un certain nombre d'arguments obligatoires:

def fun1(arg1, arg2, arg3): 
    return (arg1,arg2,arg3)

qui rendra la fonction appelable uniquement lorsque les trois arguments sont donnés:

fun1(1, 2, 3)

et vous pouvez définir les arguments comme facultatifs, en utilisant les valeurs par défaut:

def fun2(arg1='a', arg2='b', arg3='c'):
    return (arg1,arg2,arg3)

vous pouvez donc appeler la fonction de différentes manières, par exemple:

fun2(1)              → (1,b,c)
fun2(1, 2)           → (1,2,c)
fun2(arg2=2, arg3=3) → (a,2,3)
...

Mais vous pouvez aussi utiliser la syntaxe déstructurant pour emballer des arguments, donc vous pouvez assigner des variables à l' aide d' une list ou d' un dict .

Emballage d'une liste d'arguments

Considérez que vous avez une liste de valeurs

l = [1,2,3]

Vous pouvez appeler la fonction avec la liste de valeurs en tant qu'argument en utilisant la syntaxe * :

fun1(*l)
# Returns: (1,2,3)
fun1(*['w', 't', 'f'])
# Returns: ('w','t','f')

Mais si vous ne fournissez pas une liste dont la longueur correspond au nombre d'arguments:

fun1(*['oops'])
# Raises: TypeError: fun1() missing 2 required positional arguments: 'arg2' and 'arg3'

Arguments sur les mots-clés d'emballage

Maintenant, vous pouvez également empaqueter des arguments en utilisant un dictionnaire. Vous pouvez utiliser l'opérateur ** pour demander à Python de décompresser le dict tant que valeurs de paramètre:

d = {
  'arg1': 1,
  'arg2': 2,
  'arg3': 3
}
fun1(**d)
# Returns: (1, 2, 3)

Lorsque la fonction ne contient que des arguments de position (ceux sans valeur par défaut), vous avez besoin que le dictionnaire contienne tous les paramètres attendus et qu'il n'y ait pas de paramètre supplémentaire, sinon vous obtiendrez une erreur:

fun1(**{'arg1':1, 'arg2':2})
# Raises: TypeError: fun1() missing 1 required positional argument: 'arg3'
fun1(**{'arg1':1, 'arg2':2, 'arg3':3, 'arg4':4})
# Raises: TypeError: fun1() got an unexpected keyword argument 'arg4'

Pour les fonctions qui ont des arguments facultatifs, vous pouvez empaqueter les arguments sous forme de dictionnaire de la même manière:

fun2(**d)
# Returns: (1, 2, 3)

Mais là, vous pouvez omettre des valeurs, car elles seront remplacées par les valeurs par défaut:

fun2(**{'arg2': 2})
# Returns: ('a', 2, 'c')

Et comme précédemment, vous ne pouvez pas donner de valeurs supplémentaires qui ne sont pas des paramètres existants:

fun2(**{'arg1':1, 'arg2':2, 'arg3':3, 'arg4':4})
# Raises: TypeError: fun2() got an unexpected keyword argument 'arg4'

Dans l'utilisation du monde réel, les fonctions peuvent avoir des arguments à la fois positionnels et facultatifs, et cela fonctionne de la même façon:

def fun3(arg1, arg2='b', arg3='c')
    return (arg1, arg2, arg3)

vous pouvez appeler la fonction avec une simple itération:

fun3(*[1])
# Returns: (1, 'b', 'c')
fun3(*[1,2,3])
# Returns: (1, 2, 3)

ou avec juste un dictionnaire:

fun3(**{'arg1':1})
# Returns: (1, 'b', 'c')
fun3(**{'arg1':1, 'arg2':2, 'arg3':3})
# Returns: (1, 2, 3)

ou vous pouvez utiliser les deux dans le même appel:

fun3(*[1,2], **{'arg3':3})
# Returns: (1,2,3)

Attention cependant, vous ne pouvez pas fournir plusieurs valeurs pour le même argument:

fun3(*[1,2], **{'arg2':42, 'arg3':3})
# Raises: TypeError: fun3() got multiple values for argument 'arg2'

Déballage des arguments de la fonction

Lorsque vous souhaitez créer une fonction pouvant accepter un nombre quelconque d'arguments, et ne pas appliquer la position ou le nom de l'argument à la compilation, il est possible et voici comment:

def fun1(*args, **kwargs):
    print(args, kwargs)

Les paramètres *args et **kwargs sont des paramètres spéciaux définis respectivement sur un tuple et un dict :

fun1(1,2,3)
# Prints: (1, 2, 3) {}
fun1(a=1, b=2, c=3)
# Prints: () {'a': 1, 'b': 2, 'c': 3}
fun1('x', 'y', 'z', a=1, b=2, c=3)
# Prints: ('x', 'y', 'z') {'a': 1, 'b': 2, 'c': 3}

Si vous regardez suffisamment de code Python, vous découvrirez rapidement qu'il est largement utilisé lors du passage d'arguments à une autre fonction. Par exemple, si vous souhaitez étendre la classe de chaîne:

class MyString(str):
    def __init__(self, *args, **kwarg):
        print('Constructing MyString')
        super(MyString, self).__init__(*args, **kwarg)