$course$/QCM de NSI/Première/Fonctions Définition de fonctions en Python, paramètres et valeur
de retour, portée locale et globale, fonctions natives,
fonctions sans retour, paramètres par défaut, documentation
(docstrings).

]]> Fonctions — Q01 : Définir une fonction Comment définit-on une fonction carre qui
prend x en paramètre et renvoie x * x ?

]]> Syntaxe canonique : def nom(params): corps.
Le mot-clé return produit la valeur que la
fonction renvoie à l'appelant.

]]> 1.0 0.0 0 true true abc `

python

def carre(x) -> x * x

]]> Erreur : -> indique le type de retour
(annotation), pas l'expression. Il manque
le corps de la fonction.

]]> `

python

carre = x * x

]]> Erreur : on définirait une variable, pas
une fonction.

]]> `

python

function carre(x) {

    return x * x

}

]]> Erreur : syntaxe JavaScript, pas Python.

]]> `

python

def carre(x):

    return x * x

]]> Bonne réponse : mot-clé def, parenthèses,
deux-points, indentation, return.

]]> Fonctions — Q02 : Appel de fonction Après def carre(x): return x * x, comment
appelle-t-on cette fonction sur la valeur 5 ?

]]> Sans parenthèses, carre désigne la fonction
elle-même (un objet). Avec parenthèses,
carre(...) invoque la fonction.

]]> 1.0 0.0 0 true true abc carre(5)

]]> Bonne réponse : parenthèses obligatoires,
même pour un seul paramètre. Renvoie 25.

]]> carre 5

]]> Erreur : il faut des parenthèses pour
appeler une fonction en Python.

]]> call carre(5)

]]> Erreur : pas de mot-clé call en Python.

]]> carre[5]

]]> Erreur : les crochets sont pour
l'indexation, pas l'appel de fonction.

]]> Fonctions — Q03 : Mot-clé return À quoi sert l'instruction return ?

]]> Différence essentielle entre print et
return : print affiche un message à
l'utilisateur ; return produit une valeur
utilisable dans le code (par exemple,
y = carre(3)).

]]> 1.0 0.0 0 true true abc À redémarrer la fonction

]]> Le mot-clé return met
fin à l'exécution de la
fonction et fournit une
valeur à l'appelant. Il
ne relance jamais la
fonction depuis le début.

]]> À renvoyer une valeur à l'appelant et terminer la fonction

]]> Bonne réponse : la fonction s'arrête au
return, et la valeur passée est
disponible pour l'appelant.

]]> À afficher le résultat sur la console

]]> Erreur : c'est print. return produit
une valeur de retour, sans affichage.

]]> À déclarer une variable globale

]]> Erreur : c'est global.

]]> Fonctions — Q04 : Paramètres Quelle fonction a deux paramètres ?

]]> Vocabulaire : on parle de paramètres d'une
fonction, à la fois pour leur nom dans la
définition (def f(x, y):) et pour les valeurs
qu'on lui passe à l'appel (f(3, 5)).

]]> 1.0 0.0 0 true true abc `

python

def f(x):

    return x

]]> Erreur : un seul paramètre.

]]> `

python

def f():

    return 0

]]> Erreur : zéro paramètre.

]]> `

python

def f(x; y):

    return x + y

]]> Erreur : le séparateur est la virgule, pas
le point-virgule.

]]> `

python

