Python

Partie 1 — Variables et instructions élémentaires

Affectation

Une variable est un nom qui désigne une valeur stockée en mémoire. L’affectation se note = en Python (et $\leftarrow$ en langage naturel) : la valeur de droite est calculée, puis rangée dans la variable de gauche.

a = 4
b = 7
c = a + b**5
print(c)

Python affiche 16811, car $a + b^5 = 4 + 7^5 = 4 + 16\,807 = 16\,811$.

L’instruction x = x + 1 n’est pas une équation : elle remplace la valeur de x par l’ancienne valeur plus 1.

x = 10
y = 20
z = x * y
z = z + x
print(z)

Python affiche 210 : $z = 200$, puis $z = 200 + 10 = 210$.

Opérations

Opération	Python	Exemple
Addition, soustraction	a + b, a - b	10 - 3 donne 7
Multiplication	a * b	3 * 4 donne 12
Puissance	a**n	2**5 donne 32
Division décimale	a / b	7 / 2 donne 3.5
Quotient entier	a // b	7 // 2 donne 3
Reste (modulo)	a % b	17 % 5 donne 2

Types de variables

Type	Python	Exemple
Entier	int	n = 5
Flottant (nombre décimal approché)	float	x = 3.14, 7 / 2
Chaîne de caractères	str	mot = 'bonjour'
Booléen	bool	ok = True, 3 < 5

• type(x) renvoie le type de x.
• input("Message") demande une saisie et renvoie toujours une chaîne ; on convertit avec int(input("n = ")) ou float(...).
• Les flottants sont des valeurs approchées : 0.1 + 0.2 donne 0.30000000000000004.

Séquence d’instructions et formules

Les instructions s’exécutent dans l’ordre. Une formule peut combiner plusieurs variables :

from math import *
hauteur = 5
rayon = 4
volume = pi * rayon**2 * hauteur
print(volume)

Résultat : $V = \pi \times 4^2 \times 5 = 80\pi \approx 251{,}3$. from math import * donne accès à pi, sqrt (racine carrée), cos, sin, etc.

---

Partie 2 — Fonctions

Une fonction reçoit des arguments, effectue un calcul et renvoie un résultat avec return.

def aire_disque(rayon):
    return pi * rayon**2

aire_disque(12) renvoie $\pi \times 12^2 \approx 452{,}4$.

Fonctions à plusieurs arguments

def f(a, b):
    return 2 * a + b

def hypotenuse(a, b):
    return sqrt(a**2 + b**2)

f(3, 5) renvoie 11 (les arguments sont pris dans l’ordre) ; hypotenuse(5, 9) renvoie $\sqrt{106} \approx 10{,}3$.

return ou print ?

• return renvoie une valeur, réutilisable dans un calcul : 2 * f(3, 5) vaut 22.
• print affiche seulement ; une fonction qui ne fait qu’afficher renvoie None.

Fonction mathématique et image

def g(x):
    return x**2 + 2

g(5) renvoie $5^2 + 2 = 27$ : la fonction Python calcule l’image de $5$ par $g : x \mapsto x^2 + 2$.

---

Partie 3 — Instruction conditionnelle

def parite(n):
    if n % 2 == 0:
        return 'pair'
    else:
        return 'impair'

• if condition: exécute le bloc indenté si la condition est vraie ;
• else: s’exécute sinon ;
• elif (« sinon si ») permet d’enchaîner plusieurs cas : seul le premier bloc dont la condition est vraie est exécuté.

def note(x):
    if x > 15:
        return 'super'
    elif x >= 10:
        return 'bien'
    else:
        return 'insuffisant'

note(16) renvoie 'super' ; note(15) renvoie 'bien' (car 15 > 15 est faux) ; note(9) renvoie 'insuffisant'.

Opérateurs de comparaison et connecteurs

Opérateur	Signification
==	égal à (à ne pas confondre avec l’affectation =)
!=	différent de
<, >	strictement inférieur, strictement supérieur
<=, >=	inférieur ou égal, supérieur ou égal
and, or, not	et, ou, non

Exemple : 10 <= x and x <= 15 (ou 10 <= x <= 15) teste si $x \in [10\,;\, 15]$.

Algorithme du programme : multiple de $b$ ?

def est_multiple(a, b):
    if a % b == 0:
        return True
    else:
        return False

est_multiple(91, 7) renvoie True. On peut l’écrire plus simplement return a % b == 0.

---

Partie 4 — Boucles

Boucle bornée for

La boucle for répète un bloc un nombre de fois connu à l’avance.

def somme(n):
    s = 0
    for k in range(1, n + 1):
        s = s + k
    return s

range(1, n + 1) donne les entiers de $1$ inclus à $n + 1$ exclu, c’est-à-dire $1, 2, \ldots, n$. range(n) donne les $n$ entiers $0, 1, \ldots, n - 1$.

somme(5) renvoie 15 :

$k$		1	2	3	4	5
$s$	0	1	3	6	10	15

Produit des entiers de 1 à 9.

p = 1
for k in range(1, 10):
    p = p * k
print(p)

