Objectifs

• Définir une fonction en Python avec def, avec ou sans paramètres.
• Appeler une fonction en lui passant des arguments et utiliser la valeur renvoyée.
• Distinguer return (renvoyer une valeur) et print (afficher).
• Faire le lien avec les fonctions mathématiques \(x\mapsto f(x)\).
• Utiliser des fonctions pour une simulation simple (lancer de dé).

1. Qu'est-ce qu'une fonction ?

Une fonction est un bloc d'instructions auquel on donne un nom. On distingue deux moments :

• la définition : on écrit ce que fait la fonction (on construit la machine) ;
• l'appel : on demande à la fonction de travailler (on fait marcher la machine).

Syntaxe de la définition :

def nom_de_la_fonction(parametre1, parametre2):
    instructions
    return resultat

• def annonce la définition ; la ligne se termine par deux-points :.
• Les instructions de la fonction sont indentées (décalées de 4 espaces).
• Les paramètres sont les noms des entrées, entre parenthèses.
• return renvoie le résultat et termine la fonction.

flowchart LR
A[Appel avec des arguments] --> B[Parametres recoivent les valeurs]
B --> C[Instructions executees]
C --> D[return renvoie le resultat]
D --> E[Suite du programme]

2. Fonction avec arguments

def prix_pains(n):
    return 150 * n

total = prix_pains(4)
print(total)

• n est le paramètre : un nom dans la définition.
• 4 est l'argument : la valeur donnée au moment de l'appel. Pendant cet appel, n vaut 4.
• La fonction renvoie \(150\times 4=600\) ; cette valeur est rangée dans total, puis affichée : 600.

Le lien avec les fonctions en mathématiques

La fonction mathématique \(f : x\mapsto x^2-3x+1\) s'écrit en Python :

def f(x):
    return x**2 - 3*x + 1

L'appel f(4) calcule l'image de \(4\) : \(f(4)=4^2-3\times 4+1=16-12+1=5\).

Plusieurs arguments

Une fonction peut recevoir plusieurs arguments, séparés par des virgules. L'ordre compte : le premier argument va dans le premier paramètre, et ainsi de suite.

def prix_apres_remise(prix, taux):
    return prix * (1 - taux / 100)

Exemple résolu

Une chemise à 5 000 F CFA est soldée à 20 %. Que renvoie prix_apres_remise(5000, 20) ? Cherche d'abord, puis suis l'exécution pas à pas.

3. Fonction sans argument

def saluer():
    print("Bonjour Awa, bon courage pour le devoir !")

saluer()
saluer()

Ce programme affiche deux fois le message. Les parenthèses vides sont obligatoires, dans la définition comme dans l'appel.

Une fonction sans argument peut aussi renvoyer une valeur. C'est le cas pour simuler un dé :

from random import randint

def lancer_de():
    return randint(1, 6)

randint(1, 6) renvoie un entier au hasard entre 1 et 6 (inclus). Chaque appel lancer_de() donne un nouveau résultat.

4. Renvoyer ou afficher : return et print

• return renvoie une valeur au programme qui a appelé la fonction : on peut la stocker dans une variable, la réutiliser dans un calcul. Après return, la fonction s'arrête.
• print affiche seulement à l'écran ; la valeur n'est pas récupérable. Une fonction sans return renvoie la valeur spéciale None (rien).

Exemple résolu

def carre_affiche(x):
    print(x * x)

def carre_renvoie(x):
    return x * x

a = carre_affiche(3)
b = carre_renvoie(3)

Que valent a et b ? Qu'affiche le programme ?

Variables locales : une variable créée à l'intérieur d'une fonction (y compris ses paramètres) n'existe que pendant l'appel. Après l'appel, elle disparaît ; seul le résultat renvoyé reste.

5. Des fonctions pour simuler

from random import randint

def lancer_de():
    return randint(1, 6)

def frequence_six(n):
    compteur = 0
    for i in range(n):
        if lancer_de() == 6:
            compteur = compteur + 1
    return compteur / n

Explique ce que fait frequence_six(1000), puis dévoile les étapes.

Erreurs fréquentes

Récapitulatif

• On définit une fonction avec def nom(parametres): puis un bloc indenté.
• On l'appelle avec nom(arguments) ; sans argument, les parenthèses restent obligatoires.
• Les arguments sont affectés aux paramètres dans l'ordre.
• return renvoie une valeur réutilisable et termine la fonction ; print ne fait qu'afficher.
• Les fonctions rendent les programmes lisibles et permettent de répéter une expérience aléatoire pour la simuler.