def f(x, y):

    return x + y

]]> Bonne réponse : deux paramètres x et y
séparés par une virgule.

]]> Fonctions — Q05 : Fonction sans return Que renvoie une fonction qui ne contient aucun
return ?

]]> Souvent, on n'utilise pas la valeur de retour
de telles fonctions (on ne fait pas
x = print(...)). Mais elle existe (None).

]]> 1.0 0.0 0 true true abc None

]]> Bonne réponse : Python renvoie
implicitement None (la valeur « rien »).
C'est le cas typique des fonctions qui se
contentent d'afficher ou de modifier
quelque chose, sans renvoyer de valeur.

]]> Une erreur

]]> Erreur : pas d'erreur.

]]> Une chaîne vide ""

]]> Erreur : la valeur par défaut est None.

]]> 0

]]> Erreur : ce n'est pas la valeur par défaut.

]]> Fonctions — Q06 : Fonctions natives Parmi les suivants, lequel n'est pas une
fonction native de Python ?

]]> Fonctions natives utiles : print, input,
len, range, type, int, float, str,
bool, min, max, sum, abs, round,
sorted, etc.

]]> 1.0 0.0 0 true true abc carre(...)

]]> Bonne réponse : carre n'est pas natif,
c'est une fonction qu'il faut définir
soi-même.

]]> type(...)

]]> C'est bien une fonction native (renvoie le
type).

]]> len(...)

]]> C'est bien une fonction native (longueur).

]]> max(...)

]]> C'est bien une fonction native (maximum).

]]> Fonctions — Q07 : Plusieurs appels ``python
def double(x):
return x * 2

a = double(3)
b = double(double(5))
Que valent a et b ?

]]> Composition de fonctions : f(g(x)) évalue
d'abord g(x) puis applique f. Lecture de
l'intérieur vers l'extérieur.

]]> 1.0 0.0 0 true true abc a = 6, b = 20

]]> Bonne réponse : a = double(3) = 6 ;
b = double(double(5)) = double(10) = 20.

]]> a = 6, b = 25

]]> Erreur : 25 = 5², mais on multiplie par 2,
pas un carré.

]]> a = 3, b = 5

]]> Erreur : on n'a pas appelé la fonction.

]]> a = 6, b = 10

]]> Erreur sur b : double(double(5)) =
double(10) = 20.

]]> Fonctions — Q08 : Docstring Que fait la première ligne en triples
guillemets dans une fonction ?
`

python

def carre(x):

    """Renvoie le carré de x."""

    return x * x

]]> Bonne pratique : toujours documenter ses
fonctions. PEP 257 décrit les conventions
(description courte sur la première ligne,
puis détails).

]]> 1.0 0.0 0 true true abc C'est une docstring : la documentation de la fonction, accessible par help(carre) ou carre.__doc__

]]> Bonne réponse : standard Python pour
documenter ses fonctions. Très utile pour
la maintenance et l'aide automatique.

]]> C'est obligatoire pour que la fonction marche

]]> Erreur : facultatif.

]]> C'est un commentaire ignoré par Python

]]> Erreur : c'est plus qu'un commentaire, c'est
une docstring accessible
dynamiquement.

]]> C'est un test unitaire

]]> Erreur : un test serait un assert.

]]> Fonctions — Q09 : Variable locale Le code suivant lève-t-il une erreur ?
``python
def f():
x = 5

f()
print(x)
``

]]> Notion clé : la portée (ou scope). Une
variable créée dans une fonction n'existe
qu'à l'intérieur de cette fonction.

]]> 1.0 0.0 0 true true abc Non, il affiche 0

]]> Erreur : aucune valeur par défaut.

]]> Non, mais il affiche None

]]> Erreur : pas de retour silencieux.

]]> Non, il affiche 5

]]> Erreur : x est locale à f, pas
accessible à l'extérieur.

]]> Oui : NameError car x n'est pas définie hors de f

]]> Bonne réponse : la portée des variables
locales est limitée à la fonction.

]]> Fonctions — Q10 : Trace simple Que fait ce code ?
``python
def saluer(nom):
print("Bonjour", nom)

saluer("Alice")
``

]]> Distinguer print (afficher quelque chose à
l'écran) de return (renvoyer une valeur à
l'appelant). Ici, la fonction se contente
d'afficher.

]]> 1.0 0.0 0 true true abc Lève une erreur

]]> Erreur : code valide.

]]> Affiche Bonjour Alice

]]> Bonne réponse : la fonction reçoit nom =
"Alice", puis print affiche les deux
paramètres séparés par un espace.

]]> Renvoie la chaîne "Bonjour Alice" mais sans afficher

]]> Erreur : print affiche, et la fonction n'a
pas de return.

]]> N'affiche rien

]]> Erreur : print produit un affichage.

]]> Fonctions — Q11 : Paramètre par défaut Que donne ce code ?
``python
def saluer(nom="ami"):
return "Bonjour " + nom

print(saluer())
print(saluer("Alice"))
``

]]> Les paramètres par défaut rendent les
fonctions plus flexibles. Convention : les
paramètres avec valeur par défaut viennent
après les paramètres sans.

]]> 1.0 0.0 0 true true abc `



