Consolidation : variables, conditions, boucles, fonctions

Cours complet · algorithmique et programmation (première), chapitre 1 · première, algorithmique et programmation

La classe de seconde a mis en place les briques de la programmation : variables, instructions conditionnelles, boucles et fonctions. Ce chapitre les consolide — comme le demande le programme de première — en les tournant vers leurs usages de l'année : suites, seuils, second degré, simulations.

1.1 Variables, types et affectation

Définition 1.1Rappels

Une variable est une case de la mémoire, désignée par un nom, contenant une valeur d'un certain type : int (entier), float (flottant), str (chaîne), bool (booléen). L'affectation se note = en Python et $\leftarrow$ en langage naturel :

$u \leftarrow 2 u + 3$ se code u = 2*u + 3.

Le membre de droite est calculé d'abord, avec la valeur actuelle de u, puis rangé dans la case.

iRemarqueSéquence d'instructions

Les instructions s'exécutent dans l'ordre : intervertir deux lignes peut changer le résultat. En première, on enchaîne souvent deux mises à jour simultanées — le double affectation de Python est alors précieuse :


a, b = b, a + b     # Fibonacci : les DEUX membres de droite sont calculés
                    # avant toute affectation ; a = b puis b = a + b serait faux !

Le « serait faux » mérite d'être vu plutôt que cru :

1.2 Instructions conditionnelles

ImportantStructure `if` / `elif` / `else`


delta = b**2 - 4*a*c
if delta > 0:
    print("deux solutions")
elif delta == 0:
    print("une solution")
else:
    print("aucune solution réelle")

Conditions : ==, !=, <, <=, >, >=, combinées par and, or, not. Le bloc est délimité par l'indentation.

Exemple 1.2

La disjonction des cas du discriminant (chapitre 3 du manuel de mathématiques) se code mot à mot : c'est l'exemple parfait de traduction d'un raisonnement mathématique en programme.

1.3 Boucles

ImportantBoucle bornée, boucle non bornée


# for : nombre de répétitions connu -- calcul du terme u_n d'une suite
u = 1
for i in range(n):          # n tours : i = 0, 1, ..., n-1
    u = 2*u + 3

# while : on répète TANT QU'une condition est vraie -- recherche de seuil
u, n = 1, 0
while u <= 10**6:
    u = 2*u + 3
    n = n + 1               # à la sortie : premier rang où u > 10^6

Méthode : Les trois motifs de boucle à maîtriser en première

Itérer une récurrence : appliquer $n$ fois $u \leftarrow f (u)$ (calcul de $u_{n}$ ).
Accumuler : sommer ou multiplier au fil de la boucle (sommes $1 + 2 + \dots + n$ , factorielle, sommes géométriques).
Chercher un seuil : boucle while tant que l'objectif n'est pas atteint, avec un compteur.

Choisir entre les deux boucles ne demande qu'une question :

Exemple 1.3Les trois motifs en action


def somme_geometrique(q, n):
    # 1 + q + q^2 + ... + q^n : accumulateur + puissance itérée
    S, puissance = 1, 1
    for k in range(n):
        puissance = puissance * q
        S = S + puissance
    return S

def seuil_capital(c0, taux, objectif):
    # Nombre d'années pour qu'un capital à taux fixe atteigne un objectif
    c, annees = c0, 0
    while c < objectif:
        c = c * (1 + taux)
        annees = annees + 1
    return annees

print(somme_geometrique(2, 10))        # 2047 = 2^11 - 1
print(seuil_capital(1000, 0.03, 2000)) # 24 (doublement à 3 % :  24 ans)

1.4 Fonctions

Définition 1.4Rappels

Une fonction regroupe un traitement sous un nom : def nom(parametres): suivi d'un bloc indenté et d'un return. Elle peut prendre plusieurs arguments et renvoyer plusieurs valeurs (un couple). return renvoie une valeur réutilisable ; print ne fait qu'afficher.

La dernière phrase — « return renvoie, print affiche » — est la source d'erreur la plus fréquente de l'année :

Exemple 1.5Fonctions mathématiques de l'année


def discriminant(a, b, c):
    return b**2 - 4*a*c

def racines(a, b, c):
    # Renvoie le couple des racines si delta >= 0, None sinon
    delta = discriminant(a, b, c)
    if delta < 0:
        return None
    r = delta ** 0.5
    return ((-b - r) / (2*a), (-b + r) / (2*a))

def pente_secante(f, a, h):
    # Taux de variation de f entre a et a + h (chapitre Dérivation)
    return (f(a + h) - f(a)) / h

print(racines(2, -5, -3))              # (-0.5, 3.0)
print(pente_secante(lambda x: x**2, 1, 0.001))   # 2.001 -> f'(1) = 2

Noter que racines appelle discriminant : première touche de programmation modulaire, développée au dernier chapitre.

1.5 Du langage naturel à Python

ImportantCorrespondance (rappel de seconde, toujours exigible)

Langage naturel	Python
$u \leftarrow 5$	`u = 5`
Si … alors … sinon	`if …: … else:`
Pour $i$ allant de $1$ à $n$	`for i in range(1, n + 1):`
Tant que …	`while …:`
Renvoyer …	`return …`

Savoir traduire dans les deux sens reste une capacité attendue : les algorithmes du programme sont écrits « en langage naturel ou en Python ».

