Les fonctions Python pour réutiliser votre code

Les fonctions Python sont un ensemble d’instructions que vous pouvez utiliser pour réaliser une tâche spécifique lorsque vous en aurez besoin dans un programme en l’appelant avec son nom. 

Une fonction Python est un ensemble d’instructions, regroupées dans un bloc de code, que nous pouvons utiliser plusieurs fois dans une variété de contextes.

En fait, nous avons utilisé de nombreuses fonctions Python intégrées comme print(), input(), str(), int(), float(), enumerate(), range()et help().

Mais il est tout à fait possible de créer vos propres fonctions pour les utiliser plusieurs fois sans avoir besoin à réécrire le code encore et encore.

En outre, une fonction Python vous donne la possibilité de transformer un code volumineux en petits blocs réutilisables.

Dans la pratique, chaque fonction effectue une tâche précise dans un programme.

Définir et appeler une fonction Python

Pour créer une fonction Python, on utilise le mot clé def de l’anglais (define) suivi du nom de la fonction, de deux parenthèses () et de deux points.

Ouvrez votre IDLE, puis exécutez ce code en mode interactif.

def bonjour():
    print("Bonjour, bienvenue dans le monde des fonctions !")

Rien ne se passe dans la console.
Maintenant, sortez de l’indentation en retournant au début de la ligne. Appelez la fonction bonjour() et exécutez le code à nouveau.

# Définir une fonction 
def bonjour():
    print("Bonjour, bienvenue dans le monde des fonctions !")

# Appeler la fonction
bonjour()

Et comme par magie, votre fonction s’exécute.

Bonjour, bienvenue dans le monde des fonctions !

Vous êtes à présent familier avec les deux points : et l’indentation. C’est le même principe qu’on a vu dans les tutoriels précédents sur les conditions et les boucles en Python.

Donc, après les deux points, l’indentation détermine le début et la fin du bloc d’instructions d’une fonction.

Par conséquent, quand nous avons appelé notre fonction bonjour(), nous l’avons fait en début de ligne.

Les fonctions Python et l’instruction return

L’instruction return est utilisée pour renvoyer le résultat d’une fonction Python. Mais cette instruction ne peut pas être utilisée à l’extérieur d’une fonction et le code qui la suit est ignoré. Tout simplement, parce que la fonction sort dès qu’elle rencontre un return.

Écrivez la fonction précédente en mode interactif dans le Shell.

def bonjour():
    print("Bonjour, bienvenue dans le monde des fonctions !")

    

Appuyez 2 fois sur la touche Entrée, puis exécutez ce code :

>>> x = bonjour()
Bonjour, bienvenue dans le monde des fonctions !

En fait, Python est un langage orienté objet, et lorsque vous créez une fonction, vous créez également une variable qui fait référence à cette fonction.

Maintenant essayez de récupérer la valeur de x comme on l’a fait précédemment.

>>> x
>>> 

Rien n’est renvoyé, peut être qu’on devrait essayer avec la fonction print().

>>> print(x)
None

Oups, c’est encore pire. C’est quoi ce None.

En fait, les fonctions Python renvoient une valeur. Cependant, s’il n’y a aucune valeur, c’est None qui sera renvoyé.

>>> type(x)
<class 'NoneType'>

En effet, None est un type de donnée en Python. On l’utilise pour définir une valeur nulle. None, n’a rien à voir avec False, 0 ou une chaîne de caractère vide.

Essayons encore un autre code :

>>> print(bonjour())
Bonjour, bienvenue dans le monde des fonctions !
None
>>> 

None, indique qu’il n y a aucune valeur renvoyé.

Par conséquent, la fonction affiche un texte, mais ne renvoie aucune valeur.

À présent, utilisons l’instruction return avec notre fonction bonjour().

def bonjour():
    return "Bonjour, bienvenue dans le monde des fonctions !"

Stockons le résultat dans une variable.
Oui, vous pouvez stocker la valeur renvoyée par une fonction dans une variable et l’utiliser.

>>> y = bonjour()
>>> y
'Bonjour, bienvenue dans le monde des fonctions !'
>>> 

Voyons à présent si la fonction print() renverra None.

>>> print(y)
Bonjour, bienvenue dans le monde des fonctions !
>>> 

Donc, pour renvoyer le résultat d’une fonction, on utilise l’instruction return. Lorsqu’une expression est utilisée avec return, la valeur renvoyée correspond à ce que cette expression évalue.

L’instruction print(), affiche une donnée, mais elle ne renvoie pas sa valeur.

