Coding Solution

QCM Python : 12 questions corrigées (type CodinGame, SkillValue)

QCMPython12 questionsMis à jour le

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

Entraînez-vous : 12 questions corrigées

Choisissez une réponse pour voir l'explication.

Qu'affiche ce programme ?
def add(x, items=[]):
    items.append(x)
    return items

print(add(1))
print(add(2))

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.

Que se passe-t-il à l'exécution de ce programme ?
count = 0

def inc():
    count += 1
    return count

print(inc())

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.

Qu'affiche ce programme ?
def gen():
    yield 1
    yield 2
    yield 3

g = gen()
print(next(g))
print(sum(g))
print(list(g))

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

Qu'affiche ce programme ?
def f(a, *args, b=10, **kwargs):
    return a, args, b, kwargs

print(f(1, 2, 3, b=4, c=5))

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.

Qu'affiche ce programme, dans l'ordre ?
def deco(func):
    def wrapper(*args, **kwargs):
        print("avant")
        result = func(*args, **kwargs)
        print("apres")
        return result
    return wrapper

@deco
def hello(name):
    return f"Bonjour {name}"

print(hello.__name__)
print(hello("Ana"))

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

Le jour du test

  1. 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.
  2. 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.
  3. 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.
  4. 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).

S'entraîner avec Coding Solutions

Sur un QCM d'entraînement affiché à l'écran, l'extension Coding Solutions explique la bonne réponse et la règle derrière, dans 29 langages. Pour les exercices de code, voyez aussi nos solutions CodinGame expliquées et les guides par plateforme.

Questions fréquentes

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.

Autres langages

★ 5,0 · 16 avis · 928 utilisateurs Ajouter à Chrome