$course$/QCM de NSI/Terminale/Programmation fonctionnelle Paradigme fonctionnel, fonctions pures, immuabilité, fonctions
de première classe et d'ordre supérieur (map, filter, reduce),
expressions lambda, récursivité, comparaison avec le paradigme
impératif.

]]> Programmation fonctionnelle — Q01 : Paradigme fonctionnel Quelle est l'idée centrale du paradigme fonctionnel ?

]]> Origines : le lambda-calcul de Church (1936) et le
langage Lisp (1958). Aujourd'hui, des langages
purement fonctionnels (Haskell, OCaml) coexistent avec
des langages multi-paradigmes (Python, JavaScript).

]]> 1.0 0.0 0 true true abc Programmer en suivant l'ordre exact des instructions ligne par ligne

]]> Erreur : c'est le paradigme impératif, dont la
programmation fonctionnelle est précisément une
alternative.

]]> Composer des fonctions en évitant les effets de bord

]]> Bonne réponse : la programmation fonctionnelle
privilégie les fonctions sans effet de bord
(« fonctions pures »), l'immutabilité des données et
la composition de fonctions. Cela rend le code plus
prévisible et plus facile à raisonner.

]]> Programmer uniquement avec des boucles for

]]> Erreur : la programmation fonctionnelle remplace
plutôt les boucles par de la récursivité ou des
fonctions d'ordre supérieur.

]]> Programmer en utilisant uniquement des objets et des classes

]]> Erreur : c'est le paradigme orienté objet, pas
fonctionnel.

]]> Programmation fonctionnelle — Q02 : Fonction pure Qu'est-ce qu'une fonction pure ?

]]> Fonction pure typique : def carre(x): return x * x.
Fonction impure : def ajoute_a_liste(L, x): L.append(x)
modifie son argument, ce qui est un effet de bord.

]]> 1.0 0.0 0 true true abc Une fonction qui modifie directement ses propres arguments

]]> Erreur : c'est l'inverse d'une fonction pure. Modifier
ses arguments est un effet de bord, ce qui rend la
fonction impure.

]]> Une fonction qui ne contient aucun bug

]]> Erreur : « pure » est un terme technique précis,
pas un jugement de qualité.

]]> Même résultat pour les mêmes arguments, sans effet de bord

]]> Bonne réponse : la pureté implique la prévisibilité
totale et la facilité de test. C'est aussi ce qui
permet la mémoïsation transparente.

]]> Une fonction écrite uniquement en Python

]]> Erreur : la pureté est indépendante du langage.

]]> Programmation fonctionnelle — Q03 : Immutabilité Que signifie qu'une donnée est immuable ?

]]> L'immutabilité a plusieurs avantages : une donnée
partagée entre plusieurs fonctions ne subit aucune
modification inattendue (pas d'effet de bord), et
on peut raisonner sur sa valeur sans suivre toute
l'exécution du programme.

]]> 1.0 0.0 0 true true abc Elle est stockée en permanence sur le disque dur

]]> Erreur : aucun rapport avec le stockage.

]]> Elle est protégée par un mot de passe

]]> Erreur : aucun rapport avec la sécurité. C'est une
propriété structurelle de la donnée.

]]> Elle ne peut pas être lue

]]> Erreur : une donnée immuable peut être lue
librement, c'est seulement la modification qui est
interdite.

]]> Elle ne peut pas être modifiée après sa création

]]> Bonne réponse : pour modifier, on crée une nouvelle
donnée à partir de l'ancienne, sans toucher à
l'originale. Exemple en Python : les chaînes, les
tuples sont immuables.

]]> Programmation fonctionnelle — Q04 : Fonctions de première classe Que signifie « les fonctions sont des objets de première
classe » dans un langage ?

]]> Cette propriété rend possibles les fonctions d'ordre
supérieur (map, filter, sorted avec key), qui
prennent ou renvoient des fonctions, et qui sont au cœur
du paradigme fonctionnel.

]]> 1.0 0.0 0 true true abc Elles sont les plus rapides du programme

]]> Erreur : pas de lien avec la performance.

]]> On les passe, on les retourne et on les stocke comme des valeurs

]]> Bonne réponse : c'est une caractéristique majeure
des langages fonctionnels. Python, JavaScript,
OCaml, Haskell traitent les fonctions ainsi. C++,
Java l'ont ajouté plus tardivement.

]]> Elles sont écrites en majuscules

]]> Erreur : aucun rapport avec la casse.

]]> Elles sont systématiquement les premières instructions du programme

]]> Erreur : aucun rapport avec l'ordre des instructions.
Le terme est conceptuel.

]]> Programmation fonctionnelle — Q05 : Expression lambda En Python, qu'est-ce qu'une expression lambda ?

]]> Le mot lambda vient du lambda-calcul de Church. En
Python, les lambda sont limitées à une seule
expression. Pour une fonction plus complexe, on utilise
def.

]]> 1.0 0.0 0 true true abc Une fonction anonyme sur une ligne

]]> Bonne réponse : lambda x: x x est une fonction
anonyme qui prend x et renvoie son carré.
Équivalent à def f(x): return x x mais sans
nom, utilisable directement comme expression.

]]> Une variable globale

]]> Erreur : aucun rapport avec les variables globales.

]]> Une instruction spéciale dédiée au débogage

]]> Erreur : aucun rapport avec le débogage.

]]> Un type de boucle

]]> Erreur : ce n'est pas une boucle. C'est une fonction
anonyme.

]]> Programmation fonctionnelle — Q06 : Fonction map Que fait la fonction map(f, L) en Python ?

]]> map et filter sont deux fonctions d'ordre supérieur
classiques : la première transforme chaque élément, la
seconde ne garde que ceux qui vérifient un critère. Elles
correspondent à des schémas d'usage très courants.

]]> 1.0 0.0 0 true true abc Elle réduit la liste à une seule valeur

]]> Erreur : map produit une valeur pour chaque élément
de L, elle ne les combine pas en une seule.

]]> Elle filtre la liste selon un critère

]]> Erreur : c'est le rôle de filter, pas map.

]]> Elle applique f à chaque élément de L

]]> Bonne réponse : pour obtenir une liste, on fait
list(map(f, L)). Par exemple,
list(map(lambda x: x * 2, [1, 2, 3])) renvoie
[2, 4, 6].

]]> Elle modifie la liste L en y appliquant f directement

]]> Erreur : map ne modifie pas la liste d'origine. Elle
produit de nouvelles valeurs et laisse L intacte.

]]> Programmation fonctionnelle — Q07 : Fonction filter Que fait filter(p, L) en Python ?

]]> Alternative idiomatique en Python avec
compréhension de liste :
[x for x in L if p(x)]. Souvent plus lisible que
filter en Python.

]]> 1.0 0.0 0 true true abc Elle compte le nombre d'éléments dans L

]]> Erreur : pour compter, on utilise len ou sum.

]]> Elle garde les éléments de L où p est vrai

]]> Bonne réponse : par exemple,
list(filter(lambda x: x > 0, [-1, 0, 1, 2]))
renvoie [1, 2]. Les éléments pour lesquels p
renvoie True sont conservés.

]]> Elle renvoie une liste vide

]]> Erreur : filter renvoie un itérateur des éléments
conservés, pas vide.

]]> Elle modifie directement chaque élément de L

]]> Erreur : c'est plutôt le rôle de map.

]]> Programmation fonctionnelle — Q08 : Map avec une fonction booléenne On définit la fonction suivante :

