Cours de Python Prépa

1. Premiers pas : variables, types et opérations

Un programme Python manipule des valeurs rangées dans des variables. Les instructions s'exécutent dans l'ordre où elles sont écrites ; l'affectation s'écrit avec le signe =.

a = 0
b = 2*a + 3
print(b)

a = 5
b = 2*a + 3
print(b)

Python évalue d'abord le membre de droite, avec les valeurs courantes des variables, puis range le résultat dans la variable écrite à gauche. L'instruction a=a+2 remplace ainsi la valeur de a par a+2 :

a = 5
a = a + 2
print(a)
print(a == 7)

Ce programme affiche 7, puis True : le test d'égalité s'écrit ==, à ne pas confondre avec l'affectation =. Le caractère # introduit un commentaire, ignoré à l'exécution.

Les types de base

Les opérations arithmétiques sont +, -, *, / et ** (puissance).

Une comparaison renvoie un booléen : par exemple 3==2+1 vaut True.

2. Les listes

Une liste regroupe des valeurs numérotées à partir de $0$ : dans une liste de longueur $n$, les indices vont de $0$ à $n-1$.

>>> L=[4,1,7]
>>> L[0]
4
>>> L[2]=5 # L vaut maintenant [4,1,5]
>>> L.append(9) # L vaut [4,1,5,9]
>>> len(L)
4

Le piège de la copie

3. Les tests : if, elif, else

L'instruction conditionnelle exécute un bloc seulement si une condition est vraie. Le bloc est délimité par l'indentation (un décalage de quatre espaces) et les deux-points sont obligatoires.

Exemple : afficher la valeur absolue d'un réel saisi au clavier.

x=float(input())
if x>=0:
    y=x
else:
    y=-x
print(y)

La première ligne lit une chaîne de caractères au clavier avec input(), puis la convertit en flottant avec float : c'est la forme habituelle pour saisir un nombre.

La clause else est facultative. Pour enchaîner plusieurs cas exclusifs, on utilise elif :

if x>0:
    print('positif')
elif x==0:
    print('nul')
else:
    print('negatif')

4. Les boucles

La boucle for

Premier schéma fondamental, l'accumulateur : calculer $\displaystyle\sum_{k=1}^{100}k^2$.

S=0
for k in range(1,101):
    S=S+k**2
print(S)

On peut aussi parcourir directement une liste ou une chaîne de caractères : for x in L: donne à x successivement chaque élément de L.

Deuxième schéma fondamental, la suite récurrente : si $u_0=1$ et $u_{n+1}=\dfrac12\left(u_n+\dfrac2{u_n}\right)$ (méthode de Héron, qui converge vers $\sqrt2$), le script suivant affiche $u_{20}$ :

u=1
for k in range(20):
    u=(u+2/u)/2
print(u)

La boucle while

Quand le nombre d'itérations n'est pas connu à l'avance, on utilise while : le bloc est répété tant que la condition est vraie. C'est l'outil des recherches de rang d'arrêt, très fréquentes aux concours.

Exemple : pour $u_n=0{,}8^n$, afficher le plus petit entier $n$ tel que $u_n<10^{-3}$.

n=0
u=1
while u>=10**(-3):
    u=0.8*u
    n=n+1
print(n)

5. Les fonctions

Une fonction reçoit des arguments et renvoie un résultat avec return :

def f(x):
    y=x**2+1
    return y

Après cette définition, f(3) vaut 10 et on peut composer : f(f(1)) vaut 5.

Un argument peut recevoir une valeur par défaut. Par exemple, def puissance(x,n=2): return x**n permet d'écrire puissance(3) pour obtenir $9$, ou puissance(3,4) pour obtenir $81$. Cette commodité n'est pas exigible, mais sa lecture ne doit pas surprendre dans un sujet.

Une fonction peut prendre plusieurs arguments et renvoyer plusieurs valeurs :

def extremes(L):
    return min(L), max(L)

a,b = extremes([4,1,7]) # a vaut 1, b vaut 7

6. Les bibliothèques : numpy, numpy.random et matplotlib

Python de base ne connaît ni la racine carrée ni le cosinus : ces outils vivent dans des bibliothèques à importer en tête de script.

import numpy as np
import numpy.linalg as al
import numpy.random as rd
import matplotlib.pyplot as plt
from math import *

