DESCRIPTION.

Définit la création d'une nouvelle méthode personnalisée (fonction / routine).  

SYNTAXE.

def FNC_Nom ( parametres ) :

def ⇨ appel de l’instruction [ OBLIGATOIRE ]

FNC_Nom ( ) : ⇨ nom de votre fonction [ OBLIGATOIRE ]

parametres  ⇨ arguments devant être passés à la fonction [ optionnel ]

PRESENTATION.

def est une instruction composée (de plusieurs lignes), ce qui implique le symbole : (2 points) terminant l'appel de def  et l'indentation des lignes de script composant la définition de la fonction.

On pourra appeler (invoquer, exécuter) une fonction, quelle soit native (built-in), importée depuis un module (import) ou définie par le script (utilisateur, personnalisée),  par son nom (ou une référence à son nom) et en lui passant les arguments (ou attributs) qu'elle attend pour sa bonne exécution, Fonction ( Qa , Qn ).

Une fonction se termine (sort, quitte) normalement par l'instruction return. Si l'instruction return est absente, Python effectuera un return None de façon automatique, après l'exécution de la dernière ligne de code dans la fonction. Si plusieurs clauses return sont présentes, seule la première occurrence validée (rencontrée) par le code sera exécutée. Les valeurs retournées, par l'instruction return, doivent être compatibles avec les types des variables associées à l'appel de la fonction.

Une ou plusieurs valeurs peuvent être retournées pour affecter, ou modifier, la ou les variables appelantes.

def FNC_Double ( Q ) :

return Q * 2

Double7 = FNC_Double ( 7 )

print ( Double7 ) retourne 14

Si c'est une autre fonction qui est à l'origine de l'appel, en remplacement de l'un de ses arguments, la valeur de l'argument est celle du return.

def FNC_Double ( Q ) :

return Q * 2

def FNC_Carre ( Q ) :

return Q * Q 

CarreDouble7 = FNC_Carre ( FNC_Double ( 7 ) )

print ( CarreDouble7 ) retourne 196

FNC_Carre a retourné le carre de 14, c'est à dire la valeur retournée par FNC_Double ( 7 ).

Autres exemples de retours sans affectation de variable appelante (lecture directe) avec les deux fonctions définies ci-dessus.

print ( FNC_Double ( 4 ) ) retourne 8

print ( FNC_Carre ( 4 ) ) retourne 16

print ( FNC_Double ( FNC_Carre ( 4 ) ) ) retourne 32

print ( FNC_Carre ( FNC_Double ( 4 ) ) ) retourne 64

print ( FNC_Carre ( FNC_Carre ( 4 ) ) ) retourne 256

Attention au nombre de parenthèses ouvrantes et fermantes.

FONCTION SANS ARGUMENT / PARAMÈTRE.

Une fonction n'a pas obligatoirement de paramètre. Elle effectuera un traitement interne, et retournera le résultat de se traitement si nécessaire.

def FNC_Fonction ( ) : attend un appel de type FNC_Fonction ( )

LST_Fabonacci = [ 0 , 1 , 1 ]

def FNC_Fabonacci ( ) :

knouveau = LST_Fabonacci [ len ( LST_Fabonacci ) - 2 ] + LST_Fabonacci [ len ( LST_Fabonacci ) - 1 ] 

LST_Fabonacci.append ( knouveau )

print ( LST_Fabonacci )

for i in range ( 5 ) :

FNC_Fabonacci ( ) 

print ( LST_Fabonacci )

retourne 

[0, 1, 1]

[0, 1, 1, 2]

[0, 1, 1, 2, 3]

[0, 1, 1, 2, 3, 5]

[0, 1, 1, 2, 3, 5, 8]

[0, 1, 1, 2, 3, 5, 8, 13]

ou :

LST_Fabonacci = [ 0 , 1 , 1 ]

def FNC_Fabonacci ( ) :

knouveau = LST_Fabonacci [ len ( LST_Fabonacci ) - 2 ] + LST_Fabonacci [ len ( LST_Fabonacci ) - 1 ] 

return knouveau 

print ( LST_Fabonacci )

for i in range ( 5 ) :

LST_Fabonacci.append ( FNC_Fabonacci ( ) )

print ( LST_Fabonacci )

retourne 

