Numérique et sciences informatiques (spécialité) · Première

Parcours séquentiel d'un tableau : cours de NSI en Première

Publié le 7 novembre 2026 · Mis à jour le 7 novembre 2026 · Signaler une erreur

L'essentiel

Parcourir un tableau séquentiellement, c'est examiner ses cases une par une, de l'indice 0 à l'indice len(t) - 1, dans l'ordre.
Deux écritures : for i in range(len(t)) quand l'indice compte, for x in t quand seule la valeur compte ; while sert quand on peut s'arrêter avant la fin.
Presque tous les algorithmes de ce chapitre suivent le schéma initialiser, boucler, mettre à jour : somme, moyenne, comptage, minimum, maximum, recherche.
Une recherche qui peut s'arrêter dès qu'on a trouvé utilise while ou un return dans la boucle ; ne conclure « absent » qu'après avoir tout parcouru.
Pièges classiques : indice hors limites, tableau vide, initialiser un maximum à 0, ajouter ou supprimer des éléments pendant qu'on parcourt le tableau.

Introduction : pourquoi parcourir un tableau ?

Un tableau range plusieurs valeurs sous un seul nom. Notes de classe, températures relevées chaque jour, pixels d'une ligne d'image : on a presque toujours besoin de regarder ces valeurs une à une pour répondre à une question. Quelle est la plus grande note ? Combien de jours dépassent 30 degrés ? Le nombre 42 est-il présent ?

Pour répondre, il n'existe pas de raccourci magique : il faut passer sur les cases. C'est ce que l'on appelle le parcours séquentiel. Dans les exercices classiques, une boucle remplit le tableau, puis une seconde boucle en relit les valeurs ⁵. Dans ce cours, tu vas apprendre à l'écrire proprement en Python, à l'adapter à plusieurs problèmes et à éviter les erreurs les plus courantes.

Tout ce chapitre repose sur une idée simple : une boucle, une ou deux variables qui mémorisent ce qu'on a vu, et un résultat à la fin. Les algorithmes que tu verras ensuite (tris, recherche dichotomique, algorithmes gloutons) réutilisent exactement ces réflexes.

Rappels : indices, longueur, accès à une case

Indices et valeurs de t = [4, 9, 2, 7]
Indice	0	1	2	3
Valeur	4	9	2	7

Indices et valeurs de t = [4, 9, 2, 7] · Le premier indice est 0, le dernier est len(t) - 1.

Le parcours par indice avec for

ExempleAfficher toutes les valeurs avec leur position

t = [4, 9, 2, 7]
for i in range(len(t)):
    print("case", i, ":", t[i])

Le programme affiche quatre lignes, de case 0 : 4 à case 3 : 7. La boucle s'exécute exactement len(t) fois.

Ce style est le bon choix quand la position compte : on veut renvoyer un indice, comparer une case à sa voisine (t[i] et t[i+1]), ou modifier la case. Pour écrire une valeur dans une case, on affecte t[i] = ..., ce qui est impossible avec la seule valeur x de l'autre style de boucle.

Le parcours par élément

MéthodeÉcrire un parcours par élément

Quand seule la valeur compte, on écrit :

for x in t:
    ...  # x est la valeur de la case courante

Python donne successivement à x la valeur de chaque case, dans l'ordre. L'écriture est plus courte et plus lisible, et elle élimine toute erreur d'indice.

ExempleCalculer la somme

def somme(t):
    s = 0
    for x in t:
        s = s + x
    return s

Avec [4, 9, 2, 7], la variable s prend successivement les valeurs 0, 4, 13, 15, puis 22. La fonction renvoie 22.

Quel style choisir ? Si ton algorithme n'utilise jamais l'indice, préfère for x in t. Si tu dois renvoyer une position, comparer des voisins ou écrire dans le tableau, utilise for i in range(len(t)).

