Exo Fonction

Identification

Infoforall

15 - Exercices Fonction


Tous les exercices sont corrigés.

Attention : lire une correction ne garantit pas de pouvoir refaire l'exercice. Comprendre et faire sont deux capacités différentes.

1 - Fonctions basiques

01° Compléter la fonction fois10() qui possède un paramètre x et qui renvoie 10 fois cette valeur.

1 2
def fois10(x:int) -> int: pass

Exemple de fonctionnement attendu dans la console une fois la fonction en mémoire :

>>> fois10(5) 50

...CORRECTION ...

1 2
def fois10(x:int) -> int: return 10 * x

02° Lors de l'appel suivant, que va contenir le paramètre x durant l'exécution de la fonction ?

>>> fois10(7)

...CORRECTION ...

On compare la ligne d'appel et la ligne de déclaration.

Appel

>>> fois10( 7 )

Déclaration

1
def fois10( x :int) -> int:

Il est alors clair que l'argument 7 sera stocké dans le paramètre x.

03° On vous donne la déclaration d'une fonction addition() ainsi qu'un appel à cette fonction depuis la console. Lors de l'appel suivant, que vont contenir les paramètres x et y durant l'exécution de la fonction ?

1
def addition(x:int, y:int) -> int:
>>> addition(4, 10)

...CORRECTION ...

Même principe, on compare l'appel et la déclaration.

Le premier argument envoyé (4) sera stocké dans le premier paramètre (x).

Le deuxième argument envoyé (10) sera stocké dans le deuxième paramètre (y).

04° Créer une fonction dizaine() qui attend un paramètre nommé nombre. La fonction dizaine() doit renvoyer la dizaine présente dans le nombre. Pensez à retourner voir le cours Python 1 sur quotient et reste si vous ne vous souvenez plus comment on fait cela.

Voici le prototype attendu :

def dizaine(nombre:int) -> int

Exemple de fonctionnement attendu :

>>> dizaine(123) 2

...CORRECTION ...

1 2
def dizaine(x:int) -> int: return x // 10 % 10

2 - Documentation

On rappelle que les conditions sur les paramètres sont divisées en deux parties :

  1. Leurs types (qui doivent apparaître dans le prototype)
  2. Les préconditions (des conditions supplémentaires éventuelles, eun plus du simple type)

05° Rajouter la documentation longue sur les paramètres et le retour de la fonction addition() en suivant le type de documentation présentée dans le cours.

Voici le prototype attendu :

def addition(x:int, y:int) -> int

PRECONDITIONS : nous voudrions que l'utilisateur n'envoie que des entiers positifs.

1 2
def addition(x, y): return x + y

...CORRECTION ...

Conditions sur les types.

Préconditions.

1 2 3 4 5 6 7 8 9
def addition(x, y): """Renvoie l'addition de x et y :: param x(int) :: un entier POSITIF :: param y(int) :: un entier POSITIF :: return (int) :: un entier positif """ return x + y

06° Localiser et modifier l'erreur présente dans la documentation de la fonction.

1 2 3 4 5 6 7 8 9
def division(x, y): """Renvoie la division x / y :: param x(int) :: un entier :: param y(int) :: un entier non nul :: return (int) :: un entier """ return x / y

Quelques exemples pour vous aiguiller :

>>> division(100,10) 10.0 >>> division(500,2) 250.0

...CORRECTION ...

La documentation indique que le type de la sortie sera un entier.

Or, c'est faux : la fonction va renvoyer un float si on envoie bien des entiers en entrée.

L'erreur est donc sur la documentation L6.

3 - Compréhension des transferts de paramètres

Attention, cet exercice porte notamment sur la différence entre la fonction native print() et le mot-clé return.

07° Lancer le programme suivant. Expliquer clairement (en fournissant notamment la succession de lignes suivies par l'interpréteur) pourquoi il provoque l'affichage des valeurs suivantes : 5, 6 puis 5. Votre explication devra expliquer pourquoi on obtient 3 affichages, et pourquoi ces trois valeurs.

1 2 3 4 5 6 7 8 9
toto = 5 def affichage(t): t = t + 1 print(t) print(toto) affichage(toto) print(toto)

...CORRECTION ...

L1 : on initialise toto à 5.

L3 : déclaration d'une fonction, on peut passer.

L7 : on demande l'affichage de toto. 5 apparaît à l'écran.

L8 : on lance un appel à la fonction affichage() en lui envoyant l'argument toto.

L3 : l'argument toto est stocké dans le paramètre t.

L4 : on incrémente t de 1 qui devient égal à 6.

L5 : on demande l'affichage de t. 6 apparaît à l'écran.

L8 : retour en ligne 8 et on ne fait rien de la réponse None de la fonction.

L9 : on demande l'affichage de toto. 5 apparaît à l'écran.

08° Que va afficher ce programme ? Justifier votre réponse (en fournissant notamment la succession de lignes suivies par l'interpréteur). Au besoin, il suffit de passer par Python Tutor ou le débogage de Thonny.

1 2 3 4 5 6 7 8 9
toto = 10 def affichage(t): t = t * 2 print(t) print(toto) x = affichage(toto) print(x)

Attention à la subtilité. Souvenez-vous que la fonction native print() affiche mais ne renvoie rien...

...CORRECTION ...

L1 : on initialise toto à 10.

L3 : déclaration d'une fonction, on peut passer.

L7 : on demande l'affichage de toto. 10 apparaît à l'écran.

L8 : on lance un appel à la fonction affichage() en lui envoyant l'argument toto.

L3 : l'argument toto est stocké dans le paramètre t.

L4 : on multiplie t par 2 et on replace cette valeur dans t, qui devient égal à 20.

L5 : on demande l'affichage de t. 20 apparaît à l'écran.

L8 : retour en ligne 8 et on stocke la réponse None de la fonction dans la variable x.

L9 : on demande l'affichage de x. None apparaît sur l'écran.

09° Donner le contenu des variables x et y à la fin du programme. Justifier votre raisonnement (en fournissant notamment la succession de lignes suivies par l'interpréteur) pour l'expliquer clairement à quelqu'un.

1 2 3 4 5 6
def rajouter10(z): z = z + 10 return z x = 50 y = rajouter10(x)

...CORRECTION ...

L1 : déclaration d'une fonction, on peut passer.

L5 : on initialise x à 50.

L6 : on commence par lancer un appel à rajouter10() en lui envoyant x en argument.

L1 : on voit que le paramètre z reçoit l'argument x.

L2 : on incrémente z de 10, qui devient égal à 60.

L3 : on renvoit z.

L6 : l'interpréteur a parvenu à évaluer rajouter10(x) à 60, il place ce résulat dans y.

10° La ligne 2 est-elle vraiment utile en réalité ? Proposer une autre version de cette fonction qui renvoie directement la valeur attendue sans passer par une variable intermédiaire inutile. Votre fonction ne doit donc comporter qu'une seule ligne de code.

...CORRECTION ...

1 2 3 4 5
def rajouter10(z): return z + 10 x = 50 y = rajouter10(x)

Activité publiée le 15 09 2020
Dernière modification : 15 09 2020
Auteur : ows. h.