print(...) affiche une ou plusieurs valeurs. Le module math fournit cos, exp, log, atan, etc. ; numpy fournit les mêmes fonctions, utilisables sur des tableaux.

Tableaux numpy

La bibliothèque numpy manipule des vecteurs et des matrices sous forme de tableaux :

>>> A=np.array([[1,2],[3,4]])
>>> A*A # coefficient par coefficient
array([[ 1, 4], [ 9, 16]])
>>> np.dot(A,A) # produit matriciel
array([[ 7, 10], [15, 22]])

Enfin, np.sum, np.min, np.max, np.mean, np.median, np.var, np.std et np.cumsum s'appliquent à un tableau entier (somme, minimum, maximum, moyenne, médiane, variance, écart-type et sommes cumulées). Les fonctions usuelles np.exp, np.log, np.sin, np.cos, np.sqrt, np.abs, np.floor agissent élément par élément, et les constantes $e$ et $\pi$ s'écrivent np.e et np.pi.

La bibliothèque numpy.linalg (résolution de systèmes, inverse, rang) est détaillée dans la section 11, et numpy.random (échantillons de lois usuelles) dans la section 8.

7. Tracer une courbe, représenter une suite

En Python, pour représenter une fonction $f$ sur un segment $[a,b]$, on place un nombre fini de points de sa courbe, puis on relie chaque point au suivant par un segment. On choisit pour cela des abscisses $x_0<x_1<\cdots<x_{N-1}$ dans $[a,b]$ et on calcule leurs images $f(x_0),\dots,f(x_{N-1})$. Lorsque les abscisses sont assez rapprochées, la ligne brisée obtenue ne se distingue pas à l'œil de la courbe représentative de $f$.

Exemple : comparer sur $[-2,2]$ la courbe de la fonction exponentielle et sa tangente au point d'abscisse $0$. Cette tangente passe par le point $(0,1)$, et son coefficient directeur vaut $\exp'(0)=e^0=1$ : son équation est $y=1+x$.

x=np.linspace(-2,2,201)
plt.plot(x,np.exp(x))
plt.plot(x,1+x)
plt.grid()
plt.title('Exponentielle et tangente en 0')
plt.show()

La première ligne construit $201$ abscisses de $-2$ à $2$ : deux abscisses consécutives sont distantes de $\dfrac{2-(-2)}{200}=0{,}02$. La deuxième ligne calcule d'un coup les $201$ ordonnées np.exp(x) et trace la courbe de l'exponentielle. La troisième trace la tangente sans écrire de boucle, car 1+x est lui-même un tableau, calculé élément par élément. Avec np.arange(-2,2,0.02), on obtiendrait des abscisses espacées de $0{,}02$ elles aussi, mais de $-2$ à $1{,}98$ seulement, car la borne droite de np.arange est exclue, comme celle de range.

On remarque que la courbe de l'exponentielle reste au-dessus de sa tangente. Le graphique illustre ainsi l'inégalité $e^x\geq1+x$, vraie pour tout réel $x$, mais il ne la démontre pas. Pour la démontrer, on étudie la fonction $g:x\mapsto e^x-1-x$. Sa dérivée $g':x\mapsto e^x-1$ est négative sur $]-\infty,0]$ et positive sur $[0,+\infty[$, donc $g$ atteint en $0$ son minimum, qui vaut $g(0)=0$. La fonction $g$ est donc positive sur $\R$, ce qui donne l'inégalité $e^x\geq1+x$ quel que soit le réel $x$.

Représenter les termes d'une suite

Pour une suite, le programme demande de savoir représenter les points $(n,u_n)$. On range les termes dans une liste, puis on les trace avec l'option 'o' (points isolés, sans ligne). Avec la suite de Héron de la section 4 :

N=20
u=1
valeurs=[u]
for n in range(N):
    u=(u+2/u)/2
    valeurs.append(u)
plt.plot(range(N+1),valeurs,'o')
plt.show()

Le graphique rend la convergence vers $\sqrt2$ visible dès les premiers rangs.

8. Simuler une expérience aléatoire et étudier un échantillon

Le module numpy.random, abrégé en rd, fournit ainsi les briques de base :

