7 - Déclarations et appels de fonctions

⏪

⏬

⏩

1 - Cours

2 - Exercices

3 - Exercices

4 - FAQ

Les fonctions sont présentes dans les langages de programmation courants. Vous allez voir que ce terme est très proche des fonctions mathématiques.

IDE Python proposé : Thonny

Documents de cours : pdf ou odt.

MODE COURS (cacher les questions)

1 - Le cours : définition et appel de fonctions

⇩ ⇧ ⤊

✔ Intro A (Mise en place)° Réaliser les actions suivantes :

Sortir votre feuille de TP et y noter le titre Python 7.
Ouvrir Thonny. Réduire la fenêtre de Thonny et de votre navigateur Web pour que chaque fenêtre occupe la moitié de l'écran.
Ouvrir votre dossier/répertoire personnel. Créer dans le dossier SNT un nouveau sous-dossier qu'on nommera python07.
Sur Windows : vérifier via le menu affichage de votre explorateur de dossiers que vous avez bien coché la case "Afficher les extensions".

1.1 FONCTION : notion

ENTREE(S)

⇒

Fonction

⇒

SORTIE

Voir

Principe général

Une fonction est un bloc de code qui reçoit des données d'entrée et envoie une sortie.

Un exemple avec la fonction VALEUR_ABSOLUE qui n'attend qu'une entrée (un nombre) et qui renvoie la valeur absolue du nombre (le même nombre mais sans son signe).

-12

⇒

Fonction VALEUR ABSOLUE

⇒

Fonction VALEUR ABSOLUE

⇒

D'autres exemples

5, 10, 50, 0, 20

⇒

Fonction MAXIMUM

⇒

5, 10, 50, 0, 20

⇒

Fonction MINIMUM

⇒

5, 10, 50, 0, 20

⇒

Fonction SOMME

⇒

1.2 - FONCTION : native

Voir

Une fonction native est une fonction présente de base dans Python.

Dans le cadre de ce site, les fonctions natives sont toujours écrites en vert.

On fait appel à une fonction en notant son nom suivi de parenthèses contenant les entrées séparées par des virgules :

nom_fonction(a, b, c, d...)

Fonction VALEUR ABSOLUE : cette fonction se nomme abs() en Python.


>>> abs(-12)
12
 
>>> abs(12)
12

Fonction MAXIMUM : cette fonction se nomme max() en Python.


>>> max(10, 0, 50, 40)
50

✔ Intro B° Réaliser les actions suivantes :

Placez ce programme dans Thonny,

1
2
3

def fois2(a):
    b = a * 2
    return b

Affichez l'onglet des variables s'il n'apparaît pas
Lancez le programme en appuyant sur la flèche verte, en le nommant fonction07.py.

Questions / Réponses

La fonction se place-t-elle en mémoire ? On voit bien que oui.
La fonction se lance-t-elle seule ? Rien n'apparaît dans la console, donc non.

✔ Intro C° Placez ce nouveau programme où on définit d'abord la fonction puis où on y fait appel plusieurs fois.

def fois2(a):
    b = a * 2
    return b
 
x = fois2(10)
print(x)
 
y = fois2(100)
print(y)

Questions / réponses :

Sur quelle ligne se trouve le premier appel ? Ligne 5.
Qu'est-ce qu'on envoie à la fonction lors de cet appel ? 10.
Comparez l'appel et la définition : dans quelle variable va-t-on stocker la valeur envoyée ? Dans la variable a.

définition

appel

def fois2(a):
 
x = fois2(10)

Que renvoie la fonction lors de cet appel ? Elle stocke 20 dans b et renvoie ce b, donc 20.
Dans quoi stocke-t-on le résultat de la fonction ? Dans la variable x.
Sur quelle ligne se trouve le deuxième appel ? Ligne 8.
Qu'est-ce qu'on envoie à la fonction lors de cet appel ? 100.
Comparez l'appel et la définition : dans quelle variable va-t-on stocker la valeur envoyée ? Dans la variable a.

définition

appel

def fois2(a):
 
x = fois2(100)

Que renvoie la fonction lors de cet appel ? Elle stocke 200 dans b et renvoie ce b, donc 200.
Dans quoi stocke-t-on le résultat de la fonction ? Dans la variable y.

✔ Intro D° Quel est le déroulé ligne par ligne de ce programme ?

def fois2(a):
    b = a * 2
    return b
 
x = fois2(10)
print(x)
 
y = fois2(100)
print(y)

Déroulé

L01(définition de la fonction)

L05(appel à la fonction en envoyant 10) - L01(réception du 10) - L02 - L03(envoi de 20)

L05(retour de la réponse 20) - L06

L08(appel à la fonction en envoyant 100) - L01(réception du 100) - L02 - L03(envoi de 200)