Exemple 1.6Traduction type

L'algorithme en langage naturel :

$u \leftarrow 100$ ; $n \leftarrow 0$

Tant que $u > 50$ :

$u \leftarrow 0, 9 u$

$n \leftarrow n + 1$

Renvoyer $n$

se code :


def mystere():
    u, n = 100, 0
    while u > 50:
        u = 0.9 * u
        n = n + 1
    return n     # renvoie 7 : premier rang où 100 x 0,9^n <= 50

C'est un algorithme de seuil pour la suite géométrique $u_{n} = 100 \times 0, 9^{n}$ : demi-vie d'une décroissance de $10 %$ par étape.

1.6 Exercices d'entraînement

Difficulté : ★ facile ★ moyen ★ plus difficile.

Exercice

Que renvoie f(4) ? Et f(7) ?


def f(n):
    if n % 2 == 0:
        return n // 2
    else:
        return 3*n + 1

Quel est le lien avec une suite étudiée dans le manuel de mathématiques ?

Solution

f(4) renvoie 2 ; f(7) renvoie 22. C'est la fonction de récurrence de la suite de Syracuse (chapitre Suites) : $u_{n + 1} = f (u_{n})$ .

Exercice

Écrire une fonction terme(n) renvoyant le terme $u_{n}$ de la suite définie par $u_{0} = 5$ et $u_{n + 1} = 0, 8 u_{n} + 4$ , puis donner $u_{3}$ à la main.

Solution


def terme(n):
    u = 5
    for i in range(n):
        u = 0.8 * u + 4
    return u

À la main : $u_{1} = 8$ ; $u_{2} = 10, 4$ ; $u_{3} = 12, 32$ .

Exercice

Écrire une fonction somme_entiers(n) renvoyant $1 + 2 + \dots + n$ par une boucle, puis une version sans boucle utilisant la formule du cours de mathématiques. Vérifier qu'elles coïncident pour $n = 100$ .

Solution


def somme_entiers(n):
    S = 0
    for k in range(1, n + 1):
        S = S + k
    return S

def somme_formule(n):
    return n * (n + 1) // 2

print(somme_entiers(100), somme_formule(100))   # 5050 5050

Exercice

Traduire en Python l'algorithme suivant, puis expliquer ce qu'il calcule pour la fonction $f (x) = x^{2} - 2$ :

$a \leftarrow 0$ ; $b \leftarrow 2$

Pour $k$ allant de $1$ à $20$ :

$m \leftarrow (a + b) /2$

Si $f (a) \times f (m) \leq 0$ alors $b \leftarrow m$ , sinon $a \leftarrow m$

Renvoyer $m$

Solution


def dichotomie():
    a, b = 0, 2
    for k in range(20):
        m = (a + b) / 2
        if f(a) * f(m) <= 0:
            b = m
        else:
            a = m
    return m

C'est la dichotomie : on coupe l'intervalle en deux en gardant la moitié où $f$ change de signe. Pour $f (x) = x^{2} - 2$ sur $[0; 2]$ , elle approche $2 \approx 1, 4142$ (précision $2/ 2^{20} \approx 2 \times 1 0^{- 6}$ ).

Exercice

Écrire une fonction tangente(a) qui, pour $f (x) = x^{2}$ , renvoie le couple $(m; p)$ tel que la tangente au point d'abscisse $a$ ait pour équation $y = m x + p$ .

Solution

La tangente est $y = f (a) + f^{'} (a) (x - a)$ avec $f^{'} (a) = 2 a$ : pente $m = 2 a$ et ordonnée à l'origine $p = f (a) - a f^{'} (a) = a^{2} - 2 a^{2} = - a^{2}$ .


def tangente(a):
    return (2*a, -a**2)

print(tangente(1))   # (2, -1) : y = 2x - 1, comme dans le cours

Exercice

La fonction suivante est incomplète :


def euler(h, n):
    y = 1
    for k in range(n):
        y = ...          # à compléter
    return y

Compléter pour qu'elle réalise la méthode d'Euler pour l'exponentielle ( $y^{'} = y$ , $y (0) = 1$ ).
Que renvoie euler(1/n, n) quand $n$ devient grand ? Justifier avec le cours.

Solution

1. y = y * (1 + h) : sur un pas $h$ , $y (x + h) \approx y (x) + h y^{'} (x) = (1 + h) y (x)$ .
2. euler(1/n, n) calcule $(1 + \frac{1}{n})^{n}$ , qui tend vers $e \approx 2, 718$ (chapitre Fonction exponentielle).

Exercice

Écrire une fonction simule_des() renvoyant le résultat d'un lancer de dé équilibré (utiliser randint du module random), puis une fonction frequence_six(N) estimant la probabilité d'obtenir un six sur $N$ lancers. Quelle valeur attend-on pour $N$ grand ?

Solution


from random import randint

def simule_des():
    return randint(1, 6)

def frequence_six(N):
    compteur = 0
    for k in range(N):
        if simule_des() == 6:
            compteur += 1
    return compteur / N

Pour $N$ grand, la fréquence se stabilise vers $\frac{1}{6} \approx 0, 167$ (loi des grands nombres) — le principe de toutes les simulations du chapitre Variables aléatoires.

Continuer sur Adloun : animation, QCM, fiches, exercices