10 - Tranches

Les exercices se font dans Thonny, dans le fichier 10_tranches.py.

Cours associé : 11 - Tranches .

Note : les tranches de listes et de chaînes ne sont pas exigibles au programme officiel de NSI première. Cette fiche est proposée comme approfondissement : les tranches sont 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]

2. Que renvoie "Bonjour"[::-1] ?

• A. "Bonjour"
• B. "ruojnoB"
• C. "B"
• D. Une erreur

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]

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]

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]

Exercice 2 : extraction de sous-chaînes

Soit la chaîne phrase = "Numérique et Sciences Informatiques". Extraire :

1. le mot "Numérique", avec une tranche ;

   Indice

   phrase[début:fin] contient les caractères de l’indice début inclus à l’indice fin exclu. Compter les lettres du mot cherché pour choisir fin.

2. le mot "Informatiques", avec une tranche ;

   Indice

   Un indice négatif compte depuis la fin : phrase[-3:] donne les trois derniers caractères.

3. les initiales "NSI", en concaténant les caractères obtenus par leur indice (en choisissant les bons indices).

   Indice

   phrase[0] est le N. Les deux autres initiales suivent chacune un espace : compter leur position, puis concaténer les trois caractères avec +.

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, 13, 22
# Pas de pas régulier évident, donc on concatène :
print(phrase[0] + phrase[13] + phrase[22])  # "NSI"

Exercice 3 : palindrome

Un palindrome est un mot qui se lit de la même façon dans les deux sens, comme "kayak" ou "radar".

1. Écrire une fonction est_palindrome(mot) qui renvoie True si le mot est un palindrome, en utilisant une tranche.

   print(est_palindrome("kayak"))  # True
   print(est_palindrome("python")) # False
   

   Indice

   Une tranche de pas -1 lit une chaîne à l’envers : "kayak"[::-1] vaut "kayak", alors que "python"[::-1] vaut "nohtyp". Dans la fonction, comparer la variable mot (de type chaîne de caractères) au mot écrit à l’envers : la fonction renvoie True si les deux sont identiques, et False sinon.

2. Sans tranche, écrire une fonction est_palindrome_boucle(mot) qui fait le même travail : partir d’une chaîne vide, y construire le mot écrit à l’envers avec une boucle for, puis le comparer à mot.

   print(est_palindrome_boucle("kayak"))  # True
   print(est_palindrome_boucle("python")) # False
   

   Indice

   Parcourir mot lettre par lettre et ajouter chaque lettre devant la chaîne déjà construite : en partant de "", le mot "abc" donne "a", puis "ba", puis "cba". La fonction renvoie ensuite True si cette chaîne est identique à mot, et False sinon.

   Code à copier puis compléter

   def est_palindrome_boucle(mot):
       envers = ""
       for lettre in mot:
           envers = ...
       return ...
   

def est_palindrome(mot):
    """Vérifie si mot est un palindrome grâce à une tranche.

    >>> est_palindrome("kayak")
    True
    >>> est_palindrome("python")
    False
    >>> est_palindrome("radar")
    True
    >>> est_palindrome("")
    True
    """
    return mot == mot[::-1]

def est_palindrome_boucle(mot):
    """Vérifie si mot est un palindrome sans tranche, en construisant le mot à l'envers.

    >>> est_palindrome_boucle("kayak")
    True
    >>> est_palindrome_boucle("python")
    False
    """
    envers = ""
    for lettre in mot:
        envers = lettre + envers
    return envers == mot

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 les tranches et la concaténation de listes.

def rotation(L, k):
    return L[-k:] + L[...]

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]

Exercice 5 : éléments pairs aux positions impaires

Soit la liste L = [3, 8, 5, 12, 7, 4, 9, 16, 1, 6]. Avec une tranche, 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 ?

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]

Exercice 6 : défi des tranches

Soit la liste data = ['A', 0, 'B', 1, 'C', 2, 'D', 3, 'E', 4]. Obtenir chaque résultat avec une seule tranche.

1. Toutes les lettres : ['A', 'B', 'C', 'D', 'E'].

   Indice

   Les lettres sont aux indices pairs : partir de l’indice 0 avec un pas de 2.

2. Tous les chiffres dans l’ordre inverse : [4, 3, 2, 1, 0].

   Indice

   Les chiffres sont aux indices impairs ; pour les lire à l’envers, partir du dernier élément avec un pas de -2.

3. La sous-liste ['D', 2, 'C'].

   Indice

   Avec un pas de -1, la lecture recule : data[début:fin:-1] va de début inclus jusqu’à fin exclu. Prendre pour début l’indice de 'D', et pour fin l’indice de la case située juste à gauche de 'C'.

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