Les instructions qui viennent après une instruction return dans les fonctions Python ne sont pas exécutées.

En réalité, l’instruction return permet de récupérer des informations à partir d’une fonction.

Mais pourquoi auriez-vous besoin d’informations provenant d’une fonction ?

Lors du codage d’une application réelle, vous pourrez échanger les valeurs renvoyées entre les différentes parties de votre programme.

Bon, prenons un autre exemple pour ceux qui n’ont pas encore compris ce concept.

def bonjour():
    print("Bonjour, bienvenue dans le monde des fonctions !")
x = bonjour()
# Écrire le résultat de la fonction en majuscule 
>>> x.upper()
Traceback (most recent call last):
  File "<pyshell#5>", line 1, in <module>
    x.upper()
AttributeError: 'NoneType' object has no attribute 'upper'

Ici Python indique que vous ne pouvez pas appliquer la méthode upper() sur un objet de type None.

Écrivons une autre fonction avec return.

def bonsoir():
    return "Bonsoir"

>>> y = bonsoir()
>>> y.upper()
'BONSOIR'
>>> type(y)
<class 'str'>

Lorsque nous avons utilisé return, nous avons pu transformer la valeur renvoyée par la fonction, en lettres majuscule. Par contre, avec print(), il n y avait aucune valeur renvoyée.

Les autres utilisations de return

Sachez, qu’il est possible de retourner deux valeurs.

>>> def personne():
	nom = input("Saisissez votre nom : ")
	prenom = input("Saisissez votre prenom : ")
	return nom, prenom

Mais, faites attention, lorsque vous appelez cette fonction dans une instruction d’affectation, vous devrez utiliser deux variables sur le côté gauche de l’opérateur =, comme dans cet exemple :

variable_nom, variable_prenom = personne()

C’est logique, puisque nous stockons le résultat de la fonction dans la variable, et comme notre fonction renvoie deux résultats, nous aurons besoin de deux variables.

Supposons que nous avons une fonction qui effectue une action particulière au lieu de renvoyer un résultat. Dans ce cas, l’instruction return peut ne pas être suivi d’une valeur.

def bienvenue():
	return

Nous appelons la fonction bienvenue().

>>> bienvenue()   # Aucune valeur ne sera renvoyée
>>> 
>>> print(bienvenue())
None

La portée des variables dans une fonction Python

Une variable créée à l’intérieur d’une fonction appartient à cette fonction et ne peut être utilisée qu’à l’intérieur de cette fonction. C’est une variable locale.

def locale():
    x = 90
    print(x)
	
>>> locale()
90

Essayez d’afficher la variable x à l’extérieur de la fonction.

>>> print(x)
None

Affectez la même valeur à x à l’extérieur de la fonction.

>>> x = 90
>>> print(x)
90

À présent x est une variable globale et elle est accessible par tout le programme.

y = 20
def globale():
    print(y)
	
>>> globale()
20

Mais, sachez que vous pouvez créer une variable dans une fonction et lui donner la qualité d’une variable globale. En fait, il est déconseillé d’utiliser cette technique, surtout si votre variable existe dans d’autres fonctions. Si vous modifiez votre variable globale, les autres fonctions seront également modifiées. De plus, en cas de débogage, vous serez obligés de faire plus de vérifications.

Nous allons utiliser le mot-clé global à l’intérieur de la fonction.

def globale():
    global x
    x = 90
    print(x)
    
>>> globale()
90
>>> x
90

Les paramètres et les arguments des fonctions Python

Les fonctions Python peuvent prendre un argument ou même plus. Ces arguments sont affectés à des variables appelées paramètres. En effet, vous pouvez avoir autant de paramètres que vous le souhaitez. Mais, la règle de base étant que le nombre de paramètres dans la définition de la fonction doit (en règle générale) correspondre au nombre d’arguments lors d’un appel.

Voici un exemple d’une fonction qui renvoie la moyenne de deux nombres et le résultat sera de type float.

>>> def moy(a, b):
	return (a + b) / 2

Nous pouvons passer deux nombres comme arguments et récupérer leur moyenne.

>>> moy(5, 15)
10.0

Écrivons notre fonction bonjour() avec un paramètre.

>>> def bonjour(nom):
        print("Bonjour " + nom)

Remplacez le paramètre nom, par un argument comme Christine ou votre prénom.

>>> bonjour("Christine")
Bonjour Christine

Toutefois, n’oubliez pas d’écrire les chaînes de caractères entre deux guillemets lorsque vous remplacez les paramètres.

