$course$/QCM de NSI/SNT/7. Fonctions Définir une fonction avec def, l'appeler ; paramètres et arguments ;
la valeur renvoyée par return, à distinguer d'un affichage par
print ; une fonction sans return renvoie None ; réutiliser un
résultat dans un calcul ou un test ; les variables locales.

]]> 7. Fonctions — Q01 : Appeler une fonction

def double(x):
    return 2 * x
print(double(7))

Qu'affiche ce programme ?

]]> Appeler une fonction, c'est exécuter son bloc avec les arguments
fournis. La valeur qui suit return remplace l'appel dans
l'expression, ici dans print.

]]> 1.0 0.0 0 true true abc 14

]]> Bonne réponse : l'appel double(7) exécute la fonction avec x
égal à 7 et renvoie 14, que print affiche.

]]> 2 * x

]]> Erreur : return renvoie le résultat du calcul, pas le texte de
la formule.

]]> 7

]]> Erreur : 7 est l'argument. La fonction renvoie 2 fois sa valeur.

]]> Rien, une fonction n'affiche pas

]]> Erreur : la fonction n'affiche rien, mais print affiche la
valeur qu'elle renvoie.

]]> 7. Fonctions — Q02 : Paramètre et argument Une fonction est définie par def aire(largeur, hauteur): et
appelée par aire(4, 3). Que représente le 4 ?

]]> Les paramètres sont les noms écrits dans la définition ; les
arguments sont les valeurs fournies à l'appel. Ils sont associés
dans l'ordre.

]]> 1.0 0.0 0 true true abc L'argument transmis au paramètre largeur

]]> Bonne réponse : les arguments sont associés aux paramètres dans
l'ordre. largeur vaut 4 et hauteur vaut 3 pendant l'appel.

]]> Le nom du premier paramètre de la fonction

]]> Erreur : le nom du paramètre est largeur. 4 est la valeur
qu'il reçoit lors de cet appel.

]]> La valeur renvoyée par la fonction

]]> Erreur : la valeur renvoyée est calculée par la fonction, ici
probablement 12.

]]> La valeur du paramètre hauteur

]]> Erreur : l'ordre compte, le premier argument va au premier
paramètre.

]]> 7. Fonctions — Q03 : Définir sans appeler

def saluer():
    print("Bonjour")

Qu'affiche ce programme ?

]]> Définir une fonction ne l'exécute pas. Le bloc ne tourne qu'au moment
de l'appel, écrit avec le nom suivi de parenthèses.

]]> 1.0 0.0 0 true true abc Rien, la fonction n'est jamais appelée

]]> Bonne réponse : def prépare la fonction sans l'exécuter. Il
faudrait ajouter la ligne saluer().

]]> Bonjour, une seule fois, à la définition

]]> Erreur : le bloc d'une fonction ne s'exécute qu'à l'appel, et
aucun appel n'est écrit.

]]> Bonjour sans fin, la fonction se relance

]]> Erreur : une fonction n'est pas une boucle, et elle n'est même
pas appelée.

]]> Une erreur, il manque return à la fonction

]]> Erreur : return n'est pas obligatoire. Une fonction peut se
contenter d'afficher.

]]> 7. Fonctions — Q04 : Afficher n'est pas renvoyer

def carre(n):
    print(n * n)

r = carre(3)
print(r)

Qu'affiche ce programme ?

]]> print montre une valeur à l'écran, return la transmet au
programme. Une fonction sans return renvoie None, et son
résultat ne peut pas être réutilisé.

]]> 1.0 0.0 0 true true abc 9 puis None

]]> Bonne réponse : l'appel affiche 9, mais sans return la
fonction renvoie None, qui est rangé dans r puis affiché.

]]> 9 puis 9

]]> Erreur : print dans la fonction affiche, il ne renvoie rien.
r ne reçoit pas 9.

]]> None puis 9

]]> Erreur : l'affichage de 9 a lieu pendant l'appel, donc avant le
second print.

]]> 9 seulement

]]> Erreur : le second print affiche bien quelque chose, la valeur
None.

]]> 7. Fonctions — Q05 : Réutiliser un résultat