InitialiserCréer la variable résultat avant la boucle
ParcourirPasser sur chaque case, dans l'ordre
Mettre à jourModifier la variable selon la case lue
RenvoyerRendre le résultat après la boucle

Le schéma d'un parcours avec accumulateur

Les algorithmes classiques : moyenne, comptage, extremum

Calculer le plus grand et le plus petit élément d'un tableau, ou une somme portant sur certaines valeurs seulement (par exemple les valeurs négatives), figurent parmi les exercices types d'algorithmique sur les tableaux ⁵. Tous suivent le même schéma de parcours.

MéthodeMoyenne

On calcule la somme, puis on divise par le nombre de cases.

def moyenne(t):
    s = 0
    for x in t:
        s = s + x
    return s / len(t)

Si le tableau est vide, len(t) vaut 0 et la division est impossible : on vérifie ce cas avant d'appeler la fonction, ou on le traite dans la fonction.

MéthodeComptage d'occurrences

On ajoute 1 à un compteur chaque fois que la case vérifie la condition.

def occurrences(t, v):
    c = 0
    for x in t:
        if x == v:
            c = c + 1
    return c

Le compteur est initialisé à 0 : si la valeur n'apparaît jamais, la fonction renvoie 0, ce qui est la bonne réponse.

MéthodeMaximum

On mémorise le plus grand élément vu jusqu'ici. On l'initialise avec la première case, puis on compare chaque case suivante. Déterminer le plus grand et le plus petit élément d'un tableau est un exercice classique ⁵.

def maximum(t):
    m = t[0]
    for i in range(1, len(t)):
        if t[i] > m:
            m = t[i]
    return m

Le minimum s'obtient en remplaçant > par <.

ExempleTrace d'exécution du maximum

Pour t = [4, 9, 2, 7], on suit les valeurs de m :

Tour	`i`	`t[i]`	`t[i] > m` ?	`m` après
avant				4
1	1	9	oui	9
2	2	2	non	9
3	3	7	non	9

La fonction renvoie 9. À chaque instant, m est le plus grand élément parmi les cases déjà examinées : c'est ce qui garantit que le résultat final est correct.

MéthodeMaximum et son indice

Pour connaître où se trouve le maximum, on mémorise l'indice plutôt que la valeur.

def indice_maximum(t):
    imax = 0
    for i in range(1, len(t)):
        if t[i] > t[imax]:
            imax = i
    return imax

On retrouve la valeur par t[imax]. Ce style, qui mémorise des positions, resservira pour les tris.

La recherche d'une valeur : s'arrêter quand on a trouvé

Contrairement à la somme, ici il n'est pas utile de continuer une fois la valeur trouvée. Voici deux façons de l'écrire.

ExempleVersion avec return dans la boucle

def contient(t, v):
    for x in t:
        if x == v:
            return True
    return False

Le return True interrompt la fonction dès la première correspondance. Le return False se trouve après la boucle : on ne peut dire « absent » qu'après avoir tout examiné.

ExempleVersion avec while : indice de la première occurrence

def indice(t, v):
    i = 0
    while i < len(t) and t[i] != v:
        i = i + 1
    if i < len(t):
        return i
    return None

La condition i < len(t) est écrite en premier : Python évalue de gauche à droite et s'arrête dès qu'une partie du and est fausse. Ainsi t[i] n'est jamais lu quand i vaut len(t).

Bien raisonner : cas limites et erreurs à éviter

Attention, erreur fréquenteErreur fréquente : modifier le tableau en le parcourant

Supprimer ou ajouter des éléments pendant un for x in t décale les cases : des valeurs sont sautées, ou la boucle peut ne jamais finir. Pour filtrer, construis un nouveau tableau et ajoute-y les valeurs retenues :

def positifs(t):
    res = []
    for x in t:
        if x > 0:
            res.append(x)
    return res

Démonstration · Pourquoi la fonction maximum est correcte

