08 - Slicing
Note : le slicing (tranches de listes et de chaînes) n’est pas exigible au programme officiel de NSI première. Cette fiche est proposée comme approfondissement : le slicing est un outil pratique qui simplifie de nombreuses opérations sur les séquences.
QCM – vérification des prérequis
Pour chaque question, une seule réponse est correcte.
1. Que renvoie L[1:4] si L = [10, 20, 30, 40, 50] ?
- A.
[10, 20, 30, 40] - B.
[20, 30, 40] - C.
[20, 30, 40, 50] - D.
[10, 20, 30]
Correction
Réponse : B. L[1:4] extrait les éléments d’indice 1 (inclus) à 4 (exclu), soit L[1], L[2], L[3] → [20, 30, 40].
- A est faux : les indices commencent à 0, pas à 1 ; et la borne droite est exclue.
- C est faux : l’indice 4 est exclu.
- D est faux : c’est
L[0:3].
2. Que renvoie "Bonjour"[::-1] ?
- A.
"Bonjour" - B.
"ruojnoB" - C.
"B" - D. Une erreur
Correction
Réponse : B. La notation [::-1] parcourt la séquence à l’envers (pas de -1), ce qui inverse la chaîne.
- A est faux : c’est la chaîne originale, non inversée.
- C est faux : cela ne prend pas seulement le premier caractère.
- D est faux : l’expression est parfaitement valide.
3. Que renvoie L[::2] si L = [0, 1, 2, 3, 4, 5] ?
- A.
[0, 2, 4] - B.
[1, 3, 5] - C.
[0, 1] - D.
[2, 4]
Correction
Réponse : A. L[::2] prend un élément sur deux en partant de l’indice 0 : L[0], L[2], L[4] → [0, 2, 4].
- B est faux : c’est
L[1::2](qui part de l’indice 1). - C est faux : c’est
L[:2]. - D est faux : c’est
L[2::2].
4. Que renvoie L[-2:] si L = [10, 20, 30, 40, 50] ?
- A.
[10, 20] - B.
[30, 40, 50] - C.
[40, 50] - D.
[50, 40]
Correction
Réponse : C. L[-2:] prend les éléments à partir de l’avant-dernier (indice -2) jusqu’à la fin : L[-2] = 40, L[-1] = 50 → [40, 50].
- A est faux : c’est
L[:2]. - B est faux : c’est
L[-3:]. - D est faux : le slicing conserve l’ordre original.
Exercice 1 : premiers pas
Soit la liste L = [10, 20, 30, 40, 50, 60, 70, 80]. Sans exécuter le code, prédire le résultat de chaque expression, puis vérifier en Python :
L[2:5]
L[:4]
L[5:]
L[-3:]
L[1:7:2]
L[::-1]
Correction
| Expression | Résultat | Explication |
|---|---|---|
L[2:5] | [30, 40, 50] | Indices 2, 3, 4 |
L[:4] | [10, 20, 30, 40] | Du début à l’indice 3 (4 exclu) |
L[5:] | [60, 70, 80] | De l’indice 5 à la fin |
L[-3:] | [60, 70, 80] | Les 3 derniers éléments |
L[1:7:2] | [20, 40, 60] | Indices 1, 3, 5 (pas de 2) |
L[::-1] | [80, 70, 60, 50, 40, 30, 20, 10] | Liste inversée |
Exercice 2 : extraction de sous-chaînes
Soit la chaîne phrase = "Numérique et Sciences Informatiques". En utilisant uniquement le slicing, extraire :
- le mot
"Numérique"; - le mot
"Informatiques"; - les initiales
"NESI"(en choisissant les bons indices).
Correction
phrase = "Numérique et Sciences Informatiques"
# 1. "Numérique" : 9 caractères depuis le début
print(phrase[:9]) # "Numérique"
# 2. "Informatiques" : 13 caractères depuis la fin
print(phrase[-13:]) # "Informatiques"
# 3. Initiales : les caractères aux positions 0, 10, 13, 22
# Pas de pas régulier évident, donc on concatène :
print(phrase[0] + phrase[10] + phrase[13] + phrase[22]) # "NESI"
Remarque : pour la question 3, il n’existe pas de pas unique qui donne exactement les initiales, car les mots n’ont pas tous la même longueur.
Exercice 3 : palindrome
Écrire une fonction est_palindrome(mot) qui renvoie True si le mot est un palindrome (se lit de la même façon dans les deux sens), en utilisant le slicing.
print(est_palindrome("kayak")) # True
print(est_palindrome("python")) # False
Correction
def est_palindrome(mot):
"""Vérifie si mot est un palindrome grâce au slicing.
>>> est_palindrome("kayak")
True
>>> est_palindrome("python")
False
>>> est_palindrome("radar")
True
>>> est_palindrome("")
True
"""
return mot == mot[::-1]
mot[::-1] inverse la chaîne. Si la chaîne inversée est identique à l’originale, c’est un palindrome. Cette solution est concise grâce au slicing ; sans slicing, il faudrait comparer les caractères symétriques un par un.
Exercice 4 : rotation de liste
Écrire une fonction rotation(L, k) qui effectue une rotation de k positions vers la droite. Par exemple, rotation([1, 2, 3, 4, 5], 2) doit renvoyer [4, 5, 1, 2, 3].
Indication : utiliser le slicing et la concaténation de listes.
Correction
def rotation(L, k):
"""Effectue une rotation de k positions vers la droite.
>>> rotation([1, 2, 3, 4, 5], 2)
[4, 5, 1, 2, 3]
>>> rotation([1, 2, 3], 0)
[1, 2, 3]
>>> rotation([1, 2, 3], 3)
[1, 2, 3]
"""
k = k % len(L) # gérer k > len(L)
return L[-k:] + L[:-k]
Principe : L[-k:] prend les k derniers éléments, L[:-k] prend tous les éléments sauf les k derniers. La concaténation des deux donne la rotation.
Trace pour rotation([1, 2, 3, 4, 5], 2) :
L[-2:]→[4, 5]L[:-2]→[1, 2, 3]- Résultat :
[4, 5] + [1, 2, 3]→[4, 5, 1, 2, 3]
Exercice 5 : éléments pairs aux positions impaires
Soit la liste L = [3, 8, 5, 12, 7, 4, 9, 16, 1, 6]. En utilisant le slicing, extraire la sous-liste des éléments situés aux positions impaires (indices 1, 3, 5, 7, 9). Parmi ces éléments, lesquels sont pairs ?
Correction
L = [3, 8, 5, 12, 7, 4, 9, 16, 1, 6]
# Éléments aux positions impaires
impairs = L[1::2]
print(impairs) # [8, 12, 4, 16, 6]
# Parmi ceux-ci, les pairs
pairs = [x for x in impairs if x % 2 == 0]
print(pairs) # [8, 12, 4, 16, 6]
L[1::2] part de l’indice 1 et avance de 2 en 2, ce qui donne les indices 1, 3, 5, 7, 9. Tous les éléments obtenus (8, 12, 4, 16, 6) sont pairs dans cet exemple.
Exercice 6 : défi slicing
Soit la liste data = ['A', 0, 'B', 1, 'C', 2, 'D', 3, 'E', 4]. Obtenir chaque résultat avec une seule expression de slicing.
- Toutes les lettres :
['A', 'B', 'C', 'D', 'E']. - Tous les chiffres dans l’ordre inverse :
[4, 3, 2, 1, 0]. - La sous-liste
['D', 2, 'C'].
Correction
data = ['A', 0, 'B', 1, 'C', 2, 'D', 3, 'E', 4]
print(data[::2]) # depuis l'indice 0, pas de 2
print(data[::-2]) # depuis le dernier élément, pas de -2
print(data[6:3:-1]) # de l'indice 6 ('D') vers l'indice 3 exclu, pas de -1