def prix_ttc(ht):
    return ht * 1.2
total = prix_ttc(10) + prix_ttc(20)
print(total)

Qu'affiche ce programme ?

]]> Une valeur renvoyée s'utilise comme n'importe quelle valeur : dans
une addition, une affectation ou un autre appel. C'est ce qui rend
return plus puissant que print.

]]> 1.0 0.0 0 true true abc 36.0

]]> Bonne réponse : les deux appels renvoient 12.0 et 24.0, dont la
somme est 36.0.

]]> 36

]]> Erreur : la multiplication par 1.2 donne des flottants, la somme
est affichée 36.0.

]]> 30

]]> Erreur : 30 est la somme des prix hors taxe, avant la
multiplication.

]]> 12.0

]]> Erreur : 12.0 n'est que le premier appel, le second est ajouté.

]]> 7. Fonctions — Q06 : Deux paramètres, un ordre

def soustraire(a, b):
    return a - b
print(soustraire(3, 10))

Qu'affiche ce programme ?

]]> Les arguments sont affectés aux paramètres dans l'ordre de l'appel.
Inverser deux arguments change le résultat sans provoquer d'erreur,
d'où l'importance de l'ordre.

]]> 1.0 0.0 0 true true abc -7

]]> Bonne réponse : a vaut 3 et b vaut 10, la fonction renvoie
3 moins 10.

]]> 7

]]> Erreur : l'ordre des arguments compte, le premier va dans a.

]]> 13

]]> Erreur : la fonction soustrait, elle n'additionne pas.

]]> Une erreur, le résultat est négatif

]]> Erreur : un résultat négatif est un entier comme un autre.

]]> 7. Fonctions — Q07 : Ce qui suit return

def test(x):
    return x + 1
    print("Après")

print(test(1))

Qu'affiche ce programme ?

]]> return renvoie une valeur et quitte la fonction sur-le-champ. Du
code écrit après un return inconditionnel est du code mort.

]]> 1.0 0.0 0 true true abc 2 seulement

]]> Bonne réponse : return termine immédiatement la fonction. La
ligne qui suit n'est jamais exécutée.

]]> Après puis 2

]]> Erreur : la fonction s'arrête au return, avant le print.

]]> 2 puis Après

]]> Erreur : après un return, plus rien ne s'exécute dans la
fonction.

]]> Après seulement

]]> Erreur : l'appel renvoie 2, que print affiche, et Après
n'est jamais atteint.

]]> 7. Fonctions — Q08 : Une fonction qui répond par oui ou non

def est_majeur(age):
    return age >= 18

print(est_majeur(20), est_majeur(12))

Qu'affiche ce programme ?

]]> Une fonction peut renvoyer directement une comparaison. Elle sert
alors de test réutilisable, par exemple dans un if.

]]> 1.0 0.0 0 true true abc True False

]]> Bonne réponse : la fonction renvoie le résultat de la
comparaison, vrai pour 20 et faux pour 12.

]]> False True

]]> Erreur : c'est l'inverse, 20 est supérieur ou égal à 18.

]]> True True

]]> Erreur : 12 n'est pas supérieur ou égal à 18.

]]> 20 12

]]> Erreur : la fonction ne renvoie pas l'âge mais un booléen.

]]> 7. Fonctions — Q09 : Une variable locale

def calcul():
    resultat = 10
    return resultat

calcul()
print(resultat)