`python def depasse_dix(x): return x > 10

Que vaut list(map(depasse_dix, [4, 15, 10, 23]))` ?

]]> map(f, L) renvoie un résultat f(x) pour chaque élément x de
L, tandis que filter(f, L) ne garde que les éléments pour
lesquels f(x) vaut True. Avec une fonction qui renvoie un
booléen, map donne donc des booléens.

]]> 1.0 0.0 0 true true abc [4, 10] : les éléments qui ne dépassent pas 10

]]> Erreur : ce sont les éléments écartés par le test. map ne retire
aucun élément : il renvoie autant de résultats que la liste contient
d'éléments.

]]> [False, True, False, True] : un booléen par élément

]]> Bonne réponse : map applique depasse_dix à chaque élément et
rassemble les résultats : 4 > 10 donne False, 15 > 10 donne
True, 10 > 10 donne False et 23 > 10 donne True.

]]> [False, True, True, True] : un booléen par élément

]]> Erreur : 10 > 10 vaut False, car 10 n'est pas strictement
supérieur à 10. Seul 10 >= 10 vaudrait True.

]]> [15, 23] : les éléments qui dépassent 10

]]> Erreur : c'est le résultat de filter, qui ne garde que les éléments
pour lesquels la fonction renvoie True. map renvoie, pour chaque
élément, la valeur calculée par la fonction.

]]> Programmation fonctionnelle — Q09 : Composition de fonctions Que signifie « composer deux fonctions f et g » ?

]]> En programmation fonctionnelle, on construit des
programmes complexes en composant des fonctions
simples. Ce style favorise la réutilisation et la
modularité.

]]> 1.0 0.0 0 true true abc Les fusionner définitivement en une seule grosse fonction

]]> Erreur : la composition crée une nouvelle fonction
mais ne modifie pas f ni g ; elles restent
utilisables séparément.

]]> Les écrire dans le même fichier

]]> Erreur : aucun rapport. La composition est une
opération mathématique.

]]> Créer une fonction qui applique g puis f

]]> Bonne réponse : (f \circ g)(x) = f(g(x)). La
composition de fonctions est la brique de base de la
programmation fonctionnelle, qui voit les programmes
comme des chaînes de transformations.

]]> Les exécuter en parallèle

]]> Erreur : la composition est séquentielle (l'une
après l'autre).

]]> Programmation fonctionnelle — Q10 : Récursivité en programmation fonctionnelle Pourquoi la récursivité est-elle privilégiée à la
boucle dans le paradigme fonctionnel ?

]]> Les langages fonctionnels purs (Haskell) n'ont même pas
de boucles : tout est exprimé par récursivité ou par
fonctions d'ordre supérieur.

]]> 1.0 0.0 0 true true abc Parce que les appels récursifs s'exécutent plus vite qu'une boucle

]]> Erreur : la récursivité est généralement aussi
rapide ou plus lente que les boucles, mais ce
n'est pas la raison de son emploi.

]]> Parce que c'est une habitude de style, sans justification de fond

]]> Erreur : c'est une raison structurelle (éviter la
modification d'un état), pas un simple effet de
mode.

]]> Parce qu'une boucle repose sur un compteur que l'on modifie

]]> Bonne réponse : for i in range(n) modifie
implicitement i à chaque tour, ce qui contredit
l'immutabilité des données. Une approche purement
fonctionnelle évite cela en utilisant des appels
récursifs avec de nouveaux paramètres.

]]> Parce que les boucles n'existent tout simplement pas en Python

]]> Erreur : Python a des boucles. C'est par
convention ou par style qu'on les évite en
programmation fonctionnelle.

]]> Programmation fonctionnelle — Q11 : Identifier une fonction pure Parmi les fonctions Python suivantes, laquelle est
pure ?

