Les fonctions en Python

Fonctions Python

Les fonctions peuvent être utilisées pour définir un code réutilisable, d’organiser et de simplifier les programmes.

Supposons que vous avez besoin de trouver la somme des entiers de 1 à 10, 20 à 37 et 35 à 49. Si vous créez un programme pour calculer la somme de ces trois intervalles de nombres, votre code pourrait ressembler à ceci:

sum = 0
for i in range(1, 11):
   sum += i
print("La somme de 1 à 10 est ", sum)

sum = 0
for i in range(20, 38):
   sum += i
print("La somme de 20 à 37 est ", sum)

sum = 0
for i in range(35, 50):
   sum += i
print("La somme de 35 à 49 est ", sum)

Vous avez peut-être remarqué que le code pour calculer chacune de ces trois sommes est presque le même.

Ne serait-il pas agréable d’être en mesure d’écrire un seul code, puis le réutiliser? Bien sûr, vous pouvez le faire en définissant une fonction qui vous permet de créer du code réutilisable.

Par exemple, le code précédent peut être simplifié en définissant une fonction sum(), comme suit:

def sum(i1, i2): # fonction calculant la somme de i1 à i2
   result = 0
   for i in range(i1, i2 + 1):
      result += i

   return result

print("La somme de 1 à 10 est ", sum(1,10))
print("La somme de 20 à 37 est ", sum(20, 37))
print("La somme de 35 à 49 est ", sum(35, 49))

Les lignes (1-5) définissent la fonction appelée sum() qui acceptent deux paramètres i1 et i2. Le reste du code appelle les fonctions sum(1, 10) pour calculer la somme entre 1 et 10, sum(20,37) pour calculer la somme de 20 à 37 et sum(35, 49) pour calculer la somme de 35 à 49.

Une fonction est une collection d’instructions regroupées sous un nom. Dans les chapitres précédents, vous avez appris à propos des fonctions telles que eval(), input() et random.randint(a,b).

Lorsque vous appelez la fonction random.randint(a,b), par exemple, le système exécute en fait les instructions dans la fonction et renvoie le résultat. Dans ce chapitre, vous apprendrez comment définir et utiliser les fonctions pour résoudre des problèmes complexes.

Définir une fonction

La définition d’une fonction se compose d’un nom, des paramètres, et d’un jeux d’instructions.

La syntaxe pour définir une fonction est la suivante:

def NomDeLafonction (liste des paramètres):
   # jeux d'instructions

Regardons une fonction créée pour trouver le plus grand parmi deux nombres. Cette fonction, nommée max, a deux paramètres num1 et num2, dont le plus grand est renvoyé par la fonction.

La figure suivante illustre les composantes de cette fonction.

Appel Fonction Python

Une fonction contient un en-tête et un corps. L’en-tête commence par le mot-clé def, suivi par le nom et les paramètres de la fonction, et se termine par deux-points.

Les variables dans l’en-tête de fonction sont connus comme paramètres formels (arguments) ou simplement paramètres de la fonction.

Un paramètre est comme un espace réservé. Quand une fonction est appelée, vous passez une valeur au paramètre.Cette valeur est appelée un paramètre réel ou argument.

Les paramètres sont facultatifs; à savoir, une fonction peut ne pas avoir de paramètres. Par exemple, la fonction random.random () n’a pas de paramètres.

Certaines fonctions renvoient une valeur, alors que d’autres fonctions effectuent les opérations désirées sans retourner une valeur

Le corps de la fonction contient une collection de déclarations qui définissent la fonction. Par exemple, le corps de la fonction max utilise une instruction if pour déterminer quel nombre est le plus grand et retourner la valeur de ce nombre. La valeur de retour est définie en utilisant le mot-clé return.

NOTEZ BIEN QUE L’EXECUTION DU CORPS D’UNE FONCTION S’ARRETE LORSQUE L’INSTRUCTION RETURN EST EXECUTEE.

Appeler une fonction

L’appel d’une fonction exécute le code de la fonction.

Dans la définition d’une fonction, vous définissez ce qu’elle va faire. Pour utiliser une fonction, vous devez l’appeler.

Le programme/fonction/code qui appelle la fonction est appelée un appelant. Il y a deux façons pour appeler une fonction selon qu’elle possède une valeur de retour ou pas.

Si la fonction retourne une valeur, un appel à cette fonction est habituellement traité comme une valeur. Par exemple :

larger = max(3, 4)

appelle la fonction max(3, 4) et affecte son résultat à la variable larger.

Un autre exemple d’un appel considéré comme une valeur est :

print(max(3, 4))

qui affiche la valeur de retour de l’appel de fonction max(3, 4).

Si une fonction ne retourne pas de valeur, l’appel de la fonction doit être une instruction. Par exemple, la fonction print() ne retourne pas de valeur.

La ligne suivante est une instruction:

print("Programming is fun!")

Une fonction qui renvoie une valeur de retour peut également être appelée comme une instruction. Dans ce cas, la valeur de retour est ignorée.

