Comment définir des fonctions en Python 3

Introduction

A function is a block of instructions that performs an action and, once defined, can be reused. Functions make code more modular, allowing you to use the same code over and over again.

Python dispose d’un certain nombre de fonctions intégrées que vous connaissez peut-être, notamment :

• print() qui permet d’imprimer un objet dans le terminal
• int() qui convertira une chaîne de caractères ou un nombre en un type de données entier
• len() qui renvoie la longueur d’un objet

Les noms des fonctions incluent des parenthèses et peuvent inclure des paramètres.

Dans ce tutoriel, nous verrons comment définir vos propres fonctions à utiliser dans vos projets de codage.

Prérequis

Vous devez avoir Python 3 installé et un environnement de programmation configuré sur votre ordinateur ou serveur. Si vous n’avez pas d’environnement de programmation configuré, vous pouvez vous référer aux guides d’installation et de configuration pour un environnement de programmation local ou pour un environnement de programmation sur votre serveur adapté à votre système d’exploitation (Ubuntu, CentOS, Debian, etc.).

Définition d’une fonction

Commençons par transformer le classique programme « Bonjour, tout le monde ! » en une fonction.

Nous allons créer un nouveau fichier texte dans notre éditeur de texte préféré, et nommer le programme hello.py. Ensuite, nous allons définir la fonction.

A function is defined by using the def keyword, followed by a name of your choosing, followed by a set of parentheses which hold any parameters the function will take (they can be empty), and ending with a colon.

Dans ce cas, nous allons définir une fonction nommée hello():

def hello():

Cela établit l’instruction initiale pour créer une fonction.

À partir de là, nous ajouterons une deuxième ligne avec une indentation de 4 espaces pour fournir les instructions sur ce que la fonction fait. Dans ce cas, nous allons imprimer Bonjour, tout le monde ! sur la console :

def hello():
    print("Hello, World!")

Notre fonction est maintenant entièrement définie, mais si nous exécutons le programme à ce stade, rien ne se passera car nous n’avons pas appelé la fonction.

Donc, en dehors de notre bloc de fonction définie, appelons la fonction avec hello():

def hello():
    print("Hello, World!")

hello()

Maintenant, exécutons le programme :

python hello.py

Vous devriez recevoir la sortie suivante:

Output
Hello, World!

Les fonctions peuvent être plus compliquées que la fonction hello() que nous avons définie ci-dessus. Par exemple, nous pouvons utiliser des boucles for, des déclarations conditionnelles, et plus encore à l’intérieur de notre bloc de fonction.

Par exemple, la fonction définie ci-dessous utilise une déclaration conditionnelle pour vérifier si l’entrée pour la variable name contient une voyelle, puis utilise une boucle for pour itérer sur les lettres dans la chaîne name.

# Définir la fonction noms()
def names():
    # Mettre en place la variable name avec l'entrée
    name = str(input('Enter your name: '))
    # Vérifier si name contient une voyelle
    if set('aeiou').intersection(name.lower()):
        print('Your name contains a vowel.')
    else:
        print('Your name does not contain a vowel.')

    # Itérer sur name
    for letter in name:
        print(letter)

# Appeler la fonction
names()

La fonction noms() que nous avons définie ci-dessus met en place une déclaration conditionnelle et une boucle for, montrant comment le code peut être organisé à l’intérieur d’une définition de fonction. Cependant, selon ce que nous avons l’intention de faire avec notre programme et comment nous voulons organiser notre code, nous pouvons vouloir définir la déclaration conditionnelle et la boucle for comme deux fonctions distinctes.

Définir des fonctions dans un programme rend notre code modulaire et réutilisable afin que nous puissions appeler les mêmes fonctions sans les réécrire.

Travailler avec des Paramètres

Jusqu’à présent, nous avons examiné des fonctions avec des parenthèses vides qui ne prennent pas d’arguments, mais nous pouvons définir des paramètres dans les définitions de fonctions à l’intérieur de leurs parenthèses.

A parameter is a named entity in a function definition, specifying an argument that the function can accept.

Créons un petit programme qui prend en paramètres x, y et z. Nous allons créer une fonction qui ajoute les paramètres ensemble dans différentes configurations. Les sommes de ceux-ci seront imprimées par la fonction. Ensuite, nous appellerons la fonction et passerons des nombres dans la fonction.

def add_numbers(x, y, z):
    a = x + y
    b = x + z
    c = y + z
    print(a, b, c)

add_numbers(1, 2, 3)

