Les fonctions Python expliquées : Créer des modules de code réutilisables

Une fonction est un bloc de code organisé et réutilisable qui est utilisé pour effectuer une seule action liée. Les fonctions offrent une meilleure modularité pour votre application et un haut degré de réutilisation de code.

Comme vous le savez déjà, Python vous donne de nombreuses fonctions intégrées comme print(), etc. mais vous pouvez aussi créer vos propres fonctions. Ces fonctions sont appelées fonctions définies par l'utilisateur.

Définition d'une fonction

Vous pouvez définir des fonctions pour fournir la fonctionnalité requise. Voici des règles simples pour définir une fonction en Python.

• Les blocs de fonction commencent par le mot-clé def suivi du nom de la fonction et de parenthèses ( ( ) ).

• Tout paramètre d'entrée ou argument doit être placé dans ces parenthèses. Vous pouvez également définir des paramètres à l'intérieur de ces parenthèses.

• La première instruction d'une fonction peut être une instruction optionnelle - la chaîne de documentation de la fonction ou docstring.

• Le bloc de code à l'intérieur de chaque fonction commence par deux-points (:) et est indenté.

• L'instruction return [expression] quitte une fonction, en renvoyant optionnellement une expression à l'appelant. Une instruction return sans arguments est la même que return None.

Syntaxe

def nomfonction( parametres ): 
    "docstring_de_la_fonction" 
    suite_de_la_fonction 
    return [expression]

Par défaut, les paramètres ont un comportement positionnel et vous devez les informer dans le même ordre qu'ils ont été définis.

Exemple

La fonction suivante prend une chaîne comme paramètre d'entrée et l'affiche sur l'écran standard.

def printme( str ): 
    "Ceci affiche une chaîne passée dans cette fonction" 
    print str 
    return

Appel d'une fonction

Définir une fonction ne lui donne qu'un nom, spécifie les paramètres qui doivent être inclus dans la fonction et structure les blocs de code.

Une fois la structure de base d'une fonction finalisée, vous pouvez l'exécuter en l'appelant depuis une autre fonction ou directement depuis l'invite Python. Voici l'exemple pour appeler la fonction printme() :

Démonstration en direct

#!/usr/bin/python 
# La définition de la fonction est ici 
def printme( str ): 
    "Ceci affiche une chaîne passée dans cette fonction" 
    print str 
    return; 
# Maintenant, vous pouvez appeler la fonction printme 
printme("Je suis le premier appel à la fonction définie par l'utilisateur !") 
printme("Encore un second appel à la même fonction")

Lorsque le code ci-dessus est exécuté, il produit le résultat suivant :

Je suis le premier appel à la fonction définie par l'utilisateur ! 
Encore un second appel à la même fonction

Passage par référence vs valeur

Tous les paramètres (arguments) dans le langage Python sont passés par référence. Cela signifie que si vous changez ce à quoi un paramètre fait référence au sein d'une fonction, le changement se répercute également dans la fonction appelante. Par exemple :

Démonstration en direct

#!/usr/bin/python 
# La définition de la fonction est ici 
def changeme( mylist ): 
    "Ceci change une liste passée dans cette fonction" 
    mylist.append([1,2,3,4]); 
    print "Valeurs à l'intérieur de la fonction : ", mylist 
    return 
# Maintenant, vous pouvez appeler la fonction changeme 
mylist = [10,20,30]; 
changeme( mylist ); 
print "Valeurs à l'extérieur de la fonction : ", mylist

Ici, nous maintenons la référence de l'objet passé et ajoutons des valeurs dans le même objet. Cela produirait le résultat suivant :

Valeurs à l'intérieur de la fonction : [10, 20, 30, [1, 2, 3, 4]] 
Valeurs à l'extérieur de la fonction : [10, 20, 30, [1, 2, 3, 4]]

Il y a un autre exemple où l'argument est passé par référence et la référence est écrasée à l'intérieur de la fonction appelée.

Démonstration en direct

#!/usr/bin/python 
# La définition de la fonction est ici 
def changeme( mylist ): 
    "Ceci change une liste passée dans cette fonction" 
    mylist = [1,2,3,4]; # Ceci assignerait une nouvelle référence dans mylist 
    print "Valeurs à l'intérieur de la fonction : ", mylist 
    return 
# Maintenant, vous pouvez appeler la fonction changeme 
mylist = [10,20,30]; 
changeme( mylist ); 
print "Valeurs à l'extérieur de la fonction : ", mylist

