Python

Partie 2

1. Les fonctions

Lorsqu’une tâche doit être réalisée plusieurs fois par un programme avec seulement des paramètres différents,on peut l’isoler au sein d’une fonction. Une fonction est une suite d’instruction que l’on peut appeler avec un nom.
Voici deux exemples de fonctions.

def tripler(n):
"""Cette fonction retourne le triple de n
qui est donné en entrée."""
return 3 * n

def dire_bonjour(prenom):
"""Cette fonction permet de dire bonjour
à la personne dont le prénom est 
donnée en entrée"""
print("Bonjour ", prenom)

Hé! Mais il ne se passe rien quand j’exécute les programmes précédents ! Elle ne dit rien du tout la fonction !

En effet, il faut appeler la fonction :

>>>tripler(42)
126
>>>dire_bonjour("Sarah Connor")
'Sarah Connor'

Le mot clé def est utilisé pour définir une fonction, suivi du nom de la fonction. Le nom de la fonction est suivi, entre parenthèses, des paramètres de la fonction, deux points et ensuite le corps de la fonction.

def nom(parametre1, parametre2, ...):
#corps de la fonction

Pour appeler la fonction on utilise son nom suivi, entre parenthèses, des arguments :

nom(argument1, argument2, ...)

Le mot clé return est utilisé pour retourner une valeur. Attention, print ne retourne pas une valeur ! La valeur est simplement affichée.

Remarque : En toute rigueur on devrait parler de procédure plutôt que de fonction. La différence qui les sépare est la valeur de retour. Une procédure est un groupe d’instructions qui ne renvoie pas de valeur après leur exécution. Une fonction, quant à elle, est en réalité une procédure qui retourne une valeur (de type primitif ou complexe) ou un objet.

def table(n):
"Procédure qui affiche la table de n"
for i in range(1,11):
print(n, "x",i," = ",i*n)
table(7)

7 x 1  =  7
7 x 2  =  14
7 x 3  =  21
7 x 4  =  28
7 x 5  =  35
7 x 6  =  42
7 x 7  =  49
7 x 8  =  56
7 x 9  =  63
7 x 10  =  70

Ici, on voit bien l’intérêt de passer par une procédure. Nous n’avons pas besoin de récrire le programme pour obtenir la table de 6.

Portée des variables :

Testons le code suivant :

def fonction():
a = 10
fonction()
print(a)

Nous nous retrouvons avec une erreur : NameError: name ‘a’ is not defined

En effet, une variable a est créée dans le bloc de la fonction et détruite à la fin du bloc, c’est une variable locale.

Pour qu’une variable définie dans un espace local, soit connu dans l’espace global, elle doit être précédée du mot-clé global.

Testez le code suivant pour bien comprendre :

a = 0
b = 1
print("a = ", a, "Avant la fonction")
print("b = ", a, "Avant la fonction")
def une_fonction():
a = 2
global b = 3
print("a = ", a, "Dans la fonction")
print("b = ", a, "Dans la fonction")
une_fonction()
print("a = ", a, "Après la fonction")
print("b = ", a, "Après la fonction")

Le résultat :

a =  0 Avant la fonction
b =  1 Avant la fonction
a =  2 Dans la fonction
b =  3 Dans la fonction
a =  0 Après la fonction
b =  3 Après la fonction

Remarque : Évitez autant que possible d’avoir recours au mot-clé global. Voir : Variable globale Inconvénients

Petit quiz sur la portée des variables :

Deux exemples :

def puissance(x,n):
...

def puissance(x, n):
"""Fonction qui calcule x**n"""
reponse = 1
for i in range(n):
reponse *= x
return reponse

def syracuse(n):
...

def syracuse(n):
"""Fonction qui affiche les termes de la 
suite de Syracuse en partant de n"""
compteur = 0
while (n != 1 ): # On considère qu'on arrive à 1 à un moment...
if n%2 == 0:
n //= 2
else:
n = 3 * n + 1
compteur += 1
print("Le terme de rang {} est :\t{}".format(compteur,n))
print("\t ### Terminé ### \n")

Un exercice pour les curieux :

def puissance(x,n):
...

def puissance(x, n):
"""Fonction qui calcule x**n"""
if n == 0:
return 1
else:
return x * puissance(x, n-1)

Mais c’est quoi la récursivité : wiki récursivité

Bonus : Il est aussi possible d’utiliser des fonctions anonymes (ou lambda).

Deux exemples de fonctions :

>>>f = lambda x: x**2 + 2
>>>f(5)
27

>>>g = lambda x: x//2 if (x%2 == 0) else 3 * x + 1
>>>g(5)
16