Listes, tuples et tranches
Maîtrisez les opérations sur les listes Python, la syntaxe des tranches et l’immuabilité des tuples grâce à des exemples pratiques tirés de défis classiques de programmation.
Listes, tuples et tranches est une leçon DSA Interview Prep gratuite sur CoddyKit. Ceci est la leçon 1 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage DSA Interview Prep, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours DSA Interview Prep comprend 4 leçons au total.
Listes Python : tableaux dynamiques
Une liste Python est un tableau dynamique qui peut contenir n’importe quoi et qui s’agrandit automatiquement. Elle est ordonnée, modifiable et offre un accès immédiat en O(1) par indice. Le code présente les notions de base.
nums = [3, 1, 4, 1, 5]
print(nums[0]) # 3
print(nums[-1]) # 5 (last element)
nums.append(9)
print(len(nums)) # 6Opérations courantes sur les listes
Vous devez connaître ces opérations par cœur : append et pop à la fin s’exécutent en O(1), mais insert au début s’exécute en O(n). Évitez remove dans les boucles serrées : l’opération reparcourt la liste à chaque fois.
stack = []
stack.append(1)
stack.append(2)
stack.append(3)
print(stack.pop()) # 3 O(1)
print(stack) # [1, 2]
# insert at index 0 is O(n)
stack.insert(0, 0)
print(stack) # [0, 1, 2]Syntaxe du découpage expliquée
Le découpage s’écrit lst[start:stop:step] et s’arrête juste avant stop. L’astuce classique : un pas de -1 inverse une liste sans la modifier. Le code présente chaque forme.
a = [0, 1, 2, 3, 4, 5]
print(a[1:4]) # [1, 2, 3]
print(a[:3]) # [0, 1, 2]
print(a[3:]) # [3, 4, 5]
print(a[::2]) # [0, 2, 4] every other
print(a[::-1]) # [5, 4, 3, 2, 1, 0] reversedLe découpage crée des copies superficielles
Voici un piège pratique : le découpage crée toujours une nouvelle liste, donc modifier la partie découpée ne modifie pas l’originale. Mais la copie est superficielle : les listes imbriquées restent donc partagées. Soyez vigilant.
original = [1, 2, 3]
copy = original[:] # shallow copy
copy[0] = 99
print(original) # [1, 2, 3] unchanged
# Nested list pitfall
nested = [[1, 2], [3, 4]]
shallow = nested[:]
shallow[0][0] = 99
print(nested) # [[99, 2], [3, 4]] changed!Tuples : séquences immuables
Un tuple utilise des parenthèses et ne peut plus être modifié une fois créé. Comme il est hachable, il peut servir de clé de dictionnaire ou de membre d’un ensemble, ce qui est parfait pour les paires (ligne, colonne) dans les problèmes sur des grilles.
point = (3, 7)
print(point[0]) # 3
# Use as dict key
grid = {}
grid[(0, 0)] = 'start'
grid[(2, 3)] = 'end'
print(grid[(0, 0)]) # start
# Unpacking
x, y = point
print(x, y) # 3 7Quand utiliser un tuple plutôt qu’une liste
Choisissez un tuple lorsque les données ne doivent pas changer, et une liste lorsqu’elles doivent pouvoir être modifiées. Les tuples utilisent également un peu moins de mémoire, ce qui finit par compter dans les grands tas de Dijkstra.
import sys
a_list = [1, 2, 3, 4, 5]
a_tuple = (1, 2, 3, 4, 5)
print(sys.getsizeof(a_list)) # e.g. 104 bytes
print(sys.getsizeof(a_tuple)) # e.g. 80 bytes
# Tuple returned from function
def min_max(nums):
return min(nums), max(nums)
lo, hi = min_max([3, 1, 4, 1, 5])
print(lo, hi) # 1 5Erreurs de décalage d’une unité lors du découpage
Les erreurs de décalage d’une unité sont le principal piège des problèmes sur les tableaux. Retenez que lst[i:j] renvoie exactement j-i éléments. Pour séparer au milieu, la partie gauche est lst[:mid] et la partie droite est lst[mid:].
lst = [1, 2, 3, 4, 5, 6]
mid = len(lst) // 2 # 3
left = lst[:mid] # [1, 2, 3]
right = lst[mid:] # [4, 5, 6]
print(left, right)
# How many elements?
print(len(lst[2:5])) # 3 (indices 2,3,4)Indices négatifs en entretien
Python accepte les indices négatifs : lst[-1] désigne le dernier élément et lst[-2] celui qui le précède. Préférez lst[-1] à lst[len(lst)-1] : les recruteurs remarquent cette version plus claire.
s = 'abcde'
print(s[-1]) # 'e'
print(s[-3:]) # 'cde'
print(s[:-2]) # 'abc' (all except last 2)
nums = [10, 20, 30, 40]
print(nums[-2]) # 30
nums[-1] = 99
print(nums) # [10, 20, 30, 99]Tri et comparaison des listes
Le tri de Python utilise Timsort (O(n log n), stable). lst.sort() modifie la liste sur place, tandis que sorted(lst) en renvoie une nouvelle. Utilisez l’option key pour définir un ordre personnalisé. Consultez le code.
words = ['banana', 'fig', 'apple', 'kiwi']
words.sort(key=len)
print(words) # ['fig', 'kiwi', 'apple', 'banana']
nums = [3, 1, 4, 1, 5]
print(sorted(nums, reverse=True)) # [5, 4, 3, 1, 1]
print(nums) # unchanged: [3, 1, 4, 1, 5]Modifier des listes pendant leur parcours
Un piège classique : n’ajoutez ni ne supprimez jamais d’éléments pendant que vous parcourez une liste ; vous risquez de sauter des éléments ou de provoquer un plantage. Construisez plutôt une nouvelle liste avec une compréhension.
# WRONG — skips elements
nums = [1, 2, 3, 4, 5]
for n in nums:
if n % 2 == 0:
nums.remove(n) # skips 4!
print(nums) # [1, 3, 5]... but 4 got skipped? Actually removes 2,4
# CORRECT — build new list
nums = [1, 2, 3, 4, 5]
nums = [n for n in nums if n % 2 != 0]
print(nums) # [1, 3, 5]Dépaquetage de tuples dans les boucles
Le dépaquetage de tuples permet de garder des boucles claires : enumerate fournit (index, value) et zip parcourt deux listes ensemble. La syntaxe *rest récupère la fin dans sa propre variable. Consultez le code.
nums = [10, 20, 30]
for i, v in enumerate(nums):
print(i, v)
# 0 10 / 1 20 / 2 30
a = [1, 2, 3]
b = ['x', 'y', 'z']
for x, y in zip(a, b):
print(x, y)
first, *rest = [1, 2, 3, 4]
print(first, rest) # 1 [2, 3, 4]Vérification rapide
Vérification rapide : montrez ce que vous avez retenu sur les listes, les tuples et le découpage en Python. Vous y arriverez. 💪
Récapitulatif de la leçon
Récapitulatif : les listes sont des tableaux dynamiques dont l’ajout avec append s’effectue en O(1), le découpage renvoie toujours une copie indépendante et les tuples sont immuables et hachables. Ensuite : les dictionnaires et les ensembles.
Questions Fréquemment Posées
La leçon « Listes, tuples et tranches » est-elle gratuite ?
Oui — le texte complet de « Listes, tuples et tranches » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours DSA Interview Prep, passe à CoddyKit PRO. Le cours DSA Interview Prep comprend 4 leçons au total.
Qu'est-ce que j'apprendrai dans « Listes, tuples et tranches » ?
Maîtrisez les opérations sur les listes Python, la syntaxe des tranches et l’immuabilité des tuples grâce à des exemples pratiques tirés de défis classiques de programmation. Tu pratiques DSA Interview Prep avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.
Dois-je avoir de l'expérience pour commencer DSA Interview Prep ?
Aucune expérience préalable n'est requise. DSA Interview Prep sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 1 sur 4.
Combien de temps prend la leçon « Listes, tuples et tranches » ?
La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.
Peux-tu écrire et exécuter du code dans cette leçon DSA Interview Prep ?
Oui. Chaque leçon DSA Interview Prep inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.
Toutes les leçons de ce cours
- Listes, tuples et tranches
- Dictionnaires et ensembles en Python
- Compréhensions et fonctions intégrées
- Fonctions, fermetures et lambda