Erreur

Bonjour Alice

]]> Erreur : avec un paramètre par défaut,
l'appel sans paramètre est valide.

]]> `



Bonjour ami

Bonjour Alice

]]> Bonne réponse : nom="ami" est la valeur
par défaut. Si on n'en passe pas,
le paramètre vaut "ami".

]]> `



Bonjour ami

Bonjour ami

]]> Erreur : le second appel passe "Alice",
qui remplace la valeur par défaut.

]]> `



Bonjour

Bonjour Alice

]]> Erreur : la valeur par défaut est "ami",
pas une chaîne vide.

]]> Fonctions — Q12 : Paramètres nommés Quelle est la différence entre
puissance(2, 10) et
puissance(base=2, exposant=10) ?

]]> Les paramètres nommés améliorent la lisibilité,
surtout quand un appel a beaucoup de
paramètres (par exemple plt.plot(x, y,
color="red", linestyle="--")).

]]> 1.0 0.0 0 true true abc La seconde forme ne marche que pour les fonctions natives

]]> Erreur : les paramètres nommés marchent
pour toutes les fonctions.

]]> La première forme est obsolète

]]> Erreur : très utilisée.

]]> La seconde forme est plus rapide

]]> Erreur : aucune différence de performance.

]]> Aucune, les deux sont équivalents si la fonction est def puissance(base, exposant):

]]> Bonne réponse : on peut passer des
paramètres positionnellement (par
ordre) ou nommés (par mot-clé).
L'ordre n'importe pas pour les nommés.

]]> Fonctions — Q13 : Variable globale Quel est le résultat ?
``python
x = 10

def f():
return x + 1

print(f())
``

]]> Règle d'or : préférer passer en paramètre
plutôt qu'utiliser des variables globales.
Code plus testable et plus prévisible.

]]> 1.0 0.0 0 true true abc Erreur (x non défini)

]]> Erreur : f peut lire les variables du
scope englobant.

]]> 11

]]> Bonne réponse : x est une variable
globale. La fonction peut la lire,
mais pas la modifier (sans global).

]]> Aucune sortie

]]> Erreur : print(f()) affiche.

]]> 10

]]> Erreur : on ajoute 1.

]]> Fonctions — Q14 : Modifier une globale Pour modifier une variable globale dans une
fonction, quel mot-clé utiliser ?

]]> Bonne pratique : limiter l'usage de global.
Préférer le passage par paramètre + retour
explicite, beaucoup plus clair et testable.

]]> 1.0 0.0 0 true true abc nonlocal

]]> Pas tout à fait : nonlocal est pour les
fonctions imbriquées (variable du scope
intermédiaire), pas pour les globales.

]]> global

]]> Bonne réponse : global x au début de la
fonction permet d'écrire dans x
global. Sans cela, x = ... créerait une
locale qui masque la globale.

]]> outer

]]> Erreur : pas de mot-clé outer en Python.

]]> var

]]> Erreur : pas en Python (JavaScript, oui).

]]> Fonctions — Q15 : Retour multiple Que renvoie cette fonction ?
`

python

