Python, la tête dans les étoiles

Aujourd’hui, un article écrit par Kevin Samuel sous licence Creative Commons qui m’a bien aidé lors de mes débuts en python à comprendre les étoiles et notamment les fameux f(*args, **kwargs):

L’utilisation du signe étoile (*) en Python est très simple, mais certains cas sont peu intuitifs. Les nouveaux venus ont souvent besoin d’un peu plus
d’explications que ce que donne la doc. Les utilisateurs d’autres langages sont généralement déroutés car ils sont habitués certaines fonctionnalités qu’on ne retrouvent pas en Python.

Ce que « * » ne permet pas de faire

Il n’y a pas de pointeurs en Python, et les passages par références sont automatiques. Du coup :

N’existe pas en Python. On ne peut pas récupérer un pointeur. On ne peut pas choisir si l’on passe une variable par valeur ou par référence. Tout est automatique et transparent.

Les usages basiques de « * »

La multiplication et la puissance fonctionnent comme on l’attend :

Mais déjà, Python se démarque du lot car l’opérateur * est surchargé par défaut, et peut s’appliquer aux chaînes de caractères et aux listes. Pour les chaîne, c’est simple :

Pour les listes, c’est plus subtil. Une liste de nombres se multiplie sans y penser :

En revanche, multiplier une liste d’objets modifiables ne fait que répéter la référence vers cet objet:

On a l’impression que le comportement est le même que précédemment, en fait pas du tout. Ici on a pas une liste de 3 dictionnaires, mais une liste de 3 références vers le même dictionnaire. Si on modifie le premier élément de la liste, tous sont modifiés :

Unpacking

Python intègre une fonctionnalité, l’unpacking, qui permet de prendre chaque élément d’une séquence et de les attribuer à des variables distinctes, d’un seul coup. C’est un raccourcis très pratique :

Vous n’avez rien à faire, l’unpacking est automatique : il suffit de mettre à gauche du signe « = » le même nombre de variables qu’il y a d’éléments dans la séquence à droite du signe « = ». Dans le cas contraire, Python râle :

Quel rapport avec « * » ? Et bien il permet de forcer l’unpacking dans le cas où c’est ambigüe. Faisons une petite fonction de test qui ne fait qu’afficher chacun de ses paramètres :

Passer drapeau affiche logiquement le tuple comme premier paramètre, et ensuite les valeurs par défaut du premier et du second paramètre.

En utilisant « * », nous pouvons forcer l’unpacking de telle sorte que les valeurs du tuple soient passées individuellement comme autant de paramètres :

Très pratique quand vous utilisez une collection tout au long du programme pour vous éviter de sans cesse trainer des variables intermédiaires. D’autant que ça marche combiné aux slices :

Encore mieux, on peut utiliser « ** » pour forcer l’unpacking des dictionnaires. Les valeurs du dictionnaires deviennent les valeurs des paramètres, mais cette association se fait par nom : chaque clé du dictionnaire doit correspondre à un nom de paramètre. Ainsi :

Si une clé ne possède pas le nom adéquat, tout plante :

Une autre erreur courante est d’utiliser « * » avec un dictionnaire. Dans ce cas l’unpacking fonctionne, mais comme itérer sur un dictionnaire donne une liste de clés, c’est comme si vous passiez une liste en paramètres contenant les clés :

Si vous donnez moins de valeurs qu’il n’y a de paramètres, Python remplit tout ce qu’il peut :

Dans le cas inverse – si i il y a plus d’élements que de paramètres – Python refuse les séquences, mais fait au mieux avec les dictionnaires :

Paramétrage dynamique

Il est parfois pratique de définir une fonction qui accepte un nombre infini d’arguments. Par exemple, on a une fonction qui multiplie ses arguments entre eux :

Bien sûr, si on veut rajouter un troisième paramètre, il faut la réécrire. Pareil pour un quatrième. Finalement, on finit par demander de passer une liste pour permettre un nombre arbitraire :

Et bien sachez qu’il existe une autre possibilité, autoriser l’ajout d’une infinité de paramètres ! Cela se fait bien sur avec « * ».

Comment ça marche ? C’est simple, tout les arguments sont stockés dans une liste, et cette liste est le paramètre que l’on a désigné par « * ».

Ce système très puissant peut être utilisé conjointement avec des paramètres normaux :

La seule condition est de mettre « * » sur un paramètre situé après tous les autres. « * » est toujours en dernier, et il n’apparait qu’une seule fois. Enfin, il existe une convention pour le nom de cet argument : « *args ».

Bonne nouvelle, on peut utiliser aussi « ** ». Comme on peut s’y attendre, il permet de récupérer aussi une infinité de paramètres, mais sous forme de dictionnaire. Cela signifie qu’il ne récupère que les paramètres nommés :

Il faut également mettre « ** » après tous les autres arguments. La convention pour nommer ce paramètre est « **kwargs », pour « keyword arguments ».

Enfin, on peut mélanger tout ça d’un coup :

On doit absolument mettre les paramètres dans cet ordre :

  1. paramètres normaux et obligatoires;
  2. paramètres normaux facultatifs (valeur par défaut);
  3. paramètres dynamiques;
  4. paramètres dynamiques nommés.

En plus, cela permet en effet de faire jouer les valeurs par défaut de manière très souple :

Si vous vous sentez à l’aise avec tout ça, vous pouvez mélanger plusieurs usages de « * » d’un coup. Je vous laisse donc en guise de conclusion un petit combo qui utilise un code précédent:

Tweet about this on TwitterShare on Google+0Share on Facebook1Email this to someone

Laisser un commentaire

Votre adresse de messagerie ne sera pas publiée. Les champs obligatoires sont indiqués avec *