TOC

Comment définir des fonctions dans Python 3

introduction

Une * fonction * est un bloc d’instructions qui exécute une action et qui, une fois définie, peut être réutilisée. Les fonctions rendent le code plus modulaire, vous permettant d’utiliser le même code encore et encore.

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

  • + print () + qui imprimera un objet sur le terminal

  • + int () + qui convertira un type de données string ou number en un type de données entier

  • + len () + qui retourne la longueur d’un objet

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

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

Définir une fonction

Commençons par transformer le programme classique «Hello, World!» En une fonction.

Nous allons créer un nouveau fichier texte dans l’éditeur de texte de votre choix et appeler le programme + hello.py +. Ensuite, nous définirons la fonction.

Une fonction est définie en utilisant le mot-clé + def +, suivi du nom de votre choix, suivi d’un ensemble de parenthèses contenant les paramètres que la fonction prendra (ils peuvent être vides), et se terminant par un signe deux-points.

Dans ce cas, nous définirons une fonction nommée + hello () +:

bonjour.py

def hello():

Ceci configure la déclaration initiale pour créer une fonction.

A partir de là, nous allons ajouter une deuxième ligne avec un retrait de 4 espaces pour fournir les instructions relatives à l’utilisation de la fonction. Dans ce cas, nous allons imprimer + Hello, World! + Sur la console:

bonjour.py

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

Notre fonction est maintenant complètement 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 fonction défini, appelons la fonction avec + hello () +:

bonjour.py

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

hello()

Lançons maintenant le programme:

python hello.py

Vous devriez recevoir le résultat suivant:

OutputHello, World!

Les fonctions peuvent être plus compliquées que la fonction + hello () + définie plus haut. Par exemple, nous pouvons utiliser https://www.digitalocean.com/community/tutorials/how-to-construct-for-loops-in-python-3 [+ for + loops], https: //www.digitalocean .com / communauté / tutoriels / comment-écrire-instructions-conditionnelles-en-python-3-2 [instructions conditionnelles], et plus encore dans notre bloc de fonction.

Par exemple, la fonction définie ci-dessous utilise une instruction conditionnelle pour vérifier si l’entrée de la variable + nom + contient une voyelle, puis utilise une boucle + pour + pour parcourir les lettres de la chaîne + nom +.

noms.py

# Define function names()
def names():
   # Set up name variable with input
   name = str(input('Enter your name: '))
   # Check whether name has a vowel
   if set('aeiou').intersection(name.lower()):
       print('Your name contains a vowel.')
   else:
       print('Your name does not contain a vowel.')

   # Iterate over name
   for letter in name:
       print(letter)

# Call the function
names()

La fonction + names () + que nous avons définie ci-dessus établit une instruction conditionnelle et une boucle + for, montrant comment le code peut être organisé dans une définition de fonction. Toutefois, en fonction de ce que nous souhaitons avec notre programme et de la manière dont nous souhaitons configurer notre code, nous pouvons définir l’instruction conditionnelle et la boucle + pour + comme deux fonctions distinctes.

La définition de fonctions dans un programme rend notre code modulaire et réutilisable, de sorte que nous puissions appeler les mêmes fonctions sans les réécrire.

Travailler avec des paramètres

Jusqu’à présent, nous avons examiné les 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 entre parenthèses.

Un * paramètre * est une entité nommée dans une définition de fonction, spécifiant un argument que la fonction peut accepter.

Créons un petit programme qui prend en compte les paramètres + x +, + y + et + z +. Nous allons créer une fonction qui additionne les paramètres dans différentes configurations. Les sommes de celles-ci seront imprimées par la fonction. Ensuite, nous appelons la fonction et lui passons des chiffres.

add_numbers.py

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 dans lequel elles sont données.

Le programme effectue essentiellement les calculs suivants en fonction des valeurs que nous avons transmises aux paramètres:

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

La fonction affiche également + a +, + b + et + c +, et selon les calculs ci-dessus, nous nous attendrions à ce que + a + soit égal à + ​​3 +, + b + soit ` + 4 + , et + c + soit + 5 + `. Lançons le programme:

python add_numbers.py
Output3 4 5

Lorsque nous transmettons les paramètres + 1 +, '+ 2 + et + + 3 + à la fonction + add_numbers () +, nous obtenons le résultat attendu.

Les paramètres sont des arguments généralement définis en tant que variables dans les définitions de fonction. Vous pouvez leur attribuer des valeurs lorsque vous exécutez la méthode en transmettant les arguments à la fonction.

Arguments de mots clés

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