def min_max(liste):

    return min(liste), max(liste)

]]> Idiome courant : renvoyer plusieurs valeurs
sans définir de classe ad hoc. Pratique pour
les petites fonctions « utilitaires ».

]]> 1.0 0.0 0 true true abc Un tuple (min, max)

]]> Bonne réponse : Python utilise les tuples
pour les retours multiples. À la
réception : mn, mx = min_max(liste)
(déballage).

]]> Une liste de deux éléments

]]> Erreur : virgule sans crochets = tuple.

]]> Un dictionnaire

]]> Erreur : un dict s'écrit avec {}.

]]> Erreur : on ne peut pas avoir deux retours

]]> Erreur : Python le permet via le tuple.

]]> Fonctions — Q16 : Fonction comme valeur ``python
def carre(x): return x * x

f = carre
print(f(3))
``
Que se passe-t-il ?

]]> Cette propriété rend possibles : les
callbacks, les décorateurs, la programmation
fonctionnelle (map, filter, etc.).

]]> 1.0 0.0 0 true true abc Erreur : on ne peut pas affecter une fonction

]]> Erreur : Python permet d'affecter des
fonctions à des variables.

]]> Affiche 3

]]> Erreur : la fonction est bien appelée.

]]> Affiche 9

]]> Bonne réponse : en Python, les fonctions
sont des objets de première classe.
f pointe vers la même fonction que
carre. f(3) appelle la fonction sur 3.

]]> Affiche <function carre>

]]> Erreur : f(3) appelle, donc renvoie 9.

]]> Fonctions — Q17 : Portée locale ``python
x = 10

def f():
x = 20
print(x)

f()
print(x)
``
Qu'affiche ce code ?

]]> Notion de portée (scope) : une variable
définie dans une fonction n'existe qu'à
l'intérieur. C'est précieux pour
l'isolation, mais source de confusion
classique.

]]> 1.0 0.0 0 true true abc `



10

10

]]> Erreur : la fonction affiche bien 20 (sa
locale).

]]> Une exception

]]> Erreur : code valide.

]]> `



20

20

]]> Erreur : le x interne à f est une
variable locale distincte de la
variable globale.

]]> `



20

10

]]> Bonne réponse : l'affectation x = 20
dans la fonction crée une variable
locale ; elle masque la globale le
temps de l'appel mais ne la modifie pas.
Après l'appel, la globale vaut toujours
10.

]]> Fonctions — Q18 : Renvoyer ou afficher ? Quelle est la différence entre une fonction qui
renvoie une valeur et une fonction qui
affiche une valeur ?

]]> Bug classique : écrire def carre(x): print(xx)
au lieu de def carre(x): return xx. Avec la
première version, on ne peut pas faire
y = carre(3) * 2 : y vaut None. La
seconde version permet bien y = 18.

]]> 1.0 0.0 0 true true abc print est plus rapide que return

]]> Erreur : la performance n'est pas le sujet.

]]> Une fonction qui renvoie produit une valeur réutilisable par l'appelant via return ; une fonction qui affiche écrit à l'écran avec print mais ne renvoie rien d'utilisable

]]> Bonne réponse : une valeur renvoyée peut être
stockée dans une variable, transmise à une
autre fonction, comparée. print se contente
d'écrire un texte à l'écran. Si on a besoin
de la valeur, il faut un return.

]]> return n'existe pas en Python

]]> Erreur : return est l'instruction standard
pour renvoyer une valeur depuis une
fonction.

]]> Aucune différence

]]> Erreur : la confusion entre les deux est l'un
des bugs les plus classiques. print ne
rend rien d'exploitable.

]]> Fonctions — Q19 : print vs return Pourquoi ce code n'affiche-t-il rien sur la
console ?
``python
def carre(x):
return x * x

carre(5)
``

]]> Confusion classique des débutants : penser
que return affiche. print et return
sont deux mécanismes différents.

]]> 1.0 0.0 0 true true abc Parce que la fonction n'est pas appelée

]]> Erreur : carre(5) est bien un appel.

]]> Parce que 5 n'est pas un entier

]]> Erreur : 5 est un entier.

]]> Parce que return ne fait pas d'affichage : la valeur 25 est calculée puis ignorée

]]> Bonne réponse : pour voir un affichage,
écrire print(carre(5)) ou modifier la
fonction pour utiliser print (mais
alors plus de retour).

]]> Parce que la fonction est buggée

]]> Erreur : la fonction est correcte, elle
renvoie 25.

]]> Fonctions — Q20 : Décomposer Pourquoi est-il recommandé de décomposer un
programme en fonctions ?

]]> Maxime : « une fonction = une responsabilité ».
Si une fonction fait plusieurs choses, la
découper en plusieurs petites.

]]> 1.0 0.0 0 true true abc Pour économiser de la mémoire

]]> Erreur : pas un avantage notable.

]]> Parce que le compilateur le demande

]]> Erreur : Python est interprété, et il ne
l'exige pas.

]]> Pour la lisibilité, la réutilisation et la testabilité : chaque fonction fait une chose, on peut la tester séparément

]]> Bonne réponse : c'est l'un des principes
fondamentaux du génie logiciel
(« divide and conquer »). Une fonction
courte et bien nommée vaut mieux qu'un
gros bloc de code.

]]> Parce que c'est plus court d'écrire

]]> Pas forcément plus court : c'est même
parfois plus long.

]]> Fonctions — Q21 : Piège de portée ``python
x = 10

def f():
x = 20
return x

print(f())
print(x)
``
Quel est le résultat ?

]]> Cas typique d'ombrage (shadowing). Source
de confusion fréquente. Pour éviter,
privilégier le passage en paramètre.

]]> 1.0 0.0 0 true true abc `