Appeler une fonction à l’intérieur d’une autre

Les fonctions Python, vous donnent la possibilité d’appeler une fonction à l’intérieur d’une autre.

def externe(x):
    def interne(y):
        return x * y
    return interne

Pour exécuter ce code, nous allons récupérer le résultat de la fonction externe avec le premier argument et l’affecter à une variable. Comme cette variable stocke la valeur renvoyé par la fonction externe, nous allons lui passer le deuxième argument.

>>> z = externe(3)

En fait, z est une fonction aussi.

>>> type(z)
<class 'function'>

>>> z(5)
15

Une autre manière d’appeler cette fonction est :

>>> externe(3)(5)
15

Le principe ici est que la fonction interne est appelé à l’intérieur de la fonction externe.

Les arguments et les paramètres

Un paramètre est la variable spécifiée entre parenthèses lors de la définition de la fonction. Cependant, l’argument est la valeur que vous passez à la fonction pour remplacer le paramètre lorsque vous l’appelez.

Les arguments que vous passez à une fonction doivent être dans le même ordre que celui des paramètres dans la définition.

Les paramètres par défaut

Les paramètres par défaut sont une fonctionnalité intéressante des fonctions Python. Comme son nom l’indique, les paramètres par défaut vous permettent de spécifier des valeurs par défaut pour les paramètres dans la définition de la fonction Python. Toutefois, ils sont facultatifs et vous pouvez les remplacer si nécessaire.

def add_n(num, n=3):
    return num + n

Si vous ne spécifiez pas la valeur de n, elle sera remplacée par défaut par 3.

>>> add_n(5) # ici 5 remplace num
8

Par contre remplacer num par un argument est obligatoire, sinon vous aurez une erreur. Les arguments positionnels sont obligatoires et doivent respecter l’ordre avec lequel ils ont été définis.

# On enlève num et on garde le paramètre par défaut
>>> add_n(n=5)
Traceback (most recent call last):
  File "<pyshell#5>", line 1, in <module>
    add_n(n=5)
TypeError: add_n() missing 1 required positional argument: 'num'

Aussi, vous pouvez donner une autre valeur au paramètre par défaut, qui n’est pas obligatoire.

>>> add_n(5, 4)
9

Les paramètres par défaut doivent être déclarés après les paramètres positionnels. Sinon, Python vous affichera une erreur de syntaxe, SyntaxError.

Nous allons créer une fonction qui prendra comme paramètres un nom et un message.

def bonjour(nom, message):
    return "bonjour" + " " + nom + ", " + message

Pour appeler cette fonction, nous utiliserons deux arguments positionnels :

>>> bonjour("Patrick", "quel âge avez-vous ?")
'bonjour Patrick, quel âge avez-vous ?'

Aussi, il est possible de passer les arguments à une fonction sous forme de :
clé = valeur. Sachez que même si vous inversez les arguments, vous aurez le même résultat, tant que vous nommez vos arguments.

>>> bonjour(message = "quel âge avez-vous ?", nom = "Patrick")
'bonjour Patrick, quel âge avez-vous ?'

De plus, sachez que les arguments positionnels doivent précéder les arguments par défaut.

# L'argument par défaut est avant l'argument positionnel
>>> add_n(n=5, 4)
SyntaxError: positional argument follows keyword argument

Pourquoi utiliser des arguments par mots-clés ?

Les arguments par mots-clés peuvent souvent être utilisés pour rendre les appels de fonctions plus explicites.

Lorsque j’écris une fonction Python avec plusieurs paramètres, j’essaie d’utiliser des arguments avec des mots-clés pour chaque appel de cette fonction.

L’utilisation d’arguments par mots-clés avec des arguments positionnels

Utiliser les arguments positionnels et les arguments par mots-clés ensembles dans un appel d’une fonction Python est déconseillé.
En effet, il est souvent difficile de déterminer ce qui se passe lorsque vous faites cela.

Un nombre inconnu d’arguments avec * args

Il arrive parfois que vous écriviez une fonction Python dont vous ignorez le nombre de paramètres que vous allez utiliser. Dans ce cas, vous aurez besoin d’utiliser *args.

# Afficher l'exponentiation d'un nombre indéfini d'arguments
def exp(*num):
    for n in num:
        print(n ** 2)

Vous pouvez appeler la fonction exp() avec n’importe quel nombre d’arguments.

>>> exp(3,4,5)
9
16
25

Un nombre inconnu d’arguments avec ** kwargs

Il est également possible de passer un nombre indéfini d’arguments avec des mots-clés dans une fonction Python.