Exemple : estimer la probabilité d'obtenir au moins un $6$ en quatre lancers d'un dé équilibré.

import numpy.random as rd

N=10**5
c=0
for k in range(N):
    succes=0
    for i in range(4):
        if rd.randint(1,7)==6:
            succes=1
    c=c+succes
print(c/N)

La valeur exacte est $1-\left(\dfrac56\right)^4\approx0{,}5177$ ; le script affiche une fréquence proche de cette valeur.

Échantillons avec numpy.random

La commande plt.hist(ech) trace l'histogramme d'un échantillon ech : on peut ainsi comparer les fréquences observées à la loi théorique, par exemple confronter un échantillon de loi $\mathcal{B}\left(n,\frac{\lambda}{n}\right)$ à un échantillon de loi de Poisson $\mathcal{P}(\lambda)$.

Indicateurs empiriques

import numpy as np
import numpy.random as rd
import matplotlib.pyplot as plt
ech = rd.binomial(20, 0.3, 10000)
print(np.mean(ech), np.var(ech))
plt.hist(ech, bins=range(22), density=True)
plt.show()

Ici, la moyenne et la variance empiriques sont proches des valeurs théoriques $np=6$ et $np(1-p)=4{,}2$.

Approche expérimentale de la loi de Gauss

Si $X\sim\mathcal{B}(n,p)$ avec $n$ grand et $p$ éloigné de $0$ et de $1$, la variable centrée réduite

présente un histogramme proche de la courbe de densité $x\mapsto\dfrac{1}{\sqrt{2\pi}}e^{-x^2/2}$. Cette comparaison est expérimentale : elle sert à visualiser l'approximation gaussienne, pas à la démontrer.

n = 100
p = 0.4
X = rd.binomial(n, p, 20000)
Z = (X - n*p) / np.sqrt(n*p*(1-p))
x = np.linspace(-4, 4, 400)
y = np.exp(-x**2/2) / np.sqrt(2*np.pi)
plt.hist(Z, bins=35, density=True)
plt.plot(x, y)
plt.show()

9. La méthode de dichotomie

On cherche une valeur approchée d'une solution de l'équation $f(x)=0$, lorsque l'on ne sait pas la résoudre de façon exacte. La méthode de dichotomie s'applique à une fonction $f$ continue sur un segment, à condition que $f$ prenne aux deux extrémités de ce segment des valeurs de signes contraires.

Principe de la méthode

Soit $f$ continue sur $[a,b]$, avec $f(a)f(b)\leq0$. Cette condition signifie que l'un des nombres $f(a)$ et $f(b)$ est nul, ou qu'ils ont des signes contraires. Le théorème des valeurs intermédiaires assure alors l'existence d'au moins un zéro de $f$ dans $[a,b]$.

On note $m=\dfrac{a+b}{2}$ le milieu de $[a,b]$, et on examine le signe de $f(a)f(m)$ :

• si $f(a)f(m)\leq0$, le théorème des valeurs intermédiaires, appliqué sur $[a,m]$, montre que $f$ s'annule sur $[a,m]$ ; on remplace alors $b$ par $m$ ;

• sinon, $f(a)f(m)>0$, donc $f(a)$ et $f(m)$ sont non nuls et de même signe. Comme $f(a)f(b)\leq0$, le réel $f(b)$ est nul ou de signe contraire à celui de $f(a)$, donc à celui de $f(m)$. Ainsi $f(m)f(b)\leq0$ et $f$ s'annule sur $[m,b]$ ; on remplace alors $a$ par $m$.

Dans les deux cas, le nouveau segment $[a,b]$ vérifie encore $f(a)f(b)\leq0$ : il contient encore une solution, et sa longueur a été divisée par $2$. On répète cette étape. Notons $[a_n,b_n]$ le segment obtenu après $n$ étapes, avec $[a_0,b_0]=[a,b]$. Pour tout $n\in\N$, le segment $[a_n,b_n]$ contient une solution $\alpha$ de l'équation et a pour longueur $\dfrac{b-a}{2^n}$. Comme $a_n\leq\alpha\leq b_n$, chacune des bornes $a_n$ et $b_n$ est une valeur approchée de $\alpha$ à $\dfrac{b-a}{2^n}$ près.

Critère d'arrêt et nombre d'étapes

