C’est le cours python numéro 18 de la série des cours d’initiation à python.

SUJETS OPTIONNELS

Nous avons vu que certaines fonctions peuvent être appelées avec un nombre variable d’arguments. En Python, il existe plusieurs façons d’obtenir ce comportement : nous verrons ici la plus utilisée, c’est-à-dire les paramètres avec des valeurs par défaut.

Prenez le programme “saluti.py” (ici) et modifiez-le comme suit :

def salue (nom = "Peppe") :
     print ("Bonjour", nom + "!")

dis bonjour()
salue ("Ciccio")
n = entrée ("Qui voulez-vous saluer ?")
salue (n)

Dans la définition de saluta() après le paramètre name nous avons ajouté = “Peppe”. Cela signifie que ce paramètre a une valeur par défaut : si l’utilisateur appelle la fonction sans arguments, Python substitue automatiquement “Peppe” au lieu du paramètre name, si à la place l’utilisateur spécifie un argument, la substitution se produit normalement.

Dans la définition d’une fonction, nous pouvons avoir à la fois des paramètres avec une valeur par défaut (facultatif) et des paramètres ordinaires (obligatoires). Les arguments facultatifs doivent toujours suivre les arguments obligatoires dans la liste des paramètres.

Voyons quelques exemples :

def fonction1 (a, b, c = 0, d = 1) : # OK, 2 paramètres ordinaires et 2 par défaut
     ...

def func2 (a = 1, b = 2, c = 3): # OK, 3 paramètres par défaut
     ...

def func3 (a = 1, b): # Erreur : le paramètre par défaut précède le paramètre ordinaire
     ...

Vous avez peut-être remarqué que je n’ai pas laissé d’espaces avant et après le signe = dans la définition des valeurs par défaut : ce n’est pas non plus obligatoire (vous pouvez laisser autant d’espaces que vous voulez avant et après), mais c’est devenu un habitude courante, probablement pour distinguer les valeurs par défaut des affectations ; il convient donc d’adopter cette convention. Voyons un autre exemple :

def acheter (quoi, prix, quantité = 1):
     imprimer ("j'ai besoin", quantité, "hectogramme de", quoi)
     print ("Voilà")
     imprimer ("Combien ça coûte?")
     impression (prix * quantité, "euro")

acheter ("Prosciutto", 1.5, 2) # acheter 2 onces de jambon à 1,5 euros pièce
acheter ("Salame", 1.0) # acheter 1 hectogramme (par défaut) de salami pour 1,0 euro
acheter ("Viande") # ERREUR ! un seul argument (au moins 2 sont nécessaires)

dans le premier appel, nous avons écrit les trois paramètres de la fonction, dans le second, nous avons omis le paramètre optionnel quantité (et Python l’a remplacé par 1) tandis que dans le troisième, nous avons provoqué une erreur en omettant deux paramètres (un seul est facultatif).

ARGUMENTS CLÉS

Il n’y a pas de limite au nombre d’arguments (obligatoires ou facultatifs) qu’une fonction peut avoir. Cependant, lorsqu’il y a beaucoup de paramètres par défaut, les choses se compliquent : gardez toujours à l’esprit que Python effectue les substitutions selon l’ordre des paramètres dans la définition.

def analyse_logique (sujet, verbe, compl_ogg = "", compl_place = "", compl_tempo = "") :
     print (sujet, verbe, compl_ogg, compl_place, compl_time)
     print ("SUBJECT :", sujet)
     print ("PRÊCHÉ :", verbe)
     si len (compl_ogg)> 0 :
         print ("COMPLÉMENT D'OBJET :", compl_ogg)
     si len (place_complète)> 0 :
         print ("PLACE COMPLEMENT:", compl_place)
     si len (plein_temps)> 0 :
         print ("COMPLEMENT TEMPS : ", heure_complète)

analyse_logique ("je", "je mange")
logical_analysis ("Gigi", "mange", "un sandwich")
analyse_logique ("Peppe", "il mange", "les pâtes", "à table")