L08(retour de la réponse 200) - L09

✔ Intro E° Testez cette version pour vérifier qu’elle fait bien la même chose : inutile de passer par une variable intermédiaire : le mot-clé return provoque d'abord l'évaluation de l'expression fournie, puis renvoie le résultat obtenu.

def fois2(a):
    return a * 2
 
x = fois2(10)
print(x)
 
y = fois2(100)
print(y)

✔ Intro F° Testez cette nouvelle fonction qui possède plusieurs paramètres (variables d'entrée).

def moyenne_bienvellante(note1, note2):
    if note1 > note2:
        moyenne = (note1*3 + note2*1) / 4
    else:
        moyenne = (note1*1 + note2*3) / 4
    return moyenne
 
m1 = moyenne_bienvellante(5, 20)
print(m1)
 
m1 = moyenne_bienvellante(16, 8)
print(m1)

Questions-réponses

Lors du premier appel, qu'envoie-t-on à la fonction ? Ligne 8 : on envoie 5 et 20.
Comparez l'appel et la définition : dans quelles variables va-t-on stocker les valeurs envoyées ? 5 dans note1 et 20 dans note2.

 définition

 appel

def moyenne_bienvellante(note1, note2):
 
m1 = moyenne_bienvellante(5, 20)

Lors du deuxième appel, qu'envoie-t-on à la fonction ? Ligne 8 : on envoie 16 et 8.
Comparez l'appel et la définition : dans quelles variables va-t-on stocker les valeurs envoyées ? 16 dans note1 et 8 dans note2.

 définition

 appel

def moyenne_bienvellante(note1, note2):
 
m1 = moyenne_bienvellante(16, 8)

Si vous êtes en TP, passez directement à la partie 2 suivante, sans lire les bilans ci-dessous : ils seront analysés oralement à la fin du TP.

1.3 FONCTION : définition d'une fonction personnelle

def double(x):      # Déclaration
    return 2 * x    # Déclaration
 
n = double(12)      # Appel

Voir

Définir une fonction revient à stocker ses instructions pour les utiliser plus tard.

On voit d'ailleurs que vous ne pourriez pas l'utiliser pour le moment car vous ne savez pas ce que contient réellement la variable x.

Par contre, si vous avez bien compris ce qu'est une variable, vous devriez comprendre qu'on va remplir le double de ce qu'on va recevoir un jour en entrée.

Pour définir une fonction, on utilise le mot-clé def puis

le nom de la fonction
des parenthèses contenant les entrées séparées par des virgules
le caractère : pour finir cette première ligne
le bloc tabulé contenant les instructions à réaliser un jour.

1
2

def double(x):
    return 2 * x

Le mot-clé return permet d'indiquer la sortie que la fonction devra renvoyer.

Placer des commentaires en français dans le code Python

On peut placer du texte à destination des développeurs qui vont lire le programme en utilisant le caractère #. Voir la partie suivante pour un exemple.

Attention : sur votre ligne, tout ce qui se trouve derrière ce # sera purement ignoré par l'interpréteur.

1.4 FONCTION : appel de fonction

def double(x):      # Déclaration
    return 2 * x    # Déclaration
 
n = double(12)      # Appel

Voir

Lancer un appel de fonction

Lancer un appel veut dire utiliser une fonction en lui fournissant des entrées puis attendre pour récupérer la réponse qu'elle fournira.

Sur le code d'exemple, on lance un appel en ligne 4.

Lors d'un appel, l'interpréteur Python transfère les données envoyées une à une dans les variables visibles sur la définition. Pour comprendre où sont stockées les entrées, il suffit de comparer la ligne de la définition et celle de l'appel.

Avec l'appel de la ligne 5, on a 10 qui est stocké dans a lors de cet appel :

définition

appel

def fois2(a):
 
x = fois2(10)

[Déroulé] Lors d'un appel, on part de la ligne d'appel vers la ligne de définition puis la réponse est renvoyée vers la ligne d'appel.

def double(x):      # Définition
    return 2 * x    # Définition
 
n = double(12)      # Appel

L1 (déclaration)
L4 (appel) - L1 - L2 (envoi de la réponse)
L4 (réception de la réponse) - fin car il n'y a rien ensuite

Explications complètes

Ligne 1 : déclaration d'une fonction double() qui va recevoir une donnée qu'on placera dans une variable x.
Ligne 4 : appel à la fonction double() en lui envoyant 12
Ligne 1 : l'interpréteur place 12 dans x.
Ligne 2 : la fonction envoie la réponse 24 à la ligne qui a lancé l'appel
Ligne 4 : réception de la réponse et n référence 24.

Lancer plusieurs appels

Les fonctions ont deux avantages :

Permettre l'envoi d'une sortie dont la valeur dépend des entrées reçues ;
Permettre plusieurs appels successifs à une même fonction.

def double(x):
    return 2 * x
 
a = double(10)
b = double(30)

Déroulé

L1 (déclaration)
L4 (appel) - L1 - L2 (envoi de la réponse)
L4 (réception de la réponse et affectation du 20 à a)
L5 (appel) - L1 - L2 (envoi de la réponse)
L5 (réception de la réponse et affectation du 60 à b) - fin

Bilan

Vous devez donc savoir distinguer ces deux étapes, sous peine de ne pas comprendre correctement ce qui est réalisé :

La définition (mise en mémoire d'un bloc d'instructions pour l'utiliser plus tard)
L'appel (utilisation de ce bloc d'instructions)

1.5 FONCTION : plusieurs entrées ?

Voir

On peut créer des fonctions possédant 0, 1, 2 ou plus entrées. Le tout est de les déclarer.

def mystere(a, b, c): 
    reponse = a  + b*2 + c
    return reponse
 
x = mystere(10, 20, 30)

Lors de l'appel en ligne 5, on va donc envoyer 10 dans a, 20 dans b et 30 dans c.

2 - Exercices Définition - Appel- Séquence

⇩ ⇧ ⤊

⚙ 01° Donner la séquence de lignes suivies par Python puis la réponse finale qu'on stocke dans x.

def plus10(a):
    return a + 10
 
x = plus10(5)
print(x)
print("FIN")

Correction ?

...CORRECTION...

L01(définition)

L04(appel en envoyant 5) - L01(réception du 5 dans a) - L02(envoi de 15)

L04(retour du 15 qu'on stocke dans x) - L05 - L06

⚙ 02° Observer ce nouveau programme puis répondre aux questions.

def mystere(a, b, c): 
    reponse = a  + b*2 + c
    return reponse
 
x = mystere(5, 10, 30)

Questions

Sur quelle ligne se fait l'appel ?
Que vaut a lors de cet appel ?
Que vaut b ?
Que vaut c ?
Que va alors contenir x une fois que la fonction aura répondu ?

Correction ?

...CORRECTION...

Sur quelle ligne se fait l'appel ?

Ligne 5

Que vaut a lors de cet appel ?
Que vaut b ?
Que vaut c ?

Il faut comparer la définition et l'appel :

définition

appel

def mystere(a, b, c): 
 
x = mystere(5, 10, 30)

a reçoit 5, b reçoit 10 et c reçoit 30.

Que va alors contenir x une fois que la fonction aura répondu ?

Lors de cet appel, la fonction réalise le calcul 5 + 10*2 + 30 ce qui donne 55.

La réponse va renvoyer ce 55, qui sera alors stocké dans la variable x.

⚙ 03° Fournir la séquence de lignes suivie par Python.

def mystere(a, b, c): 
    reponse = a  + b*2 + c
    return reponse
 
print("Avant l'appel")
x = mystere(5, 10, 30)
print("Après l'appel")
print(x)

Correction ?

...CORRECTION...

L01(définition)

L05

L06(appel en envoyant 5-10-30) - L01(réception du 5 dans a ect...) - L02(calcul de 80) - L03(envoi de 80)

L06(retour du 80 qu'on stocke dans x) - L07 - L08

⚙ 04° Utiliser ce dernier programme : on définie une fonction carre() qui permet de dessiner un carré de 20 pixels de large en fournissant les coordonnées x et y voulues ainsi que la couleur.

Lancer le programme puis
réaliser un petit dessin en pixel art contenant 9 appels (et donc 9 carrés).

from turtle import *
 
def carre(x, y, c):
    largeur = 20
    penup()
    goto(x*largeur, y*largeur)
    pendown()
    setheading(0)         # on force la tortue à regarder à droite
    pencolor(c)           # on définit la couleur du crayon
    fillcolor(c)          # on définit la couleur de remplissage
    begin_fill()          # demande de surveillance de ce qui est dessiné
    for _ in range(4):
        forward(20)
        left(90)
    end_fill()            # fin du dessin, turtle peut maintenant colorier l'intérieur
 
carre(0, 0, "#FF0000")    # carré rouge
carre(1, 0, "#00FF00")    # carré vert
carre(0, 1, "#0000FF")    # carré bleu
carre(0, 2, "#FFFF00")    # carré jaune

3 - Exercices de programmation

⇩ ⇧ ⤊

✎ 05° Compléter la fonction addition() : elle doit renvoyer l’addition de deux entiers qu’on fournira lors de l’appel. Compléter également le deuxième appel pour lui envoyer les valeurs 10 et 15.

def addition(a, b):
    ...
 
x = addition(10, 40)
print(x)
 
y = addition(..., ...)
print(y)

Sur votre feuille : noter la définition de la fonction sur votre copie puis l’appel qu’on doit en faire pour additionner 10 et 15.

Correction ?

...CORRECTION...

def addition(a, b):
    return a + b
 
x = addition(10, 40)
print(x)
 
y = addition(10, 15)
print(y)

✎ 06° Compléter la fonction affine() pour renvoyer a*x + b à partir des paramètres a, b et x.

def affine(a, x, b):
    ...
 
r1 = affine(2, 4, 3)
print(r1)
 
r2 = affine(..., ..., ...)
print(r2)

Sur votre feuille : noter la définition de la fonction sur votre copie puis l’appel qu’on doit en faire pour connaître l'image de la fonction avec a=10, x=2 et b=100.

Correction ?

...CORRECTION...

def affine(a, x, b):
    return a*x + b
 
r1 = affine(2, 4, 3)
print(r1)
 
r2 = affine(10, 2, 100)
print(r2)

✎ 07° Créer une fonction carre() qui a x associe x².

Sur votre feuille : noter la définition de la fonction sur votre copie puis l’appel et l'affichage de la valeur de sortie (l'image) si on envoie 10.

Correction ?

...CORRECTION...

def carre(x):
    return x*x
 
r1 = carre(10)
print(r1)

✔ 08° Tapez ceci dans la console pour vous souvenir de la façon de tester une égalité entre deux variables a et b.


>>> a = 10
>>> b = 20
>>> a == b
False
 
>>> a*2 == b
True
 
>>> a == b
False

✎ 09° Compléter la dernière ligne de verification() pour renvoyer True si le paramètre mot_recu passé en paramètre est le même que le bon mot de passe, contenu dans une variable mdp, locale à la fonction. Sinon, elle renvoie False.

def verification(mot_recu):
    mdp = '1234!'
    return ...
 
print(verification(...))

Sur votre feuille : noter la définition de la fonction.

Correction ?

...CORRECTION...

def verification(mot_recu):
    mdp = '1234!'
    return mdp == mot_recu
 
print(verification("0000"))

⚙ 10° Compléter ce programme pour qu'il demande le mot de passe jusqu'à ce que l'utilisateur donne le bon.

def verification(mot_recu):
    mdp = '1234!'
    return ...
 
tentative = ""
while verification(tentative) == ...:
    print("Donnez le mot de passe :")
    tentative = input()
 
print("Autorisation accordée.")

Correction ?

...CORRECTION...

def verification(mot_recu):
    mdp = '1234!'
    return mdp == mot_recu
 
tentative = ""
while verification(tentative) == False:
    print("Donnez le mot de passe :")
    tentative = input()
 
print("Autorisation accordée.")

⚙ 11° Utiliser la fonction ci-dessous pour vérifier qu’elle renvoie la même chose que la précédente (mais en plus "naïve" puisque cette version teste si c'est Vrai pour renvoyer Vrai, sinon elle renvoie Faux).

Question

Un utilisateur peut-il se rendre compte que les instructions internes des deux fonctions sont différentes ?

def verification_v2(mot_recu):
    mdp = '1234!'
    if mot_recu != mdp:
        return False
    else:
        return True

RAPPEL sur != : cet opérateur booléen teste la différence entre les deux termes à sa gauche et à sa droite.

Correction ?

...CORRECTION...

L'utilisateur ne pourra pas voir la différence.

⚙ 12° Compléter la fonction verification_v3() pour qu'elle utilise plutôt l'opérateur d'égalité (==). Son utilisation doit renvoyer exactement les mêmes réponses : seule la façon dont elle est conçue à l'interne diffère. Du point de vue de l'extérieur, on ne doit se rendre compte de rien.

def verification_v3(mot_recu):
    mdp = '1234!'
    if ... == ...:
        return ...
    else:
        return ...

Correction ?

...CORRECTION...

def verification_v3(mot_recu):
    mdp = '1234!'
    if mdp == mot_recu:
        return True
    else:
        return False

✎ 13° Créer une fonction plus_grand(a, b) qui doit renvoyer la plus grande valeur fournie entre a et b.

def plus_grand(a, b):
    if ... >= ...:
        return ...
    else:
        return ...

Sur votre feuille : noter la définition de la fonction.

Correction ?

...CORRECTION...

def plus_grand(a, b):
    if a >= b:
        return a
    else:
        return b

✎ 14° Sur votre feuille : noter deux exemples permettant de vérifier que votre fonction fonctionne correctement.

4 - FAQ

⇩ ⇧ ⤊

On fait comment avec une fonction sans paramètre ?

On n'en place pas, c'est tout. Pas contre, on laisse les parenthèses.

Exemple de déclaration :

1
2

def nom():
    return 'Iron Man'

Exemple d'appel :


>>> nom()
'Iron Man'

Activité publiée le 25 02 2021
Dernière modification : 25 02 2021
Auteur : ows. h.

⏪

⏫

⏩