Nous avons passé le nombre 1 pour le paramètre x, 2 pour le paramètre y et 3 pour le paramètre z. Ces valeurs correspondent à chaque paramètre dans l’ordre où ils sont donnés.

Le programme fait essentiellement le calcul suivant en fonction des valeurs que nous avons passées aux paramètres:

a = 1 + 2
b = 1 + 3
c = 2 + 3

La fonction imprime également a, b et c, et en fonction du calcul ci-dessus, nous nous attendons à ce que a soit égal à 3, b soit 4 et c soit 5. Exécutons le programme:

python add_numbers.py

Output
3 4 5

Lorsque nous passons 1, 2 et 3 comme paramètres à la fonction add_numbers(), nous obtenons la sortie attendue.

Les paramètres sont des arguments qui sont généralement définis comme des variables dans les définitions de fonction. Ils peuvent recevoir des valeurs lors de l’exécution de la méthode, en passant les arguments dans la fonction.

Arguments par mot-clé

En plus d’appeler les paramètres dans l’ordre, vous pouvez utiliser des arguments par mot-clé dans un appel de fonction, où l’appelant identifie les arguments par le nom du paramètre.

Lorsque vous utilisez des arguments par mot-clé, vous pouvez utiliser des paramètres dans un ordre différent car l’interpréteur Python utilisera les mots-clés fournis pour faire correspondre les valeurs aux paramètres.

Créons maintenant une fonction qui nous montrera les informations de profil pour un utilisateur. Nous passerons des paramètres sous forme de nom_utilisateur (censé être une chaîne de caractères) et abonnés (censé être un entier).

# Définir la fonction avec des paramètres
def profile_info(username, followers):
    print("Username: " + username)
    print("Followers: " + str(followers))

Dans la déclaration de définition de fonction, nom_utilisateur et abonnés sont contenus entre parenthèses de la fonction profile_info(). Le bloc de la fonction imprime des informations sur l’utilisateur sous forme de chaînes de caractères, en utilisant les deux paramètres.

Maintenant, nous pouvons appeler la fonction et lui attribuer des paramètres :

def profile_info(username, followers):
    print("Username: " + username)
    print("Followers: " + str(followers))

# Appeler la fonction avec des paramètres attribués comme ci-dessus
profile_info("sammyshark", 945)

# Appeler la fonction avec des arguments par mot-clé
profile_info(username="AlexAnglerfish", followers=342)

Dans le premier appel de fonction, nous avons rempli les informations avec un nom d’utilisateur de sammyshark et un nombre de followers de 945, dans le deuxième appel de fonction nous avons utilisé des arguments de mots-clés, attribuant des valeurs aux variables d’argument.

Exécutons le programme :

python profile.py

Output
Username: sammyshark
Followers: 945
Username: AlexAnglerfish
Followers: 342

La sortie nous montre les noms d’utilisateur et les nombres de followers pour les deux utilisateurs.

Cela nous permet également de modifier l’ordre des paramètres, comme dans cet exemple du même programme avec un appel différent :

def profile_info(username, followers):
    print("Username: " + username)
    print("Followers: " + str(followers))

# Changer l'ordre des paramètres
profile_info(followers=820, username="cameron-catfish")

Quand nous exécutons à nouveau le programme avec la commande python profile.py, nous recevrons la sortie suivante :

Output
Username: cameron-catfish
Followers: 820

Parce que la définition de fonction maintient le même ordre des instructions print(), si nous utilisons des arguments de mots-clés, l’ordre dans lequel nous les passons à l’appel de fonction n’a pas d’importance.

Valeurs d’argument par défaut

Nous pouvons également fournir des valeurs par défaut pour un ou les deux paramètres. Créons une valeur par défaut pour le paramètre followers avec une valeur de 1 :

def profile_info(username, followers=1):
    print("Username: " + username)
    print("Followers: " + str(followers))

Maintenant, nous pouvons exécuter la fonction avec seulement la fonction d’utilisateur attribuée, et le nombre de followers sera automatiquement par défaut à 1. Nous pouvons également toujours changer le nombre de followers si nous le souhaitons.

def profile_info(username, followers=1):
    print("Username: " + username)
    print("Followers: " + str(followers))

profile_info(username="JOctopus")
profile_info(username="sammyshark", followers=945)

Quand nous exécutons le programme avec la commande python profile.py, nous recevrons la sortie suivante :

Output
Username: JOctopus
Followers: 1
Username: sammyshark
Followers: 945

Fournir des paramètres par défaut avec des valeurs peut nous permettre de sauter la définition de valeurs pour chaque argument qui a déjà une valeur par défaut.