10

10

]]> Erreur : f() renvoie sa propre x locale
(= 20).

]]> `



20

20

]]> Erreur : sans global x, le x = 20 dans
f crée une variable locale, qui ne
modifie pas la globale.

]]> `



20

10

]]> Bonne réponse : x à l'intérieur de f
est local et masque la globale. À l'extérieur,
la globale x reste à 10.

]]> Erreur

]]> Erreur : aucune erreur.

]]> Fonctions — Q22 : Retours multiples `

python

def signe(x):

    if x > 0:

        return 1

    if x < 0:

        return -1

    return 0

Pourquoi ce code marche-t-il sans elif` ?

]]> Idiome « early return » : sortir tôt des cas
particuliers, simplifier la logique.

]]> 1.0 0.0 0 true true abc Parce que return interrompt la fonction : si x > 0, le premier return 1 empêche l'exécution des suivants

]]> Bonne réponse : return est plus fort
qu'un break, il quitte la fonction
entièrement. Pas besoin d'elif. Code
plus plat et lisible.

]]> Parce que Python comprend automatiquement

]]> Python n'a aucune capacité
d'inférence sur l'intention
du code. Si chaque branche
fonctionne correctement
ici, c'est uniquement parce
que return quitte la
fonction immédiatement.

]]> Parce que les if sont équivalents à des elif

]]> Erreur : ils ne sont pas mutuellement
exclusifs sans return (chaque if
serait testé).

]]> Parce qu'il n'y a qu'un seul else

]]> Erreur : il n'y a aucun else.

]]> Fonctions — Q23 : Paramètre mutable ``python
def ajouter(liste, x):
liste.append(x)

ma_liste = [1, 2]
ajouter(ma_liste, 3)
print(ma_liste)
``
Que produit ce code ?

]]> En Python, lorsqu'on passe une variable à une
fonction, on transmet une référence vers la
même valeur. Pour les types mutables
(listes, dicts), les modifications dans la
fonction affectent donc l'original. Pour les
immuables (int, str, tuple), aucun effet
de bord n'est possible.

]]> 1.0 0.0 0 true true abc [3]

]]> Erreur : on ajoute, on ne remplace pas.

]]> [1, 2, 3]

]]> Bonne réponse : les listes sont passées
par référence. La fonction modifie
donc directement la liste de l'appelant,
ce qui peut surprendre.

]]> Erreur

]]> Erreur : code valide.

]]> [1, 2]

]]> Erreur : la liste est modifiée par la
fonction.

]]> Fonctions — Q24 : Piège du défaut mutable ``python
def ajouter(x, liste=[]):
liste.append(x)
return liste

