Formations — 1 037 leçons en français

Accueil › Python › Boucles, fonctions et compréhensions

Boucles, fonctions et compréhensions — entretien Python

5 questions posées en entretien sur 2 sujets, avec la bonne réponse et son explication.

Boucles

Deux listes de longueurs différentes sont passées à `zip`. Que se passe-t-il, et comment s'en protéger ?

produits = ["pain", "lait", "sel"]
prix = [1.20, 0.95]

lignes = list(zip(produits, prix))
  1. `zip` s'arrête sur la liste la plus courte sans rien signaler ; `strict=True` lève alors une `ValueError` ✓
  2. `zip` complète la liste la plus courte avec `None`
  3. `zip` lève une `ValueError` dès que les longueurs diffèrent
  4. `zip` parcourt la plus longue et répète le dernier élément de l'autre

Pourquoi : La troncature silencieuse de `zip` est un vrai incident de production : une ligne de données disparaît et le programme réussit. `zip(..., strict=True)`, disponible depuis Python 3.10, lève `ValueError: zip() argument 2 is shorter than argument 1`. Pour compléter plutôt que tronquer, c'est `itertools.zip_longest`.

Niveau confirme

Que se passe-t-il à l'exécution de ce code ?

i = 0
while i < 3:
    if i == 1:
        continue
    print(i)
    i += 1
  1. Il affiche 0, puis tourne indéfiniment ✓
  2. Il affiche 0 et 2
  3. Il affiche 0, 1 et 2
  4. Il lève une `RuntimeError` après un trop grand nombre de tours

Pourquoi : `continue` repart au test de la condition **sans exécuter `i += 1`** : `i` reste bloqué à 1 et la condition reste vraie. Aucune erreur n'est levée, le processus consomme simplement un cœur à 100 %. Dans un `while`, l'incrément doit précéder tout `continue` — ou la boucle doit être un `for`.

Niveau junior

Fonctions

Qu'affiche ce code ?

def total(montants):
    print(sum(montants))

resultat = total([10, 20])
print(resultat)
  1. 30 puis None ✓
  2. 30 puis 30
  3. 30 seulement
  4. None puis 30

Pourquoi : `print` affiche, il ne renvoie pas : la fonction n'a pas de `return`, donc elle renvoie `None`. C'est la question de tri la plus simple sur les fonctions, et elle élimine encore beaucoup de candidats. Corollaire utile à citer : `liste.sort()` renvoie également `None`, d'où l'erreur `liste = liste.sort()`.

Niveau junior

Qu'affiche ce code, et pourquoi ?

def ajouter(produit, panier=[]):
    panier.append(produit)
    return panier

print(ajouter("pain"))
print(ajouter("lait"))
  1. `['pain']` puis `['pain', 'lait']` : la liste par défaut est créée une seule fois, à la définition ✓
  2. `['pain']` puis `['lait']` : une nouvelle liste est créée à chaque appel
  3. `['pain']` puis `['pain']` : la valeur par défaut est restaurée entre les appels
  4. `['pain']` puis une `TypeError` : une liste ne peut pas servir de valeur par défaut

Pourquoi : Les valeurs par défaut sont évaluées quand l'instruction `def` est exécutée, et stockées sur l'objet fonction (`ajouter.__defaults__`). Elles sont donc partagées par tous les appels. Le correctif attendu : `panier=None` puis `if panier is None: panier = []`. C'est la question piège la plus posée sur les fonctions Python.

Niveau confirme

Qu'affiche ce code ?

calculs = []
for taux in (0.0, 0.1, 0.2):
    calculs.append(lambda prix: prix * (1 - taux))

print([round(c(100), 1) for c in calculs])
  1. `[80.0, 80.0, 80.0]` ✓
  2. `[100.0, 90.0, 80.0]`
  3. `[100.0, 100.0, 100.0]`
  4. Une `NameError` : `taux` n'existe plus hors de la boucle

Pourquoi : Une closure capture la **variable**, pas sa valeur au moment de la définition : les trois lambdas lisent `taux` à l'appel, après la boucle, quand elle vaut `0.2`. C'est la capture tardive. Pour figer la valeur, on passe par un argument par défaut (`lambda prix, taux=taux: ...`), évalué à la définition, ou par `functools.partial`. Le même piège frappe les gestionnaires d'événements créés dans une boucle.

Niveau senior

S'entraîner sur ces questions, chronométré →