Constructions élémentaires en Python : cours de NSI Première

Quand tu écris un programme, tu ne fais jamais rien d'autre que combiner quelques briques de base. Ces briques sont peu nombreuses, mais elles permettent de décrire presque n'importe quel traitement : tester une situation, répéter une action, réutiliser un morceau de code, ranger des données.

Le programme officiel de NSI de Première parle de « constructions élémentaires ». Il demande de mettre en évidence un corpus de constructions élémentaires.¹ Ce qui compte, ce sont les briques elles-mêmes et la façon de les utiliser. Ce cours les passe en revue, une par une, avec du code Python que tu peux recopier et tester.

Le plan du cours :

1. l'algorithme et le langage, pour fixer le cadre ;
2. les instructions exécutées l'une après l'autre ;
3. les conditionnelles ;
4. les boucles bornées ;
5. les boucles non bornées ;
6. les appels de fonction ;
7. les types construits (tuples, listes, dictionnaires) ;
8. la combinaison de toutes ces briques et les erreurs fréquentes.

Deux idées comptent dans cette définition. « Limitée » : l'algorithme doit finir par s'arrêter. « Ordre fixé » : intervertir deux opérations peut changer le résultat. Par exemple, « ajouter 1 puis doubler » et « doubler puis ajouter 1 » ne donnent pas la même valeur à partir de 5 : on obtient 12 dans le premier cas, 11 dans le second.

Un algorithme est une idée abstraite. Pour qu'une machine l'exécute, il faut le traduire dans un langage de programmation. Selon le programme officiel, ce sont les langages qui rendent possible le passage d'un algorithme abstrait à un programme.¹ En NSI, le langage retenu est Python, un langage interprété.⁴

La construction la plus simple est la séquence : les instructions s'exécutent de haut en bas, dans l'ordre où elles sont écrites. L'instruction de base est l'affectation, qui associe un nom à une valeur.

a = 5
a = a + 1
a = a * 2
print(a)

Ce programme affiche 12. Lis-le comme une suite d'actions : a vaut 5 ; a prend l'ancienne valeur plus 1, soit 6 ; a prend l'ancienne valeur multipliée par 2, soit 12.

En Python, on utilise if, elif (« sinon si ») et else (« sinon »). Le bloc concerné est décalé vers la droite (indentation), et la ligne du test se termine par deux-points.

note = 13
if note >= 16:
    mention = "très bien"
elif note >= 14:
    mention = "bien"
elif note >= 12:
    mention = "assez bien"
else:
    mention = "aucune"
print(mention)

Le programme teste les conditions dans l'ordre, s'arrête à la première qui est vraie et ignore les autres. Avec note = 13, les deux premiers tests échouent, le troisième réussit : mention vaut "assez bien".

Les conditions s'écrivent avec des comparaisons (<, <=, >, >=, ==, !=) que l'on peut combiner avec and (les deux doivent être vraies), or (au moins une) et not (contraire). Par exemple, 0 <= x and x <= 10 teste si x est dans l'intervalle $[0\,;\,10]$.

En Python, la boucle bornée s'écrit avec for. La fonction range fournit les valeurs successives que prend la variable de boucle :

• range(n) donne les entiers de 0 à $n-1$ (donc $n$ valeurs) ;
• range(a, b) donne les entiers de $a$ à $b-1$ ;
• range(a, b, p) avance avec un pas de $p$.

total = 0
for i in range(1, 6):
    total = total + i
print(total)

La variable i prend successivement les valeurs 1, 2, 3, 4, 5, et total vaut 15 à la fin, car $1+2+3+4+5=15$.

Une boucle bornée peut aussi parcourir directement les éléments d'une séquence, sans passer par les indices :

fruits = ["pomme", "poire", "kiwi"]
for f in fruits:
    print(f)

Le nombre de tours est alors la longueur de la séquence, connue avant le début de la boucle : la boucle est bien bornée.

En Python, elle s'écrit avec while. La condition est testée avant chaque tour, y compris le premier : si elle est fausse dès le départ, le bloc n'est jamais exécuté.

n = 1
compteur = 0
while n < 100:
    n = n * 2
    compteur = compteur + 1
print(n, compteur)

Trace d'exécution : n passe par 2, 4, 8, 16, 32, 64, 128. À 128, la condition n < 100 devient fausse et la boucle s'arrête. Le programme affiche 128 7.

On définit une fonction avec def et on renvoie un résultat avec return :

def est_pair(n):
    return n % 2 == 0

print(est_pair(10))
print(est_pair(7))

L'appel est_pair(10) renvoie True, l'appel est_pair(7) renvoie False. La définition ne s'exécute pas toute seule : elle ne fait que mémoriser le bloc. C'est l'appel qui le déclenche.

Une fonction sert à ne pas recopier le même code et à lui donner un nom qui explique ce qu'il fait. Elle peut contenir toutes les autres constructions :

def somme_jusqua(n):
    total = 0
    for i in range(1, n + 1):
        total = total + i
    return total

print(somme_jusqua(100))

Le programme affiche 5050.

Jusqu'ici, chaque variable contenait une seule valeur. Or on a souvent besoin de manipuler plusieurs valeurs à la fois : les notes d'une classe, les coordonnées d'un point. Les ressources d'Éduscol présentent l'objectif ainsi : construire un type de variable capable de contenir plusieurs valeurs.³ On s'inspire pour cela du type str (chaîne de caractères) et de l'usage d'indices pour repérer les éléments, ce qui conduit aux p-uplets (type tuple) et aux listes (type list).³

Éduscol donne ces écritures, qu'il faut retenir :³

• t = "a", "b", "c", 3 : un tuple à 4 éléments ;
• t = "a", : un tuple à 1 élément, la virgule est indispensable ;
• t = () : un tuple à 0 élément, avec des parenthèses et sans virgule.

Pour écrire un p-uplet qui en contient un autre, les parenthèses sont nécessaires.³

La liste (type list) se repère elle aussi par des indices, mais on peut la modifier : ajouter, retirer ou remplacer des éléments. Le premier élément a l'indice 0.

notes = [12, 15, 9]
notes.append(18)
notes[0] = 13
print(notes[0], len(notes))

Le programme affiche 13 4 : la liste vaut [13, 15, 9, 18], le premier élément est 13 et elle a 4 éléments. Un tuple, au contraire, ne se modifie pas après sa création.

Le dictionnaire (type dict) fonctionne autrement. Selon Éduscol, on n'y repère pas un élément par un indice entier mais par une « clé » : le dictionnaire n'est pas pensé comme une suite ordonnée.³

age = {"Lina": 16, "Hugo": 17}
age["Lina"] = 17
print(age["Lina"])

Le programme affiche 17. On accède à une valeur en donnant sa clé, pas sa position.

La puissance des constructions élémentaires vient de leur imbrication. On peut placer un test dans une boucle, une boucle dans une fonction, un appel de fonction dans une condition. Chaque bloc imbriqué est décalé d'un niveau d'indentation supplémentaire.