`python def f1(x): return x + 1 def f2(x): print(x); return x def f3(L, x): L.append(x); return L def f4(): return random.random()`

]]> Les effets de bord typiques : modifier une variable
globale, écrire dans un fichier, appeler print,
utiliser le hasard, lire l'horloge système, etc. Toutes
ces opérations rendent une fonction impure.

]]> 1.0 0.0 0 true true abc f1 et f4

]]> Erreur : f4 n'est pas pure. Pour les mêmes
arguments (aucun ici), elle renvoie des résultats
différents (génération aléatoire).

]]> Les quatre fonctions

]]> Erreur : seule f1 respecte les deux conditions de
pureté.

]]> f1 et f2

]]> Erreur : f2 appelle print, ce qui est un effet
de bord (interaction avec le terminal).

]]> f1 seule

]]> Bonne réponse : f1 ne modifie rien et retourne
toujours la même valeur pour le même argument. f2
a un effet de bord (print), f3 modifie son
argument, f4 retourne un résultat différent à
chaque appel.

]]> Programmation fonctionnelle — Q12 : Lambda avec map Que renvoie l'expression Python suivante ?
`

python

list(map(lambda x: x ** 2, [1, 2, 3, 4]))

]]> Cette construction est très idiomatique en
programmation fonctionnelle. En Python, on peut aussi
écrire [x ** 2 for x in [1, 2, 3, 4]], qui est
souvent considéré plus lisible.

]]> 1.0 0.0 0 true true abc [1, 4, 9, 16]

]]> Bonne réponse : la lambda calcule le carré, et map
l'applique à chaque élément. On obtient
[1², 2², 3², 4²] = [1, 4, 9, 16].

]]> [1, 2, 3, 4]

]]> Erreur : map applique la fonction à chaque
élément, donc transforme la liste.

]]> [2, 4, 6, 8]

]]> Erreur : ce serait lambda x: x * 2, pas x 2.
est l'opérateur puissance en Python.

]]> [1, 16]

]]> Erreur : map applique à chaque élément, on
n'en perd pas en chemin.

]]> Programmation fonctionnelle — Q13 : Filter pour les nombres pairs Que renvoie cette expression ?
`

python

list(filter(lambda x: x % 2 == 0, range(10)))

]]> Équivalent en compréhension de liste :
[x for x in range(10) if x % 2 == 0]. Les deux
formes sont fréquentes en Python.

]]> 1.0 0.0 0 true true abc [1, 3, 5, 7, 9]

]]> Erreur : x % 2 == 0 teste si x est pair.
Donc on garde les pairs, pas les impairs.

]]> [0, 2, 4, 6, 8]

]]> Bonne réponse : filter conserve les éléments pour
lesquels la condition est vraie. range(10) produit
0, 1, \ldots, 9 ; on garde les pairs 0, 2, 4, 6, 8.

]]> [0, 1, 2, ..., 9]

]]> Erreur : ce serait range(10) complet, sans filtre.

]]> []

]]> Erreur : il y a bien des nombres pairs dans
range(10).

]]> Programmation fonctionnelle — Q14 : Compréhension de liste Quelle est la compréhension de liste Python équivalente
à list(map(lambda x: x * 2, filter(lambda x: x > 0, L))) ?

]]> Les compréhensions de liste, inspirées des langages
fonctionnels, s'intègrent naturellement à Python.
Elles combinent élégamment map et filter en
une seule expression. Pour réduire une liste à une
valeur unique, on utilise sum, max, min, etc.

]]> 1.0 0.0 0 true true abc [x for x in L * 2]

]]> Erreur : cela multiplie la liste par 2 (deux
répétitions de la liste), pas chaque élément. De
plus, le filtre est absent.

]]> [x * 2 for x in L if x > 0]

]]> Bonne réponse : on combine map et filter dans une
seule compréhension. Cette forme est plus lisible
et idiomatique en Python.

]]> [x > 0 * 2 for x in L]

]]> Erreur : syntaxiquement valide mais sémantiquement
faux. La condition est ailleurs.

]]> [L if x > 0 for x in L]

]]> Erreur : syntaxe incorrecte de compréhension.

]]> Programmation fonctionnelle — Q15 : Fonction d'ordre supérieur Quelle est la définition d'une fonction d'ordre supérieur ?

]]> Les fonctions d'ordre supérieur sont la signature du
paradigme fonctionnel. Elles permettent l'abstraction
du comportement : par exemple, sorted(L, key=f)
laisse l'utilisateur définir comment trier sans changer
l'algorithme de tri.

]]> 1.0 0.0 0 true true abc Une fonction très complexe

]]> Erreur : « ordre supérieur » est un terme technique,
pas un jugement de complexité.

]]> Une fonction qui prend ou renvoie une fonction

]]> Bonne réponse : map, filter et sorted (avec key)
sont des fonctions d'ordre supérieur. Elles manipulent
les fonctions comme n'importe quelle autre valeur.

]]> Une fonction qui appelle d'autres fonctions

]]> Erreur : la plupart des fonctions appellent d'autres
fonctions. Le critère est plus précis.

]]> Une fonction définie au niveau global du module

]]> Erreur : aucun rapport avec la portée.

]]> Programmation fonctionnelle — Q17 : Des fonctions rangées dans un dictionnaire Que vaut resultat après l'exécution de ce programme ?