On fixe une précision $\varepsilon>0$, et on arrête les étapes dès que la longueur $b_n-a_n$ est inférieure ou égale à $\varepsilon$. Comme $b_n-a_n=\dfrac{b-a}{2^n}$, cette condition équivaut à $2^n\geq\dfrac{b-a}{\varepsilon}$, c'est-à-dire à

Le nombre d'étapes est donc connu avant même de lancer le calcul, et la boucle se termine toujours. Ce nombre dépend seulement de la longueur du segment de départ et de la précision demandée, et non de la fonction $f$.

Programme

En Python, une fonction peut recevoir une autre fonction en argument. La fonction dichotomie ci-dessous reçoit ainsi la fonction f dont on cherche un zéro, les bornes a et b du segment de départ et la précision eps. Elle renvoie les bornes du segment final et le nombre n d'étapes effectuées. Le programme l'applique ensuite à deux équations.

def dichotomie(f,a,b,eps):
    n=0
    while b-a>eps:
        m=(a+b)/2
        if f(a)*f(m)<=0:
            b=m
        else:
            a=m
        n=n+1
    return a,b,n

def f(x):
    return x**3+x-1

def g(x):
    return np.sin(x)

print(dichotomie(f,0,1,10**(-4)))
print(dichotomie(g,3,4,10**(-5)))

Exemple 1. La fonction $f:x\mapsto x^3+x-1$ est dérivable sur $\R$, et $f'(x)=3x^2+1>0$ pour tout réel $x$ : $f$ est strictement croissante. Elle est aussi continue, et ses valeurs $f(0)=-1$ et $f(1)=1$ encadrent $0$. Le théorème de la bijection montre alors que l'équation $x^3+x-1=0$ a exactement une solution $\alpha$ dans $[0,1]$. Pour la précision $\varepsilon=10^{-4}$, il faut $n\geq\dfrac{\ln\left(10^4\right)}{\ln2}\approx13{,}3$, soit $14$ étapes. Le programme affiche en effet (0.68231201171875, 0.682373046875, 14). Les bornes affichées encadrent $\alpha$ : $0{,}68231\leq\alpha\leq0{,}68238$. Le réel $0{,}6823$ approche donc $\alpha$ à $10^{-4}$ près.

Exemple 2. On prend $g=\sin$, dont la dérivée est $\cos$. Pour tout $x\in[3,4]$, on a $\dfrac{\pi}{2}<x<\dfrac{3\pi}{2}$, donc $\cos x<0$ : $g$ est strictement décroissante sur $[3,4]$. De plus, $\sin3>0$ car $0<3<\pi$, et $\sin4<0$ car $\pi<4<2\pi$. La fonction $\sin$ s'annule donc une seule fois sur $[3,4]$, en $\pi$, et la dichotomie fournit des valeurs approchées de $\pi$. Cette fois, la fonction est positive en $3$ et négative en $4$. Le programme s'applique sans modification, car le test f(a)*f(m)<=0 porte sur le signe du produit, et non sur le signe de chacun des deux facteurs. Pour $\varepsilon=10^{-5}$, il faut $n\geq\dfrac{\ln\left(10^5\right)}{\ln2}\approx16{,}6$, soit $17$ étapes, et le programme affiche (3.1415863037109375, 3.1415939331054688, 17). Le réel $3{,}14159$ est compris entre ces deux bornes, donc il approche $\pi$ à $10^{-5}$ près.

Limites de la méthode

• Lorsque l'équation admet plusieurs solutions dans $[a,b]$, la méthode en approche une seule, et elle ne dit pas laquelle. Pour approcher une solution précise, on l'isole d'abord dans un segment sur lequel $f$ est strictement monotone, comme dans les deux exemples.

• La méthode exige un changement de signe. La fonction $h:x\mapsto1-\cos x$ s'annule en $0$, mais elle ne prend aucune valeur strictement négative, car $\cos x\leq1$ pour tout réel $x$. Pour un segment $[a,b]$, la condition $h(a)h(b)\leq0$ n'est donc vérifiée que si $a$ ou $b$ annule $h$, c'est-à-dire si l'on connaît déjà un zéro de $h$ : la méthode ne sert pas à trouver les zéros de cette fonction.

• Chaque étape divise la longueur du segment par $2$ seulement. Comme $2^{10}=1024\approx10^3$, dix étapes font gagner environ trois décimales.