Que se passe-t-il ?

]]> Les variables créées dans une fonction sont locales : elles
disparaissent à la fin de l'appel. Pour transmettre une valeur à
l'extérieur, on utilise return.

]]> 1.0 0.0 0 true true abc Une erreur, resultat n'existe que dans la fonction

]]> Bonne réponse : resultat est une variable locale, créée à
l'appel et détruite à la sortie. En dehors, elle n'existe pas.

]]> Python affiche 10, la valeur renvoyée par l'appel

]]> Erreur : pour obtenir 10, il faudrait écrire
print(calcul()), ou ranger la valeur renvoyée dans une
variable.

]]> Python affiche None, faute de valeur conservée

]]> Erreur : la fonction renvoie bien 10, mais ce résultat n'est pas
conservé, et resultat est inconnu à l'extérieur.

]]> Python affiche le mot resultat, sans sa valeur

]]> Erreur : print affiche la valeur d'une variable, et ici la
variable n'existe pas.

]]> 7. Fonctions — Q10 : Trop d'arguments

def moyenne(a, b):
    return (a + b) / 2

print(moyenne(10, 12, 14))

Que se passe-t-il ?

]]> Un appel doit fournir exactement un argument par paramètre. En
donner trop ou trop peu déclenche une erreur TypeError, dont le
message indique le nombre attendu.

]]> 1.0 0.0 0 true true abc Une erreur, la fonction attend deux arguments et en reçoit trois

]]> Bonne réponse : le nombre d'arguments doit correspondre au
nombre de paramètres. Python signale une TypeError.

]]> Python affiche 12.0, la moyenne des trois valeurs

]]> Erreur : la fonction ne sait calculer qu'avec deux valeurs,
elle ne s'adapte pas.

]]> Python affiche 11.0, le troisième argument est ignoré

]]> Erreur : Python n'ignore pas un argument en trop, il refuse
l'appel.

]]> Python affiche 13.0, à partir des deux derniers arguments

]]> Erreur : aucun choix n'est fait parmi les arguments, l'appel est
refusé.

]]> 7. Fonctions — Q11 : Une fonction appelée dans une autre

def double(x):
    return 2 * x
def quadruple(x):
    return double(double(x))
print(quadruple(3))

Qu'affiche ce programme ?

]]> Une fonction peut en appeler une autre, y compris avec le résultat
d'un premier appel comme argument. On évalue de l'intérieur vers
l'extérieur.

]]> 1.0 0.0 0 true true abc 12

]]> Bonne réponse : double(3) vaut 6, et double(6) vaut 12.

]]> 6

]]> Erreur : 6 est le résultat du premier double, auquel on
applique encore double.

]]> 24

]]> Erreur : deux multiplications par 2 font un facteur 4, pas 8.

]]> 9

]]> Erreur : la fonction multiplie par 2, elle n'élève pas au carré.

]]> 7. Fonctions — Q12 : Deux return dans une fonction

def categorie(age):
    if age < 12:
        return "enfant"
    return "adulte"

print(categorie(9), categorie(30))

Qu'affiche ce programme ?

]]> Plusieurs return peuvent figurer dans une fonction ; seul le
premier rencontré s'exécute. Un return dans un if évite parfois
un else.

]]> 1.0 0.0 0 true true abc enfant adulte

]]> Bonne réponse : pour 9, le premier return s'exécute et la
fonction s'arrête ; pour 30, la condition est fausse et le
second return est atteint.

]]> enfant enfant

]]> Erreur : pour 30, la condition age < 12 est fausse.

]]> adulte adulte

]]> Erreur : pour 9, la condition est vraie et enfant est renvoyé
avant d'atteindre le second return.

]]> Une erreur, une fonction n'a qu'un seul return

]]> Erreur : une fonction peut contenir plusieurs return. Le
premier atteint termine l'appel.

]]> 7. Fonctions — Q13 : Commencer une définition Quelle ligne commence correctement la définition d'une fonction
aire à deux paramètres ?

]]> Une définition s'écrit def nom(parametres): suivie d'un bloc
indenté. Les deux-points et l'indentation sont obligatoires, comme
pour if et for.

]]> 1.0 0.0 0 true true abc def aire(l, h):

]]> Bonne réponse : le mot-clé def, le nom, les paramètres entre
parenthèses et les deux-points.

]]> function aire(l, h):

]]> Erreur : function n'est pas un mot-clé de Python.

]]> def aire(l, h)

]]> Erreur : il manque les deux-points qui annoncent le bloc.

]]> aire(l, h) = def

]]> Erreur : def se place en tête de ligne, avant le nom.

]]> 7. Fonctions — Q14 : Un appel dans un appel

