Questions entretien Python sur le slicing de listes

Maîtrisez les questions d’entretien sur le slicing de listes Python : bornes, indices négatifs, copies et affectation. Répondez juste en entretien.

Vous connaissez la syntaxe du slicing. Vous avez écrit `my_list[1:4]` une centaine de fois et obtenu la bonne réponse. Le problème, c’est que connaître la syntaxe et être capable d’expliquer les règles qui la sous-tendent sous la pression d’un entretien en direct sont deux compétences totalement différentes. Les questions d’entretien sur le slicing de listes Python ne sont pas difficiles parce que la mécanique serait obscure — elles sont difficiles parce que les relances testent les cas limites : pourquoi `stop` est exclusif, ce qui se passe lorsque vous dépassez les bornes, et si la tranche que vous venez de créer est réellement une copie. Ce guide associe chaque règle à la question exacte, au piège qui s’y cache et à la réponse courte qui donne l’impression que vous y avez déjà réfléchi.

La bonne nouvelle, c’est que le périmètre est réduit. Il existe grosso modo six catégories de questions, et elles reviennent dans presque tous les entretiens techniques qui touchent à Python. Maîtrisez proprement ces six catégories et vous ne récitez pas des détails anecdotiques — vous construisez un modèle mental solide, qui tient lorsque l’intervieweur commence à improviser.

Dites la syntaxe du slicing à voix haute avant même d’essayer de l’expliquer

Que signifie exactement start:stop:step ?

La syntaxe est `sequence[start:stop:step]`. `start` est l’indice où la tranche commence — inclus. `stop` est l’endroit où elle se termine — exclus. `step` est l’incrément, c’est-à-dire le nombre de positions à avancer entre chaque élément sélectionné.

La réponse courte qui fonctionne bien en entretien : « Start est inclus, stop est exclu, et step contrôle la manière dont je parcours l’intervalle. » C’est tout. N’ajoutez pas d’explication plus longue tant que l’intervieweur ne vous la demande pas.

D’après la documentation officielle de Python sur les séquences, le slicing est défini de manière cohérente pour tous les types de séquences intégrés. Le même modèle mental s’applique donc aussi aux chaînes de caractères et aux tuples, pas seulement aux listes.

Pourquoi stop est il exclusif et non inclusif ?

La réponse honnête, c’est la convention — une convention qui existe pour de bonnes raisons. Quand `stop` est exclusif, la longueur de la tranche est simplement `stop - start`. Vous n’avez pas à ajouter 1 ni à corriger des erreurs de type off-by-one. Cela signifie aussi que deux tranches adjacentes, `a[:n]` et `a[n:]`, partitionnent proprement la liste sans chevauchement ni trou.

Les recruteurs posent cette question comme test de cohérence. Ils veulent voir si vous avez réellement intériorisé la règle ou si vous l’avez juste apprise par cœur. L’argument de la version inclusive, c’est qu’elle paraît plus naturelle — « donnez-moi les éléments de 1 à 3 » évoque spontanément 1, 2 et 3. Mais la logique s’effondre dès que vous commencez à composer des tranches, et les concepteurs de Python ont choisi la version qui reste cohérente. Comprendre pourquoi cette convention existe, c’est ce qui distingue une vraie réponse d’une récitation.

Ce que cela donne en pratique

Prenez `a = [0, 1, 2, 3, 4, 5]`. La tranche `a[1:4]` renvoie `[1, 2, 3]`. `stop` vaut 4, mais l’indice 4 — la valeur `4` — n’est pas inclus. L’erreur la plus fréquente dans un entretien chronométré est d’écrire `a[1:3]` en s’attendant à `[1, 2, 3]`, puis de s’étonner d’obtenir `[1, 2]`.

Lors d’un mock interview, une candidate a un jour expliqué `stop` comme « le dernier indice souhaité, moins un » — ce qui est techniquement correct mais sonne à l’envers et a embrouillé l’intervieweur. Formulation plus claire : `stop` est le premier indice que vous ne voulez pas.

