TP 3 : Fonctions

BIU IA - Python

19 Février 2026

Pourquoi utiliser les fonctions

Lorsqu’on écrit un programme, on est souvent confronté au fait de devoir répéter des opérations que l’on a fait à un autre endroit du code. Par exemple, le code suivant dessine un carré à l’écran :

import turtle as t

t.forward(100)
t.left(90)
t.forward(100)
t.left(90)
t.forward(100)
t.left(90)
t.forward(100)
t.left(90)

On a vu la semaine dernière qu’on pouvait utiliser des boucles pour obtenir un code plus lisible, compact et modulaire dans ce cas :

import turtle as t

for i in range(4):
    t.forward(100)
    t.left(90)

Maintenant, on peut être amené à dessiner plusieurs carré à l’écran, par exemple :

import turtle as t

# Carré 1
for i in range(4):
    t.forward(100)
    t.left(90)

# On bouge le crayon
t.up()
t.forward(200)
t.down()

# Carré 2
for i in range(4):
    t.forward(100)
    t.left(90)

On voit ici qu’on a une opération de base “dessiner un carré” qu’on a besoin d’appeler plusieurs fois dans le code. Dans ce cas, il est intéressant d’écrire une fonction qui fera exactement cela et qu’on pourra réutiliser où l’on veut. On écrire :

# Une fonction qui dessine un carré
def carre():
    for i in range(4):
        t.forward(100)
        t.left(90)
 
carre()

# On bouge le crayon
t.up()
t.forward(200)
t.down()

carre()

Écrire une fonction check() qui dessine un carré avec ses deux diagonales. On prendra soin de repositioner le crayon à l’endroit où il était au début de l’appel de fonction.

Les paramètres

On remarque l’utilisation du mot-clé def pour définir une fonction. Pour appeler une fonction, on utilise son nom suivi de parenthèses. On remarque que cette fonction n’est pas très utiles lorsque l’on souhaite dessiner des carrés de tailles différentes. On peut ajouter des paramètres à notre fonction pour modifier son comportement en fonctions de valeurs données lors de son appel. Le code suivant définit une fonction carre qui prend en paramètre la longueur du côté, puis dessine un carré de côté 100 et un carré de côté 200.

def carre(l):
    for i in range(4):
        t.forward(l)
        t.left(90)
 
carre(100)

# On bouge le crayon
t.up()
t.forward(200)
t.down()

carre(200)

Écrire une fonction rectangle(l1, l2) qui dessine un rectangle de taille l1 par l2, l1 étant la longueur du premier côté dessiné.

Écrire une fonction polygone(n, l) qui dessine un polygone régulier à n côtés, chacun de longueur r.

Valeurs de retour

Jusqu’ici nous avons vu des fonctions qui effectuent une action. Dans beaucoup de cas, on a besoin de calculer une valeur. On peut faire en sorte que notre fonction retourne une valeur qu’elle a calculée avec le mot clé return. Par exemple :

import datetime

# Calcul l'âge d'une personne en fonction de son année de naissance
def age(annee):
    current = datetime.datetime.today().year # année en cours
    return current-annee
    
print("J'ai "+age(2006)+" ans.")

Une remarque : return arrête l’exécution de la fonction en cours, donc si vous écrivez du code après, il sera ignoré. Par exemple :

# Calcul l'âge d'une personne en fonction de son année de naissance
def age(annee):
    current = datetime.datetime.today().year # année en cours
    return current-annee
    print("Cette commande ne sera jamais exécutée !")

Écrire une fonction majeur(annee) qui retourne True si une personne née en annee est majeure et False sinon.

Effets d’une fonctions

Lorsqu’on appelle une fonction en Python, elle peut modifier l’environnement du programme, c’est-à-dire la valeur de certaines variables. On va considérer le programme suivant :

def plus_un(x):
    x = x+1
    
def lzero(l):
    l[0] = 0

y = 6
plus_un(y)
print("La valeur de y est :")
print(y)

q = [1,2,3]
lzero(q)
print("La valeur de q est :")
print(q)
  1. Sans exécuter le programme précédent, essayez de deviner ce qu’afficher le programme. Notez-le sur une feuille.
  2. Exécuter le programme. Est-ce que cela correspond à votre intuition ?

Quand on passe une variable en argument à une fonction, Python va en général copier sa valeur et utiliser seulement sa valeur dans le corps de la fonction. C’est pourquoi la fonction plus_un() ne modifie pas la valeur de la variable y, puisque la valeur 6 est copié dans une variable temporaire propre à la fonction qui est ensuite incrémenté de 1. Cependant, si la variable est une liste, sa “valeur” n’est pas forcément ce que vous croyez. En effet, pour gérer une liste en mémoire, Python doit écrire toutes les valeurs de la liste à la suite quelque part dans la mémoire vive de votre ordinateur et la “valeur” d’une liste n’est pas l’ensemble des valeurs de la liste mais plutôt l’emplacement mémoire où ces valeurs sont écrites. C’est pourquoi la fonction lzero(q) modifie la liste q. Lorsqu’on appelle lzero(q), on copie dans une variable temporaire l propre à la fonction l’endroit où les valeurs des éléments q sont écrites. Donc l[0]=0 va écrire 0 là où q a écrit ses valeurs.

Bien comprendre les effets d’une fonction sur l’environnement requiert une bonne compréhension de comment Python gère la mémoire, ce qui est un peu difficile à votre niveau. On se rappellera donc de la règle approximative suivante : si une variable avec un type “simple” (int, float, bool etc.) est passé en argument d’une fonction, la valeur de variable n’est pas modifiée par la fonction (car elle a été copiée). Si le type est complexe (list, dict, etc), alors la valeur de la variable sera modifiée.

Essayez de deviner ce qu’affichera le programme suivante et expliquez pourquoi.

q2 = [1]
lzero(q2+q2)
print(q2)

Écrire une fonction reset(l) qui prend une liste l d’entiers en paramètre et mets toutes ses valeurs à 0. Par exemple :

l = [1,2,3,4,5]
reset(l)
print(l)

devrait afficher [0,0,0,0,0].