Il existe trois types de paramètres :
• les paramètres explicites et valeurs par défaut ;
• les paramètres non explicites ;
• les paramètres arbitraires.
Paramètres explicites et valeurs par défaut
Les paramètres explicites sont les paramètres utilisés dans les exemples précédents, à savoir des noms séparés par des virgules. Chacun de ces paramètres peut en outre être enrichi d’une valeur par défaut et devenir optionnel.
Valeur par défaut
Il est cependant nécessaire de regrouper tous les paramètres optionnels à la fin de la liste des paramètres.
>>> def three_nums():
... return 1, 2, 3 ...
>>> three_nums() (1, 2, 3)
CULTURE L’écriture pythonique
Renvoyer les éléments séparés par des virgules est très spécifique au langage et est souvent préféré à l’utilisation d’une structure regroupante. Cette écriture est souvent employée lorsqu’une fonction doit renvoyer deux ou trois résultats. On parle ici d’écriture pythonique.
>>> def home(firstname, lastname='Doe'):
... print('%s %s' % (firstname, lastname)) ...
>>> home('John') John Doe
>>> home('John', 'Dull') John Dull
Lorsqu’il y a plusieurs paramètres optionnels, le code appelant peut définir ou non la valeur de chacun sans avoir à respecter un ordre précis, en utilisant la notation
nom=valeur pour ce paramètre. On parle alors de nommage des paramètres.
Nommage des paramètres
Enfin, les valeurs par défaut ne sont interprétées qu’une seule fois, au moment de la lecture de la définition, ce qui peut être relativement important si ces valeurs sont retournées par des objets modifiables. Chaque nouvel appel à la fonction appellera les mêmes objets qui ont été évalués à l’initialisation de la fonction.
Lecture par l’interpréteur des valeurs par défaut
>>> def sum(a, b=2, c=3):
... return a + b + c ...
>>> sum(2) 7
>>> sum(2, 3, 4) 9
>>> sum(2, c=4) 8
>>> sum(a=2, b=3, c=4) 9
À RETENIR Les paramètre nommés
Tous les paramètres peuvent êtres nommés. Cette notation permet aussi de fournir les valeurs dans un ordre quelconque.
>>> def sub(a, b):
... return a – b ...
>>> sub(10, 5) 5
>>> sub(b=10, a=5) -5
>>> sub(a=10, b=5) 5
Lorsqu’une fonction possède beaucoup de paramètres, il est judicieux de nommer systématiquement tous les paramètres, afin de rendre le code plus lisible.
>>> def param():
... print('param() appelé') ... return [1, 2, 3]
...
Les paramètres non explicites
Python propose un système de paramètres non explicites qui permet de laisser l’appe-lant fournir autant de valeurs nommées qu’il le souhaite sans qu’il soit nécessaire de les définir dans la liste des arguments. Ces paramètres sont fournis sous la forme
nom=valeur à la fonction. L’interpréteur place ces valeurs dans un dictionnaire qu’il faut au préalable définir en fin de liste par son nom précédé de deux étoiles :
Utilisation de paramètres non explicites
Cette écriture offre un maximum de souplesse puisqu’elle peut être combinée avec les paramètres explicites.
... print ('Liste des mots: %s' % ' '.join(words.values())) ... print ('Nom des paramètres: %s' % ' '.join(words.keys())) ...
Liste des mots: des mots des mots Nom des paramètres: encore toujours
>>> sentence() Reçu 0 mot(s) Liste des mots:
Nom des paramètres:
Combinaison de paramètres explicites et non explicites
Les paramètres arbitraires
Les paramètres arbitraires sont équivalents aux paramètres non explicites sauf qu’ils ne sont pas nommés. L’interpréteur les regroupe dans un tuple nommé qu’il passe à la fonction. Le nom du tuple est fourni préfixé cette fois-ci d’une seule étoile.
Paramètres arbitraires
Lorsque des paramètres arbitraires sont combinés avec des paramètres explicites ou non explicites, la déclaration du nom du tuple qui contiendra les valeurs se place tou-jours après les paramètres explicites et avant les paramètres non explicites.
>> def team(name, leader='non défini', **players):
... print('Equipe %s' % name
... print('Capitaine: %s' % leader) ... for name, value in players.items():
... print('%s: %s' % (name, value)) ...
>>> team('Les bleus') Equipe Les bleus Capitaine: non défini
>>> team('Les vaillants', 'Robert', gardien='André', attaquant='Micheline')
Equipe Les vaillants Capitaine: Robert attaquant: Micheline gardien: André
ASTUCE Utiliser un dictionnaire
Le dictionnaire players peut aussi être directement fourni.
L’écriture :
team('Nom', 'Capitaine', gardien='André', attaquant='Micheline') étant équivalente à :
players = {gardien: 'André', attaquant: 'Micheline'}
team('Nom', 'Capitaine', **players)
>>> def format(sentence, *args):
... print(sentence % args) ...
>>> format('%d fois plus de %s possibles', 2, 'combinaisons') 2 fois plus de combinaisons possibles
Ainsi, une fonction sera toujours sous la forme indiquée ci-dessous.
Forme d’une fonction
Collisions de paramètres
Une fonction peut donc utiliser trois types de paramétrages et les combiner. Il faut cependant prendre garde aux collisions possibles : un paramètre doit rester unique dans l’ensemble des paramètres fournis. En cas de doublons, une exception
TypeError est retournée.
Collisions de noms
Signatures multiples de fonctions
La signature d’une fonction est représentée par la liste de ses paramètres. Certains langages proposent des systèmes de surcharge pour permettre au développeur de définir plusieurs fois la même fonction avec des signatures différentes. C’est le rôle de la directive overload en Delphi par exemple.
Les combinaisons infinies de paramétrage de fonction offertes par Python répondent beaucoup plus simplement à ce problème de signature multiple.
ASTUCE Utiliser la notation arbitraire
Il est possible d’utiliser la notation arbitraire dans des fonctions à paramétrage classique en fournissant une séquence comme valeur. La séquence sera décompressée en une liste de paramètres.
>>> def sum(a, b, c):
... return a + b + c ...
>>> elements = [1, 3, 5]
>>> sum(*elements) 9
def nom_fonction(a, b, c, ..., *arbitraires, **explicites)
>>> def display(a, **kw):
... print('a: %s' % a)
... for name, value in kw.items():
... print('%s: %s' % (name, value)) ...
>>> display(12, a=2, b=3, c=4) Traceback (most recent call last):
File "<stdin>", line 1, in ?
TypeError: display() got multiple values for keyword argument 'a'