Utilisez les valeurs omises sans donner l’impression de deviner

Que se passe t il quand start , stop ou step est absent ?

Le slicing des listes en Python complète toute valeur omise avec des valeurs par défaut sensées. Si `start` est omis, il vaut le début de la liste. Si `stop` est omis, il vaut la fin. Si `step` est omis, il vaut 1. Le point que les candidats oublient le plus souvent, c’est que l’omission de `step` n’est pas équivalente à écrire `step=1` explicitement dans tous les contextes — en particulier lorsque des pas négatifs entrent en jeu, car les valeurs par défaut de `start` et `stop` s’inversent.

La référence du langage Python sur le slicing précise ces valeurs par défaut avec exactitude : la borne inférieure manquante devient 0 pour les pas positifs et la fin de la séquence pour les pas négatifs.

La réponse courte pour [:] , [a:] et [:b]

• `a[:]` — copie toute la liste, du premier au dernier élément, avec un pas de 1.
• `a[n:]` — tout ce qui va de l’indice `n` jusqu’à la fin.
• `a[:n]` — tout ce qui va jusqu’à, mais sans inclure, l’indice `n`.

En entretien, gardez l’explication aussi simple. Trop développer les valeurs par défaut signale de l’incertitude, pas de la profondeur. Si l’intervieweur veut davantage, il vous le demandera.

Ce que cela donne en pratique

`a[:]` sur `[0, 1, 2, 3, 4, 5]` renvoie `[0, 1, 2, 3, 4, 5]` — une nouvelle liste contenant les mêmes éléments. C’est une copie superficielle, ce qui comptera pour la question de suivi (j’y reviens à la section 4). `a[3:]` renvoie `[3, 4, 5]`. L’omission change l’intervalle, pas la règle. La règle reste toujours la même : `start` est inclus, `stop` est exclu, `step` est l’incrément.

Gérez les indices négatifs et les tranches inversées sans tourner autour du pot

Pourquoi les indices négatifs paraissent évidents… jusqu’à ce qu’ils ne le soient plus

La notation de slicing de Python accepte les indices négatifs, et le modèle mental est simple : `-1` est le dernier élément, `-2` l’avant-dernier, et ainsi de suite. La raison structurelle pour laquelle on se trompe sous pression, c’est qu’on suit deux choses en même temps — la forme actuelle de la liste et le décalage négatif — et lorsqu’on raisonne sur une liste hypothétique ou en cours de modification, l’arithmétique dérape.

La bonne manière de penser est la suivante : un indice négatif `i` sur une liste de longueur `n` équivaut à `n + i`. Donc, sur une liste de six éléments, `-2` correspond à l’indice 4. Appuyez-vous sur cette conversion et les calculs restent stables.

Pourquoi un pas négatif inverse toute la logique

Un pas négatif inverse le sens de parcours. `a[::-1]` parcourt la liste de la fin vers le début, un élément à la fois. Le piège, c’est que lorsque `step` est négatif, la valeur par défaut de `start` devient la fin de la liste et celle de `stop` devient avant le début — ce qui explique pourquoi `a[::-1]` inverse correctement toute la liste sans bornes explicites.

L’erreur d’entretien la plus courante : écrire `a[0:-1:-1]` en s’attendant à un renversement, puis obtenir une liste vide. La raison est qu’avec `step = -1`, vous demandez à Python de parcourir la liste à rebours depuis l’indice 0 jusqu’à l’indice `-1` (qui est le dernier élément) — mais cette direction n’atteint jamais `stop`, donc elle ne renvoie rien. L’indice de `stop` reste exclusif, et le sens de parcours détermine ce que « exclusif » veut dire.

Une vraie question d’entretien qui teste bien cela : « Inversez les trois derniers éléments d’une liste sans utiliser `reverse()`. » La réponse est `a[-3:][::-1]` — on isole d’abord la fin de la liste, puis on l’inverse. Cette approche en deux étapes est plus propre et moins risquée que d’essayer d’écrire d’un coup une tranche avec bornes et pas négatifs.

