Atelier facultatif : Python, listes et tableur

1. Variables, affectation et conditions

Une variable donne un nom à une valeur. Dans un algorithme écrit en français, on note « capital ← 200 ». En Python, capital = 200 est une affectation, pas une équation à résoudre. L’instruction capital = capital + 50 lit l’ancienne valeur, ajoute 50, puis stocke le résultat.

Un entier est de type int, un nombre décimal approché de type float, un texte de type str, une valeur vraie ou fausse de type bool. En Python, on écrit 0.25 avec un point. L’opérateur de puissance est **, pas ^. Le test d’égalité s’écrit ==, différent de =.

capital = 200
capital = capital + 50
if capital >= 240:
    message = "Seuil atteint"
else:
    message = "Seuil non atteint"
print(message)

L’indentation délimite les blocs. and, or et not traduisent « et », « ou », « non ». Pour tester l’intervalle [0 ; 1], on peut écrire 0 <= p <= 1. Un test qui porte sur des décimaux calculés doit tenir compte des arrondis de la machine.

2. Fonctions : entrées, sortie et réutilisation

Une fonction regroupe des instructions. Ses paramètres sont les entrées ; return transmet le résultat. print affiche un texte mais ne remplace pas le retour d’une valeur.

def valeur_finale(initiale, taux):
    return initiale * (1 + taux)

def taux_evolution(initiale, finale):
    if initiale <= 0:
        raise ValueError("La valeur initiale doit etre positive")
    return (finale - initiale) / initiale

prix = valeur_finale(200, 0.15)
print(prix)                         # environ 230
print(taux_evolution(200, prix))    # environ 0.15

On peut appeler une fonction dans une autre : c’est la programmation modulaire. Décomposer « lire les données », « calculer » et « afficher » rend un programme plus facile à vérifier. Tester quelques cas simples dont le résultat est connu, puis les cas limites autorisés.

3. Construire et modifier des listes

Une liste rassemble des valeurs dans un ordre donné. Les indices commencent à 0 : pour une liste de longueur n, les indices usuels vont de 0 à n − 1. Accéder à l’indice n provoquerait une erreur.

# En extension : on ecrit les elements.
notes = [8, 12, 15]
print(notes[0])       # 8
notes[1] = 13        # remplace 12 par 13
notes.append(16)     # ajoute a la fin
valeur = notes.pop() # retire et renvoie 16
del notes[0]         # supprime la premiere valeur
# notes vaut maintenant [13, 15]

# Par ajouts successifs :
carres = []
for n in range(5):
    carres.append(n ** 2)

# En comprehension, meme resultat :
carres = [n ** 2 for n in range(5)]
# [0, 1, 4, 9, 16]
positifs = [x for x in [-2, 0, 3, 5] if x > 0]

len(notes) donne la longueur de la liste. Pour lire ses valeurs, utiliser for note in notes. Pour avoir besoin de leurs positions, utiliser for i in range(len(notes)). Attention : copie = notes ne crée pas une liste indépendante ; copie = notes.copy() crée une nouvelle liste pour une liste simple de nombres.

4. Boucles, compteurs et accumulateurs

Une boucle for répète un nombre connu de fois. range(5) fournit 0, 1, 2, 3, 4. Une boucle while continue tant qu’une condition est vraie ; il faut que son corps fasse évoluer cette condition vers l’arrêt.

valeurs = [3, 7, 2, 10]
total = 0
produit = 1
compteur = 0
for x in valeurs:
    total += x
    produit *= x
    if x >= 5:
        compteur += 1
# total = 22 ; produit = 420 ; compteur = 2

Une somme commence à 0, un produit à 1. Un compteur augmente lorsqu’un critère est satisfait. Pour construire les termes d’une suite, conserver le terme courant et le mettre à jour à chaque étape. Les cours sur les suites arithmétiques et géométriques proposent les programmes complets de calcul et de seuil.

5. Traiter un fichier de données réelles

Télécharge le CSV des naissances en France, 2018–2023 et place-le dans le dossier depuis lequel tu exécutes Python. Source : Insee Focus 339, figure 1. Il contient six totaux annuels, France y compris Mayotte, et aucune donnée individuelle.

import csv
from statistics import mean

