Quelle est la différence entre une liste et un tuple en Python ?

Une liste est mutable : on peut la modifier après création (ajouter, supprimer, remplacer des éléments). Un tuple est immuable : une fois créé, on ne peut plus le modifier. En NSI, on utilise un tuple pour des données fixes comme un point (x, y), et une liste pour des données évolutives comme des notes.

Pourquoi le premier indice d'une liste Python est-il 0 ?

En Python (comme en C ou Java), les indices commencent à 0 car ils représentent un décalage par rapport au début de la structure en mémoire. Le premier élément est à l'indice 0, le deuxième à 1, etc. Le dernier élément est donc à l'indice len(liste) - 1.

Comment copier une liste sans modifier l'originale en Python ?

Il faut créer une nouvelle liste avec liste.copy(), liste[:] ou list(liste). Attention : b = a ne copie pas la liste, cela crée une seconde référence vers le même objet en mémoire. Pour une liste 2D, utilise copy.deepcopy du module copy.

Quelle est la différence entre sort() et sorted() en Python ?

sort() est une méthode qui trie la liste sur place et renvoie None. sorted() est une fonction qui renvoie une nouvelle liste triée sans modifier l'originale. En NSI, il faut savoir choisir selon que l'on veuille conserver ou non l'ordre initial.

Comment parcourir une liste Python avec l'indice et la valeur en même temps ?

On utilise la fonction enumerate : for i, valeur in enumerate(liste): ... Cela évite d'écrire for i in range(len(liste)) et d'accéder ensuite à liste[i]. C'est plus lisible et considéré comme plus pythonique.

Comment créer un tableau 2D en Python sans piège ?

Il faut éviter [[0]*3]*3 car cela crée trois références vers la même ligne. On utilise plutôt une compréhension de liste : [[0]*3 for _ in range(3)]. Chaque ligne est alors un objet distinct, et modifier une case n'affecte pas les autres.

Les listes Python sont-elles au programme du bac NSI ?

Oui, les listes font partie des structures de données fondamentales du programme de Première et Terminale NSI. Elles apparaissent dans les algorithmes de tri, de recherche, dans la manipulation de tableaux 2D et dans de nombreux exercices de l'épreuve pratique et écrite.

Listes Python NSI : le guide complet des tableaux

En NSI, tu vas très vite rencontrer un type de données qui revient partout : la liste Python. Que ce soit pour stocker des notes, des pixels d'une image, des scores de jeu ou des données issues d'un fichier CSV, les listes sont au cœur du programme. Si tu débutes, elles peuvent paraître simples… et pourtant, beaucoup d'erreurs classiques viennent d'une mauvaise compréhension des indices, des méthodes ou des copies de listes. Dans ce guide complet, on va décortiquer ensemble les listes Python en NSI, aussi appelées tableaux dans d'autres langages, avec des exemples testables et des conseils pour l'épreuve du bac.

Qu'est-ce qu'une liste en Python ?

Une liste (en anglais list) est une structure de données mutable et ordonnée qui permet de stocker plusieurs valeurs dans une seule variable. En NSI, on parle souvent de tableaux Python pour désigner ces listes, même si en Python le mot « tableau » peut aussi désigner un objet du module array ou de la bibliothèque numpy. Au lycée, c'est la liste native qui est utilisée.

Quelques caractéristiques essentielles :

Ordonnée : chaque élément a une position précise, appelée indice.
Indexée à partir de 0 : le premier élément est à l'indice 0, pas 1.
Mutable : on peut modifier, ajouter ou supprimer des éléments après création.
Hétérogène : une liste peut contenir des entiers, des chaînes, d'autres listes…

En Python, une liste s'écrit entre crochets [ ], avec des éléments séparés par des virgules.

notes = [12, 15, 8, 17, 14]
fruits = ["pomme", "banane", "cerise"]
mixte = [1, "deux", 3.0, True]

Attention : en NSI, on distingue bien la liste (mutable) du tuple (immutable, écrit entre parenthèses). Le tuple sert quand les données ne doivent pas changer, par exemple pour représenter un point (x, y).

Indices, tranches et opérations de base

Accéder à un élément

On accède à un élément grâce à son indice entre crochets. Le premier indice est 0.