Affiche $1 \times 2 \times \cdots \times 9 = 362\,880$. Il faut initialiser p = 1 (et non p = 0, sinon le produit reste nul).

Répéter une chaîne.

c = 'on est au '
for k in range(3):
    c = c + 'top '

c vaut 'on est au top top top ' : le bloc s’exécute 3 fois ($k$ va de 0 à 2).

Boucle non bornée while

La boucle while répète un bloc tant que la condition est vraie. On ne connaît pas forcément à l’avance le nombre de répétitions.

n = 0
while n < 10:
    print(n)
    n = n + 1

Affiche les entiers de 0 à 9. La boucle s’arrête quand n < 10 devient faux. Une variable de la condition doit être modifiée dans le bloc, sinon la boucle est infinie.

Recherche de seuil (algorithme du programme)

Plus petit entier $n$ tel que $2^n > 1000$ :

def seuil():
    n = 0
    while 2**n <= 1000:
        n = n + 1
    return n

seuil() renvoie 10 car $2^9 = 512 \leq 1000$ et $2^{10} = 1024 > 1000$.

À partir de quel entier $n$ la somme $1 + 2 + \cdots + n$ dépasse-t-elle $10\,000$ ?

def rang():
    s = 0
    k = 0
    while s < 10000:
        k = k + 1
        s = s + k
    return k

rang() renvoie 141 : $1 + \cdots + 140 = 9\,870 < 10\,000$ et $1 + \cdots + 141 = 10\,011$.

Algorithme du programme : encadrement de $\sqrt{2}$ par balayage

def encadrement(n):
    pas = 10**(-n)
    x = 1
    while x**2 <= 2:
        x = x + pas
    return x - pas, x

encadrement(2) renvoie un couple proche de (1.41, 1.42) : un encadrement de $\sqrt{2}$ d’amplitude $10^{-2}$.

Algorithme du programme : plus grand multiple de $a$ inférieur ou égal à $b$

def plus_grand_multiple(a, b):
    m = 0
    while m + a <= b:
        m = m + a
    return m

plus_grand_multiple(12, 200) renvoie 192.

---

Partie 5 — Nombres aléatoires et simulation

Après from random import * :

• randint(a, b) renvoie un entier aléatoire entre a et b inclus (les deux bornes, contrairement à range) ;
• random() renvoie un flottant aléatoire dans $[0\,;\, 1[$.

Une expérience aléatoire

from random import *

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

def pile_ou_face():
    if random() < 0.5:
        return 'pile'
    else:
        return 'face'

Répéter une expérience et calculer une fréquence

def frequence(n):
    c = 0
    for k in range(n):
        if randint(1, 6) == 6:
            c = c + 1
    return c / n

frequence(1000) renvoie la fréquence du 6 sur 1000 lancers, par exemple 0.172. Elle change à chaque exécution, mais pour $n$ grand elle est proche de $\dfrac{1}{6} \approx 0{,}167$ : c’est la loi des grands nombres.

La répétition de l’appel d’une fonction aléatoire produit une série statistique : on peut en calculer la moyenne.

Lire une fonction qui renvoie une moyenne

def moyenne_des(n):
    s = 0
    for k in range(n):
        s = s + randint(1, 6)
    return s / n

moyenne_des(10000) renvoie une valeur proche de $3{,}5$, la moyenne des faces $\dfrac{1 + 2 + 3 + 4 + 5 + 6}{6}$.

Lire une fonction qui renvoie un écart type

Le programme demande de savoir lire et comprendre une fonction renvoyant une moyenne ou un écart type (aucune connaissance sur les listes n’est exigée).

def ecart_type_des(n):
    s = 0
    s2 = 0
    for k in range(n):
        d = randint(1, 6)
        s = s + d
        s2 = s2 + d**2
    m = s / n
    V = s2 / n - m**2
    return V ** 0.5

La variable s cumule les valeurs, s2 leurs carrés ; m est la moyenne, V la variance (moyenne des carrés moins carré de la moyenne) et V ** 0.5 sa racine carrée, l’écart type. ecart_type_des(10000) renvoie une valeur proche de $1{,}71$.

---

Partie 6 — Du langage naturel à Python

Un algorithme peut s’écrire en langage naturel avant d’être traduit.

Exemple — Afficher les six premiers termes suivants de la suite de Fibonacci ($1, 1, 2, 3, 5, 8, 13, 21, \ldots$) :

n ← 0
A ← 1
B ← 1
Tant que n < 6
    n ← n + 1
    C ← B
    B ← A + B
    A ← C
    Afficher B
Fin Tant que

n = 0
A = 1
B = 1
while n < 6:
    n = n + 1
    C = B
    B = A + B
    A = C
    print(B)

Affiche 2, 3, 5, 8, 13, 21. Tableau d’exécution :

$n$	0	1	2	3	4	5	6
$A$	1	1	2	3	5	8	13
$B$	1	2	3	5	8	13	21
$C$		1	2	3	5	8	13

Faire tourner un programme « à la main » dans un tableau permet de vérifier son fonctionnement, une exigence de rigueur essentielle en programmation.