Retourner une valeur

Vous pouvez passer une valeur de paramètre dans une fonction, et une fonction peut également produire une valeur.

A function can produce a value with the return statement, which will exit a function and optionally pass an expression back to the caller. If you use a return statement with no arguments, the function will return None.

Jusqu’à présent, nous avons utilisé l’instruction print() au lieu de l’instruction return dans nos fonctions. Créons un programme qui, au lieu d’imprimer, renverra une variable.

Dans un nouveau fichier texte appelé square.py, nous allons créer un programme qui élève au carré le paramètre x et renvoie la variable y. Nous effectuons un appel à print de la variable résultat, qui est formée en exécutant la fonction square() avec 3 passé en paramètre.

def square(x):
    y = x ** 2
    return y

result = square(3)
print(result)

Nous pouvons exécuter le programme et recevoir la sortie :

python square.py

Output
9

L’entier 9 est retourné en sortie, ce à quoi nous nous attendrions en demandant à Python de trouver le carré de 3.

Pour mieux comprendre le fonctionnement de l’instruction return, nous pouvons commenter l’instruction return dans le programme :

def square(x):
    y = x ** 2
    # retour y

result = square(3)
print(result)

Maintenant, exécutons à nouveau le programme :

python square.py

Output
None

Sans utiliser l’instruction return ici, le programme ne peut pas renvoyer de valeur, donc la valeur par défaut est None.

Comme autre exemple, dans le programme add_numbers.py ci-dessus, nous pourrions remplacer l’instruction print() par une instruction return.

def add_numbers(x, y, z):
    a = x + y
    b = x + z
    c = y + z
    return a, b, c

sums = add_numbers(1, 2, 3)
print(sums)

En dehors de la fonction, nous avons défini la variable sums égale au résultat de la fonction prenant 1, 2 et 3 comme nous l’avons fait précédemment. Ensuite, nous avons appelé un affichage de la variable sums.

Exécutons à nouveau le programme maintenant qu’il contient l’instruction return:

python add_numbers.py

Output
(3, 4, 5)

Nous recevons les mêmes nombres 3, 4 et 5 en sortie que ceux que nous avons obtenus précédemment en utilisant l’instruction print() dans la fonction. Cette fois, il est livré sous forme de tuple car la liste d’expressions de l’instruction return comporte au moins une virgule.

Les fonctions se terminent immédiatement lorsqu’elles rencontrent une instruction return, qu’elles retournent ou non une valeur.

def loop_five():
    for x in range(0, 25):
        print(x)
        if x == 5:
            # Arrêter la fonction à x == 5
            return
    print("This line will not execute.")

loop_five()

En utilisant l’instruction return à l’intérieur de la boucle for, la fonction se termine, donc la ligne qui est en dehors de la boucle ne s’exécutera pas. Si, au contraire, nous avions utilisé une instruction break, seule la boucle aurait été interrompue à ce moment-là, et la dernière ligne print() s’exécuterait.

Le statement return quitte une fonction et peut retourner une valeur lorsqu’il est émis avec un paramètre.

Utilisation de main() comme une fonction

Bien que en Python vous puissiez appeler la fonction en bas de votre programme et qu’elle s’exécutera (comme nous l’avons fait dans les exemples ci-dessus), de nombreux langages de programmation (comme C++ et Java) nécessitent une fonction main pour s’exécuter. Inclure une fonction main(), bien que ce ne soit pas obligatoire, peut structurer nos programmes Python de manière logique en regroupant les composants les plus importants du programme dans une seule fonction. Cela peut également rendre nos programmes plus faciles à lire pour les non-programmeurs Python.

Nous allons commencer par ajouter une fonction main() au programme hello.py ci-dessus. Nous conserverons notre fonction hello(), puis définirons une fonction main():

def hello():
    print("Hello, World!")

def main():

Dans la fonction main(), incluons une instruction print() pour nous indiquer que nous sommes dans la fonction main(). De plus, appelons la fonction hello() dans la fonction main():

def hello():
    print("Hello, World!")


def main():
    print("This is the main function")
    hello()

Enfin, au bas du programme, nous appellerons la fonction main():

def hello():
    print("Hello, World!")

def main():
    print("This is the main function.")
    hello()

main()

À ce stade, nous pouvons exécuter notre programme:

python hello.py

Nous recevrons la sortie suivante:

Output
This is the main function.
Hello, World!

Parce que nous avons appelé la fonction hello() à l’intérieur de main() et ensuite seulement appelé main() pour l’exécuter, le texte Hello, World! s’est imprimé une seule fois, après la chaîne qui nous indiquait que nous étions dans la fonction principale.