``python
def ajouter(a, b):
return a + b

def multiplier(a, b):
return a * b

operations = {"+": ajouter, "": multiplier}
resultat = operations[""](4, 5)
``

]]> Les fonctions sont des valeurs : on peut les stocker dans un
dictionnaire et choisir laquelle appeler selon une clé.
operations["*"](4, 5) revient à multiplier(4, 5), soit 20.

]]> 1.0 0.0 0 true true abc La fonction multiplier elle-même, sans l'appeler

]]> Erreur : operations["*"] seul serait la fonction, mais il est
suivi de (4, 5), qui provoque son appel. resultat reçoit donc la
valeur renvoyée, 20.

]]> 9

]]> Erreur : 9 serait le résultat de ajouter(4, 5), rangée sous la
clé "+". La clé "*" désigne multiplier.

]]> Une erreur, car un dictionnaire ne peut pas contenir de fonctions

]]> Erreur : en Python, une fonction est une valeur comme une autre. On
peut la ranger dans un dictionnaire, la passer en argument ou la
renvoyer.

]]> 20

]]> Bonne réponse : operations["*"] désigne la fonction multiplier,
et les parenthèses (4, 5) l'appellent aussitôt : multiplier(4, 5)
renvoie 20.

]]> Programmation fonctionnelle — Q18 : Une remise qui lit une variable globale On considère le programme suivant :
`

python

taux = 0.1

def remise(prix):

    return prix - prix * taux

a = remise(200)

taux = 0.5

b = remise(200)

Que valent a et b`, et que peut-on en conclure ?

]]> Une fonction pure ne dépend que de ses arguments. En lisant la
variable globale taux, remise renvoie des valeurs différentes
pour un même prix dès que taux change. Pour la rendre pure, on
passe le taux en paramètre : remise(prix, taux).

]]> 1.0 0.0 0 true true abc Une erreur : taux n'est pas défini à l'intérieur de remise

]]> Erreur : une fonction peut lire une variable définie en dehors d'elle
sans global. Le mot-clé global n'est nécessaire que pour la
modifier.

]]> 180.0 et 180.0 : taux est lu une fois, à la définition

]]> Erreur : Python lit taux au moment de chaque appel, pas lors de la
définition de remise. Le second appel utilise donc 0.5 et
renvoie 100.0.

]]> 180.0 et 100.0 : remise est pure, elle ne modifie rien

]]> Erreur : ne rien modifier ne suffit pas. Une fonction pure doit
aussi renvoyer la même valeur pour les mêmes arguments, or
remise(200) vaut 180.0 puis 100.0.

]]> 180.0 et 100.0 : remise n'est pas une fonction pure

]]> Bonne réponse : la valeur de taux est lue à chaque appel, 0.1
puis 0.5. Le même argument 200 donne deux résultats différents :
le résultat ne dépend pas que des arguments, la fonction n'est donc
pas pure.

]]> Programmation fonctionnelle — Q19 : Impératif vs fonctionnel Quel est l'équivalent fonctionnel du code impératif
suivant ?

`python total = 0 for x in L: if x > 0: total += x ** 2`

]]> Le code fonctionnel est plus court, sans variable
modifiable, et exprime directement l'intention
(« la somme des carrés des positifs ») plutôt que la
mécanique d'accumulation.

]]> 1.0 0.0 0 true true abc for x in L: total += x ** 2

]]> Erreur : c'est une boucle impérative qui modifie
total. On veut s'en abstraire.

]]> list(map(lambda x: x ** 2, filter(lambda x: x > 0, L)))

]]> Erreur : le filtrage et la mise au carré sont corrects,
mais cette expression renvoie la liste des carrés et non
leur somme. Pour L = [2, -1, 3], elle donne [4, 9]
au lieu de 13.

]]> sum(x ** 2 if x > 0 for x in L)

]]> Erreur : syntaxe invalide. x ** 2 if x > 0 sans else
n'est pas une expression correcte : le filtre se place
après le for, sous la forme for x in L if x > 0.

]]> sum(x ** 2 for x in L if x > 0)

]]> Bonne réponse : le filtre if x > 0 écarte les valeurs
négatives ou nulles, x ** 2 transforme chaque valeur
retenue et sum additionne le tout. Pas de variable
modifiée, pas de boucle explicite.

]]> Programmation fonctionnelle — Q20 : Récursivité sans boucle Quelle fonction calcule récursivement, sans boucle, la somme des
éléments d'une liste L, l'appel somme(L, 0) devant renvoyer la
somme de toute la liste ?

]]> Une fonction récursive a besoin d'un cas de base, qui arrête les
appels, et d'un appel sur un problème plus petit, ici la fin de la
liste à partir de i + 1. En Python, le nombre d'appels imbriqués
est limité : pour de très longues listes, on préfère sum.

]]> 1.0 0.0 0 true true abc `

python

def somme(L, i):

    if i == len(L):

        return 0

    return L[i] + somme(L, i + 1)

]]> Bonne réponse : le cas de base traite l'indice qui dépasse la liste
en renvoyant 0, et chaque appel ajoute L[i] à la somme des
éléments suivants. Aucune boucle, aucune variable modifiée.

]]> `

