Python
Oral
MP, PC, PSI, TSI
Analyse numérique
La plupart des fonctions présentées dans cette section nécessitent l’import du module numpy et de sous-modules
du module scipy. Les instructions nécessaires aux exemples suivants sont listés ci-dessous.
import numpy as np
import [Link] as resol
import [Link] as integr
import [Link] as plt
Nombres complexes
Python calcule avec les nombres complexes. Le nombre imaginaire pur 𝑖 se note 1j. Les attributs real et imag
permettent d’obtenir la partie réelle et la partie imaginaire. La fonction abs calcule le module d’un complexe.
>>> a = 2 + 3j
>>> b = 5 - 3j
>>> a*b
(19+9j)
>>> [Link]
2.0
>>> [Link]
3.0
>>> abs(a)
3.6055512754639896
Fonctions mathématiques
La constante 𝜋 s’obtient grâce à la commande pi.
Le module numpy connaît les fonctions mathématiques usuelles. La fonction partie entière s’obtient par la
commande floor. Attention la fonction logarithme népérien a pour nom de commande log.
>>> [Link](1)
2.7182818284590451
>>> [Link]([Link])
-1.0
>>> [Link]([Link](1))
1.0
>>> [Link](3.4)
3
>>> [Link](-3.7)
-4
15 mai 2017 08:37 Python-AN-1
Résolution approchée d’équations
Pour résoudre une équation du type 𝑓(𝑥) = 0 où 𝑓 est une fonction d’une variable réelle, on peut utiliser la
fonction fsolve du module [Link]. Il faut préciser la valeur initiale 𝑥0 de l’algorithme employé par
la fonction fsolve. Le résultat peut dépendre de cette condition initiale.
def f(x) :
return x**2 - 2
>>> [Link](f, -2.)
array([-1.41421356])
>>> [Link](f, 2.)
array([ 1.41421356])
Dans le cas d’une fonction 𝑓 à valeurs vectorielles, on utilise la fonction root. Par exemple, pour résoudre le
système non linéaire
𝑥2 − 𝑦2 = 1
{
𝑥 + 2𝑦 − 3 = 0
def f(v) :
return v[0]**2 - v[1]**2 - 1, v[0] + 2*v[1] - 3
>>> sol = [Link](f, [0,0])
>>> [Link]
True
>>> sol.x
array([ 1.30940108, 0.84529946])
>>> sol=[Link](f, [-5,5])
>>> [Link]
True
>>> sol.x
array([-3.30940108, 3.15470054])
Calcul approché d’intégrales
La fonction quad du module [Link] permet de calculer des valeurs approchées d’intégrales. Elle
renvoie une valeur approchée de l’intégrale ainsi qu’un majorant de l’erreur commise. Cette fonction peut aussi
s’employer avec des bornes d’intégration égales à +∞ ou −∞.
def f(x) :
return [Link](-x)
>>> [Link](f, 0, 1)
(0.6321205588285578, 7.017947987503856e-15)
>>> [Link](f, 0, [Link])
(1.0000000000000002, 5.842607038578007e-11)
Cette fonction peut être employée pour la définition d’intégrales à paramètres. Ainsi si on veut obtenir des
+∞
valeurs approchées de Γ(𝑥) = ∫ 𝑒−𝑡 𝑡𝑥−1 d𝑡 pour 𝑥 réel strictement positif on pourra procéder ainsi :
0
def g(x) :
def f(t) :
return [Link](-t)*t**(x-1)
return [Link](f,0,[Link])[0]
>>> g(2)
0.9999999999999998
15 mai 2017 08:37 Python-AN-2
Résolution approchées d’équations différentielles
Pour résoudre une équation différentielle 𝑥′ = 𝑓(𝑥, 𝑡), on peut utiliser la fonction odeint du module [Link]-
tegrate. Cette fonction nécessite une liste de valeurs de 𝑡, commençant en 𝑡0 , et une condition initiale 𝑥0 . La
fonction renvoie des valeurs approchées (aux points contenus dans la liste des valeurs de 𝑡) de la solution 𝑥
de l’équation différentielle qui vérifie 𝑥(𝑡0 ) = 𝑥0 . Pour trouver des valeurs approchées sur [0, 1] de la solution
𝑥′(𝑡) = 𝑡𝑥(𝑡) qui vérifie 𝑥(0) = 1, on peut employer le code suivant.
def f(x, t) :
return t*x
>>> T = [Link](0, 1.01, 0.01)
>>> X = [Link](f, 1, T)
>>> X[0]
array([ 1.])
>>> X[-1]
array([ 1.64872143])
>>> [Link](T,X)
>>> [Link]()
Si on veut résoudre, sur [0, 1], le système différentiel
𝑥′(𝑡) = −𝑥(𝑡) − 𝑦(𝑡)
{
𝑦′(𝑡) = 𝑥(𝑡) − 𝑦(𝑡)
avec la condition initiale 𝑥(0) = 2, 𝑦(0) = 1 le code devient le suivant.
def f(x, t) :
return [Link]([-x[0]-x[1], x[0]-x[1]])
>>> T = [Link](0, 5.01, 0.01)
>>> X = [Link](f, [Link]([2.,1.]), T)
>>> X[0]
array([ 2., 1.])
>>> [Link](X[ :,0], X[ :,1])
>>> [Link]()
15 mai 2017 08:37 Python-AN-3
Pour résoudre une équation différentielle scalaire d’ordre 2 de solution 𝑥, on demandera la résolution du système
𝑥(𝑡)
différentiel d’ordre 1 satisfait par 𝑋(𝑡) = ( ).
𝑥′(𝑡)
Ainsi, si on considère la fonction 𝑥 qui vérifie l’équation différentielle 𝑥″(𝑡) + 2𝑥′(𝑡) + 3𝑥(𝑡) = sin(𝑡) avec les
𝑥′(𝑡)
conditions initiales 𝑥(0) = 0, 𝑥′(0) = 1 et , le vecteur 𝑋 vérifiera 𝑋′(𝑡) = ( ). Pour
−2𝑥′(𝑡) − 3𝑥(𝑡) − sin(𝑡)
obtenir la représentation graphique de 𝑥 sur l’intervalle [0, 3𝜋], on pourra utiliser le code suivant :
def f(x,t) :
return [Link]([x[1], -2*x[1] - 3*x[0] + [Link](t)])
T = [Link](0, 3*[Link] + 0.01, 0.01)
X = [Link](f, [Link]([0,1]), T)
[Link](T, X[ :,0])
[Link]()
15 mai 2017 08:37 Python-AN-4