Définition — Variable et affectation. Une variable porte un nom et contient une valeur : un entier (int), un décimal (float), une chaîne de caractères (str) ou un booléen (bool, True ou False). L'affectation x = 5 (notée $x \leftarrow 5$ x ← 5 en langage naturel) range $5$ 5 dans $x$ x.

Exemple — Condition et boucles.

U = 230
if U > 240 or U < 220:
    print("tension hors tolérance")
else:
    print("tension correcte")

for k in range(1, 4):      # k prend les valeurs 1, 2, 3
    print(k * k)

n = 0
while 2**n < 1000:         # tant que la condition est vraie
    n = n + 1
print(n)                   # affiche 10

Fonctions

Définition — Fonction. Une fonction reçoit des entrées (les paramètres) et renvoie une sortie avec return. Découper un programme en fonctions simples le rend plus lisible et plus facile à tester.

Exemple — Puissance électrique.

def puissance(U, I):
    return U * I

def energie_kWh(U, I, heures):
    return puissance(U, I) * heures / 1000

print(energie_kWh(230, 2, 5))   # 2.3

La fonction energie_kWh réutilise puissance : c'est la programmation modulaire.

Compteur et accumulateur

Méthode — Compteur. Un compteur part de $0$ 0 et augmente de $1$ 1 chaque fois qu'une condition est réalisée.

Méthode — Accumulateur. Un accumulateur part de $0$ 0 pour une somme (de $1$ 1 pour un produit) et intègre une nouvelle valeur à chaque tour de boucle.

Exemple — Somme et produit.

s = 0
for k in range(1, 101):
    s = s + k
print(s)          # 5050 : somme des entiers de 1 à 100

p = 1
for k in range(5):
    p = p * 1.02
print(p)          # coefficient global de 5 hausses de 2 % : 1,104...

Exemple — Simuler une loi de Bernoulli. random() renvoie un nombre au hasard dans $[0; 1 [$ [0 ;1[, inférieur à $p$ p avec la probabilité $p$ p.

from random import random

def nb_succes(n, p):
    compteur = 0
    for k in range(n):
        if random() < p:
            compteur = compteur + 1
    return compteur

nb_succes(100, 0.3) / 100 donne la fréquence des succès dans un échantillon de taille $100$ 100.

Listes

Définition — Liste. Une liste est une suite ordonnée de valeurs entre crochets. Les indices commencent à $0$ 0 : L[0] est le premier élément, L[-1] le dernier, len(L) le nombre d'éléments.

Méthode — Trois façons de générer une liste.

L = [12, 15, 15, 18, 20]               # en extension

carres = []                             # par ajouts successifs
for k in range(6):
    carres.append(k**2)                 # [0, 1, 4, 9, 16, 25]

pairs = [k for k in range(20) if k % 2 == 0]   # en compréhension

La liste en compréhension traduit l'ensemble ${k \in {0, \dots, 19} ∣ k pair}$ {k ∈ {0, …, 19} | k pair } : la condition après if est un filtre.

Méthode — Manipuler une liste.

L = [12, 15, 15, 18, 20]
L[1] = 14           # modifie l'élément d'indice 1
L.append(22)        # ajoute 22 à la fin
L.remove(15)        # supprime la première occurrence de 15
del L[0]            # supprime l'élément d'indice 0
print(L)            # [14, 18, 20, 22]

Méthode — Parcourir une liste.

mesures = [4.8, 5.1, 5.0, 4.7, 5.3]
total = 0
for m in mesures:                  # parcours des éléments
    total = total + m
moyenne = total / len(mesures)     # 4.98

for i in range(len(mesures)):      # parcours des indices
    if mesures[i] > 5:
        print("mesure", i, "au-dessus de 5")

Sélection de données

Méthode — Filtrer des données réelles. Des relevés sont souvent stockés sous forme de liste de lignes, chaque ligne étant une liste de valeurs (lues par exemple dans un fichier CSV). On les filtre avec une condition.

Exemple — Tableau croisé à partir de données brutes. Chaque pièce contrôlée est décrite par sa machine et son état :

pieces = [["M1", "OK"], ["M2", "D"], ["M1", "OK"],
          ["M1", "D"], ["M2", "OK"], ["M2", "OK"]]

def effectif(machine, etat):
    c = 0
    for p in pieces:
        if p[0] == machine and p[1] == etat:
            c = c + 1
    return c

for m in ["M1", "M2"]:
    print(m, effectif(m, "OK"), effectif(m, "D"))

Le programme affiche M1 2 1 puis M2 2 1 : ce sont les lignes du tableau croisé « machine × état ».

Erreurs classiques

Attention — À éviter.

Oublier que les indices commencent à $0$ 0 : le dernier élément d'une liste de $5$ 5 éléments est L[4].
Initialiser un produit à $0$ 0 au lieu de $1$ 1.
Oublier que range(1, 101) s'arrête à $100$ 100.
Confondre = (affectation) et == (test d'égalité).
Oublier return : la fonction ne renvoie alors rien (None).

Fiche de synthèse

Boucles	`for k in range(a, b)` : de $a$ a à $b - 1$ b - 1 ; `while condition`
Fonction	`def f(x):` … `return` ; entrées et sortie
Compteur, accumulateur	`c = c + 1` ; `s = s + x` (départ $0$ 0) ; `p = p * x` (départ $1$ 1)
Bernoulli	`if random() < p:` succès
Listes	`L[0]`, `L[-1]`, `len(L)`, `append`, `remove`, `del` ; `[f(k) for k in … if …]`

Exercices d'application

Exercice 1 – Lire un programme

Qu'affiche ce programme ?

L = [3, 5, 8]
L.append(10)
print(L[1] + L[-1], len(L))

Exercice 2 – Compréhension

Écrire en compréhension la liste des carrés des entiers pairs de $0$ 0 à $20$ 20.

Exercice 3 – Moyenne

Écrire une fonction moyenne(L) qui renvoie la moyenne des éléments d'une liste de nombres.

Exercice 4 – Mesures hors tolérance

Écrire une fonction hors_tolerance(L, a, b) qui renvoie le nombre de mesures de la liste L qui ne sont pas dans $[a; b]$ [a ;b].

Corrigés des exercices

Corrigé de l'exercice 1

Corrigé. Après l'ajout, L = [3, 5, 8, 10] : L[1] + L[-1] vaut $5 + 10 = 15$ 5 + 10 = 15 et la liste a $4$ 4 éléments. Affichage : 15 4.

Corrigé de l'exercice 2

Corrigé. [k**2 for k in range(21) if k \% 2 == 0], soit [0, 4, 16, 36, 64, 100, 144, 196, 256, 324, 400].

Corrigé de l'exercice 3

Corrigé.

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

Corrigé de l'exercice 4

Corrigé.

def hors_tolerance(L, a, b):
    c = 0
    for x in L:
        if x < a or x > b:
            c = c + 1
    return c

Tous les chapitres de Première STI2D

Poursuis ta révision avec les autres chapitres du programme de Première STI2D.

Algorithmique et Python en Première STI2D

Cours et fiche

Leçon

Fiche de révision

S'entraîner

Fiches d'exercices à télécharger (PDF)

Plaquette 1 – Boucles, seuils, listes et simulations techniques

Plaquette 2 – Dérouler un programme et prévoir sa sortie

Plaquette 3 – Écrire une fonction : calculs techniques et tests

Plaquette 4 – Listes, cumuls et recherche de seuil

Plaquette 5 – Simuler une expérience aléatoire

Leçon complète