Ce que cela donne en pratique

Sur `a = [0, 1, 2, 3, 4, 5]` :

• `a[-3:]` renvoie `[3, 4, 5]` — les trois derniers éléments.
• `a[::-1]` renvoie `[5, 4, 3, 2, 1, 0]` — inversion complète.
• `a[-1:-4:-1]` renvoie `[5, 4, 3]` — les trois derniers en ordre inverse, avec des bornes négatives explicites.

Comparez ces deux approches d’inversion de la fin de la liste et la direction des bornes devient concrète plutôt qu’abstraite.

Répondez au piège copie versus vue avant qu’il ne vous réponde

Le slicing renvoie t il une copie ou une vue ?

Pour les listes Python ordinaires, le slicing renvoie toujours une nouvelle liste — une copie superficielle. Ce n’est pas une vue. C’est l’un des pièges du slicing Python qui surprend les candidats ayant travaillé avec NumPy, où le slicing renvoie bien une vue et où les mutations se répercutent sur le tableau d’origine. La distinction compte, car lorsqu’un recruteur demande « est-ce une copie ou une vue ? », il vérifie si vous comprenez l’identité des objets, pas seulement la syntaxe.

La réponse courte : « Le slicing d’une liste renvoie un nouvel objet liste. Modifier la tranche n’affecte pas l’original — sauf si la liste contient des objets mutables. » C’est cette dernière précision qui porte la vraie relance.

Pourquoi les listes imbriquées rendent la réponse plus subtile

La réponse simpliste « c’est une copie » est correcte au premier niveau et fausse au niveau imbriqué. Quand vous tranchez une liste de listes, vous obtenez une nouvelle liste externe — mais les listes internes ne sont pas copiées. Ce sont les mêmes objets, référencés à deux endroits. Modifiez une liste interne via la tranche, et vous modifiez aussi l’original.

C’est le comportement de copie superficielle documenté dans la bibliothèque standard de Python. Une copie profonde — `copy.deepcopy()` — dupliquerait aussi les objets imbriqués. Les recruteurs adorent ce suivi, car il révèle si le candidat raisonne en mémoire ou se contente de reconnaître un motif syntaxique.

Ce que cela donne en pratique

La liste externe est un nouvel objet — `sliced is not original` vaut `True`. Mais `sliced[0] is original[0]` vaut aussi `True`. La mutation effectuée via la tranche a touché la liste interne partagée. En revue de code, c’est le genre de bug qui prend vingt minutes à trouver et cinq secondes à expliquer une fois qu’on comprend ce que signifie copie superficielle.

Considérez les dépassements de bornes et les tranches vides comme une fonctionnalité, pas comme un bug

Que se passe t il lorsque la tranche dépasse les extrémités ?

Contrairement à l’indexation directe — où `a[10]` sur une liste de six éléments lève un `IndexError` — le slicing ne lève jamais d’erreur pour des bornes hors limites. Python ajuste silencieusement les bornes. Si vous écrivez `a[0:100]` sur une liste de six éléments, vous obtenez les six. Si vous écrivez `a[-100:]`, vous obtenez toute la liste depuis le début.

C’est intentionnel, et cela apparaît souvent dans les questions d’entretien sur le slicing Python précisément parce que les candidats s’attendent à un échec. Ce n’est pas le cas. Le langage considère les bornes hors plage comme « aussi loin que possible dans cette direction ».

Pourquoi les tranches vides apparaissent en entretien

Le piège, c’est qu’une tranche qui semble fausse peut renvoyer une liste vide plutôt qu’une erreur, et cette liste vide est la bonne réponse. Les candidats qui s’attendent à une exception doutent parfois d’eux-mêmes et sur-analysent la situation, ce qui signale de l’incertitude.

La règle simple : si `start` est déjà au-delà de `stop`, ou à sa hauteur, dans le sens du parcours, le résultat est `[]`. Aucune exception, aucun avertissement.