python

def somme(L, i):

    if i == len(L) - 1:

        return 0

    return L[i] + somme(L, i + 1)

]]> Erreur : le cas de base renvoie 0 sur le dernier indice au lieu
d'ajouter L[i], si bien que le dernier élément est oublié :
somme([1, 2, 3], 0) renvoie 3 au lieu de 6.

]]> `

python

def somme(L, i):

    return L[i] + somme(L, i + 1)

]]> Erreur : il manque le cas de base. Quand i atteint len(L),
L[i] n'existe pas : somme([1, 2, 3], 0) lève IndexError.

]]> `

python

def somme(L, i):

    total = 0

    for j in range(i, len(L)):

        total = total + L[j]

    return total

]]> Erreur : le résultat est juste, mais la fonction utilise une boucle
et une variable total modifiée à chaque tour. C'est l'écriture
impérative, pas récursive.

]]> Programmation fonctionnelle — Q21 : Mélange de paradigmes Un programme Python utilise une boucle for pour
parcourir une liste, puis appelle sorted avec une
fonction lambda comme critère. Combien de paradigmes
de programmation différents ce code combine-t-il ?

]]> Python est un langage multi-paradigme : il
permet d'écrire dans le style impératif (boucles,
affectations), fonctionnel (lambda, map,
compréhensions) ou objet (classes), et de
combiner librement les trois selon les besoins.

]]> 1.0 0.0 0 true true abc Trois : impératif, fonctionnel et objet

]]> Erreur : aucune classe ni objet n'est défini
dans cet exemple, donc le paradigme objet n'est
pas mobilisé.

]]> Aucun, ce n'est pas vraiment un programme correct et valide

]]> Erreur : c'est bien un programme valide, et il
utilise plusieurs paradigmes.

]]> Deux : impératif (la boucle) et fonctionnel (la lambda)

]]> Bonne réponse : c'est exactement ce que dit le
programme officiel : « Dans un même programme,
on peut utiliser des paradigmes différents. »

]]> Un seul, l'impératif

]]> Erreur : la boucle for est bien impérative,
mais l'usage de sorted avec une lambda relève
du style fonctionnel.

]]> Programmation fonctionnelle — Q22 : Calculer la somme des carrés On veut calculer la somme des carrés des entiers
d'une liste nombres. Quel code suit le style fonctionnel ?

]]> Le style fonctionnel privilégie les expressions
sans état modifiable. La compréhension de liste et
les fonctions comme sum, map, filter
permettent souvent d'écrire des traitements de
données très concis dans ce style.

]]> 1.0 0.0 0 true true abc `

python

total = sum(n * n for n in nombres)

]]> Bonne réponse : ce code est fonctionnel : il
construit une expression sans variable d'état
intermédiaire et passe le résultat à la fonction
sum. Pas d'effet de bord.

]]> `

python

total = 0

for n in nombres:

    total = total + n * n

]]> Erreur : ce code est impératif : il modifie
une variable total à chaque itération.

]]> `

python

total = nombres

]]> Erreur : ce code ne calcule pas du tout la
somme des carrés.

]]> `

python