[0, 1, 1]

[0, 1, 1, 2]

[0, 1, 1, 2, 3]

[0, 1, 1, 2, 3, 5]

[0, 1, 1, 2, 3, 5, 8]

[0, 1, 1, 2, 3, 5, 8, 13]

FONCTION AVEC ARGUMENT(S) / PARAMÈTRE(S) OBLIGATOOIRE(S).

Si on définie une fonction avec des paramètres sans autre précision, lors de l'appel de la fonction, il devra y avoir autant d'arguments passés que de paramètres dans la définition. Les arguments devront aussi être dans le même ordre que les paramètres (fonction dite ordonnée ou positionnelle)  et du type attendu.

def fonction ( Qa , Qb , ... , Qn ) : attend un appel de type 

fonction ( a , b , ... , n )

def FNC_Rectangle ( Qlargeur , Qlongeur ) :

kperimetre = 2 * ( Qlargeur + Qlongeur )

ksuperficie = Qlargeur * Qlongeur 

kdiagonale = ( ( Qlargeur ** 2 ) + ( Qlongeur ** 2 ) ) ** .5

kcaracteristiques = ( kperimetre , ksuperficie , kdiagonale )

return kcaracteristiques

TPL_Rectangle = FNC_Rectangle ( 4 , 7 )

print ( f"Périmètre = { TPL_Rectangle [ 0 ] }. / Aire = { TPL_Rectangle [ 1 ] }. / Diagonale = { TPL_Rectangle [ 2 ] }." )

retourne Périmètre = 22. / Aire = 28. / Diagonale = 8.06225774829855.