def suivant(n):
    return n + 1
print(suivant(1), suivant(suivant(1)))

Qu'affiche ce programme ?

]]> Chaque appel est indépendant et reçoit ses propres arguments. Quand
un appel sert d'argument à un autre, on calcule d'abord le plus
intérieur.

]]> 1.0 0.0 0 true true abc 2 3

]]> Bonne réponse : suivant(1) vaut 2, et suivant(2) vaut 3.

]]> 2 2

]]> Erreur : le second appel reçoit 2 en argument, il renvoie 3.

]]> 1 2

]]> Erreur : le premier appel renvoie déjà 2.

]]> 3 3

]]> Erreur : le premier appel n'ajoute 1 qu'une fois.

]]> 7. Fonctions — Q15 : Le paramètre n'est pas la variable extérieure

def augmenter(n):
    n = n + 5
    return n
valeur = 10
augmenter(valeur)
print(valeur)

Qu'affiche ce programme ?

]]> Un paramètre reçoit une copie de l'argument. Modifier le paramètre ne
change pas la variable de l'appelant : pour garder un résultat, on
affecte la valeur renvoyée.

]]> 1.0 0.0 0 true true abc 10

]]> Bonne réponse : la fonction travaille sur son paramètre n, une
copie de la valeur. valeur n'est pas modifiée, et le résultat
renvoyé, 15, n'est pas conservé.

]]> 15

]]> Erreur : 15 est renvoyé mais jamais rangé. Il faudrait écrire
valeur = augmenter(valeur).

]]> 5

]]> Erreur : rien ne ramène valeur à 5, elle reste à 10.

]]> None

]]> Erreur : valeur a bien une valeur, 10, inchangée par l'appel.

]]> 7. Fonctions — Q16 : Écrire la bonne fonction Quelle fonction renvoie le périmètre d'un rectangle de largeur l
et de hauteur h ?

]]> Une fonction qui calcule doit renvoyer son résultat avec return,
pour que l'appelant puisse s'en servir. Et les parenthèses restent
indispensables dans la formule.

]]> 1.0 0.0 0 true true abc def perimetre(l, h): return 2 * (l + h)

]]> Bonne réponse : le périmètre est le double de la somme des deux
dimensions, et la valeur est renvoyée avec return.

]]> def perimetre(l, h): return l * h

]]> Erreur : l * h est l'aire, pas le périmètre.

]]> def perimetre(l, h): print(2 * (l + h))

]]> Erreur : le calcul est juste, mais il est affiché et non
renvoyé. La fonction renverrait None.

]]> def perimetre(l, h): return 2 * l + h

]]> Erreur : sans parenthèses, seule la largeur est doublée.

]]> 7. Fonctions — Q17 : Une boucle dans une fonction

def premier_multiple(n, seuil):
    k = 1
    while n * k <= seuil:
        k = k + 1
    return n * k
print(premier_multiple(7, 30))

Qu'affiche ce programme ?

]]> Une fonction peut contenir une boucle, et renvoyer une valeur
calculée après elle. On suit k tour par tour, puis on applique le
return.

]]> 1.0 0.0 0 true true abc 35

]]> Bonne réponse : k augmente tant que 7 * k reste inférieur ou
égal à 30, jusqu'à 5. La fonction renvoie 35, le premier
multiple de 7 au-delà de 30.

]]> 28

]]> Erreur : 28 est encore inférieur ou égal à 30, la boucle
continue et k passe à 5.

]]> 5

]]> Erreur : 5 est la valeur finale de k, mais la fonction renvoie
n * k.

]]> 4

]]> Erreur : ni k ni le résultat ne valent 4 à la fin.

]]> 7. Fonctions — Q18 : Deux affichages