class Sommateur:

    def __init__(self):

        self.total = 0

    def ajouter(self, n):

        self.total += n * n

]]> Erreur : ce code définit une classe ; c'est le
style objet, pas fonctionnel.

]]> Programmation fonctionnelle — Q23 : Choisir un paradigme Pour écrire un script court qui transforme une
liste de prix en y appliquant une remise de 10\%,
quel paradigme est le plus naturel en Python ?

]]> Une même tâche peut souvent s'écrire dans plusieurs
paradigmes. Le bon choix dépend de la nature du
problème : transformations de données pour le
fonctionnel, modélisation d'entités pour l'objet,
séquences d'instructions pour l'impératif. Python
permet de mélanger les trois.

]]> 1.0 0.0 0 true true abc Une approche fonctionnelle avec une compréhension de liste ou un map sur une lambda

]]> Bonne réponse : la transformation d'une liste en
une autre par une fonction simple est typique du
style fonctionnel. Une compréhension de liste
comme [p * 0.9 for p in prix] est concise et
claire.

]]> Un paradigme logique type Prolog

]]> Possible théoriquement mais inadapté ici, et
Prolog n'est pas Python. Le paradigme logique
n'est pas étudié au lycée.

]]> Aucun paradigme : il faut tout écrire à la main, avec des goto

]]> Erreur : il n'existe pas de goto en Python, et
aucun paradigme moderne ne le promeut.

]]> Une approche objet avec une classe Remiseur et une méthode appliquer

]]> Possible mais nettement excessif pour une
transformation de liste de quelques lignes. La
POO se justifie quand on modélise des entités
avec un état et plusieurs comportements.

]]> Programmation fonctionnelle — Q24 : Programmation fonctionnelle et parallélisme Pourquoi la programmation fonctionnelle est-elle
particulièrement adaptée au calcul parallèle ?

]]> C'est un argument fort à l'heure des processeurs à
plusieurs cœurs : des calculs sans effet de bord peuvent
être répartis entre plusieurs processus sans qu'ils se
gênent.

]]> 1.0 0.0 0 true true abc Elle utilise moins de mémoire

]]> Erreur : au contraire, l'immutabilité peut consommer
plus de mémoire (création de nouveaux objets plutôt
que modification en place).

]]> Elle est plus simple à apprendre

]]> Erreur : c'est subjectif, et de toute façon pas la
raison de l'aptitude au parallélisme.

]]> Sans effets de bord ni mutation, pas de conflit d'accès

]]> Bonne réponse : en programmation impérative, deux calculs
menés en parallèle qui modifient la même variable doivent
se coordonner, ce qui est complexe et lent. Avec des
données qui ne changent pas, chaque calcul avance seul,
sans risque de conflit.

]]> Elle utilise automatiquement davantage de cœurs du processeur

]]> Erreur : ce n'est pas la cause, c'est l'effet
recherché. La cause est plus profonde.

]]> Programmation fonctionnelle — Q25 : Comparaison des paradigmes Parmi les affirmations suivantes, laquelle est vraie ?

]]> L'idéal pragmatique : utiliser le bon paradigme pour
le bon problème. Une bonne formation NSI inclut donc
les deux pour développer la flexibilité de pensée
algorithmique.

]]> 1.0 0.0 0 true true abc La programmation fonctionnelle interdit l'utilisation des classes

]]> Erreur : on peut utiliser des classes en
programmation fonctionnelle, surtout dans des
langages multi-paradigmes. Les puristes les évitent,
mais ce n'est pas une interdiction du paradigme
lui-même.

]]> Fonctionnelle et objet sont complémentaires, selon les situations

]]> Bonne réponse : OO modélise des entités avec état
et comportement (interfaces graphiques, simulation,
jeux). Fonctionnelle modélise des transformations
de données (calcul, science des données). Beaucoup
de programmes mélangent les deux.

]]> La programmation fonctionnelle remplace définitivement l'orientée objet

]]> Erreur : les deux paradigmes coexistent et se
complètent. La plupart des langages modernes sont
multi-paradigmes (Python, JavaScript, Scala).

]]> La programmation fonctionnelle ne fonctionne que sur les ordinateurs récents

]]> Erreur : Lisp date de 1958 et tournait sur les
premiers ordinateurs. La programmation fonctionnelle
est antérieure à l'orientée objet.

]]> Programmation fonctionnelle — Q26 : Une fonction qui affiche La fonction double est-elle pure ?
`

python

def double(x):

    print(x)

    return 2 * x

]]> Une fonction pure ne fait que calculer sa valeur de retour :
afficher, écrire dans un fichier ou modifier une variable globale
sont des effets de bord.

]]> 1.0 0.0 0 true true abc Non, car elle ne contient pas de boucle

]]> Erreur : la présence ou l'absence de boucle ne définit pas la
pureté.

]]> Oui, car print ne modifie aucune variable

]]> Erreur : écrire à l'écran est un effet de bord même sans
variable modifiée.

]]> Oui, le résultat ne dépendant que de x

]]> Erreur : la pureté exige aussi l'absence de tout effet
extérieur, et print en est un.

]]> Non, l'affichage est un effet de bord

]]> Bonne réponse : le résultat ne dépend que de x, mais la
fonction agit sur l'extérieur en écrivant à l'écran. Deux appels
identiques n'ont pas le même effet sur le monde.

]]> Programmation fonctionnelle — Q27 : Ajouter un élément sans rien modifier Quelle version respecte l'immuabilité, en laissant intacte la
structure reçue ?

]]> L'immuabilité se pratique en renvoyant de nouvelles valeurs : les
tuples s'y prêtent, les listes exigent une copie.

]]> 1.0 0.0 0 true true abc def ajoute(l, x): l += [x], avec l une liste

]]> Erreur : sur une liste, += modifie l'objet existant, comme
append.

]]> def ajoute(l, x): l.insert(len(l), x), avec l une liste

]]> Erreur : insert modifie la liste en place.

]]> def ajoute(t, x): return t + (x,), avec t un tuple

]]> Bonne réponse : t + (x,) construit un nouveau tuple ; t
reste inchangé pour tous ceux qui le partagent.

]]> def ajoute(l, x): l.append(x), avec l une liste

]]> Erreur : append modifie la liste reçue, visible depuis
l'appelant.

]]> Programmation fonctionnelle — Q28 : Pureté et mémorisation des résultats Pourquoi peut-on mémoriser les résultats d'une fonction pure dans
un dictionnaire pour éviter de les recalculer, alors que c'est
risqué pour une fonction quelconque ?

]]> La mémoïsation suppose qu'un résultat ne change pas d'un appel à
l'autre : c'est exactement ce que garantit la pureté.

]]> 1.0 0.0 0 true true abc Une fonction pure s'exécute plus vite, le dictionnaire restant petit

]]> Erreur : la vitesse n'a rien à voir ; c'est la stabilité du
résultat qui compte.

]]> Une fonction pure n'accepte qu'un seul argument, facile à utiliser comme clé

]]> Erreur : une fonction pure peut avoir plusieurs arguments, un
tuple sert alors de clé.

]]> Une fonction pure renvoie toujours la même valeur pour les mêmes arguments

]]> Bonne réponse : le résultat mémorisé reste valable à tout
moment. Une fonction qui lit une variable globale ou l'heure
pourrait rendre une valeur différente au prochain appel.

]]> Une fonction pure ne peut pas lever d'exception, le dictionnaire reste cohérent

]]> Erreur : une fonction pure peut lever une exception, par
exemple une division par zéro.

]]> Programmation fonctionnelle — Q29 : Calculer une somme sans réaffecter Parmi ces façons de calculer la somme d'une liste l, laquelle ne
modifie aucune variable ni aucune structure ?

]]> Le style fonctionnel compose des fonctions qui renvoient des
valeurs au lieu de mettre à jour des variables.

]]> 1.0 0.0 0 true true abc Un appel sum(l), qui renvoie la somme sans rien changer

]]> Bonne réponse : sum reçoit la liste et renvoie une valeur, sans
rien changer ni réaffecter.

]]> Une boucle for accumulant dans total, réaffecté à chaque tour

]]> Erreur : total est réaffecté à chaque tour, c'est le style
impératif.

]]> Un l.append(sum(l)) suivi de la lecture de l[-1]

]]> Erreur : la liste reçoit un élément de plus.

]]> Une boucle remplaçant l[0] par l[0] + l[1] et retirant l[1]

]]> Erreur : la liste est détruite au passage.

]]> Programmation fonctionnelle — Q30 : Un argument modifié par la fonction Qu'affiche ce programme, et la fonction sans_tete est-elle pure ?
``python
def sans_tete(l):
l.pop(0)
return l

a = [1, 2, 3]
b = sans_tete(a)
print(a)
``

]]> Une version pure construirait une nouvelle liste, l[1:], sans
toucher à celle reçue.

]]> 1.0 0.0 0 true true abc [2, 3], et la fonction n'est pas pure, elle modifie a

]]> Bonne réponse : pop(0) retire le premier élément de la liste
reçue, qui est a elle-même. Un appel a changé une valeur
extérieure, c'est un effet de bord.

]]> [1, 2, 3], et la fonction n'est pas pure, elle utilise pop

]]> Erreur : la fonction n'est effectivement pas pure, mais a a
bien été modifiée.

]]> [1, 2, 3], et la fonction est pure, elle renvoie une liste

]]> Erreur : a et l désignent la même liste, modifiée par
pop.

]]> [2, 3], et la fonction est pure, le résultat étant renvoyé

]]> Erreur : renvoyer un résultat n'efface pas l'effet de bord sur
a.

]]> Programmation fonctionnelle — Q31 : Tester une fonction pure Pourquoi une fonction pure est-elle plus simple à tester qu'une
fonction qui lit et modifie des variables globales ?

]]> Une fonction qui dépend d'un état global oblige à reconstruire cet
état avant chaque test et à le vérifier après.

]]> 1.0 0.0 0 true true abc Une fonction pure s'exécute plus vite, les tests durent donc moins

]]> Erreur : la vitesse n'est pas en cause, c'est l'absence d'état à
préparer.

]]> Il suffit de choisir des arguments et de vérifier la valeur renvoyée

]]> Bonne réponse : rien à préparer avant l'appel, rien à inspecter
après, sinon le résultat. Chaque test est indépendant des
autres.

]]> Une fonction pure n'a jamais besoin d'être testée, étant correcte par nature

]]> Erreur : la pureté ne garantit pas que le calcul est juste.

]]> Les tests d'une fonction pure peuvent s'écrire sans connaître ses arguments

]]> Erreur : un test appelle la fonction avec des arguments précis.

]]> Programmation fonctionnelle — Q32 : Où se trouve l'état d'un programme fonctionnel Un programme impératif garde l'état du jeu dans des variables qu'il
met à jour. Comment un programme fonctionnel représente-t-il
l'évolution de cet état ?

]]> Sans variable mutable, le temps qui passe se traduit par une suite
de valeurs, chacune calculée à partir de la précédente.

]]> 1.0 0.0 0 true true abc Il n'a pas d'état, un programme fonctionnel ne pouvant rien faire évoluer

]]> Erreur : l'état évolue, mais par création de nouvelles valeurs.

]]> Il stocke l'état dans une variable globale lue par toutes les fonctions

]]> Erreur : c'est précisément ce que le style fonctionnel évite.

]]> Chaque fonction modifie l'état reçu avant de le renvoyer

]]> Erreur : modifier l'état reçu serait un effet de bord.

]]> Chaque fonction reçoit l'état et renvoie un nouvel état

]]> Bonne réponse : l'état circule dans les paramètres et les
valeurs de retour ; l'ancien état n'est jamais modifié, un
nouveau est construit à chaque étape.

]]> Programmation fonctionnelle — Q33 : Déplacer un point en objet et en fonctionnel Deux programmes déplacent un point. Lequel relève du style
fonctionnel ?
``python
# Version A
p.deplace(2, 3)

# Version B
q = deplace(p, 2, 3)
``

]]> En objet, l'opération change l'objet ; en fonctionnel, elle produit
une nouvelle valeur et laisse l'ancienne intacte.

]]> 1.0 0.0 0 true true abc La version A, qui regroupe la donnée et son comportement

]]> Erreur : regrouper données et méthodes et modifier l'état est le
propre du style objet.

]]> La version B, qui renvoie un nouveau point sans toucher à p

]]> Bonne réponse : deplace reçoit p et renvoie un point
distinct ; p reste disponible tel quel. La version A modifie
l'état interne de l'objet p.

]]> Les deux, puisque toutes deux appellent une fonction deplace

]]> Erreur : appeler une fonction ne suffit pas ; c'est l'absence de
modification qui compte.

]]> Aucune, le style fonctionnel interdisant les objets comme p

]]> Erreur : toute donnée peut être manipulée en style fonctionnel,
pourvu qu'on ne la modifie pas.

]]> Programmation fonctionnelle — Q34 : Les effets de bord inévitables Un programme doit bien, à un moment, afficher un résultat ou écrire
un fichier. Comment le style fonctionnel compose-t-il avec ces
effets de bord nécessaires ?

]]> Le style fonctionnel ne supprime pas les effets de bord, il les
cantonne aux frontières du programme.

]]> 1.0 0.0 0 true true abc Il les répartit dans toutes les fonctions, pour qu'aucune ne domine

]]> Erreur : disperser les effets rend chaque fonction impure, c'est
l'inverse du but.

]]> Il les isole dans quelques fonctions, le cœur du calcul restant pur

]]> Bonne réponse : les fonctions pures calculent, et une mince
couche de fonctions impures affiche ou enregistre leurs
résultats. Le programme est pur presque partout.

]]> Il les remplace par des valeurs de retour, sans jamais rien afficher

]]> Erreur : renvoyer une valeur ne l'affiche pas ; un effet reste
nécessaire au bout de la chaîne.

]]> Il les interdit totalement, un programme fonctionnel n'affichant rien

]]> Erreur : un programme qui ne produit aucun effet ne sert à
rien.

]]> Programmation fonctionnelle — Q35 : Une fonction fabriquée par une autre Qu'affiche ce programme ?
``python
def multiplieur(k):
return lambda x: k * x

f = multiplieur(3)
print(f(5))
``

]]> Une fonction peut en renvoyer une autre, qui garde en mémoire les
variables de l'appel qui l'a créée.

]]> 1.0 0.0 0 true true abc 15

]]> Bonne réponse : multiplieur(3) renvoie une fonction qui
multiplie son argument par 3 ; f(5) vaut
3 × 5 = 15.

]]> Une erreur, k ayant disparu

]]> Erreur : la fonction renvoyée conserve la valeur de k, c'est
une fermeture.

]]> 8

]]> Erreur : la fonction renvoyée multiplie, elle n'additionne pas.

]]> 3

]]> Erreur : f n'est pas la valeur 3, c'est une fonction qui
se souvient de 3.

]]> Programmation fonctionnelle — Q36 : Trier avec une fonction de clé Que renvoie sorted(['pomme', 'kiwi', 'banane'], key=len) ?

]]> Le paramètre key de sorted reçoit une fonction : c'est un
exemple de fonction d'ordre supérieur dans la bibliothèque
standard.

]]> 1.0 0.0 0 true true abc ['banane', 'kiwi', 'pomme']

]]> Erreur : ce serait l'ordre alphabétique, sans key.

]]> ['banane', 'pomme', 'kiwi']

]]> Erreur : l'ordre est croissant, du plus court au plus long.

]]> Une erreur, len devant être appelée

]]> Erreur : c'est la fonction elle-même qui est attendue, pas son
résultat.

]]> ['kiwi', 'pomme', 'banane']

]]> Bonne réponse : key=len indique de comparer les mots par leur
longueur ; la fonction len est passée en argument, sans être
appelée.

]]> Programmation fonctionnelle — Q37 : Enchaîner des fonctions rangées dans une liste Qu'affiche ce programme ?
``python
def enchaine(fonctions, x):
for f in fonctions:
x = f(x)
return x

print(enchaine([lambda x: x + 1, lambda x: x * 2], 3))
``

]]> Une liste de fonctions parcourue par une boucle réalise une
composition : l'ordre des éléments est l'ordre d'application.

]]> 1.0 0.0 0 true true abc Une erreur, une liste ne pouvant contenir des fonctions

]]> Erreur : les fonctions sont des valeurs comme les autres, une
liste peut en contenir.

]]> 8

]]> Bonne réponse : les fonctions s'appliquent dans l'ordre de la
liste, d'abord +1 puis × 2 :
(3 + 1) × 2 = 8.

]]> 4

]]> Erreur : seule la première fonction aurait été appliquée.

]]> 7

]]> Erreur : ce serait l'ordre inverse, × 2 puis +1.

]]>