nom = "naissances-france-2018-2023.csv"
with open(nom, encoding="utf-8", newline="") as fichier:
    lecteur = csv.reader(fichier)
    entete = next(lecteur)
    if entete != ["annee", "naissances"]:
        raise ValueError("Colonnes inattendues")
    donnees = []
    for ligne in lecteur:
        if len(ligne) != 2:
            raise ValueError("Chaque ligne doit avoir deux colonnes")
        annee, nombre = int(ligne[0]), int(ligne[1])
        if nombre < 0:
            raise ValueError("Nombre de naissances negatif")
        donnees.append([annee, nombre])

if not donnees:
    raise ValueError("Fichier sans observations")
naissances = [ligne[1] for ligne in donnees]
print(mean(naissances))  # environ 732170.17
selection = [ligne for ligne in donnees
             if ligne[0] >= 2020 and ligne[1] < 740000]
print(selection)
# [[2020, 735196], [2022, 725997], [2023, 677803]]

Le fichier contient du texte : int transforme les champs en nombres. Chaque sous-liste conserve une année et sa valeur ensemble. L’absence du fichier provoque une erreur explicite ; on vérifie alors son nom et son dossier, sans remplacer les données par des valeurs inventées.

La moyenne calculée est une moyenne de six totaux annuels, pas une moyenne par habitant. Pour l’évolution de 2022 à 2023, (677 803 − 725 997)/725 997 ≈ −0,06638, soit environ −6,64 %. Ces données décrivent une période historique, pas les chiffres de l’année en cours.

6. Construire un tableau croisé à partir de données brutes

On dispose cette fois de huit observations fictives. Chaque ligne indique le canal de commande et l’adhésion. Ce petit jeu de données est distinct du tableau de 200 clients du chapitre 09.

clients = [
    ["ligne", "oui"], ["ligne", "oui"],
    ["ligne", "oui"], ["ligne", "non"],
    ["magasin", "oui"], ["magasin", "non"],
    ["magasin", "non"], ["magasin", "non"]
]
canaux = ["ligne", "magasin"]
adhesions = ["oui", "non"]
tableau = [[0, 0], [0, 0]]
for client in clients:
    i = canaux.index(client[0])
    j = adhesions.index(client[1])
    tableau[i][j] += 1
print(tableau)  # [[3, 1], [1, 3]]
print([sum(ligne) for ligne in tableau])  # totaux : [4, 4]
print([sum(tableau[i][j] for i in range(2))
       for j in range(2)])               # colonnes : [4, 4]

La cellule [0][0] compte les clients en ligne et adhérents. Leur fréquence dans l’ensemble est 3/8 ; leur fréquence parmi les clients en ligne est 3/4. Le tableau croisé est construit par comptage de deux critères, pas saisi directement sous forme de résultats.

7. Organiser une feuille de calcul

Une cellule peut contenir un nombre, un texte ou une formule commençant par =. En recopiant une formule, une référence relative change avec la position : =B2*1,04 devient =B3*1,04 à la ligne suivante. Une référence absolue garde sa position : $E$1. Les références mixtes $A2 et A$2 ne fixent qu’une dimension.

Pour une suite de raison stockée en E1, =B2*$E$1 permet de recopier la relation sans déplacer la raison. Pour une moyenne, utiliser =MOYENNE(B2:B7). Pour un total, =SOMME(B2:B7). Afficher les unités dans l’en-tête, pas à l’intérieur des cellules numériques.

Si les canaux fictifs sont en A2:A9 et les adhésions en B2:B9, la cellule croisée « ligne et oui » peut se calculer avec =NB.SI.ENS($A$2:$A$9;"ligne";$B$2:$B$9;"oui"). Un tableau croisé dynamique réalise aussi ces regroupements, en choisissant l’un des critères en lignes et l’autre en colonnes, puis un comptage en valeurs. Les noms de fonctions et les séparateurs dépendent de la langue du tableur.

8. Lire, tester et expliquer un programme

Pour vérifier un algorithme, dresser un tableau de suivi : valeur initiale, condition, valeurs après chaque passage, sortie. Comparer un petit exemple calculé à la main avec le résultat du programme, puis tester le cas n = 0 si celui-ci est autorisé, les bornes de probabilité 0 et 1, et les entrées non valides.

Que valent u et total après ce programme ?

u = 2
total = 0
for _ in range(3):
    total += u
    u *= 2

def encadrement_racine2():
    x = 1
    pas = 0.01

    while (x + pas) ** 2 < 2:
        x = x + pas

    return round(x, 2), round(x + pas, 2)