notes = [12, 15, 8, 17, 14]
print(notes[0])   # 12
print(notes[2])   # 8
print(notes[-1])  # 14 (dernier élément)
print(notes[-2])  # 17 (avant-dernier)

Les indices négatifs permettent de partir de la fin : -1 est le dernier, -2 l'avant-dernier, etc. Très pratique pour éviter de calculer len(notes) - 1.

Longueur d'une liste

La fonction len() renvoie le nombre d'éléments. C'est indispensable pour parcourir une liste avec une boucle for en utilisant les indices.

notes = [12, 15, 8, 17, 14]
print(len(notes))  # 5

Tranches (slicing)

Une tranche extrait une sous-liste. La syntaxe est liste[début:fin], où fin est exclu.

notes = [12, 15, 8, 17, 14]
print(notes[1:4])   # [15, 8, 17]
print(notes[:3])    # [12, 15, 8]
print(notes[2:])    # [8, 17, 14]
print(notes[::2])   # [12, 8, 14] (un élément sur deux)

Concaténation et répétition

L'opérateur + concatène deux listes, et * répète une liste.

a = [1, 2]
b = [3, 4]
print(a + b)    # [1, 2, 3, 4]
print(a * 3)    # [1, 2, 1, 2, 1, 2]

Test d'appartenance

L'opérateur in teste si une valeur est présente dans la liste.

notes = [12, 15, 8, 17, 14]
print(15 in notes)   # True
print(20 in notes)   # False

Les méthodes essentielles des listes

Les listes possèdent de nombreuses méthodes. Voici celles du programme NSI que tu dois absolument connaître.

append(x) : ajoute x à la fin.
insert(i, x) : insère x à l'indice i.
pop() ou pop(i) : retire et renvoie le dernier élément, ou celui d'indice i.
remove(x) : retire la première occurrence de x.
index(x) : renvoie l'indice de la première occurrence de x.
count(x) : compte les occurrences de x.
sort() : trie la liste sur place (modifie la liste).
reverse() : inverse la liste sur place.
extend(l) : ajoute tous les éléments de l à la fin.

notes = [12, 15, 8]
notes.append(17)        # [12, 15, 8, 17]
notes.insert(1, 20)     # [12, 20, 15, 8, 17]
notes.remove(15)        # [12, 20, 8, 17]
valeur = notes.pop()    # valeur = 17, notes = [12, 20, 8]
notes.sort()            # [8, 12, 20]
notes.reverse()         # [20, 12, 8]
print(notes.index(12))  # 1
print(notes.count(20))  # 1

⚠️ Piège fréquent : sort() modifie la liste et renvoie None. Si tu écris notes = notes.sort(), ta variable devient None. Pour obtenir une nouvelle liste triée sans modifier l'originale, utilise sorted(notes).

Parcourir une liste : deux méthodes

Parcours par élément

C'est le parcours le plus simple, quand tu n'as pas besoin de l'indice.

notes = [12, 15, 8, 17, 14]
somme = 0
for note in notes:
    somme += note
moyenne = somme / len(notes)
print(moyenne)  # 13.2

Parcours par indice

Utile quand tu dois modifier les éléments ou connaître leur position.

notes = [12, 15, 8, 17, 14]
for i in range(len(notes)):
    if notes[i] < 10:
        notes[i] = 10  # on remonte les notes sous 10
print(notes)  # [12, 15, 10, 17, 14]

La fonction enumerate

enumerate renvoie à la fois l'indice et l'élément. Très pratique et plus pythonique.

fruits = ["pomme", "banane", "cerise"]
for i, fruit in enumerate(fruits):
    print(i, fruit)
# 0 pomme
# 1 banane
# 2 cerise

Les listes en compréhension

Une liste en compréhension permet de construire une liste en une seule ligne. C'est au programme de Première NSI et très apprécié des correcteurs.

carres = [x**2 for x in range(10)]
print(carres)  # [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

# Avec condition
pairs = [x for x in range(20) if x % 2 == 0]
print(pairs)  # [0, 2, 4, 6, 8, 10, 12, 14, 16, 18]

