Ce QCM s'adresse aux développeurs qui préparent un test technique Python (SkillValue, CodinGame, HackerRank) ou un entretien. Vous y trouverez 12 questions de niveau mêlé, chacune avec la bonne réponse et une explication détaillée des pièges.
En bref
Les tests Python de recrutement reposent peu sur la syntaxe de base et beaucoup sur le comportement réel de l'interpréteur. Les thèmes qui reviennent le plus souvent sur SkillValue, CodinGame et HackerRank sont les arguments par défaut mutables, la différence entre copie superficielle et copie profonde, la portée des variables et les closures, la consommation des générateurs et la complexité des opérations sur list, dict et set. Les questions prennent presque toujours la forme « qu'affiche ce programme ? » avec des choix très proches les uns des autres. Il faut donc exécuter le code dans sa tête, ligne par ligne, plutôt que se fier à l'intuition.
Les thèmes qui tombent le plus
Arguments par défaut mutables et *args / **kwargsLa valeur par défaut d'un paramètre est évaluée une seule fois, à la définition de la fonction. Une liste ou un dict par défaut est donc partagé entre tous les appels : c'est le piège le plus cité des tests Python.
Listes, dicts, sets et copiesLes tests vérifient que vous savez quand une affectation crée un alias et quand elle crée un nouvel objet. Le piège classique : une copie superficielle (slice, list(), copy()) partage toujours les sous-listes avec l'original.
Slicing et compréhensionsLe slicing avec pas négatif, les indices hors bornes qui ne lèvent pas d'erreur et les compréhensions de dict où plusieurs éléments produisent la même clé sont des sources de confusion fréquentes.
is vs == et identité des objets== compare les valeurs, is compare l'identité (même objet en mémoire). Les tests jouent sur deux listes de même contenu, ou sur un alias, pour voir si vous faites la différence.
Portée, closures et décorateursUne variable affectée dans une fonction est locale sur toute la fonction, d'où les UnboundLocalError. Les lambdas créées dans une boucle capturent la variable, pas sa valeur, et un décorateur mal écrit remplace le nom de la fonction d'origine.
Générateurs et complexitéUn générateur se consomme une seule fois et sum(), list() ou une boucle for l'épuisent. Côté complexité, on vous demande de distinguer x in liste (O(n)) de x in set (O(1) en moyenne) et de connaître le coût de insert(0, x) ou pop(0).
La liste par défaut est créée une seule fois, au moment du def, et réutilisée à chaque appel sans argument items. Le premier appel ajoute 1 et renvoie [1] ; le second ajoute 2 à la même liste et renvoie [1, 2]. [1] puis [2] serait le résultat si une nouvelle liste était créée à chaque appel, ce qui n'est pas le cas. Aucune erreur n'est levée : la définition est parfaitement valide, c'est son comportement qui surprend. La bonne pratique est items=None puis items = [] if items is None else items.
Qu'affiche ce programme ?
a = [1, 2, 3]
b = [1, 2, 3]
c = a
print(a == b, a is b, a is c)
== compare le contenu : a et b ont les mêmes éléments, donc True. is compare l'identité : a et b sont deux objets liste distincts créés séparément, donc a is b vaut False. c = a ne copie rien, c'est un second nom pour le même objet, donc a is c vaut True. Les autres propositions confondent égalité de valeur et identité d'objet.
Qu'affiche ce programme ?
s = "python"
print(s[1:4], s[::-1], s[-2:])
s[1:4] prend les indices 1, 2 et 3 (la borne haute est exclue) : « yth ». s[::-1] parcourt la chaîne avec un pas de -1 et la renverse : « nohtyp ». s[-2:] prend les deux derniers caractères dans l'ordre normal : « on ». Les mauvaises réponses incluent l'indice 4 dans le slice, renversent aussi le dernier slice, ou partent de l'indice 0 au lieu de 1.
Laquelle de ces opérations a une complexité O(1) en moyenne en Python ?
Un set est une table de hachage : tester l'appartenance se fait en O(1) en moyenne, quelle que soit la taille. x in ma_liste et ma_liste.index(x) parcourent la liste élément par élément, donc O(n). ma_liste.insert(0, x) doit décaler tous les éléments existants d'une case, ce qui est aussi O(n) ; pour des insertions en tête fréquentes on utilise collections.deque.
Qu'affiche ce programme ?
import copy
a = [[1, 2], [3, 4]]
b = a[:]
c = copy.deepcopy(a)
a[0].append(99)
print(b[0], c[0])
a[:] est une copie superficielle : b est une nouvelle liste, mais ses éléments sont les mêmes objets sous-liste que ceux de a. Modifier a[0] en place modifie donc aussi b[0], qui devient [1, 2, 99]. deepcopy copie récursivement chaque sous-liste, donc c[0] reste [1, 2]. La première réponse suppose à tort que le slice copie en profondeur ; la deuxième suppose que deepcopy partage les sous-objets.
Qu'affiche ce programme ?
funcs = [lambda: i for i in range(3)]
print([f() for f in funcs])
Chaque lambda capture la variable i, pas sa valeur au moment de la création. Quand les lambdas sont appelées, la boucle est terminée et i vaut 2, la dernière valeur de range(3), d'où [2, 2, 2]. [3, 3, 3] est faux car range(3) s'arrête à 2. Il n'y a pas de NameError : la variable de la compréhension reste accessible à la closure. Pour capturer la valeur courante, on écrit lambda i=i: i.
count += 1 est une affectation, donc Python considère count comme une variable locale de inc sur tout le corps de la fonction. Au moment de lire count pour calculer count + 1, la locale n'a encore aucune valeur : UnboundLocalError. Le code est syntaxiquement valide, il ne s'agit pas d'une SyntaxError, et il n'affiche ni 0 ni 1. Il faudrait déclarer global count (ou nonlocal dans une fonction imbriquée) pour modifier la variable englobante.
Un générateur conserve sa position et ne se rembobine jamais. next(g) consomme le 1. sum(g) consomme le reste, 2 et 3, et renvoie 5. list(g) arrive sur un générateur épuisé et renvoie une liste vide. Les réponses avec 6 supposent que sum repart du début, et celle avec [2, 3] oublie que sum a déjà tout consommé.
a reçoit 1, le premier positionnel. *args collecte les positionnels restants dans un tuple : (2, 3). b est un paramètre keyword-only placé après *args ; il est fourni explicitement avec b=4, donc la valeur par défaut 10 n'est pas utilisée. **kwargs récupère les mots-clés non déclarés dans un dict : {'c': 5}. args est toujours un tuple, jamais une liste, et c ne provoque pas d'erreur grâce à **kwargs.
@deco remplace le nom hello par la fonction wrapper renvoyée par deco, donc hello.__name__ vaut « wrapper » (functools.wraps corrigerait cela). Lors de l'appel, wrapper affiche « avant », appelle hello qui renvoie la chaîne sans rien afficher, affiche « apres », puis renvoie la chaîne ; c'est seulement alors que le print extérieur affiche « Bonjour Ana ». Les réponses qui placent « Bonjour Ana » avant « apres » confondent return et print.
Qu'affiche ce programme ?
d = {x % 3: x for x in range(10)}
print(d)
print(sorted({x % 3 for x in range(10)}))
Dans une compréhension de dict, une clé déjà présente est simplement écrasée par la nouvelle valeur. Les clés possibles sont 0, 1 et 2 ; la dernière valeur de x pour chaque clé est 9 (9 % 3 == 0), 7 (7 % 3 == 1) et 8 (8 % 3 == 2). L'ordre d'insertion des clés (0, 1, 2) est conservé, d'où {0: 9, 1: 7, 2: 8}. La compréhension de set ne garde que les restes distincts, triés : [0, 1, 2]. Aucun doublon de clé ne lève d'erreur en Python.
Que se passe-t-il à l'exécution de ce programme ?
t = (1, [2, 3])
t[1] += [4]
print(t)
t[1] += [4] se déroule en deux temps : d'abord t[1].__iadd__([4]), qui étend la liste en place (elle devient [2, 3, 4]), puis l'affectation t[1] = résultat, qui échoue parce qu'un tuple ne supporte pas l'affectation d'élément. L'exception est levée après la mutation : la liste est bien modifiée mais le print n'est jamais exécuté. C'est un cas d'école qui montre que += n'est pas atomique et que l'immutabilité du tuple porte sur ses références, pas sur les objets référencés.
Score0 / 12
Le jour du test
Exécutez chaque extrait dans votre tête ligne par ligne et notez l'état des variables ; les choix proposés sont conçus pour piéger ceux qui lisent en diagonale.
Dès que vous voyez une liste ou un dict en valeur par défaut, un slice de liste imbriquée ou une lambda dans une boucle, cherchez le partage d'objet : c'est presque toujours le sujet de la question.
Distinguez ce qui est affiché (print) de ce qui est renvoyé (return) : beaucoup de questions sur les décorateurs et les générateurs jouent sur cet ordre.
Révisez les complexités de base avant le test : list (append O(1), insert/pop en tête O(n), in O(n)), dict et set (accès et in O(1) en moyenne), sorted O(n log n).
Quel niveau de Python faut-il pour réussir ce type de QCM ?
Un niveau intermédiaire suffit : les questions portent rarement sur des bibliothèques, mais sur le fonctionnement du langage lui-même. Connaître le modèle objet (références, mutabilité), les générateurs et la portée des variables couvre la grande majorité des questions.
Quelle version de Python est utilisée dans les tests de recrutement ?
Python 3, presque toujours une version 3.8 ou plus récente. Les tests ne portent plus sur Python 2 ; en revanche, les différences classiques (print fonction, division entière, ordre des dicts garanti depuis 3.7) peuvent encore servir de base à une question.
Combien de temps dure un QCM Python sur SkillValue ou CodinGame ?
Généralement entre 15 et 40 minutes pour 15 à 30 questions, soit environ une minute par question. Les questions de lecture de code demandent plus de temps que les questions théoriques, d'où l'intérêt de s'entraîner à simuler l'exécution rapidement.
Comment progresser après ce QCM ?
Reprenez chaque question ratée et tapez le code dans un interpréteur pour observer le résultat, puis modifiez-le pour vérifier votre compréhension. Les exercices de HackerRank et les puzzles CodinGame en Python complètent bien ce travail sur les pièges du langage.