Ce que cela donne en pratique

Sur `a = [0, 1, 2, 3, 4, 5]` :

• `a[2:100]` renvoie `[2, 3, 4, 5]` — bornes ramenées à la fin.
• `a[4:2]` renvoie `[]` — `start` est au-delà de `stop` avec un pas positif, donc il n’y a rien à collecter.
• `a[4:2:-1]` renvoie `[4, 3]` — mêmes bornes, pas négatif, il existe maintenant un intervalle valable à parcourir à rebours.

La différence entre les deux derniers tient au sens de parcours. Mêmes nombres, signe du pas opposé, résultats complètement différents. C’est le genre de détail qui distingue une réponse apprise par cœur d’une réponse solide.

Sachez quand le slicing modifie la liste et quand il se contente d’en créer une nouvelle

Comment fonctionne réellement l’affectation par tranche ?

L’affectation par tranche — `a[1:3] = [10, 20]` — modifie la liste originale en place. Elle remplace les éléments aux positions indiquées par les nouvelles valeurs. Pour les tranches contiguës, la taille de la valeur de remplacement peut être différente de celle de la tranche remplacée, et Python ajuste alors la taille de la liste en conséquence.

La subtilité des tranches étendues est l’endroit où les recruteurs deviennent créatifs. Une tranche étendue utilise un pas différent de 1 — par exemple, `a[::2] = [10, 20, 30]`. Pour les tranches étendues, la valeur de remplacement doit exactement avoir la même longueur que le nombre de positions sélectionnées par la tranche. Si vous ne respectez pas cette règle, Python lève un `ValueError`. C’est une règle que presque personne ne retient avant de l’avoir rencontrée en production ou en entretien.

D’après la documentation du modèle de données de Python, la contrainte d’égalité de longueur pour les tranches étendues est explicite et non négociable.

En quoi la suppression par tranche est elle différente du slicing normal ?

`del a[1:3]` supprime ces éléments de la liste originale. Ce n’est pas la même chose que `a[1:3] = []`, même si le résultat final est identique pour les tranches contiguës. La distinction conceptuelle compte : la suppression est une instruction qui retire des éléments ; l’affectation les remplace. Pour les tranches étendues, `del a[::2]` supprime un élément sur deux sans contrainte de longueur — la suppression n’exige pas de remplacement de taille égale.

Lors d’un débogage, l’échec d’une affectation par tranche étendue avec un `ValueError` est l’un de ces messages d’erreur qui semblent totalement mystérieux jusqu’à ce que vous connaissiez la règle d’égalité des longueurs. Une fois la règle connue, le message devient immédiatement logique.

Ce que cela donne en pratique

La différence de mutation est l’essentiel : le slicing normal lit une liste et en renvoie une nouvelle ; l’affectation et la suppression par tranche écrivent dans l’original.

Concluez avec les questions que les recruteurs recyclent sans cesse

Quelles sont les questions de slicing les plus fréquentes ?

D’après les tendances observées dans les entretiens techniques et les mock interviews, les questions récurrentes se regroupent autour de six thèmes : la syntaxe de base `start:stop:step`, la raison pour laquelle `stop` est exclusif, les valeurs par défaut des bornes omises, l’interaction entre indices négatifs et pas négatifs, la question de savoir si le slicing renvoie une copie ou une vue (et ce que cela implique pour les listes imbriquées), ainsi que l’affectation par tranche avec sa règle de longueur pour les tranches étendues.

Ce ne sont pas des questions aléatoires. Elles correspondent directement aux bugs les plus fréquents écrits par les développeurs Python en production : erreurs off-by-one, mutations accidentelles via des copies superficielles et résultats vides inattendus après inversion.

Pourquoi ces questions testent en réalité votre jugement

