🔢Algorithmes classiques

Beaucoup d'algorithmes suivent le même squelette : on prépare une variable avant la boucle, on la met à jour à chaque tour, puis on la renvoie :

def somme(liste):
    total = 0            # on prépare
    for x in liste:
        total = total + x  # on accumule
    return total         # on renvoie

1. Initialise l'accumulateur (souvent 0 pour une somme, 0 pour un compteur).
2. Parcours la liste et mets à jour l'accumulateur.
3. Renvoie le résultat après la boucle (jamais à l'intérieur).

Mettre le return dans la boucle est un piège classique : la fonction s'arrêterait dès le premier tour ! Décale-le hors de la boucle.

Pour compter combien d'éléments vérifient une condition, on part d'un compteur à 0 et on l'incrémente quand la condition est vraie :

def combien_positifs(liste):
    c = 0
    for x in liste:
        if x > 0:
            c = c + 1
    return c

L'if à l'intérieur de la boucle filtre les éléments à compter. c = c + 1 se lit « j'en ai trouvé un de plus ».

Pour compter, l'accumulateur démarre à 0 et augmente de 1. Pour sommer, il augmente de x. Ne confonds pas les deux !

La moyenne d'une liste, c'est la somme divisée par le nombre d'éléments :

def moyenne(liste):
    return sum(liste) / len(liste)

On peut bien sûr recalculer la somme « à la main » avec une boucle plutôt qu'avec sum.

Moyenne = (somme des valeurs) ÷ (nombre de valeurs). Attention : la moyenne d'une liste vide n'a pas de sens (division par zéro).

print(moyenne([8, 12, 10]))   # 10.0

Somme = 30, nombre = 3, moyenne = 30 / 3 = 10.0 (un float).

Comme / renvoie un float, la moyenne de [8, 12, 10] s'affiche 10.0 et non 10.

Pour trouver le plus grand élément, on prend le premier comme « record » provisoire, puis on compare chaque élément suivant :

def maxi(liste):
    record = liste[0]
    for x in liste:
        if x > record:
            record = x
    return record

⭐ Pour les curieux — pourquoi ça marche ? Suis l'idée d'un record qui ne ment jamais : juste après avoir regardé les premiers éléments, record est exactement le plus grand parmi ceux-là. C'est vrai au départ (avec un seul élément vu, il est forcément le plus grand de cette mini-liste), et ça reste vrai à chaque tour, car on ne remplace record que par un élément strictement plus grand. À la fin, tous les éléments ont été vus, donc record est le plus grand de toute la liste. Et comme record est, à chaque instant, l'une des valeurs réellement présentes, partir de $0$ casserait tout : si la liste est par exemple $[-3 ; -7 ; -1]$, le $0$ n'y figure pas et resterait à tort le record.

1. Pars du premier élément comme record.
2. Compare chaque élément au record ; s'il est plus grand, il devient le nouveau record.
3. Pour un minimum, remplace > par <.

Démarrer le record à 0 est une erreur : si tous les nombres sont négatifs, le résultat serait faux ! Pars toujours du premier élément de la liste.

Pour savoir si une valeur est présente dans une liste, on la parcourt et on signale dès qu'on la trouve :

def present(liste, cible):
    for x in liste:
        if x == cible:
            return True
    return False

Si la boucle se termine sans avoir trouvé, c'est que la valeur est absente : on renvoie False.

⭐ Pour les curieux — pourquoi ça marche ? Le return False n'est pas un pari : il est certain. La boucle teste chaque élément, un par un, sans en sauter aucun. Si la cible avait été présente, on l'aurait rencontrée à un tour, le test x == cible aurait été vrai et on serait déjà sorti avec return True. Donc arriver après la boucle ne peut signifier qu'une seule chose : aucun des éléments n'était égal à la cible. On a tout vérifié, l'absence est prouvée, pas devinée.

Le return True dès qu'on trouve permet de s'arrêter tôt. Le return False est placé après la boucle (tout a été testé sans succès).

En Python, cible in liste fait exactement ce travail en une seule expression : 8 in [3, 8, 5] vaut True.

Une simulation rejoue une situation pas à pas. Comme on n'utilise pas le hasard ici, on impose les données dans une liste.

Par exemple, simuler un solde de compte à partir d'une liste d'opérations (positives = dépôts, négatives = retraits) :

def solde_final(operations, depart):
    solde = depart
    for op in operations:
        solde = solde + op
    return solde

On part d'un état initial (depart), puis on applique chaque opération l'une après l'autre pour faire évoluer l'état.

print(solde_final([10, -4, 5], 0))   # 11

0 + 10 = 10, puis 10 − 4 = 6, puis 6 + 5 = 11.

Imposer les entrées (au lieu de random) rend la simulation reproductible : on obtient toujours le même résultat, ce qui permet de la tester.