Ensuite, nous allons travailler avec plusieurs fonctions, donc il vaut la peine de passer en revue la portée des variables globales et locales. Si vous définissez une variable dans un bloc de fonction, vous ne pourrez utiliser cette variable que dans cette fonction. Si vous souhaitez utiliser des variables entre les fonctions, il peut être préférable de déclarer une variable globale.

En Python, '__main__' est le nom de l’espace où le code de niveau supérieur s’exécutera. Lorsqu’un programme est exécuté à partir de l’entrée standard, d’un script ou d’un invite interactif, son __name__ est défini sur '__main__'.

En raison de cela, il y a une convention d’utiliser la construction suivante:

if __name__ == '__main__':
    # Code à exécuter lorsque c'est le programme principal ici

Cela permet aux fichiers de programme d’être utilisés soit:

• comme le programme principal et exécute ce qui suit l’instruction if
• comme un module et n’exécute pas ce qui suit l’instruction if.

Tout code qui n’est pas contenu dans cette déclaration sera exécuté lors de l’exécution. Si vous utilisez votre fichier de programme comme un module, le code qui n’est pas dans cette déclaration s’exécutera également lors de son importation lors de l’exécution du fichier secondaire.

Élargissons notre programme names.py ci-dessus, et créons un nouveau fichier appelé more_names.py. Dans ce programme, nous allons déclarer une variable globale et modifier notre fonction names() originale afin que les instructions soient dans deux fonctions distinctes.

La première fonction, has_vowel(), vérifiera si la chaîne name contient une voyelle.

La deuxième fonction print_letters() imprimera chaque lettre de la chaîne name.

# Déclarer la variable globale name pour une utilisation dans toutes les fonctions
name = str(input('Enter your name: '))


# Définir une fonction pour vérifier si le nom contient une voyelle
def has_vowel():
    if set('aeiou').intersection(name.lower()):
        print('Your name contains a vowel.')
    else:
        print('Your name does not contain a vowel.')


# Itérer sur les lettres dans la chaîne de nom
def print_letters():
    for letter in name:
        print(letter)

Avec cette configuration, définissons la fonction main() qui contiendra un appel aux fonctions has_vowel() et print_letters().

# Déclarer la variable globale name pour une utilisation dans toutes les fonctions
name = str(input('Enter your name: '))


# Définir une fonction pour vérifier si le nom contient une voyelle
def has_vowel():
    if set('aeiou').intersection(name.lower()):
        print('Your name contains a vowel.')
    else:
        print('Your name does not contain a vowel.')


# Itérer sur les lettres dans la chaîne de nom
def print_letters():
    for letter in name:
        print(letter)


# Définir la méthode principale qui appelle les autres fonctions
def main():
    has_vowel()
    print_letters()

Finalement, nous ajouterons la construction if __name__ == '__main__': en bas du fichier. Pour nos besoins, puisque nous avons mis toutes les fonctions que nous aimerions exécuter dans la fonction main(), nous appellerons la fonction main() suivant cette instruction if.

# Déclarer la variable globale name pour une utilisation dans toutes les fonctions
name = str(input('Enter your name: '))


# Définir la fonction pour vérifier si le nom contient une voyelle
def has_vowel():
    if set('aeiou').intersection(name.lower()):
        print('Your name contains a vowel.')
    else:
        print('Your name does not contain a vowel.')


# Itérer sur les lettres dans la chaîne de nom
def print_letters():
    for letter in name:
        print(letter)


# Définir la méthode principale qui appelle d'autres fonctions
def main():
    has_vowel()
    print_letters()


# Exécuter la fonction main()
if __name__ == '__main__':
    main()

Nous pouvons maintenant exécuter le programme:

python more_names.py

Le programme affichera la même sortie que le programme names.py, mais ici le code est plus organisé et peut être utilisé de manière modulaire sans modification.

Si vous ne vouliez pas déclarer une fonction main(), vous auriez alternativement pu terminer le programme de cette manière:

...
if __name__ == '__main__':
    has_vowel()
    print_letters()

Utiliser main() comme fonction et l’instruction if __name__ == '__main__': peut organiser votre code de manière logique, le rendant plus lisible et modulaire.

Conclusion

Les fonctions sont des blocs de code d’instructions qui effectuent des actions dans un programme, aidant à rendre notre code réutilisable et modulaire.

Pour en savoir plus sur la manière de rendre votre code plus modulaire, vous pouvez lire notre guide sur Comment écrire des modules en Python 3.