print(encadrement_racine2())
# Affiche : (1.41, 1.42)

def stock(n):
    if not isinstance(n, int) or n < 0:
        raise ValueError("n doit etre un entier positif ou nul")
    v = 200
    for _ in range(n):
        v = 0.8 * v + 50
    return v

# stock(0) = 200 ; stock(2) = 218

def premier_mois(seuil):
    n = 0
    capital = 200
    while capital < seuil:
        capital += 50
        n += 1
    return n

# premier_mois(1025) renvoie 17

def somme_arithmetique(u0, raison, m):
    if not isinstance(m, int) or m < 0:
        raise ValueError("m doit etre un entier positif ou nul")
    terme = u0
    total = 0
    for _ in range(m + 1):
        total += terme
        terme += raison
    return total

# 100 + 120 + 140 + 160 + 180 + 200 = 900
# somme_arithmetique(100, 20, 5) renvoie 900

def seuil_capital(seuil):
    n, capital = 0, 1000
    while capital <= seuil:
        capital *= 1.04
        n += 1
    return n, capital

# seuil_capital(1500) donne n = 11

def premier_depassement():
    # n = 0 donne une egalite : on commence au rang 1.
    n = 1
    a, g = 1050, 1040
    while g <= a and n < 10000:
        n += 1
        a += 50
        g *= 1.04
    if g <= a:
        return None  # limite de recherche atteinte
    return n

# Renvoie 12

def somme_geometrique(u0, q, m):
    if not isinstance(m, int) or m < 0:
        raise ValueError("m doit etre un entier positif ou nul")
    terme, total = u0, 0
    for _ in range(m + 1):
        total += terme
        terme *= q
    return total

# somme_geometrique(100, 0.5, 3) = 187.5

def pente_secante(f, a, h):
    if h == 0:
        raise ValueError("h ne doit pas etre nul")
    return (f(a + h) - f(a)) / h

for h in [0.1, 0.01, -0.01, -0.1]:
    print(h, pente_secante(lambda x: x*x, 2, h))

from random import random

def succes(p):
    if not 0 <= p <= 1:
        raise ValueError("p doit etre entre 0 et 1")
    return 1 if random() < p else 0

def nombre_succes(n, p):
    if not isinstance(n, int) or n < 1:
        raise ValueError("n doit etre un entier positif")
    total = 0
    for _ in range(n):
        total += succes(p)
    return total

# Une simulation d'un groupe de quatre essais :
print(nombre_succes(4, 0.3))

from random import random
from statistics import mean, pstdev

def echantillon(n, p):
    if not isinstance(n, int) or n < 1 or not 0 <= p <= 1:
        raise ValueError("n entier positif, p entre 0 et 1")
    return [1 if random() < p else 0 for _ in range(n)]

def simuler_frequences(N, n, p):
    if not isinstance(N, int) or N < 2:
        raise ValueError("N doit etre au moins egal a 2")
    return [sum(echantillon(n, p)) / n for _ in range(N)]

p, n, N = 0.3, 100, 400
frequences = simuler_frequences(N, n, p)
s = pstdev(frequences)
print("Moyenne :", mean(frequences), "Ecart-type :", s)
for k in [1, 2, 3]:
    effectif = sum(1 for f in frequences if abs(f - p) <= k*s)
    print(k, effectif, 100 * effectif / N)

import matplotlib.pyplot as plt

plt.figure()
plt.hist(frequences, bins=20)
plt.xlabel("Frequence des succes")
plt.ylabel("Nombre d'echantillons")
plt.show()

plt.figure()
plt.scatter(range(N), frequences, s=10)
plt.axhline(p, linestyle="--")
plt.xlabel("Numero de l'echantillon")
plt.ylabel("Frequence des succes")
plt.show()

from math import sqrt

tailles = [25, 100, 400, 1600]
abscisses = [1 / sqrt(n) for n in tailles]
dispersions = [pstdev(simuler_frequences(400, n, 0.3))
               for n in tailles]
# Dans un nuage de points, placer abscisses en x
# et dispersions en y ; ou exporter ces deux listes.

from statistics import mean, median, pstdev

durees = [8, 10, 10, 12, 14, 16, 18, 20]
print(mean(durees))    # 13.5
print(median(durees))  # 13.0
print(pstdev(durees))  # environ 3.9686