Le paramètre mylist est local à la fonction changeme. Changer mylist à l'intérieur de la fonction n'affecte pas mylist. La fonction n'accomplit rien et finalement cela produirait le résultat suivant :

Valeurs à l'intérieur de la fonction : [1, 2, 3, 4] 
Valeurs à l'extérieur de la fonction : [10, 20, 30]

Arguments de fonction

Vous pouvez appeler une fonction en utilisant les types d'arguments formels suivants :

• Arguments requis
• Arguments par mot-clé
• Arguments par défaut
• Arguments de longueur variable

Arguments requis

Les arguments requis sont les arguments passés à une fonction dans l'ordre positionnel correct. Ici, le nombre d'arguments dans l'appel de fonction doit correspondre exactement à la définition de la fonction.

Pour appeler la fonction printme(), vous devez absolument passer un argument, sinon cela donne une erreur de syntaxe comme suit :

Démonstration en direct

#!/usr/bin/python 
# La définition de la fonction est ici 
def printme( str ): 
    "Ceci affiche une chaîne passée dans cette fonction" 
    print str 
    return; 
# Maintenant, vous pouvez appeler la fonction printme 
printme()

Lorsque le code ci-dessus est exécuté, il produit le résultat suivant :

Traceback (most recent call last): 
File "test.py", line 11, in <module> 
printme(); 
TypeError: printme() takes exactly 1 argument (0 given)

Arguments par mot-clé

Les arguments par mot-clé sont liés aux appels de fonction. Lorsque vous utilisez des arguments par mot-clé dans un appel de fonction, l'appelant identifie les arguments par le nom du paramètre.

Cela vous permet d'ignorer des arguments ou de les placer hors ordre car l'interpréteur Python est capable d'utiliser les mots-clés fournis pour faire correspondre les valeurs avec les paramètres. Vous pouvez également faire des appels par mot-clé à la fonction printme() de la manière suivante :

Démonstration en direct

#!/usr/bin/python 
# La définition de la fonction est ici 
def printme( str ): 
    "Ceci affiche une chaîne passée dans cette fonction" 
    print str 
    return; 
# Maintenant, vous pouvez appeler la fonction printme 
printme( str = "Ma chaîne")

Lorsque le code ci-dessus est exécuté, il produit le résultat suivant :

Ma chaîne

L'exemple suivant donne une image plus claire. Notez que l'ordre des paramètres n'a pas d'importance.

Démonstration en direct

#!/usr/bin/python 
# La définition de la fonction est ici 
def printinfo( name, age ): 
    "Ceci affiche une info passée dans cette fonction" 
    print "Nom : ", name 
    print "Âge ", age 
    return; 
# Maintenant, vous pouvez appeler la fonction printinfo 
printinfo( age=50, name="miki" )

Lorsque le code ci-dessus est exécuté, il produit le résultat suivant :

Nom : miki 
Âge 50

Arguments par défaut

Un argument par défaut est un argument qui assume une valeur par défaut si une valeur n'est pas fournie dans l'appel de fonction pour cet argument. L'exemple suivant donne une idée sur les arguments par défaut, il affiche l'âge par défaut s'il n'est pas passé :

Démonstration en direct

#!/usr/bin/python 
# La définition de la fonction est ici 
def printinfo( name, age = 35 ): 
    "Ceci affiche une info passée dans cette fonction" 
    print "Nom : ", name 
    print "Âge ", age 
    return; 
# Maintenant, vous pouvez appeler la fonction printinfo 
printinfo( age=50, name="miki" ) 
printinfo( name="miki" )

Lorsque le code ci-dessus est exécuté, il produit le résultat suivant :

Nom : miki 
Âge 50 
Nom : miki 
Âge 35

Arguments de longueur variable

Vous pourriez avoir besoin de traiter une fonction pour plus d'arguments que vous n'en avez spécifié lors de la définition de la fonction. Ces arguments sont appelés arguments de longueur variable et ne sont pas nommés dans la définition de la fonction, contrairement aux arguments requis et par défaut.

La syntaxe pour une fonction avec des arguments variables sans mot-clé est la suivante :

def nomfonction([formal_args,] *var_args_tuple ): 
    "docstring_de_la_fonction" 
    suite_de_la_fonction 
    return [expression]

Un astérisque (*) est placé avant le nom de la variable qui contient les valeurs de tous les arguments variables sans mot-clé. Ce tuple reste vide si aucun argument additionnel n'est spécifié lors de l'appel de fonction. Voici un exemple simple :

Démonstration en direct

