$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 composant des fonctions, en évitant les modifications d'état (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 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.

]]> 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, pour les mêmes arguments, retourne toujours le même résultat et n'a aucun effet de bord (modification de variable globale, écriture dans un fichier, etc.)

]]> 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 qui modifie ses 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 écrite uniquement en Python

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

]]> Une fonction qui ne contient aucun bug

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

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

]]> L'immutabilité a plusieurs avantages : pas de
modifications inattendues, partage sûr entre threads,
possibilité de cacher les valeurs (les chaînes de
caractères en Python sont parfois cachées en interne).

]]> 1.0 0.0 0 true true abc Elle est stockée 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 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.

]]> Elle ne peut pas être lue

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

]]> 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, reduce), 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.

]]> Elles peuvent être passées en paramètre, retournées par d'autres fonctions, et stockées dans des variables, comme n'importe quelle autre valeur

]]> 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 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 variable globale

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

]]> Une fonction anonyme définie en une seule 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.

]]> Un type de boucle

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

]]> Une instruction de débogage

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

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

]]> map, filter et reduce (dans functools) sont les
trois fonctions d'ordre supérieur classiques en
programmation fonctionnelle. Elles correspondent à des
schémas d'usage très courants.

]]> 1.0 0.0 0 true true abc Elle filtre la liste selon un critère

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

]]> Elle réduit la liste à une seule valeur

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

]]> Elle applique la fonction f à chaque élément de L et renvoie un itérateur des résultats

]]> 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 renvoie un nouvel itérateur (fonction pure).

]]> 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 conserve uniquement les éléments de L pour lesquels p(element) 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 modifie chaque élément de L

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

]]> Elle renvoie une liste vide

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

]]> Programmation fonctionnelle — Q08 : Fonction reduce Quel est le rôle de reduce(f, L) (du module functools) ?

]]> reduce (aussi appelé fold) est très puissant : il
capture les schémas de somme, produit, maximum,
concaténation, etc. En Python, il est moins idiomatique
qu'en Haskell, et souvent on lui préfère sum, max,
etc.

]]> 1.0 0.0 0 true true abc Trier la liste

]]> Erreur : c'est le rôle de sorted ou list.sort.

]]> Combiner les éléments de L deux par deux à l'aide de f jusqu'à obtenir une seule valeur

]]> Bonne réponse : par exemple,
reduce(lambda a, b: a + b, [1, 2, 3, 4]) calcule
((1 + 2) + 3) + 4 = 10. C'est l'agrégation par
excellence.

]]> Faire une boucle

]]> Erreur : reduce est une abstraction de boucle
d'agrégation, mais ce n'est pas une boucle au sens
syntaxique.

]]> Réduire la taille d'une liste en supprimant les doublons

]]> Erreur : ce n'est pas le rôle de reduce. Pour les
doublons, on utiliserait set(L).

]]> 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 exécuter en parallèle

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

]]> Créer une nouvelle fonction qui applique d'abord g, puis f au résultat (notée f \circ g)

]]> 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 écrire dans le même fichier

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

]]> Les fusionner 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.

]]> 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 qu'elle est plus rapide

]]> 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 qu'une boucle nécessite la modification d'une variable de compteur, ce qui contredit l'idéal d'immutabilité

]]> Bonne réponse : for i in range(n) modifie
implicitement i. Une approche purement
fonctionnelle évite cela en utilisant des appels
récursifs avec de nouveaux paramètres.

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

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

]]> Parce que c'est la mode

]]> Erreur : c'est une raison structurelle, pas un effet
de mode.

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

`
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).

]]> f1 et f2

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

]]> f1 uniquement

]]> 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.

]]> Toutes

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

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

`
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.

]]> [1, 16]

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

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

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

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

