Terminale · Fiche de révision

Algorithmique et Python — fiche résumé

L'essentiel du chapitre en une page : 6 points à retenir et 7 méthodes. À relire avant un contrôle, ou à imprimer.

À retenir

1. Variables, types et affectation

Notions de base

Un algorithme est une suite finie et non ambiguë d'instructions. En Python, = effectue une affectation et == teste une égalité. Les principaux types sont int (entier), float (décimal approché), bool (booléen), str (texte) et list (liste).

2. Conditions

Structure conditionnelle

if condition:
    instructions_si_vraie
elif autre_condition:
    autres_instructions
else:
    instructions_si_fausse

L'indentation délimite les blocs. Les comparaisons sont <, <=, >, >=, ==, !=. On combine avec and, or, not.

3. Boucles bornées et non bornées

Définition

Boucle for

for k in range(n): fait prendre à k les valeurs 0, 1, ..., n-1. range(a,b) va de a inclus à b exclu.

Définition

Boucle while

Une boucle while condition: se répète tant que la condition reste vraie. Il faut vérifier qu'une variable évolue vers la sortie, sinon la boucle peut être infinie.

10. Listes et compréhensions

Liste

Une liste stocke plusieurs valeurs ordonnées. Les indices commencent à 0. Une compréhension permet de construire une liste : [f(k) for k in range(n)].

11. Valeurs approchées et flottants

Précision numérique

Un nombre de type float est stocké avec une précision finie. Ainsi, certains décimaux ne sont pas représentés exactement et 0.1 + 0.2 == 0.3 peut être faux. Pour comparer deux résultats approchés, tester plutôt abs(a-b) < epsilon.

Les méthodes

Ce qu'il faut savoir faire, et dans quel ordre.

Méthode 1Écrire une fonction fiable

Préciser les entrées, leurs types et leurs conditions.
Préciser la sortie attendue.
Traiter les cas limites.
Tester sur des cas simples calculables à la main.
Distinguer return, qui renvoie une valeur, de print, qui l'affiche seulement.

Méthode 2Calculer un terme récurrent

def terme_suite(n):
    u = 1
    for k in range(n):
        u = 0.8 * u + 6
    return u

Avant la première itération, u vaut u₀. Après k itérations, il vaut u_k : c'est l'invariant de boucle.

Méthode 3Premier rang dépassant un seuil

def premier_rang(seuil):
    n = 0
    u = 1
    while u < seuil:
        u = 0.8 * u + 6
        n = n + 1
    return n, u

Cette fonction n'a de sens que pour un seuil effectivement atteignable. Ici la suite tend vers 30 en restant inférieure à 30 : un seuil supérieur ou égal à 30 provoquerait une boucle qui ne s'arrête pas. Ajouter un contrôle est prudent.

Méthode 4Version avec précondition

def dichotomie(f, a, b, epsilon):
    if epsilon <= 0:
        raise ValueError("epsilon doit être positif")
    if f(a) * f(b) > 0:
        raise ValueError("pas de changement de signe")
    while b - a > epsilon:
        m = (a + b) / 2
        if f(a) * f(m) <= 0:
            b = m
        else:
            a = m
    return a, b

Si f est continue et possède une unique racine sur l'intervalle, l'invariant est : « la racine appartient à [a ; b] ». La longueur est divisée par deux à chaque tour, ce qui assure la terminaison.

Méthode 5Rectangles et trapèzes

def trapezes(f, a, b, n):
    h = (b - a) / n
    somme = (f(a) + f(b)) / 2
    for k in range(1, n):
        somme += f(a + k*h)
    return h * somme

La méthode des trapèzes remplace la courbe par des segments. Pour une fonction régulière, elle est souvent plus précise que les rectangles à nombre de subdivisions égal. Comparer avec une intégrale exacte sur une fonction simple permet de valider le programme.

Méthode 6Bonnes pratiques

Ne pas arrondir les valeurs intermédiaires inutilement.
Choisir un critère d'arrêt explicite.
Prévoir les domaines interdits (division par zéro, logarithme d'un nombre non positif).
Tester les bornes et les cas dégénérés.
Commenter l'idée mathématique, pas chaque symbole évident.

Méthode 7Erreurs fréquentes

Confondre = et ==.
Oublier que la borne droite de range est exclue.
Modifier une variable dans le mauvais ordre au sein d'une boucle.
Employer une boucle while sans preuve ou garantie de terminaison.
Présenter un résultat simulé comme une preuve exacte.

Le cours en détail, avec les exemples → 8 exercices corrigés