On montre que, juste avant d'examiner la case d'indice $i$ , la variable m est le plus grand élément des cases d'indices $0$ à $i-1$ .

Au départ, $i = 1$ et m = t[0] : c'est bien le plus grand élément de la seule case 0.
Si cette propriété est vraie avant la case $i$ , deux cas se présentent. Si t[i] > m, alors m devient t[i], le plus grand des cases $0$ à $i$ . Sinon, m reste le plus grand, car t[i] n'est pas plus grand.
Après la dernière case, m est donc le plus grand élément de tout le tableau.

Une propriété vraie avant la boucle, conservée à chaque tour, s'appelle un invariant de boucle.

Exercices corrigés

Exercice 1 Somme des valeurs négatives

★☆☆Environ 8 min

On considère le tableau t = [4, -2, 7, -5, 0, -1, 3].

Écris une fonction somme_negatifs(t) qui renvoie la somme des valeurs strictement négatives.
Calcule le résultat pour ce tableau.

Indice 1

Utilise un accumulateur initialisé à 0 avant la boucle.

Indice 2

N'ajoute x à l'accumulateur que si x < 0.

Voir la correction pas à pas

On choisit un parcours par élément, car l'indice n'est pas utile : for x in t.
On initialise s = 0 avant la boucle.
Dans la boucle : if x < 0: s = s + x. Le code complet est def somme_negatifs(t): puis s = 0, la boucle, et return s après la boucle.
On suit les valeurs négatives du tableau dans l'ordre : -2, puis -5, puis -1. L'accumulateur passe de 0 à -2, puis à -7, puis à -8.
Les autres valeurs (4, 7, 0, 3) ne vérifient pas x < 0 : elles sont ignorées. Le résultat est -8.

L'accumulateur conditionnel est le même schéma que la somme, avec un if en plus. Le résultat est -8.

Exercice 2 Moyenne et valeurs au-dessus de la moyenne

★★☆Environ 12 min

Un élève a obtenu les notes notes = [12, 15, 9, 18].

Calcule la moyenne des notes.
Écris une fonction au_dessus(t) qui renvoie le nombre de notes strictement supérieures à la moyenne.
Quelle valeur renvoie-t-elle pour ces notes ?

Indice 1

Il faut deux parcours : un pour la moyenne, un pour le comptage.

Indice 2

Calcule la moyenne une seule fois, avant le second parcours.

Voir la correction pas à pas

La somme des notes est 12 + 15 + 9 + 18 = 54. Il y a 4 notes, donc la moyenne est 54 / 4 = 13,5.
Dans la fonction, on calcule d'abord m = moyenne(t) à l'aide du premier parcours. On ne recalcule pas la moyenne à chaque tour de la seconde boucle.
Second parcours : c = 0, puis for x in t: if x > m: c = c + 1, et enfin return c.
On compare chaque note à 13,5 : 12 non, 15 oui, 9 non, 18 oui.
Le compteur vaut donc 2 : deux notes dépassent la moyenne. La moyenne demandée à la question 1 est 13,5.

La moyenne vaut 13,5 et deux notes la dépassent. Un algorithme peut demander deux parcours successifs du même tableau : le premier prépare une valeur que le second utilise.

Exercice 3 Indice du minimum

★★★Environ 15 min

Écris une fonction indice_minimum(t) qui renvoie l'indice de la première case contenant la plus petite valeur d'un tableau non vide d'entiers.

Écris la fonction.
Fais la trace pour t = [6, 3, 8, 3, 5].
Que change-t-il d'écrire <= au lieu de < dans la comparaison ?

Indice 1

Mémorise un indice, pas une valeur : initialise-le à 0.

Indice 2

Compare t[i] à t[imin], pas à i.

Voir la correction pas à pas