def f(x):
    return x * 10
print(f(2))
print(f(2) + f(3))

Qu'affiche ce programme ?

]]> Chaque appel renvoie une valeur, utilisable dans un calcul. Une
fonction peut être appelée autant de fois qu'on veut, avec des
arguments différents.

]]> 1.0 0.0 0 true true abc 20 puis 50

]]> Bonne réponse : f(2) vaut 20, et f(2) + f(3) vaut 20 plus
30.

]]> 20 puis 20

]]> Erreur : la seconde ligne additionne deux appels, 20 et 30.

]]> 20 puis 2030

]]> Erreur : les résultats sont des entiers, + les additionne.

]]> 50 puis 20

]]> Erreur : c'est l'ordre inverse des lignes du programme.

]]> 7. Fonctions — Q19 : Une fonction dans un test

def est_pair(n):
    return n % 2 == 0

for k in range(1, 7):
    if est_pair(k):
        print(k)

Qu'affiche ce programme ?

]]> Une fonction qui renvoie un booléen s'utilise directement comme
condition dans un if. Elle donne un nom parlant au test et évite de
répéter la formule.

]]> 1.0 0.0 0 true true abc 2, 4 et 6

]]> Bonne réponse : la fonction renvoie True pour les nombres
pairs, et seuls ceux-là sont affichés.

]]> 1, 3 et 5

]]> Erreur : n % 2 == 0 est vrai pour les pairs.

]]> True, True et True

]]> Erreur : le programme affiche k, pas le résultat de la
fonction.

]]> 2 et 4

]]> Erreur : range(1, 7) va jusqu'à 6, qui est pair.

]]> 7. Fonctions — Q20 : À quoi sert une fonction Pourquoi définit-on une fonction dans un programme ?

]]> Une fonction regroupe un traitement sous un nom. On l'écrit une fois
et on l'appelle partout où l'on en a besoin, ce qui évite les
répétitions et facilite les corrections.

]]> 1.0 0.0 0 true true abc Pour réutiliser un même traitement avec des valeurs différentes

]]> Bonne réponse : une fonction écrite une fois s'appelle autant de
fois que nécessaire, avec d'autres arguments. Le programme est
plus court et plus lisible.

]]> Pour rendre l'exécution du programme plus rapide

]]> Erreur : une fonction ne change pas la vitesse d'exécution. Son
intérêt est l'organisation du code.

]]> Pour se passer de variables dans le programme

]]> Erreur : les fonctions utilisent des variables, paramètres et
variables locales.

]]> Pour afficher automatiquement chaque résultat

]]> Erreur : une fonction n'affiche rien par elle-même. Elle renvoie
une valeur, que l'appelant affiche s'il le souhaite.

]]> 7. Fonctions — Q21 : Le carré d'un nombre Qu'affiche ce programme ?

def carre(x):
    return x * x

print(carre(5))

]]> Appeler une fonction, c'est remplacer son paramètre par l'argument
et récupérer ce que return renvoie.

]]> 1.0 0.0 0 true true abc 25

]]> Bonne réponse : l'appel carre(5) donne la valeur 5 au
paramètre x, et la fonction renvoie 5 × 5 = 25.

]]> 10

]]> Erreur : x * x multiplie x par lui-même, ce n'est pas le
double.

]]> x * x

]]> Erreur : return renvoie le résultat du calcul, pas son
écriture.

]]> Rien, la fonction ne contenant pas de print

]]> Erreur : le print entoure l'appel et affiche la valeur
renvoyée.

]]> 7. Fonctions — Q22 : Une fonction appelée plusieurs fois Combien de fois ce programme affiche-t-il Bonjour ?

def saluer():
    print("Bonjour")