Lorsque vous utilisez des arguments de mots clés, vous pouvez utiliser des paramètres non conformes car l’interpréteur Python utilisera les mots clés fournis pour faire correspondre les valeurs aux paramètres.

Créons une fonction qui nous montrera les informations de profil d’un utilisateur. Nous lui transmettrons les paramètres sous la forme + nom d’utilisateur + (destiné à être une chaîne), et + suiveurs + (destiné à être un entier).

profile.py

# Define function with parameters
def profile_info(username, followers):
   print("Username: " + username)
   print("Followers: " + str(followers))

Dans la déclaration de définition de fonction, + nom d’utilisateur + et + + suiveurs + sont contenus dans les parenthèses de la fonction + profile_info () +. Le bloc de la fonction imprime des informations sur l’utilisateur sous forme de chaînes, en utilisant les deux paramètres.

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

profile.py

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

# Call function with parameters assigned as above


# Call function with keyword arguments

Dans le premier appel de fonction, nous avons renseigné les informations avec un nom d’utilisateur «+ sammyshark » et les suiveurs étant « 945 +», dans le deuxième appel de fonction, nous avons utilisé des arguments de mots clés, en attribuant des valeurs aux variables d’argument.

Lançons le programme:

python profile.py
OutputUsername: sammyshark
Followers: 945
Username: AlexAnglerfish
Followers: 342

La sortie nous montre les noms d’utilisateur et le nombre d’abonnés 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:

profile.py

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

# Change order of parameters

Lorsque nous relancerons le programme avec la commande + python profile.py +, nous recevrons le résultat suivant:

OutputUsername: cameron-catfish
Followers: 820

Étant donné que la définition de la fonction conserve le même ordre d’instructions + print () +, si nous utilisons des arguments de mots clés, l’ordre dans lequel nous les transmettons n’a pas d’importance.

Valeurs d’argument par défaut

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

profile.py

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

Maintenant, nous pouvons exécuter la fonction avec uniquement la fonction de nom d’utilisateur attribuée, et le nombre de suiveurs passera automatiquement à 1. Nous pouvons également changer le nombre d’adeptes si nous le souhaitons.

profile.py

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

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

Lorsque nous exécutons le programme avec la commande + python profile.py +, nous recevons le résultat suivant:

OutputUsername: JOctopus
Followers: 1
Username: sammyshark
Followers: 945

La fourniture de paramètres par défaut avec des valeurs peut nous permettre d’ignorer la définition de valeurs pour chaque argument ayant déjà un paramètre par défaut.

Renvoyer une valeur

Vous pouvez transmettre une valeur de paramètre à une fonction et une fonction peut également générer une valeur.

Une fonction peut produire une valeur avec l’instruction + return +, qui permet de quitter une fonction et de transmettre éventuellement une expression à l’appelant. Si vous utilisez une instruction + return sans arguments, la fonction renverra` + aucun`.

Jusqu’ici, 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 met le paramètre + x + au carré et renvoie la variable + y +. Nous émettons un appel pour imprimer la variable + résultat +, qui est formée en exécutant la fonction + square () + avec + 3 + passée dans celle-ci.

square.py

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

result = square(3)
print(result)

Nous pouvons exécuter le programme et voir le résultat:

python square.py
Output9

L’entier + 9 + est renvoyé en sortie, ce à quoi nous nous attendions 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:

square.py

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

result = square(3)
print(result)

Maintenant, relançons le programme:

python square.py
OutputNone

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

Autre exemple, dans le programme + add_numbers.py + ci-dessus, nous pourrions échanger l’instruction + print () + contre une instruction + return +.

add_numbers.py

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 définissons la variable + sums + égale au résultat de la fonction prenant en '+ 1 + , + 2 + et + 3 + comme nous l’avons fait ci-dessus. Nous avons ensuite appelé une empreinte de la variable `+ sums +.

Lançons le programme à nouveau 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 + que ceux que nous avions précédemment reçus en utilisant l’instruction + print () + dans la fonction. Cette fois, il est livré sous la forme tuple car la déclaration + return + de l’instruction https://docs.python.org/ 3.6 / reference / expressions.html # grammar-token-expression_list [liste d’expressions] a au moins une virgule.

Les fonctions se terminent immédiatement lorsqu’elles atteignent une instruction + return +, qu’elles renvoient ou non une valeur.

return_loop.py

def loop_five():
   for x in range(0, 25):
       print(x)
       if x == 5:
           # Stop function at x == 5
           return
   print("This line will not execute.")

loop_five()