On a besoin de l'indice, donc on parcourt avec for i in range(1, len(t)). On initialise imin = 0.
Dans la boucle : if t[i] < t[imin]: imin = i. Après la boucle : return imin.
Trace pour [6, 3, 8, 3, 5] : départ imin = 0 (valeur 6). Pour i = 1, 3 < 6 donc imin = 1. Pour i = 2, 8 < 3 est faux. Pour i = 3, 3 < 3 est faux (égalité). Pour i = 4, 5 < 3 est faux.
La fonction renvoie 1 : la première case contenant 3.
Avec <=, l'égalité à i = 3 suffirait pour mettre à jour : imin vaudrait 3 à la fin, c'est-à-dire la dernière occurrence du minimum.

Une comparaison stricte garde la première occurrence, une comparaison large garde la dernière. Penser à ce détail évite des résultats surprenants quand le minimum est répété.

Les questions qu'on se pose

Quelle différence entre `for x in t` et `for i in range(len(t))` ?

Dans le premier cas, x est la valeur de chaque case ; dans le second, i est l'indice, et on lit la valeur avec t[i]. Les deux parcourent le tableau dans le même ordre. Choisis le second dès que la position compte ou que tu dois modifier une case.

Quand préférer while à for ?

On le peut presque toujours en ajoutant un return ou un break, mais while exprime directement « continuer tant que la valeur n'est pas trouvée et qu'il reste des cases ». C'est pratique pour une recherche qui peut s'arrêter tôt.

Que faire si le tableau est vide ?

Cela dépend de la fonction. Une somme ou un comptage valent 0, sans problème. Un maximum ou un minimum n'existe pas : t[0] provoque une erreur, donc il faut soit exclure ce cas dans l'énoncé, soit le traiter avant la boucle.

Quelle est la différence entre un indice et une valeur ?

Dans t = [4, 9, 2, 7], la valeur 9 est rangée à l'indice 1. L'indice est le numéro de la case, la valeur est ce qu'elle contient. Beaucoup d'erreurs viennent d'un mélange des deux : écrire t[x] au lieu de x dans un parcours par élément est typique.

Faut-il toujours parcourir tout le tableau pour trouver le maximum ?

Oui pour un tableau quelconque : tant qu'une case n'a pas été vue, elle peut contenir une valeur plus grande que toutes les autres. Une recherche de valeur donnée peut en revanche s'arrêter dès qu'on l'a trouvée.

Sources

Programmes et ressources en numérique et sciences informatiques - voie générale, Éduscol. Consulté le 7 novembre 2026.
Vademecum Sciences numériques et technologie, Numérique et Sciences Informatiques, Éduscol. Consulté le 7 novembre 2026.
Ressources d'accompagnement - Algorithmique et programmation, Éduscol. Consulté le 7 novembre 2026.
Annexe 1 - Programme NSI Première (arrêté ministériel officiel), Ministère de l'Éducation nationale et de la Jeunesse. Consulté le 7 novembre 2026.
TD10 Algo 2006-2007 : Algorithmique et structures de données, CNRS - LiRIS (Laboratoire d'Informatique en Image et Systèmes d'information). Consulté le 7 novembre 2026.
Tableau associatif, Wikipédia. Consulté le 7 novembre 2026.

Les numéros dans le texte renvoient à ces sources. Une source qui ne dit pas ce qu'on lui fait dire ? Signale-le.

Signaler une erreur sur cette page

Parcours séquentiel d'un tableau : cours de NSI en Première

L'essentiel

Introduction : pourquoi parcourir un tableau ?

Rappels : indices, longueur, accès à une case

Le parcours par indice avec for

Le parcours par élément

Les algorithmes classiques : moyenne, comptage, extremum

La recherche d'une valeur : s'arrêter quand on a trouvé

Bien raisonner : cas limites et erreurs à éviter

Exercices corrigés

Exercice 1 Somme des valeurs négatives

Exercice 2 Moyenne et valeurs au-dessus de la moyenne

Exercice 3 Indice du minimum

Quiz

Les questions qu'on se pose

Sources

Primaire

Collège

Lycée

Supérieur