saluer()
saluer()

]]> Une fonction s'écrit une fois et s'appelle autant de fois que
nécessaire. Chaque appel exécute son corps.

]]> 1.0 0.0 0 true true abc deux fois

]]> Bonne réponse : la définition n'affiche rien, mais chaque appel
saluer() exécute le corps de la fonction.

]]> Une seule fois, la fonction n'étant définie qu'une fois

]]> Erreur : définir une fonction ne l'exécute pas ; ce sont les
appels qui comptent, et il y en a deux.

]]> 3 fois, la définition comptant pour un affichage

]]> Erreur : la ligne def ne provoque aucun affichage.

]]> Aucune fois, la fonction ne renvoyant rien

]]> Erreur : une fonction sans return peut tout de même afficher
avec print.

]]> 7. Fonctions — Q23 : Un résultat rangé dans une variable Qu'affiche ce programme ?

def aire(largeur, hauteur):
    return largeur * hauteur

r = aire(3, 4)
print(r)

]]> La valeur renvoyée par return peut être rangée dans une variable
pour servir plus tard.

]]> 1.0 0.0 0 true true abc 12

]]> Bonne réponse : l'appel renvoie 3 × 4 = 12, rangé dans r
puis affiché.

]]> 7

]]> Erreur : la fonction multiplie ses deux paramètres.

]]> aire(3, 4)

]]> Erreur : r contient le résultat de l'appel, pas son écriture.

]]> Rien, r ne pouvant recevoir une fonction

]]> Erreur : r reçoit la valeur renvoyée par la fonction, un
nombre.

]]> 7. Fonctions — Q24 : Une fonction qui affiche au lieu de renvoyer Qu'affiche ce programme ?

def montrer(x):
    print(x)

r = montrer(3)
print(r)

]]> print affiche, return renvoie. Une fonction sans return
renvoie None, ce qui trahit souvent une confusion entre les deux.

]]> 1.0 0.0 0 true true abc 3 puis None

]]> Bonne réponse : l'appel affiche 3, mais la fonction ne renvoie
rien ; r reçoit donc None, la valeur « rien », que le second
print affiche.

]]> 3 puis 3

]]> Erreur : sans return, la fonction ne transmet pas 3 à
l'appelant.

]]> 3 seulement

]]> Erreur : le second print affiche quand même quelque chose, la
valeur None.

]]> Une erreur, r ne recevant aucune valeur

]]> Erreur : Python ne signale rien ; il range None dans r.

]]> 7. Fonctions — Q25 : Un calcul passé en argument Qu'affiche ce programme ?

def double(x):
    return 2 * x

print(double(2 + 3))

]]> Les arguments sont évalués avant l'appel : la fonction reçoit le
résultat du calcul, pas le calcul.

]]> 1.0 0.0 0 true true abc 10

]]> Bonne réponse : l'argument 2 + 3 est calculé avant l'appel,
puis la fonction double 5.

]]> 7

]]> Erreur : c'est la somme entière qui est doublée, pas seulement
2.

]]> 5

]]> Erreur : la fonction double la valeur reçue.

]]> Une erreur, un argument devant être une simple valeur

]]> Erreur : tout calcul peut servir d'argument, il est évalué
d'abord.

]]> 7. Fonctions — Q26 : Un appel avant la définition Que produit ce programme ?

print(triple(4))

def triple(x):
    return 3 * x

]]> Une fonction doit être définie avant d'être appelée. Les
définitions se placent en tête du programme.

]]> 1.0 0.0 0 true true abc Une erreur, triple n'étant pas encore définie

]]> Bonne réponse : Python lit le programme de haut en bas. À la
première ligne, aucune fonction triple n'a été définie.

]]> 12, la définition étant lue avant l'exécution

]]> Erreur : ce serait le résultat si la définition précédait
l'appel.

]]> 4, l'argument étant affiché faute de fonction

]]> Erreur : le programme s'arrête avant d'afficher quoi que ce
soit.

]]> Rien, la définition annulant l'appel précédent

]]> Erreur : l'appel est exécuté en premier et échoue, la suite
n'est jamais atteinte.

]]> 7. Fonctions — Q27 : Deux return sous condition Qu'affiche ce programme ?