`
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 []

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

]]> [1, 3, 5, 7, 9]

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

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

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

]]> [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.

]]> 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 > 0 * 2 for x in L]

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

]]> [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.

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

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

]]> [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.

]]> 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 définie au niveau global

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

]]> 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 qui prend une fonction en argument et/ou en retourne une

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

]]> Une fonction très complexe

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

]]> Programmation fonctionnelle — Q16 : Mémoïsation et fonctions pures Pourquoi la mémoïsation est-elle particulièrement adaptée
aux fonctions pures ?

]]> C'est aussi pour cela que des langages purs comme
Haskell peuvent automatiquement mémoïser des fonctions
sans surprise. Avec Python, il faut être prudent,
lru_cache ne fonctionne correctement qu'avec des
fonctions pures.

]]> 1.0 0.0 0 true true abc Une fonction pure renvoie toujours la même valeur pour les mêmes arguments, donc le cache est toujours fiable

]]> Bonne réponse : si la fonction n'était pas pure (par
exemple, dépendait de l'horloge), le cache pourrait
renvoyer une valeur obsolète. La pureté garantit que
le résultat est invariable.

]]> La mémoïsation modifie la fonction

]]> Erreur : la mémoïsation enveloppe la fonction sans
la modifier. C'est la pureté qui rend cette
enveloppe correcte.

]]> Les fonctions pures sont plus rapides

]]> Erreur : ce n'est pas une question de vitesse
intrinsèque, mais de correction de la mémoïsation.

]]> Les fonctions pures n'ont pas besoin de mémoire

]]> Erreur : la mémoïsation utilise précisément de
la mémoire (un cache). C'est la fiabilité de cette
mise en cache qui dépend de la pureté.

]]> Programmation fonctionnelle — Q17 : Calcul avec reduce Que calcule cette expression ?

`
from functools import reduce
reduce(lambda a, b: a * b, [1, 2, 3, 4, 5])
`

]]> reduce exprime des agrégations très variées : somme,
produit, max, min, concaténation. C'est l'opération
« repli » (fold) en programmation fonctionnelle.

]]> 1.0 0.0 0 true true abc Le maximum (5)

]]> Erreur : ce serait
reduce(lambda a, b: a if a > b else b, ...).

]]> La somme des éléments (15)

]]> Erreur : la lambda multiplie (*), pas additionne.

]]> La longueur (5)

]]> Erreur : ce serait len([...]), pas reduce.

]]> Le produit des éléments (120)

]]> Bonne réponse : on calcule
((((1 · 2) · 3) · 4) · 5) = 120,
autrement dit 5! = 120. C'est la factorielle.

]]> Programmation fonctionnelle — Q18 : Transparence référentielle Que désigne la transparence référentielle d'une
expression ?

]]> La transparence référentielle est synonyme de pureté.
Elle facilite le raisonnement sur le code : on peut
remplacer mentalement une expression par sa valeur
pour comprendre un programme.

]]> 1.0 0.0 0 true true abc L'expression contient des commentaires

]]> Erreur : aucun rapport avec les commentaires.

]]> L'expression est écrite en blanc sur fond noir

]]> Erreur : sigle inventé.

]]> L'expression peut être remplacée par sa valeur sans changer le comportement du programme

]]> Bonne réponse : si f(3) renvoie toujours 9, alors
on peut remplacer f(3) par 9 partout dans le
code, sans rien casser. C'est une propriété forte
des fonctions pures.

]]> L'expression renvoie une référence vers un objet

]]> Erreur : aucun rapport avec les références ou les
pointeurs.

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

`
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 L.sum() if L > 0

]]> Erreur : syntaxe incorrecte. Les listes Python n'ont
pas de méthode sum.

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

]]> Bonne réponse : on combine filter (if x > 0),
map (x ** 2) et reduce (sum) en une seule
expression. Pas de variable mutable, pas de boucle
explicite.

]]> reduce(L)

]]> Erreur : reduce requiert une fonction et une
séquence, pas seulement une séquence.

]]> for x in L: total += x 2

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

]]> Programmation fonctionnelle — Q20 : Récursivité sans boucle Quelle est l'écriture récursive pure de la fonction
qui calcule la somme des éléments d'une liste ?

]]> Cette implémentation récursive est belle et simple,
mais en Python elle est limitée par la pile (~1000
éléments). Pour des listes plus longues, on combine
avec une stratégie (récursivité terminale, division
par moitié, ou plus simplement sum).

]]> 1.0 0.0 0 true true abc `
def somme(L):
return sum(L)
`

]]> Erreur : sum est correcte mais elle ne montre pas
la récursivité. Et elle utilise en interne une
boucle impérative.

]]> `
def somme(L):
total = 0
for x in L: total += x
return total
`

]]> Erreur : c'est l'écriture impérative. Elle
utilise une variable mutable (total), contraire à
l'idéal fonctionnel.

]]> `
def somme(L):
if L == []:
return 0
return L[0] + somme(L[1:])
`

]]> Bonne réponse : aucune variable mutable, aucune
boucle. Juste un cas de base et un appel récursif.
C'est l'archétype du style fonctionnel pur.

]]> `
def somme(L):
return reduce(lambda a, b: a + b, L)
`

]]> Erreur : c'est aussi correct et fonctionnel, mais ce
n'est pas une définition récursive au sens
strict. La question demandait la récursivité
explicite.

]]> 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 Aucun, ce n'est pas un vrai programme

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

]]> Deux : impératif (la boucle for) et fonctionnel (le tri par 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. »

]]> 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é.

]]> 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 = 0
for n in nombres:
total = total + n * n
`

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

]]> `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.

]]> `python
total = nombres
`

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

]]> `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.

]]> 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.

]]> 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.

]]> 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.

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

]]> C'est l'argument phare des promoteurs du fonctionnel à
l'ère des processeurs multi-cœurs. Spark, MapReduce,
les architectures d'informatique en nuage reposent
largement sur ces principes.

]]> 1.0 0.0 0 true true abc Elle utilise plus de cœurs du processeur

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

]]> 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.

]]> L'absence d'effets de bord et l'immutabilité éliminent les conflits d'accès aux données partagées

]]> Bonne réponse : en programmation impérative, deux
threads modifiant la même variable doivent se
synchroniser, ce qui est complexe et lent. Avec des
données immuables, aucune synchronisation n'est
requise, on peut paralléliser sans crainte.

]]> 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 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.

]]> 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.

]]> La programmation fonctionnelle et l'orientée objet sont des paradigmes complémentaires, chacun adapté à certaines 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.

]]> Programmation fonctionnelle — Q26 : Fermeture (closure) On considère le code Python suivant :
``
def faire_compteur():
n = 0
def incrementer():
nonlocal n
n += 1
return n
return incrementer

c = faire_compteur()
print(c(), c(), c())

Que renvoie l'appel print(c(), c(), c()) et de
quel concept s'agit-il ?

]]> Les fermetures permettent de créer des fonctions avec
état, sans recourir aux classes. Très utilisées en
JavaScript, Python, Lisp. Elles sont à la base des
décorateurs et des fonctions partiellement
appliquées.

]]> 1.0 0.0 0 true true abc Affiche 1 2 3. C'est un exemple de fermeture
(closure) : la fonction interne incrementer
capture la variable n de la fonction englobante,
même après que celle-ci a terminé son exécution

]]> Bonne réponse : incrementer « se souvient » de
la variable n de l'environnement où elle a été
définie. Chaque appel à c() incrémente cette
variable persistante. La fermeture est un concept
fondamental qui montre que les fonctions de
première classe peuvent porter avec elles un
contexte.

]]> Lève une erreur car n est une variable locale à
faire_compteur

]]> Erreur : grâce au mot-clé nonlocal (ou même sans
en lecture), Python autorise l'accès à n.
C'est précisément le mécanisme de fermeture.

]]> Affiche 1 1 1 car n est réinitialisé à chaque
appel

]]> Erreur : c'est précisément ce que la fermeture
empêche. La variable n est capturée et persistée
entre les appels. Sans nonlocal, on aurait une
erreur car on tenterait de modifier une variable
qui semblerait locale.

]]> Affiche 0 0 0 car n ne peut pas être modifié
dans une fonction interne

]]> Erreur : avec nonlocal n, on indique à Python
que n se réfère à la variable de la fonction
englobante, et qu'on peut la modifier. La sortie
est bien 1 2 3.

]]> Programmation fonctionnelle — Q27 : Décorateur Python Les décorateurs Python (@nom) sont une application
directe d'un concept fondamental de la programmation
fonctionnelle. Lequel ?

]]> Exemple de décorateur classique : @functools.lru_cache
qui ajoute une mémoïsation à n'importe quelle fonction
pure. Autres : @property (transformer une méthode
en attribut), @staticmethod, @classmethod. Tous
reposent sur l'idée de manipuler les fonctions comme
des valeurs.

]]> 1.0 0.0 0 true true abc La compréhension de liste

]]> Erreur : la compréhension de liste est une
syntaxe fonctionnelle pour transformer des
collections, pas pour modifier des fonctions.
Aucun lien avec les décorateurs.

]]> Le filtrage par motif (pattern matching)

]]> Erreur : le filtrage par motif est une
fonctionnalité distincte (introduite en Python
3.10 avec match). Il n'a aucun rapport avec
les décorateurs.

]]> La récursivité

]]> Erreur : un décorateur n'a aucun rapport avec la
récursivité. Il s'agit d'un mécanisme totalement
différent. La récursivité est l'auto-appel d'une
fonction.

]]> Les fonctions d'ordre supérieur : un décorateur
est une fonction qui prend une fonction en
paramètre et renvoie une nouvelle fonction
(souvent enrichie d'un comportement
supplémentaire)

]]> Bonne réponse : la syntaxe @decorator au-dessus
de def f(): ... est strictement équivalente à
f = decorator(f). Le décorateur reçoit la
fonction f en paramètre et renvoie une nouvelle
fonction qui généralement appelle f en y
ajoutant des comportements (mesure du temps,
journalisation, mémoïsation, vérification de
droits, etc.).

]]>