Quelles sont les trois façons de construire une liste en Python ?

En extension, en écrivant tous ses éléments : `L = [2, 3, 5, 7]`. Par ajouts successifs, en partant de la liste vide et en utilisant `append` dans une boucle. En compréhension, en décrivant les éléments par une expression et une condition : `[k**2 for k in range(10) if k % 2 == 0]`, ce qui correspond à la notation ensembliste $\{k^2 \mid k \in \{0, \ldots, 9\},\ k \text{ pair}\}$.

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

La première boucle itère directement sur les éléments : `x` prend successivement chaque valeur de la liste. La seconde parcourt les indices `0, 1, ..., len(L) - 1` ; on accède alors à l'élément par `L[i]`, ce qui est nécessaire pour modifier la liste ou comparer des éléments voisins.

Que signifie « programmation modulaire » ?

Découper une tâche complexe en fonctions plus simples, chacune ayant un rôle précis et pouvant être testée séparément, puis les combiner. Par exemple une fonction qui simule une épreuve de Bernoulli, une autre qui l'appelle $n$ fois pour simuler une loi binomiale, une troisième qui répète l'expérience pour obtenir un échantillon.

Algorithmique et programmation

Le programme de Terminale ne comporte pas de notion nouvelle : il consolide variables, types, affectation, conditions, boucles, fonctions et listes, avec l’accent sur la programmation modulaire. Les algorithmes s’écrivent en Python ou en langage naturel (affectation notée ←).

Définitions

Définition 1 — Algorithme, fonction. Un algorithme est une suite finie d’instructions qui résout un problème. Une fonction reçoit des paramètres et renvoie une valeur avec return (print se contente d’afficher). La programmation modulaire consiste à découper une tâche complexe en fonctions simples, testées séparément puis combinées.

Définition 2 — Liste. Suite ordonnée de valeurs : L[i] est l’élément d’indice i, le premier étant L[0] et le dernier L[len(L) - 1] (ou L[-1]). Un tableau à deux dimensions est une liste de listes : T[i][j] (ligne i, colonne j).

Définition 3 — Les trois constructions d’une liste. En extension : L = [2, 3, 5, 7]. Par ajouts successifs : partir de [] et utiliser append dans une boucle. En compréhension : [expression for variable in iterable if condition], comme l’ensemble $\{k^2 \mid k \in \{0, \ldots, 9\},\ k \text{ pair}\}$ .

Théorèmes et propriétés

Propriété 1 — indices et range. Les indices vont de 0 à len(L) - 1. range(a, b) parcourt les entiers de a à b - 1 (la borne b est exclue) ; range(n) équivaut à range(0, n).

Propriété 2 — boucles et return. Une boucle for répète un nombre de tours connu ; une boucle while répète tant que sa condition est vraie et doit modifier une variable de cette condition pour s’arrêter. return termine immédiatement la fonction. = est une affectation, == un test d’égalité.

Propriété 3 — opérations sur les listes. L.append(x) ajoute en fin ; L.pop(i) retire et renvoie l’élément d’indice i (L.pop(0) retire l’élément d’indice 0, pas la valeur 0) ; del L[i] supprime ; L.insert(i, x) insère ; len(L) longueur ; x in L appartenance ; L[a:b] sous-liste des indices a à b - 1.