L’entretien ne vise pas un quiz de culture générale. Une question comme « que renvoie `a[4:2:-1]` ? » teste votre capacité à raisonner simultanément sur les bornes et la direction sous contrainte de temps. La recherche de SHRM sur les entretiens techniques structurés montre de façon constante que les meilleures questions techniques sont celles qui révèlent comment un candidat pense, et pas seulement ce qu’il a mémorisé. Les cas limites du slicing sont idéaux pour cela, parce que la syntaxe de surface est assez simple pour qu’un candidat préparé la connaisse, mais les relances exigent un vrai raisonnement.

Ce que cela donne en pratique

Voici un exercice compact de mock interview. Pour chaque question, la forme de la réponse courte compte davantage que les mots exacts :

• « Que renvoie `a[1:4]` sur `[0,1,2,3,4,5]` ? » → `[1, 2, 3]`. `start` inclus, `stop` exclus.
• « Pourquoi `stop` est-il exclusif ? » → Pour que `stop - start` soit égal à la longueur de la tranche et que les tranches adjacentes se partitionnent proprement.
• « Que renvoie `a[:]` ? » → Une copie superficielle de toute la liste.
• « Que fait `a[::-1]` ? » → Inverse la liste en la parcourant à rebours avec les bornes par défaut.
• « Le slicing modifie-t-il l’original ? » → Non — le slicing renvoie une nouvelle liste. L’affectation par tranche modifie l’original.
• « Que se passe-t-il avec `a[0:100]` ? » → Renvoie toute la liste. Les bornes sont ajustées silencieusement ; il n’y a pas d’erreur.
• « Quel est le piège avec les listes imbriquées et le slicing ? » → Copie superficielle : les objets internes sont partagés, donc une mutation via la tranche modifie aussi le contenu imbriqué de l’original.

Parcourez cette liste une fois avant votre entretien. Pas pour mémoriser les mots, mais pour vérifier que le raisonnement derrière chaque réponse est assez solide pour résister à une relance.

Comment Verve AI peut vous aider à réussir votre entretien de codage sur le slicing des listes Python

La vraie difficulté des questions de slicing Python n’est pas d’apprendre les règles — c’est de les expliquer à voix haute, dans l’ordre, pendant qu’un intervieweur observe et enchaîne les relances en temps réel. C’est une compétence de performance, qui ne s’améliore qu’avec une pratique en direct face à des relances imprévisibles. Verve AI Coding Copilot a été conçu précisément pour ce manque : il lit votre écran pendant que vous travaillez sur un problème sur LeetCode, HackerRank ou CodeSignal, et affiche des suggestions contextuelles basées sur ce que vous faites réellement — pas un indice générique supposant que vous êtes bloqué au même endroit que tous les autres candidats. Si vous travaillez sur un problème de slicing et que l’intervieweur vous demande pourquoi votre tranche est vide, Verve AI Coding Copilot peut afficher immédiatement l’explication liée au sens de parcours, sans vous laisser patauger. Le mode Secondary Copilot vous permet de rester concentré sur un seul problème pendant de longues périodes sans perdre le fil, ce qui compte quand un entretien technique fait dériver une question de slicing vers une discussion plus large sur les structures de données. Lors des tours techniques en direct comme des exercices de codage asynchrones, Verve AI Coding Copilot suggère des réponses en direct tout en restant invisible — ainsi, le raisonnement que vous exposez paraît bien être le vôtre, parce qu’il s’appuie sur ce que vous êtes déjà en train de penser.

---

Le sentiment de pression que vous avez ressenti la première fois où vous êtes resté bloqué sur « pourquoi `stop` est-il exclusif ? » ne disparaît pas en lisant davantage de documentation. Il disparaît lorsque vous pouvez expliquer la syntaxe, les valeurs par défaut, le sens de parcours, la sémantique de copie et la mutation sans vous embrouiller — dans cet ordre, sous pression, avec une relance imminente. C’est là tout l’enjeu. Reprenez une fois de plus les sept questions d’entraînement de la dernière section avant votre entretien. Pas pour ajouter du contenu, mais pour vous assurer que le raisonnement derrière chaque réponse est assez rapide pour survivre à la relance. Si c’est le cas, vous êtes prêt.