#!/usr/bin/python 
# La définition de la fonction est ici 
def printinfo( arg1, *vartuple ): 
    "Ceci affiche des arguments variables passés" 
    print "La sortie est : " 
    print arg1 
    for var in vartuple: 
        print var 
    return; 
# Maintenant, vous pouvez appeler la fonction printinfo 
printinfo( 10 ) 
printinfo( 70, 60, 50 )

Lorsque le code ci-dessus est exécuté, il produit le résultat suivant :

La sortie est : 
10 
La sortie est : 
70 
60 
50

Les fonctions Anonymes

Ces fonctions sont appelées anonymes car elles ne sont pas déclarées de la manière standard en utilisant le mot-clé def. Vous pouvez utiliser le mot-clé lambda pour créer de petites fonctions anonymes.

• Les formes lambda peuvent prendre n'importe quel nombre d'arguments mais retournent une seule valeur sous forme d'expression. Elles ne peuvent pas contenir de commandes ou d'expressions multiples.

• Une fonction anonyme ne peut pas être un appel direct à print car lambda nécessite une expression.

• Les fonctions lambda ont leur propre espace de noms local et ne peuvent pas accéder aux variables autres que celles dans leur liste de paramètres et celles dans l'espace de noms global.

• Bien qu'il apparaisse que les lambda sont une version en une ligne d'une fonction, ils ne sont pas équivalents aux instructions inline en C ou C++, dont le but est d'éviter l'allocation de pile de fonction lors de l'invocation pour des raisons de performance.

Syntaxe

La syntaxe des fonctions lambda ne contient qu'une seule instruction, qui est la suivante :

lambda [arg1 [,arg2,.....argn]]:expression

Voici l'exemple pour montrer comment la forme lambda de fonction fonctionne :

Démonstration en direct

#!/usr/bin/python 
# La définition de la fonction est ici 
sum = lambda arg1, arg2: arg1 + arg2; 
# Maintenant, vous pouvez appeler sum comme une fonction 
print "Valeur du total : ", sum( 10, 20 ) 
print "Valeur du total : ", sum( 20, 20 )

Lorsque le code ci-dessus est exécuté, il produit le résultat suivant :

Valeur du total : 30 
Valeur du total : 40

L'instruction return

L'instruction return [expression] quitte une fonction, en renvoyant optionnellement une expression à l'appelant. Une instruction return sans arguments est la même que return None.

Tous les exemples ci-dessus ne retournent aucune valeur. Vous pouvez retourner une valeur d'une fonction comme suit :

Démonstration en direct

#!/usr/bin/python 
# La définition de la fonction est ici 
def sum( arg1, arg2 ): 
    # Additionne les deux paramètres et les retourne. 
    total = arg1 + arg2 
    print "À l'intérieur de la fonction : ", total 
    return total; 
# Maintenant, vous pouvez appeler la fonction sum 
total = sum( 10, 20 ); 
print "À l'extérieur de la fonction : ", total

Lorsque le code ci-dessus est exécuté, il produit le résultat suivant :

À l'intérieur de la fonction : 30 
À l'extérieur de la fonction : 30

Portée des variables

Toutes les variables dans un programme peuvent ne pas être accessibles à tous les emplacements de ce programme. Cela dépend de l'endroit où vous avez déclaré une variable.

La portée d'une variable détermine la partie du programme où vous pouvez accéder à un identifiant particulier. Il y a deux portées de base des variables en Python :

• Variables globales
• Variables locales

Variables globales vs locales

Les variables définies à l'intérieur d'un corps de fonction ont une portée locale, et celles définies à l'extérieur ont une portée globale.

Cela signifie que les variables locales ne peuvent être accessibles qu'à l'intérieur de la fonction dans laquelle elles sont déclarées, alors que les variables globales peuvent être accessibles dans tout le corps du programme par toutes les fonctions. Lorsque vous appelez une fonction, les variables déclarées à l'intérieur sont mises en portée. Voici un exemple simple :

Démonstration en direct

#!/usr/bin/python 
total = 0; # Ceci est une variable globale. 
# La définition de la fonction est ici 
def sum( arg1, arg2 ): 
    # Additionne les deux paramètres et les retourne. 
    total = arg1 + arg2; # Ici total est une variable locale. 
    print "À l'intérieur de la fonction total local : ", total 
    return total; 
# Maintenant, vous pouvez appeler la fonction sum 
sum( 10, 20 ); 
print "À l'extérieur de la fonction total global : ", total

Lorsque le code ci-dessus est exécuté, il produit le résultat suivant :

À l'intérieur de la fonction total local : 30 
À l'extérieur de la fonction total global : 0