Propriété 4 — simulation d’une épreuve de Bernoulli. random() renvoie un réel uniforme de $[0\,;\,1[$ : le test random() < p est vrai avec probabilité exactement $p$ (longueur de l’intervalle $[0\,;\,p[$ ).

Méthodes

Méthode 1 — parcourir une liste et accumuler.

def somme(L):
    s = 0              # accumulateur
    for x in L:        # itérer sur les éléments
        s = s + x
    return s           # moyenne : s / len(L)

Exemple. s = 0 puis for i in range(1, 6): s = s + i donne $1 + 2 + 3 + 4 + 5 = 15$ .

Méthode 2 — rechercher dans une liste (maximum, position).

def maximum(L):
    m = L[0]                 # meilleur candidat rencontré
    for x in L:
        if x > m:
            m = x
    return m

def recherche(L, x):         # indice de x dans L, ou -1
    for i in range(len(L)):  # parcours par indices
        if L[i] == x:
            return i         # trouvé : on sort immédiatement
    return -1                # atteint seulement si x est absent

Exemple. maximum([4, 7, 2, 9]) renvoie 9 ; recherche([2, 5, 8, 12], 12) renvoie 3.

Méthode 3 — compter, filtrer (compteur).

def nb_pairs(L):
    c = 0                    # compteur
    for x in L:
        if x % 2 == 0:       # condition
            c = c + 1
    return c

Exemple. Fréquence d’une valeur k dans un échantillon E : compter ses occurrences puis diviser par len(E).

Méthode 4 — générer une liste (ajouts successifs, compréhension).

carres = []
for k in range(10):
    carres.append(k**2)                              # par ajouts successifs

pairs = [k**2 for k in range(10) if k % 2 == 0]      # en compréhension, avec filtre

Exemple. [k for k in range(1, 21) if k % 3 == 0] donne les multiples de 3 de 1 à 20 : [3, 6, 9, 12, 15, 18].

Méthode 5 — recherche de seuil avec while.

def seuil(p, alpha):         # plus petit n tel que (1 - p)**n <= alpha
    n = 0
    q = 1                    # invariant : q vaut (1 - p)**n
    while q > alpha:         # tant que le seuil n'est pas atteint
        q = q * (1 - p)
        n = n + 1
    return n

Exemple. seuil(0.5, 0.01) renvoie 7 car $0{,}5^6 \approx 0{,}0156 > 0{,}01 \geq 0{,}5^7$ .

Méthode 6 — boucles imbriquées (paires d’indices).

for i in range(n):
    for j in range(i + 1, n):   # j > i : chaque paire une seule fois
        ...

Exemple. Pour $n = 4$ , la boucle interne s’exécute $3 + 2 + 1 + 0 = 6 = \binom{4}{2}$ fois.

Méthode 7 — simulation (programmation modulaire).

from random import random

def bernoulli(p):            # 1 avec probabilité p, 0 sinon (Propriété 4)
    if random() < p:
        return 1
    return 0

def binomiale(n, p):         # nombre de succès en n épreuves
    s = 0
    for _ in range(n):
        s = s + bernoulli(p)
    return s

def echantillon(N, n, p):    # N valeurs de B(n, p)
    return [binomiale(n, p) for _ in range(N)]

Exemple. Marche aléatoire : accumuler choice([-1, 1]) à chaque pas. Permutation aléatoire : retirer avec pop un élément d’indice randint(0, len(reste) - 1) jusqu’à épuisement.

Méthode 8 — dichotomie dans une liste triée.

def dichotomie(L, x):
    g = 0
    d = len(L) - 1
    while g <= d:
        m = (g + d) // 2     # indice du milieu
        if L[m] == x:
            return m
        elif L[m] < x:
            g = m + 1        # on élimine la moitié gauche
        else:
            d = m - 1        # on élimine la moitié droite
    return -1

Exemple. Au plus 10 étapes pour 1000 éléments, car $2^{10} > 1000$ .

Méthode 9 — ligne du triangle de Pascal.

def ligne_pascal(n):
    ligne = [1]
    for _ in range(n):                               # n passages à la ligne suivante
        suivante = [1]
        for k in range(len(ligne) - 1):
            suivante.append(ligne[k] + ligne[k + 1]) # relation de Pascal
        suivante.append(1)
        ligne = suivante
    return ligne

Exemple. ligne_pascal(4) renvoie [1, 4, 6, 4, 1], les coefficients $\binom{4}{k}$ .

Définitions

Théorèmes et propriétés

Méthodes

Reste informé