L’utilisation de l’instruction + return dans la boucle` + for` termine la fonction, ainsi la ligne située en dehors de la boucle ne sera pas exécutée. Si, au contraire, nous avions utilisé un https://www.digitalocean.com/community/tutorials/how-to-use-break-continue-and-pass-statements-when-working-with-loops-in-python- 3 # break-statement [+ break + statement], seule la boucle se serait terminée à ce moment-là et la dernière ligne + print () + serait exécutée.

L’instruction + return quitte une fonction et peut renvoyer une valeur si un paramètre lui est attribué.

Utiliser + main () + comme fonction

Bien qu’en Python, vous puissiez appeler la fonction située au 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) requièrent une fonction ` main ` pour s'exécuter. L'inclusion d'une fonction ` main () +`, bien que non requise, 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 faciliter la lecture de nos programmes pour les programmeurs non Python.

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

bonjour.py

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

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

bonjour.py

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


def main():

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

bonjour.py

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

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

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

python hello.py

Nous recevrons le résultat suivant:

OutputThis is the main function.
Hello, World!

Parce que nous avons appelé la fonction + hello () + dans + main () + et ensuite seulement appelé + main () + pour s’exécuter, le texte `+ Hello, World! + 'N’a été imprimé qu’une fois, après la chaîne qui nous a dit que nous étions dans la fonction principale.

Ensuite, nous allons travailler avec plusieurs fonctions. Il est donc intéressant de revoir la portée variable de https://www.digitalocean.com/community/tutorials/how-to-use-variables-in-python-3#global. -and-local-variables [variables globales et locales]. Si vous définissez une variable dans un bloc de fonction, vous ne pourrez l’utiliser que dans cette fonction. Si vous souhaitez utiliser des variables pour toutes les fonctions, il peut être préférable de déclarer une variable globale.

En Python, + ' main ' + est le nom de la portée où le code de niveau supérieur sera exécuté. Lorsqu’un programme est exécuté à partir d’une entrée standard, d’un script ou d’une invite interactive, son + nom + est défini sur égal à + ​​' main ' +.

Pour cette raison, il existe une convention pour utiliser la construction suivante:

if __name__ == '__main__':
   # Code to run when this is the main program here

Cela permet d’utiliser les fichiers du programme:

  • en tant que programme principal et exécutez ce qui suit l’instruction + if +

  • en tant que module et ne pas exécuter ce qui suit l’instruction + if +.

Tout code qui n’est pas contenu dans cette instruction sera exécuté lors de son exécution. Si vous utilisez votre fichier programme en tant que module, le code qui ne figure pas dans cette instruction sera également exécuté lors de son importation lors de l’exécution du fichier secondaire.

Développons notre programme + names.py + ci-dessus et créons un nouveau fichier nommé + 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 discrètes.

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

La deuxième fonction + print_letters () + affichera chaque lettre de la chaîne + nom +.

more_names.py

# Declare global variable name for use in all functions
name = str(input('Enter your name: '))


# Define function to check if name contains a vowel
def has_vowel():
   if set('aeiou').intersection(name.lower()):
       print('Your name contains a vowel.')
   else:
       print('Your name does not contain a vowel.')


# Iterate over letters in name string
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 () +.

more_names.py

# Declare global variable name for use in all functions
name = str(input('Enter your name: '))


# Define function to check if name contains a vowel
def has_vowel():
   if set('aeiou').intersection(name.lower()):
       print('Your name contains a vowel.')
   else:
       print('Your name does not contain a vowel.')


# Iterate over letters in name string
def print_letters():
   for letter in name:
       print(letter)


# Define main method that calls other functions

Enfin, nous ajouterons la construction si’ name == 'main ': + `au bas du fichier. Pour notre propos, puisque nous avons placé toutes les fonctions que nous aimerions utiliser dans la fonction `+ main () +, nous appellerons la fonction + main () + après cette instruction + if +.

more_names.py

# Declare global variable name for use in all functions
name = str(input('Enter your name: '))


# Define function to check if name contains a vowel
def has_vowel():
   if set('aeiou').intersection(name.lower()):
       print('Your name contains a vowel.')
   else:
       print('Your name does not contain a vowel.')


# Iterate over letters in name string
def print_letters():
   for letter in name:
       print(letter)


# Define main method that calls other functions





# Execute main() function

Nous pouvons maintenant exécuter le programme:

python more_names.py

Le programme affichera le même résultat 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 pu terminer le programme comme ceci:

more_names.py

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

En utilisant + main () + comme fonction et l’instruction + if name == 'main ': +, vous pouvez organiser votre code de manière logique, en le rendant plus lisible et modulaire.

Conclusion

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

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

Related