Après avoir compris ce que fait la fonction logical_analysis(), demandez-vous : que se passerait-il si je voulais faire l’analyse logique de « je mange à midi » ? Je devrais passer les paramètres subject, verb, compl_time (c’est-à-dire les deux premiers, obligatoires, plus le cinquième, facultatif) à la fonction, mais comment Python pourrait-il déterminer lequel des trois paramètres facultatifs je lui passe?

Une solution serait d’appeler la fonction comme ceci :

analisi_logica("Io", "mangio", "", "", "a mezzogiorno")

respectant ainsi l’ordre des arguments que nous avons établi dans la définition de la fonction. Cependant, cela nous oblige à indiquer dans l’appel tous les paramètres, même les paramètres facultatifs, ce qui nous annule la possibilité de laisser de côté ceux dont nous n’avons pas besoin.

Le problème est résolu élégamment par Python avec la possibilité d’insérer le nom des arguments que nous passons également dans l’appel de fonction. Essayez d’ajouter ces deux autres lignes à la fin du programme :

analyse_logique ("je", "je mange", compl_tempo = "à midi")
analyse_logique ("Luigi", "manger", compl_luogo = "au restaurant")

On indique ainsi explicitement à Python qu’il doit remplacer la chaîne “à midi” à la place du paramètre formel compl_time indiqué dans la définition de la fonction et la chaîne “au restaurant” à la place du paramètre compl_place.

Lorsque nous indiquons explicitement le nom d’un paramètre, nous ne sommes plus liés à l’ordre de la définition (et cela est certainement utile si les paramètres sont nombreux et que nous ne nous souvenons plus de leur ordre). De plus, nous pouvons également indiquer avec le nom les paramètres obligatoires (qui ne peuvent en aucun cas être omis). Python appelle les paramètres sans arguments de position de nom (paramètres qui seront substitués selon leur position) et ceux avec les arguments de mot-clé de nom (paramètres substitués selon leur nom) ; La seule restriction est que si nous utilisons des arguments de mots-clés dans l’appel, ils doivent suivre les arguments de position. Essayez ces autres appels :

analyse_logique (compl_ogg = "un croissant", sogg = "je", verbe = "je mange")
analyse_logique (verbe = "manger", sujet = "Luigino")
analyse_logique (compl_ogg = "pasta", "Mon cousin", "manger")

Le dernier appel provoque une erreur car un argument de mot-clé vient avant les arguments positionnels. Enfin, analysons mieux l’ancienne et chère fonction print() : ce n’est que maintenant que nous pouvons comprendre ce qu’elle fait réellement.

>>> help(print)
Help on built-in function print in module builtins:

print(...)
    print(value, ..., sep=' ', end='\n', file=sys.stdout, flush=False)
    
    Prints the values to a stream, or to sys.stdout by default.
    Optional keyword arguments:
    file:  a file-like object (stream); defaults to the current sys.stdout.
    sep:   string inserted between values, default a space.
    end:   string appended after the last value, default a newline.
    flush: whether to forcibly flush the stream.

En analysant les paramètres de print(), nous voyons que value, …, représente la liste variable des arguments à imprimer (nous n’expliquerons pas comment cela se fait ici). Plus intéressants sont les paramètres par défaut. En lisant la description en anglais on apprend que :

Paramètre	Signification
sep	C’est la chaîne qui s’insère entre les différentes valeurs à imprimer : par défaut un espace
end	C’est la chaîne qui est imprimée après le dernier argument, par défaut un \ n (retour chariot)
file	C’est un objet de type fichier (nous les verrons dans la prochaine leçon) sur lequel sont imprimés les arguments : par défaut la console IDLE (sys.stdout indique la sortie standard du système)
flush	Vérifiez l’impression dans les fichiers, nous n’en traitons pas ici

Ainsi, en utilisant les paramètres sep et end, nous pouvons modifier considérablement le comportement standard de print(). Par exemple, nous pouvons empêcher la fonction de s’envelopper en remplaçant le caractère “\ n” du paramètre end par un espace ou une chaîne vide.