print(ajouter(1))
print(ajouter(2))
``
Quel résultat (surprenant) ?

]]> Bonne pratique : ne jamais utiliser un
mutable comme valeur par défaut. Préférer
None et tester explicitement.

]]> 1.0 0.0 0 true true abc Erreur

]]> Erreur : code valide.

]]> `



[1]

[1, 2]

]]> Bonne réponse : c'est l'un des pièges
célèbres de Python. Le défaut [] est
partagé entre tous les appels. Solution :
utiliser liste=None puis
if liste is None: liste = [].

]]> `



[1, 2]

[1, 2]

]]> Erreur : seulement le premier appel reçoit
juste [1].

]]> `



[1]

[2]

]]> On pourrait s'y attendre, mais c'est faux.
Python évalue la valeur par défaut une
seule fois, à la définition de la
fonction.

]]> Fonctions — Q25 : Synthèse Parmi les affirmations suivantes sur les
fonctions Python, laquelle est fausse ?

]]> Mnémonique : portée = « ce qui est défini
dans une fonction reste dans la fonction »
(sauf retour explicite).

]]> 1.0 0.0 0 true true abc Les fonctions Python peuvent être passées comme paramètres d'autres fonctions

]]> Vrai : objets de première classe.

]]> On peut renvoyer plusieurs valeurs avec un tuple (ex. return a, b).

]]> Vrai : idiome Python pour les retours
multiples.

]]> Une fonction sans return renvoie implicitement None

]]> Vrai : convention Python.

]]> Les variables locales d'une fonction sont accessibles depuis l'extérieur

]]> Faux (donc bonne réponse) : les variables
locales sont confinées à la fonction.
C'est le principe de la portée (scope).

]]> Fonctions — Q26 : Composition d'appels de fonctions On considère le code suivant :

``python
def carre(x):
return x * x

def incremente(x):
return x + 1

a = carre(incremente(3))
`

Quelle est la valeur de a` après l'exécution ?

]]> Pour évaluer une expression f(g(x)), Python
calcule d'abord g(x), puis applique f à ce
résultat. Cette composition est l'un des moyens
les plus simples de combiner des fonctions
réutilisables, sans variables intermédiaires.

]]> 1.0 0.0 0 true true abc 10

]]> Erreur : on a additionné le résultat de
incremente(3) = 4 à un autre nombre. Mais
carre calcule un carré, pas une somme. La bonne
opération est 4 × 4.

]]> 7

]]> Erreur : confusion sur l'ordre des opérations.
Python évalue toujours les fonctions de
l'intérieur vers l'extérieur, donc
incremente(3) est évalué d'abord, puis le
résultat est passé à carre.

]]> 9

]]> Erreur : on a appliqué seulement carre(3), sans
tenir compte de incremente. Or incremente
est appliqué en premier, à 3, ce qui donne 4.

]]> 16

]]> Bonne réponse : Python évalue d'abord l'argument
le plus interne, soit incremente(3) = 4, puis
applique carre à ce résultat : 4 × 4 = 16.

]]> Fonctions — Q27 : Annotations de type On lit la signature suivante :

`python def aire(longueur: float, largeur: float) -> float:

Que signifie la flèche -> et l'annotation float`
qui la suit ?

]]> L'annotation param: type documente le type
attendu d'un paramètre, l'annotation -> type
documente celui de la valeur de retour. Ces
indications n'ont aucun effet à l'exécution mais
sont précieuses pour la lecture du code et pour les
analyseurs statiques.

]]> 1.0 0.0 0 true true abc C'est une annotation indiquant que la fonction est censée renvoyer un flottant ; cela documente l'intention sans imposer de vérification à l'exécution

]]> Bonne réponse : la flèche introduit
l'annotation du type renvoyé. Comme les
annotations de paramètres, elle est optionnelle
et purement informative ; les outils comme
mypy peuvent ensuite vérifier la cohérence
des types statiquement.

]]> La syntaxe est invalide en Python

]]> Erreur : les annotations de type sont
parfaitement valides depuis Python 3{.}5. Elles
sont aujourd'hui largement utilisées pour
améliorer la lisibilité et la sûreté du code.

]]> La flèche transforme le résultat en flottant avant de le renvoyer

]]> Erreur : les annotations n'effectuent aucune
conversion. La fonction renvoie strictement la
valeur retournée par son return, sans
modification.

]]> La fonction renvoie obligatoirement un nombre flottant, sinon Python lève une exception

]]> Erreur : Python ne vérifie pas les annotations à
l'exécution. La fonction peut tout à fait
renvoyer un autre type sans erreur. Les
annotations servent uniquement à la
documentation et aux outils d'analyse statique
(mypy, IDE).

]]> Fonctions — Q28 : Effet de bord sur une liste paramètre On exécute le code suivant :

``python
def ajouter_zero(t):
t.append(0)

ma_liste = [1, 2, 3]
ajouter_zero(ma_liste)
print(ma_liste)
`

Que va afficher print` ?

]]> Quand un paramètre est un objet mutable (liste,
dictionnaire, ensemble), une fonction peut le
modifier en place sans avoir à le renvoyer. C'est un
effet de bord, à utiliser avec parcimonie : il rend
le comportement moins prévisible et complique la
lecture du code.

]]> 1.0 0.0 0 true true abc [1, 2, 3, 0]

]]> Bonne réponse : t et ma_liste désignent le
même objet liste en mémoire. La méthode
append modifie cet objet ; après l'appel,
ma_liste reflète donc le changement.

]]> Le code lève une erreur car t n'est pas connu en dehors de la fonction

]]> Erreur : t n'est utilisé qu'à l'intérieur de
la fonction, mais la liste qu'il référence
continue d'exister à l'extérieur. Python passe
les paramètres par référence d'objet.

]]> [1, 2, 3]

]]> Erreur : la fonction modifie effectivement la
liste passée en paramètre. La méthode append
agit sur l'objet partagé entre l'appelant et la
fonction, donc la modification est visible à
l'extérieur.

]]> [0, 1, 2, 3]

]]> Erreur : append ajoute en fin de liste, pas
en début. Pour insérer à l'index 0, il
faudrait écrire t.insert(0, 0).

]]> Fonctions — Q29 : Fonction prédicat On souhaite écrire une fonction est_pair(n) qui
renvoie True si l'entier n est pair, False
sinon. Quelle écriture est la plus claire et la plus
idiomatique ?

]]> Une fonction qui renvoie True ou False est
appelée prédicat. Convention : nommer ces
fonctions avec un préfixe est_, a_, verifie_
ou similaire, pour signaler immédiatement qu'elles
renvoient un booléen.

]]> 1.0 0.0 0 true true abc `

python

def est_pair(n):

    if n % 2 == 0:

        return True

    else:

        return False

]]> Code correct mais redondant : on construit un
booléen à partir d'un test booléen. Préférer
return n % 2 == 0, qui exprime directement
l'idée.

]]> `

python

def est_pair(n):

    return n % 2 == 0

]]> Bonne réponse : on renvoie directement la
valeur du test booléen, sans passer par un
if. C'est plus court, plus lisible, et c'est
l'idiome Python pour ce qu'on appelle un
prédicat.

]]> `

python

def est_pair(n):

    return n / 2

]]> Erreur : la division n / 2 renvoie un
flottant (par exemple 1{,}5 ou 2{,}0),
pas un booléen. Pour tester la parité, il faut
utiliser le reste (modulo %), pas le
quotient.

]]> `

python

def est_pair(n):

    print(n % 2 == 0)

]]> Erreur : la fonction ne renvoie rien (elle
renvoie None). Elle ne peut donc pas être
utilisée dans un test comme
if est_pair(x):. Préférer return plutôt
que print.

]]>