# Afficher plusieurs arguments avec des mots-clés
def commande(**kwargs):
    print(kwargs)

>>> commande(boisson="jus", nombres=2, ingredient="citron")
{'boisson': 'jus', 'nombres': 2, 'ingredient': 'citron'}

Les fonctions Python et les docstrings

Python possède une fonctionnalité utile appelée docstrings . C’est un outil important que vous pouvez utiliser pour vous aider à documenter votre programme et le rendre plus facile à comprendre.

Écrivons une fonction qui compare deux valeurs.

def comparer(x, y):
    """Comparer deux nombres.
    Les deux nombres doivent être des entiers."""

    # convertir en entier
    x = int(x)
    y = int(y)

    if x > y:
        print(x, 'est supérieur à', y)
    else:
        print(y, 'est supérieur à',x)

>>> comparer(50, 100)
100 est supérieur à 50

Tapez help(comparer).

>>> help(comparer)
Help on function comparer in module __main__:

comparer(x, y)
    Comparer deux nombres.
    Les deux nombres doivent être des entiers.

La docstring est la chaîne de caractère qui se trouve à l’intérieur des triples guillemets juste après la définition de la fonction comparer(). Vous pouvez également utiliser les triples apostrophes.

Maintenant tapez ce code :

print(comparer.__doc__)

Vous aurez ce résultat :

Comparer deux nombres.
Les deux nombres doivent être des entiers.

La documentation de notre fonction comparer() est accessible à l’aide de l’attribut __doc__.

Lorsque vous écrivez une fonction, n’oubliez pas d’ajouter de la documentation. Vous pouvez oublier le fonctionnement d’un programme après quelques jours.

Les fonctions anonymes en Python

Les fonctions Python anonymes ou les fonctions lambda n’utilisent pas de mot – clé def dans la définition. Toutefois, le mot – clé lambda sera utilisé.

# Une fonction lambda renvoyant l'exponentiation d'un nombre x
>>> lambda x : x * x
<function <lambda> at 0x7f0457329a60>

x est le paramètre et x*x est l’expression ou l’instruction qui sera évaluée et renvoyée. Cependant, cette fonction n’a pas de nom.

Stockons la fonction dans une variable.

>>> exp = lambda x : x * x

Testons notre fonction.

>>> exp(10)
100
>>> exp(100)
10000

En outre, la fonction lambda peut accepter d’autres paramètres. Voici une fonction qui renvoie le résultat de la multiplication de 3 nombres.

>>> mult = lambda x,y,z : x * y * z
>>> mult(2,3,4)
24

Les fonctions lambda sont à utiliser avec précaution. Elles sont utiles lorsque vous voudrez récupérer un résultat rapidement et simplement. Par exemple, si vous avez besoin d’un petit code non-réutilisable, vous pouvez utiliser de cette fonction.

Les fonctions Python et la récursivité

On a vu qu’une fonction peu appeler une autre fonction dans son bloc d’instructions. Pour aller plus loin, sachez qu’il est également possible d’appeler une fonction à l’intérieur d’elle-même. C’est ce qu’on appel en programmation, la récursivité, c’est une fonctionnalité très puissante dans la programmation.

Dans certains cas, l’utilisation de la récursivité, est plus efficace que l’itération.

# Calculer la somme de x avec :
# (x-1) + (x-2) + (x-3) jusqu'à 0
# Ce code ne fonctionnera pas pour les grands nombres
>>> def add(x):
	if(x>0):
	    result = x + add(x-1)
	else:
	    result = 0
	return result

La fonction add(x), additionne chaque nombre à partir de x avec celui qui lui est strictement inférieur, jusqu’à zéro.

>>> add(10)
55
>>> add(5)
15

Pour pouvoir récupérer le résultat final, la fonction devrait récupérer la dernière valeur connue qui est result = 0 et le calcul se fait du dernier au premier.

add(1) = 1 + add(0)    # vaut 1, sera remplacé ci dessous
add(2) = 2 + add(1)    # vaut 3, sera remplacé ci dessous
add(3) = 3 + add(2)    # vaut 6, sera remplacé ci dessous
add(4) = 4 + add(3)    # vaut 10, sera remplacé ci dessous
add(5) = 5 + add(4)    # vaut 15

Les boucles servent à répéter une opération, tandis que la récursivité sert à décomposer une grande opération.

En fait, la récursivité rend notre programme facile à écrire, plus court et plus lisible. Toutefois, sachez que ce n’est pas une baguette magique qui réglera tous vos problèmes.