Attention à ne pas en abuser : si la logique devient complexe, une boucle classique est plus lisible. En NSI, la clarté du code compte autant que son efficacité.

Listes de listes : les tableaux 2D

Une liste peut contenir d'autres listes : on parle alors de liste de listes ou tableau 2D. C'est la structure utilisée pour représenter une grille, une matrice ou une image.

grille = [
    [1, 2, 3],
    [4, 5, 6],
    [7, 8, 9]
]
print(grille[0][1])  # 2 (ligne 0, colonne 1)
print(grille[2][2])  # 9

Pour parcourir un tableau 2D, on utilise deux boucles imbriquées :

for ligne in grille:
    for valeur in ligne:
        print(valeur, end=" ")
    print()
# 1 2 3
# 4 5 6
# 7 8 9

⚠️ Piège classique : ne crée jamais une matrice avec [[0]*3]*3. Cela crée 3 références vers la même ligne. Modifier une case modifie les trois lignes ! Utilise plutôt :

matrice = [[0]*3 for _ in range(3)]

Copier une liste : le piège des références

En Python, une variable qui contient une liste ne stocke pas la liste elle-même, mais une référence vers celle-ci. Donc b = a ne copie pas la liste : a et b pointent vers le même objet.

a = [1, 2, 3]
b = a
b.append(4)
print(a)  # [1, 2, 3, 4] 😱

Pour faire une vraie copie, plusieurs solutions :

a = [1, 2, 3]
b = a.copy()        # copie superficielle
c = a[:]            # copie par tranche
d = list(a)         # copie via constructeur

Pour une copie en profondeur (utile pour les listes 2D), il faut utiliser copy.deepcopy du module copy. Ce point est souvent source d'erreurs lors des projets NSI.

Cas d'usage concret : calculer des statistiques

Imaginons que tu récupères les notes d'une classe dans une liste et que tu veuilles calculer la moyenne, la note maximale et le nombre d'élèves ayant la moyenne.

notes = [12, 15, 8, 17, 14, 9, 11, 18, 6, 13]

# Moyenne
moyenne = sum(notes) / len(notes)

# Note maximale et minimale
maximum = max(notes)
minimum = min(notes)

# Nombre d'élèves ayant la moyenne
nb_moyens = 0
for note in notes:
    if note >= 10:
        nb_moyens += 1

print(f"Moyenne : {moyenne:.2f}")
print(f"Max : {maximum}, Min : {minimum}")
print(f"Élèves avec la moyenne : {nb_moyens}")

Ce type d'exercice est typique de l'épreuve pratique de NSI. Pense toujours à bien séparer les étapes et à vérifier les cas limites (liste vide, un seul élément).

Conseils de méthode et lien avec le bac NSI

Pour réussir sur les listes le jour de l'épreuve, garde en tête ces quelques réflexes :

Vérifie les indices : le premier est 0, le dernier est len(liste) - 1.
Attention aux mutations : sort(), append(), pop() modifient la liste. sorted(), reversed() renvoient une nouvelle liste.
Copie explicite : dès que tu veux garder l'original, fais liste.copy().
Teste avec des cas simples : liste vide, un élément, éléments identiques.
Commente ton code : les correcteurs valorisent la clarté.

Si tu veux t'entraîner, tu trouveras des exercices progressifs sur notre page d'exercices. Et si une erreur Python te bloque, jette un œil à notre guide des erreurs fréquentes en Python. Pour revoir les bases du langage, le cours de NSI est là pour ça.

Enfin, si tu veux un accompagnement plus personnalisé, n'hésite pas à consulter les ressources d'Allolycée ou d'Allobac, qui proposent des fiches et des exercices complémentaires pour préparer sereinement le bac.

Conclusion : les listes, ton outil quotidien en NSI

Les listes Python sont partout en NSI : algorithmes de tri, traitement d'images, jeux, statistiques, files et piles… Les maîtriser, c'est te donner une longueur d'avance pour toute l'année. Retiens surtout les indices qui commencent à 0, la différence entre mutation et copie, et les méthodes clés comme append, pop, sort. Entraîne-toi régulièrement sur des petits programmes : c'est la meilleure façon d'ancrer ces réflexes. Tu vas y arriver, une ligne de code à la fois ! 🚀