Cette situation est rare, mais elle est permise si l’appelant n’est pas intéressé par la valeur de retour.

Fonction avec/sans valeurs de retour

Une fonction ne doit pas forcément renvoyer une valeur.

La section précédente donne un exemple d’une fonction avec valeur de retour. Cette section montre comment définir et appeler une fonction qui ne retourne pas de valeur.

Une telle fonction est souvent connue comme une procédure dans la terminologie de la programmation.

Le programme ci-dessous définit une fonction nommée printGrade et puis l’appelle pour afficher la note pour une valeur donnée.

# Afficher la note
def printGrade(valeur):
   if valeur >= 90.0:
      print('A')
   elif valeur >= 80.0:
      print('B')
   elif valeur >= 70.0:
      print('C')
   elif valeur >= 60.0:
      print('D')
   else:
      print('F')

valeur = eval(input("Entrer une valeur: "))
print("La note est ", end = " ")
printGrade(valeur)

Voici le résultat du code ci-dessus :

Entrer une valeur: 78.5
La note est C

La fonction printGrade ne retourne aucune valeur. Ainsi, il est appelée comme une instruction. Pour voir les différences entre une fonction qui ne renvoie pas de valeur et une fonction qui retourne une valeur, nous allons réécrire la fonction printGrade afin de renvoyer une valeur.

Nous appelons notre nouvelle fonction getGrade.

def getGrade(valeur):
   if valeur>= 90.0:
      return 'A'
   elif valeur>= 80.0:
      return 'B'
   elif valeur>= 70.0:
      return 'C'
   elif valeur>= 60.0:
      return 'D'
   else:
      return 'F'

valeur = eval(input("Entrer une valeur: "))
print("La Note est", getGrade(valeur))

Voici le résultat du code ci-dessus :

Entrer une valeur: 78.5
La note est C

La fonction getGrade définie dans les lignes 1-11 retourne une note sur la base d’une valeur passée en paramètre.

La fonction getGrade renvoie un caractère, et elle peut être appelée et utilisée comme un caractère. La fonction printGrade ne retourne pas de valeur, et elle doit être appelée comme une instruction.

Techniquement, chaque fonction en Python renvoie une valeur même si vous n’avez pas utilisé le mot clé return. Si une fonction ne retourne pas de valeur, par défaut, elle renvoie la valeur spéciale None.

La valeur None ne peut pas être affectée à une variable pour indiquer que la variable ne fait référence à aucune donnée. Par exemple, si vous exécutez le programme suivant:

def sum(number1, number2):
   total = number1 + number2

print(sum(1, 2))

vous verrez que la sortie est None parce que la fonction sum() n’a pas une instruction return. Par défaut, elle retourne None.

Passage des arguments par référence

Lorsque vous appelez une fonction avec des arguments, la référence de chacun des arguments est passée par valeur à la fonction.

Puisque toutes les données en Python sont des objets, une variable est en fait une référence à un objet. Lorsque vous appelez une fonction avec des arguments, la valeur de le la référence (« adresse mémoire ») de chaque argument est passée en paramètre.

Ceci est appelé passage par valeur dans la terminologie de la programmation. Nous disons que la valeur d’un argument est passée à un paramètre lors de l’appel d’une fonction. La valeur est en fait une valeur de référence à l’objet.

Si l’argument est un nombre ou une chaîne, l’argument ne peut pas être affecté, quelles que soient les modifications apportées au paramètre dans la fonction. Le code suivant donne un exemple.

x = 1
print("Avant l'appel, la valeur de x est ", x)
increment(x)
print("Après l'appel, la valeur de x est ", x)

def increment(n):
   n += 1
   print("La valeur de n à l'intérieur de la fonction est", n)

Voici le résultat d’exécution du code ci-dessus :

Avant l'appel, la valeur de x est 1
La valeur de n à l'intérieur de la fonction est 2
Après l'appel, la valeur de x est 1

Comme on le voit, la valeur de x (1) est transmise au paramètre n pour appeler la fonction d’incrémentation (ligne 3). Le paramètre n est incrémenté de 1 dans la fonction (ligne 6), mais le code de la fonction n’a pas pu changer la valeur de x car la fonction traite juste une copie de la valeur de x.

D’autre part, les nombres et les chaînes sont connus comme des objets immuables. Ainsi, le contenu des objets immuables ne peut pas être modifié. Chaque fois que vous attribuez une nouvelle valeur à une variable, Python crée un nouvel objet pour la nouvelle valeur et attribue sa référence à la variable.

Considérez le code suivant:

>>> x = 4
>>>y = x
>>>id(x) # la référence de x
505408920
>>>id(y) # la référence de y est la même que celle de x
505408920
>>>

Vous affectez x à y, et x et y pointer maintenant vers le même objet pour la valeur entière 4, comme le montre les figure a et b.

Mais si vous ajoutez 1 à y, un nouvel objet est créé et affecté à y, comme le montre la figure c. Maintenant, y fait référence à un nouvel objet, comme indiqué dans le code suivant:

>>> y = y + 1 # y pointe maintenant vers un nouveau objet
>>>id(y)
505408936
>>>

La portée des variables

La portée d’une variable est la partie du programme où la variable peut être utilisée et y accéder.

Une variable créée à l’intérieur d’une fonction est appelée une variable locale.
Les variables locales ne sont accessibles que dans une fonction. La portée d’une variable locale commence à partir de sa création et continue jusqu’à la fin de la fonction qui contient la variable.

En Python, vous pouvez également utiliser des variables globales. Ils sont créés en dehors de toutes les fonctions et elles sont accessibles à toutes les fonctions dans leur champ d’application.

Considérons les exemples suivants.
Exemple 1

globalVar = 1
def f1():
localVar = 2
print(globalVar)
print(localVar)

f1()
print(globalVar)
print(localVar) # Hors de la portée, ce qui donne une erreur

Une variable globale est créée dans la ligne 1. Elle est accessible au sein de la fonction dans la ligne 4 et à l’extérieur de la fonction dans la ligne 7. Une variable locale est créée dans la ligne 3 et elle est accessible au sein de la fonction dans la ligne 5.

Le fait de tenter d’accéder à la variable locale localVar de l’extérieur de la fonction provoque une erreur dans la ligne 8.

Exemple 2

x = 1
def f1():
x = 2
print(x) # affiche 2

f1()
print(x) # affiche 1

Dans ce deuxième exemple, une variable globale x est créé dans la ligne 1 et une variable locale avec le même nom (x) est créée dans la ligne 3.

A partir de cette ligne, la variable globale x n’est plus accessible dans la fonction. En fait, la fonction f1() peut seulement manipuler la variable x locale.

En dehors de la fonction f1(), la variable globale x est toujours accessible. Par contre, la variable x locale est inaccessible en dehors de la fonction f1(). C’est pour cela que la ligne 6 affichera 1.

Exemple 3

x = 1
def increase():
global x
x = x + 1
print(x) # affiche 2

increase()
print(x) # affiche 2

Dans ce troisième exemple, une variable globale x est créée dans la ligne 1. En plus, on a déclaré une variable x lié à la fonction avec le mot clé global (ligne 3).

Cela signifie que la variable locale x dans la fonction est la même que la variable globale x déclarée en dehors de la fonction increase(). Par conséquent, la fonction peut maintenant modifier le contenu de la variable globale x.

Vous pouvez constater que la variable globale x s’est assignée 1 au début, puis la fonction increase() l’a incrémenté par 1 pour avoir comme valeur finale 2.

Arguments par défaut

Python vous permet de définir des fonctions avec des valeurs d’argument par défaut. Les valeurs par défaut sont transmises aux paramètres lorsque la fonction est appelée sans arguments.

Le code suivant montre comment définir des fonctions avec des arguments acceptant des valeurs par défaut et comment les appeler.

def printAire( longueur = 1, largeur = 2 ):
   aire = longueur * largeur
   print("longueur: ", longueur, "\tlargeur: ", largeur, "\taire: ", aire)

printAire() # Les arguments par défaut longueur = 1 et 2 = largeur
printAire(4, 2.5) # arguments positionnel length = 4 et largeur = 2,5
printAire(1.2) # largeur par défaut = 2

Voici le résultat d’exécution du code ci-dessus :

longueur:  1 	largeur:  2 	aire:  2
longueur:  4 	largeur:  2.5 	aire:  10.0
longueur:  1.2 	largeur:  2 	aire:  2.4

La ligne 1 définit la fonction printAire() dont les paramètres sont la longueur et la largeur. L’argument largeur a pour valeur par défaut 1 et la longueur a pour valeur par défaut 2.

La ligne 4 appelle la fonction printAire sans y passer un argument. Dans ce cas, la fonction a utilisé la valeur par défaut 1 attribuée à la longueur et la valeur par défaut 2 attribuée à la largeur.

La ligne 5 appelle la fonction en passant la valeur 4 pour la longueur et 2,5 pour la largeur.

La ligne 6 appelle la fonction printAire en y passant seulement la valeur 1.2 en paramètre. La fonction va considérer 1.2 en tant que valeur de l’argument « longueur » et elle va utilisera la valeur par défaut du paramètre « largeur » pour calculer l’aire du rectangle correspondant.

Renvoyer plusieurs valeurs

Python permet à une fonction de retourner plusieurs valeurs. Le code ci-dessous définit une fonction qui prend deux nombres et les renvoie dans l’ordre croissant.

def Sort(number1, number2):
   if number1 < number2:
      return number1, number2
   else:
      return number2, number1

n1, n2 = Sort(3, 2)
print("n1 est ", n1)
print("n2 est ", n2)

Voici le résultat du code ci-dessus :

n1 est 2
n2 est 3

La fonction Sort renvoie deux valeurs. Quand elle est appelée, vous devez récupérer les valeurs retournées en utilisant une affectation simultanée (n1, n2 = Sort(3, 2)).

LAISSER UN COMMENTAIRE

Please enter your comment!
Please enter your name here