10. La méthode des rectangles

La fonction $\ln$ est la primitive sur $]0,+\infty[$ de la fonction $t\mapsto\dfrac1t$ qui s'annule en $1$. Par conséquent, $\ln2=\displaystyle\int_1^2\frac{dt}{t}$ : le nombre $\ln2$ est l'aire du domaine situé sous la courbe de $t\mapsto\dfrac1t$, au-dessus de l'axe des abscisses, pour $t$ allant de $1$ à $2$. La méthode des rectangles approche une telle aire par une somme d'aires de rectangles, que l'on calcule avec des additions et des multiplications seulement. Cette section majore l'erreur commise, puis elle confronte cette majoration à la valeur de $\ln2$ que donne Python.

On fixe un segment $[a,b]$, une fonction $f$ de classe $\mathcal{C}^1$ sur $[a,b]$ et un entier $n\geq1$. On partage $[a,b]$ en $n$ segments de même longueur $h=\dfrac{b-a}{n}$, d'extrémités $x_k=a+kh$ pour $k\in\llbracket0,n\rrbracket$. Sur chaque segment $[x_k,x_{k+1}]$, on remplace $f$ par la constante $f(x_k)$, sa valeur en l'extrémité gauche du segment. On obtient la somme des rectangles à gauche

Majoration de l'erreur

La dérivée $f'$ est continue sur le segment $[a,b]$ ; on note $M$ le maximum de $|f'|$ sur ce segment. On fixe $k\in\llbracket0,n-1\rrbracket$, et on note

l'écart, sur le segment $[x_k,x_{k+1}]$, entre l'intégrale de $f$ et la contribution du rectangle. Le nombre $hf(x_k)$ est l'intégrale sur ce segment de la fonction constante égale à $f(x_k)$. La valeur absolue de $e_k$ est donc au plus l'aire du domaine compris, pour $t$ allant de $x_k$ à $x_{k+1}$, entre la droite horizontale d'équation $y=f(x_k)$ et la courbe de $f$.

À l'abscisse $t$, ce domaine a pour hauteur $|f(t)-f(x_k)|$. D'après l'inégalité des accroissements finis, vue au chapitre Dérivation, cette hauteur est au plus égale à $M$ fois la distance de $t$ à $x_k$. Or, à la même abscisse $t$, le triangle rectangle de sommets $(x_k,0)$, $(x_{k+1},0)$ et $(x_{k+1},Mh)$ a précisément pour hauteur $M(t-x_k)$. L'aire du domaine est donc au plus celle de ce triangle, dont les côtés de l'angle droit mesurent $h$ et $Mh$ :

D'après la relation de Chasles, l'erreur totale $\displaystyle\int_a^bf(t)\,dt-R_n$ est la somme des $n$ écarts $e_0,\dots,e_{n-1}$. L'inégalité triangulaire donne alors

Le majorant devient aussi petit que l'on veut lorsque $n$ grandit. La somme $R_n$ approche ainsi l'intégrale de $f$ sur $[a,b]$, et l'inégalité indique combien de rectangles prendre pour garantir une précision donnée.

def rectangles(f,a,b,n):
    h=(b-a)/n
    total=0
    for k in range(n):
        total=total+f(a+k*h)
    return h*total

def f(t):
    return 1/t

R=rectangles(f,1,2,500)
print(R)
print(R-np.log(2))

11. Résolution des systèmes linéaires

Un système de $n$ équations linéaires à $n$ inconnues s'écrit sous la forme matricielle $AX=B$, où $A\in\mathcal{M}_n(\R)$ est la matrice des coefficients, $X$ la colonne des inconnues et $B$ la colonne des seconds membres. Lorsque $A$ est inversible, on multiplie à gauche par $A^{-1}$ : $X=A^{-1}B$ est alors la seule solution. La commande al.solve(A,B) de la bibliothèque numpy.linalg, importée sous l'abréviation al (section 6), calcule cette solution.

>>> A=np.array([[2,1,0],[0,1,1],[1,0,3]])
>>> B=np.array([7,3,9])
>>> X=al.solve(A,B)
>>> X
array([3., 1., 2.])
>>> np.dot(A,X)
array([7., 3., 9.])