def tarif(age):
    if age < 18:
        return 5
    return 8

print(tarif(18))

]]> Un return dans un if renvoie et sort aussitôt. Le return qui
suit n'est atteint que si la condition est fausse.

]]> 1.0 0.0 0 true true abc 8

]]> Bonne réponse : si age < 18, le premier return termine la
fonction avec 5 ; sinon le second renvoie 8. Avec 18, on
obtient 8.

]]> 5

]]> Erreur : relis la condition age < 18 avec age égal à 18.

]]> 5 puis 8

]]> Erreur : le premier return exécuté arrête la fonction, un seul
résultat est renvoyé.

]]> Une erreur, une fonction ne pouvant contenir deux return

]]> Erreur : plusieurs return sont permis, un seul est atteint à
chaque appel.

]]> 7. Fonctions — Q28 : Le périmètre d'un rectangle Qu'affiche ce programme ?

def perimetre(l, L):
    return 2 * (l + L)

print(perimetre(3, 5))

]]> Les arguments sont distribués aux paramètres dans l'ordre, puis le
corps de la fonction calcule avec ces valeurs.

]]> 1.0 0.0 0 true true abc 16

]]> Bonne réponse : l vaut 3 et L vaut 5, et
2 × (3 + 5) = 16.

]]> 11

]]> Erreur : les parenthèses font porter le doublement sur la somme
entière.

]]> 15

]]> Erreur : le produit serait l'aire, la fonction calcule le
périmètre.

]]> Une erreur, l et L étant le même nom

]]> Erreur : Python distingue majuscules et minuscules, l et L
sont deux paramètres différents.

]]> 7. Fonctions — Q29 : Un paramètre qui porte le nom d'une variable Qu'affiche ce programme ?

x = 5

def f(x):
    return x + 1

print(f(10), x)

]]> Le paramètre d'une fonction est une variable locale : même nom
qu'une variable extérieure ou non, il vit séparément.

]]> 1.0 0.0 0 true true abc 11 5

]]> Bonne réponse : dans f, x est le paramètre et vaut 10,
d'où 11. En dehors, x reste la variable initiale, 5.

]]> 11 10

]]> Erreur : l'appel ne modifie pas la variable x extérieure.

]]> 6 5

]]> Erreur : dans la fonction, x prend la valeur de l'argument,
10, pas celle de la variable extérieure.

]]> Une erreur, le nom x étant déjà utilisé

]]> Erreur : un paramètre peut porter le même nom qu'une variable
extérieure, les deux restent indépendants.

]]> 7. Fonctions — Q30 : Un résultat absent utilisé dans un calcul Que produit ce programme ?

def affiche(x):
    print(x)

y = affiche(2) + 1

]]> Pour utiliser le résultat d'une fonction dans un calcul, il faut
que la fonction le renvoie avec return. Un print seul ne suffit
pas.

]]> 1.0 0.0 0 true true abc 2 s'affiche, puis une erreur sur None + 1

]]> Bonne réponse : l'appel affiche 2 et renvoie None. Le calcul
None + 1 échoue, car None n'est pas un nombre.

]]> 2 s'affiche et y vaut 3, la fonction renvoyant x

]]> Erreur : la fonction n'a pas de return, elle ne renvoie pas 2.

]]> Rien ne s'affiche et y vaut 3, le print étant ignoré

]]> Erreur : le print de la fonction s'exécute bien, puis
l'addition échoue.

]]> 3 s'affiche, l'addition étant faite avant l'affichage

]]> Erreur : c'est x, égal à 2, qui est affiché, et aucun 3 n'est
calculé.

]]>