Dans tous les types de fonction (types d'arguments / paramètres ci-dessous) la valeur des arguments peut être passée par une variable du type valide.

def FNC_Rectangle ( Qlargeur , Qlongueur ) :

kperimetre = 2 * ( Qlargeur + Qlongueur )

ksuperficie = Qlargeur * Qlongueur 

kdiagonale = ( ( Qlargeur ** 2 ) + ( Qlongueur ** 2 ) ) ** .5

kcaracteristiques = ( kperimetre , ksuperficie , kdiagonale )

return kcaracteristiques

while True :

klargeur = int ( input ( "Entrez la largeur ... " ) )

    klongeur = int ( input ( "Entrez la longueur ... " ) )

TPL_Rectangle = FNC_Rectangle ( klargeur  , klongeur )

print ( f"Périmètre = { TPL_Rectangle [ 0 ] }. / Aire = { TPL_Rectangle [ 1 ] }. / Diagonale = { TPL_Rectangle [ 2 ] }." )

kchoix = input ( "Souhaitez-vous recommencer (entrez n ou N pour arrêter) ... " )

if kchoix == "n" or kchoix  == "N" : break

retourne

Entrez la largeur ... 4

Entrez la longueur ... 7

Périmètre = 22. / Aire = 28. / Diagonale = 8.06225774829855.

Souhaitez-vous recommencer (entrez n ou N pour arrêter) ... 

Entrez la largeur ... 8

Entrez la longueur ... 2

Périmètre = 20. / Aire = 16. / Diagonale = 8.246211251235321.

Souhaitez-vous recommencer (entrez n ou N pour arrêter) ... n

Cependant, si vous connaissez le nom des paramètres utilisés lors de la définition de la fonction, il vous est possible de passer les arguments dans un ordre quelconque, en précisant ce nom et en lui affectant la valeur correspondante.

def FNC_Civilite ( Qnom , Qprenom , Qgenre , Qcategorie ) :

print ( f"Nom : { Qnom }. Prénom : { Qprenom }. Genre : { Qgenre }. Catégorie : { Qcategorie }." )

FNC_Civilite ( Qnom = "ORANGE" , Qprenom = "Sam" , Qgenre = "Masculin" , Qcategorie = "Débutant" )

FNC_Civilite ( Qprenom = "Bill" , Qgenre = "Masculin" , Qnom = "BLEU" , Qcategorie = "Novice" ) 

FNC_Civilite ( Qcategorie = "Gestionnaire" , Qprenom = "Joe" , Qgenre = "Trans" , Qnom = "ROUGE" ) 

FNC_Civilite ( Qgenre = "Féminin" , Qnom = "BLANC" , Qcategorie = "Confirmé" , Qprenom = "Claude" ) 

FNC_Civilite ( Qprenom = "Arim" , Qcategorie = "Apprenti" , Qnom = "VERT" , Qgenre = "Féminin" ) 

FNC_Civilite ( Qgenre = "Trans" , Qcategorie = "Dirigeant" , Qprenom = "Fima" , Qnom = "JAUNE" )

retourne

Nom : ORANGE. Prénom : Sam. Genre : Masculin. Catégorie : Débutant. 

Nom : BLEU. Prénom : Bill. Genre : Masculin. Catégorie : Novice. 

Nom : ROUGE. Prénom : Joe. Genre : Trans. Catégorie : Gestionnaire. 

Nom : BLANC. Prénom : Claude. Genre : Féminin. Catégorie : Confirmé. 

Nom : VERT. Prénom : Arim. Genre : Féminin. Catégorie : Apprenti. 

Nom : JAUNE. Prénom : Fima. Genre : Trans. Catégorie : Dirigeant. 

FONCTION AVEC ATTRIBUT(S) / PARAMÈTRE(S) OPTIONNEL(S).

Si on définie une fonction avec des paramètres ayant une affectation, les arguments correspondants à ces paramètres pourront être omis. Dans ce cas, c'est la valeur de l'affectation qui sera pris comme valeur de l'attribut (fonction dite à arguments nommées).  

def fonction ( Qa = "abc" , Qb = 4 , ... , Qn = ( 2 , 4 , 7 ) ) : attend un appel de type

fonction ( Qa = "new" , Qb = 23 , ... , Qn = ( 0 , 2 , 4 ) ) 

Il est possible de passer les arguments dans un ordre quelconque, en précisant ce nom et en lui affectant la valeur correspondante, mais chaque valeur passé doit être précédée d'un nom d'attribut valide, c'est á dire présent dans la définition de la fonction. Si on indique un couple nom/valeur, avec nom d'attribut absent de la définition, Python lèvera une exception.

def FNC_Test ( Qa = "abc" , Qb = 123 , Qc = ( "T" , "u" , "p" , "l" , "e" ) , Qd = [ "L" , "i" , "s" , "t" ,"e" ] ) :

print ( f" Qa = { Qa } " )

print ( f" Qb = { Qb } " )

print ( f" Qc = { Qc } " )

print ( f" Qd = { Qd } " )

print ( "==============" )

FNC_Test ( Qa = "changé" , Qb = 9876543210 , Qc = ( "N" , "o" , "u" , "e" , "a"  , "u" , "x" ) , Qd = [ "P" , "Y" , "T" , "H" ,"O" , "N" ] )

FNC_Test ( Qb = 9876543210 , Qc = ( "N" , "o" , "u" , "e" , "a"  , "u" , "x" ) , Qd = [ "P" , "Y" , "T" , "H" ,"O" , "N" ] )

FNC_Test ( Qa = "changé" , Qc = ( "N" , "o" , "u" , "e" , "a"  , "u" , "x" ) , Qd = [ "P" , "Y" , "T" , "H" ,"O" , "N" ] )

FNC_Test ( Qa = "changé" , Qb = 9876543210 , Qd = [ "P" , "Y" , "T" , "H" ,"O" , "N" ] )

FNC_Test ( Qa = "changé" , Qb = 9876543210 , Qc = ( "N" , "o" , "u" , "e" , "a"  , "u" , "x" ) )

FNC_Test (  )

FNC_Test ( Qc = ( "N" , "o" , "u" , "e" , "a"  , "u" , "x" ) , Qb = 9876543210 , Qd = [ "P" , "Y" , "T" , "H" ,"O" , "N" ] , Qa = "changé"  )

FNC_Test ( Qd = [ "P" , "Y" , "T" , "H" ,"O" , "N" ] )

retourne

 Qa = changé 

 Qb = 9876543210 

 Qc = ('N', 'o', 'u', 'e', 'a', 'u', 'x') 

 Qd = ['P', 'Y', 'T', 'H', 'O', 'N'] 

==============

 Qa = abc 

 Qb = 9876543210 

 Qc = ('N', 'o', 'u', 'e', 'a', 'u', 'x') 

 Qd = ['P', 'Y', 'T', 'H', 'O', 'N'] 

==============

 Qa = changé 

 Qb = 123 

 Qc = ('N', 'o', 'u', 'e', 'a', 'u', 'x') 

 Qd = ['P', 'Y', 'T', 'H', 'O', 'N'] 

==============

 Qa = changé 

 Qb = 9876543210 

 Qc = ('T', 'u', 'p', 'l', 'e') 

 Qd = ['P', 'Y', 'T', 'H', 'O', 'N'] 

==============

 Qa = changé 

 Qb = 9876543210 

 Qc = ('N', 'o', 'u', 'e', 'a', 'u', 'x') 

 Qd = ['L', 'i', 's', 't', 'e'] 

==============

 Qa = abc 

 Qb = 123 

 Qc = ('T', 'u', 'p', 'l', 'e') 

 Qd = ['L', 'i', 's', 't', 'e'] 

==============

 Qa = changé 

 Qb = 9876543210 

 Qc = ('N', 'o', 'u', 'e', 'a', 'u', 'x') 

 Qd = ['P', 'Y', 'T', 'H', 'O', 'N'] 

==============

 Qa = abc 

 Qb = 123 

 Qc = ('T', 'u', 'p', 'l', 'e') 

 Qd = ['P', 'Y', 'T', 'H', 'O', 'N'] 

==============

FONCTION AVEC ARGUMENT(S) / PARAMÈTRE(S) INCONNU(S).

Lors de la définition de la fonction, on ne connait pas forcément la quantité d'arguments qui seront passés. Dans ce cas, on utilisera la notation *Qtuple. Cette notation stipule que Qtuple est un tuple ( ) qui recevra comme éléments, toutes les valeurs passées lors de l'appel de la fonction (dite étoile *), et du type attendu.

def fonction ( *Qtuple ) : attend un appel de type 

fonction ( a , b , ... , n )

def FNC_Bizard ( *Qtuple ) :

if len ( Qtuple ) == 0 : return "C'est quoi ça, sans argument ?"

kstring = ""

kentier = 0

for kelement in Qtuple :

if type ( kelement ) == str :  kstring = kstring + kelement 

if type ( kelement ) == int : kentier = kentier + kelement 

return kstring , kentier

print ( FNC_Bizard ( 2 , 3 , 4 , "a" , "b" , "c" ) ) retourne ('abc', 9)

print ( FNC_Bizard ( ) ) retourne C'est quoi ça, sans argument ?

print ( FNC_Bizard ( 1, 1.5 , "y" , 2 , "e" , "s" , 3.0 , 4 , "!" ) ) retourne ('yes!', 7)

FONCTION AVEC ARGUMENT(S) / PARAMÈTRE(S) POLYNOMMEE(S).

De même, il est possible de définir une fonction acceptant comme argument un ou plusieurs, voire aucun, arguments nommés. Pour cela on utilisera la notation **Qdict. Cette notation stipule que Qdict est un dict ( ) qui recevra tous les couples clé/valeur comme éléments passés lors de l'appel de la fonction (dite double étoiles **).

def fonction ( **Qdict ) : attend un appel de type

fonction ( Qa = "new" , Qb = 23 , ... , Qn = ( 0 , 2 , 4 ) )

def FNC_Reorganisation ( **Qdict ) :

knouveau = { }

print ( Qdict )

for kcle , kvaleur in Qdict.items ( ) :

if kcle == "Nom" : knouveau.update ( { kcle : kvaleur } )

if kcle == "Prénom" : knouveau.update ( { kcle : kvaleur } )

return knouveau 

print ( FNC_Reorganisation ( Age = 42 , Ville  = "Montréal" , Prénom = "Michel" , Taille = 1.82 , Nom = "BARHETTE" ) )

retourne  {'Age': 42, 'Ville': 'Montréal', 'Prénom': 'Michel', 'Taille': 1.82, 'Nom': 'BARHETTE'}

{'Prénom': 'Michel', 'Nom': 'BARHETTE'}

FONCTION AVEC ANNOTATION DES ARGUMENT(S) / PARAMÈTRE(S) ET VALEUR DE RETOUR.

Depuis Python 3.5, il est devenu possible, mais sans obligation, d'annoter les variables passer comme arguments ou comme valeur de retour. Cela pourra être utile pour, lors de la relecture pour la maintenant ou pour permettre une meilleure conversion depuis un autre langage, préciser le, ou les, types de valeur attendu par le, ou les, arguments et et la, ou les, valeurs retournées par la fonction.

L'annotation des variables dans la définition d'une fonction, n'est qu'une indication et n'est pas coercitive. Aucune vérification ne sera faite, par Python, pour savoir si les valeurs passées à la fonction sont bien du type indiqué dans sa définition. Ni même si les valeurs retournées sont bien du type donné. Il  appartient toujours au développeur de faire les tests pour s'assurer de la bonne correspondance entres les types des valeurs passées et celui attendu. Ces test pourront être fait soit avant l'appel, soit dans le corps de la fonction.

La syntaxe générale définissant une fonction avec annotation de variables est : def FNC_Nom ( Q : type = defaut ) -> type :, où : - Q est la désignation du paramètre ;

- : type précise le type de valeur pour Q ;

- = defaut est la valeur par défaut de Q ;

- -> type indique le type de valeur qui sera retourné.

type doit être être une expression valide pour désigner un type de donnés, tel que : 

- bool pour les valeurs booléennes de la classe bool ( ) ;

- int pour les nombres entiers de la classe int ( ) ;

- float pour les nombres réels de la classe float ( ) ;

- str pour les chaine de caractères de la classe str ( ) ;

- n'importe quel objet pouvant être affectée à une variable, même s'il ont été importés ou créés.

def FNC_Table ( Qtable : int , Qdebut : int = 1 ) -> int :

for kvaleur in range ( Qdebut , Qdebut + 10 ) :

print ( kvaleur , "x" , Qtable , "=" , kvaleur * Qtable )

return Qtable ** 2

FNC_Table ( 7 , 4 )

retourne

4 x 7 = 28

5 x 7 = 35

6 x 7 = 42

7 x 7 = 49

8 x 7 = 56

9 x 7 = 63

10 x 7 = 70

11 x 7 = 77

12 x 7 = 84

13 x 7 = 91

Depuis Python 3.10, il est possible d'indiquer plusieurs types pour une même variable en les séparant par le symbole |. 

def FNC_Table ( Qtable : int | float , Qdebut : int = 1 ) -> int | float :

for kvaleur in range ( Qdebut , Qdebut + 10 ) :

print ( kvaleur , "x" , Qtable , "=" , kvaleur * Qtable )

return Qtable ** 2

REMARQUES.

Il est possible de combiner 2, 3 ou 4 types de paramètres lors de la définition d'une fonction, à condition de respecter l'ordre de suivant :

- les paramètres obligatoires ;

- les paramètres nommés ;

- les paramètres étoilés ;

- les paramètres double étoilés.

Selon la forme général suivante :

def FNC_Modele (  Qa , Qb , Qn , Qaa = 3 , Qbb = "ABC" , Qnn = "951" , * Qtuple , **Qdict ) : 

Quelques formes légales possibles en exemple :

def FNC_Modele (  Qbb = "ABC" , Qnn = "951" , * Qtuple , **Qdict ) : 

def FNC_Modele (  Qa , Qb , Qn , Qnn = "951" , * Qtuple ) : 

def FNC_Modele (  Qbb = "ABC" , Qnn = "951" , **Qdict ) : 

def FNC_Modele (  Qa , Qb , Qn , * Qtuple , **Qdict ) : 

Et des formes non-légales :

def FNC_Modele (  Qbb = "ABC" , Qnn = "951" , Qa , Qb , Qn ,  * Qtuple , **Qdict ) : 

def FNC_Modele (  Qa , Qb , Qn , Qnn = "951" , * Qtuple , Qbb = "ABC" , Qnn = "951" ) : 

def FNC_Modele (  * Qtuple , Qbb = "ABC" , Qnn = "951" , **Qdict ) : 

def FNC_Modele (  **Qdict , Qa , Qb , Qn , * Qtuple ,  ) : 

Toutefois, cette méthode est peu recommandée, pour des questions de lisibilité et de maintenances futures. De plus, l'appel d'une méthode doit être faite selon les mêmes priorité. Il n'est pas possible de passer un argument nommé après les arguments étoilés par exemple.

Voir aussi l'instruction yield comme complément d'information.