CHAPITRE

 6  
 

Outils  numériques  et  graphiques  de  Python  

 
 
Pour  pouvoir  traiter  efficacement    des  problèmes  scientifiques  à  l’aide  de  l’outil  informatique,  il  est  
nécessaire   de   savoir   utiliser   les   outils   numériques   à   disposition   (fonctions   mathématiques,   outils   de  
résolution  numérique  pour  les  équations  différentielles,  calcul  de  dérivées  et  d’intégrales…)  ainsi  que  
de  savoir  tracer  des  graphiques  à  l’écran.  C’est  tout  le  but  de  ce  chapitre.  

1. Le  module  Numpy  
Le   module   Numpy   de   Python   est   un   ensemble   de   fonctions   pour   le   calcul   scientifique,   regroupant  
des  fonctions  mathématiques  (valeur  absolue,  module  et  argument  d’un  nombre  complexe,  fonctions  
trigonométriques…),  ainsi  que  des  fonctions  destinées  à  manipuler  des  vecteurs  ou  tableaux.  
L’ensemble  de  la  documentation  sur  le  module  Numpy  est  accessible  sur  le  site  :  
http://www.numpy.org/  

1.1.  Importation  du  module  Numpy  

L’importation  du  module  Numpy  peut  se  réaliser  selon  l’une  des  deux  syntaxes  suivantes  :  
from numpy import *
ou  
import numpy as np

La  première  syntaxe  charge  le  module  Numpy,  l’exécute  et  place  toutes  les  fonctions  du  module  dans  
l’espace  des  noms  communs.  Si  deux  modules  possèdent  des  fonctions  portant  le  même  nom,  seule  la  
fonction   du   dernier   module   importé   sera   exécutable   (puisque   son   importation   aura   écrasé   la  
précédente).  C’est  pourquoi,  on  préfèrera  toujours  la  seconde  syntaxe,  qui  réalise  une  importation  en  
notation   pointée.   Avec   ce   type   de   syntaxe,   les   fonctions   du   module   ne   sont   pas   importées   dans  
l’espace  des  noms  communs  mais  dans  un  espace  dédié.  Pour  y  accéder,  il  faudra  en  revanche  préciser  
dans  quel  espace  propre  il  faut  aller  chercher  la  fonction,  selon  la  syntaxe  :  
import numpy as np # on importe le module Numpy, en nommant l’espace dédié np
np.linspace(0,1,5) # on appelle ici la fonction linspace du module Numpy

1.2.  Fonctions  mathématiques  basiques  de  Numpy  

Voici  quelques  exemples  de  fonctions  mathématiques  contenues  dans  le  module  Numpy  :  
•  np.rint(x)  :  renvoie  le  nombre  entier  le  plus  proche  du  nombre  flottant  x  
•  np.floor(x)  :  renvoie  la  partie  entière  supérieure  du  nombre  flottant  x  
•  np.ceil(x)  :  renvoie  la  partie  entière  inférieure  du  nombre  flottant  x  
•  np.sqrt(x)  :  renvoie  la  racine  carrée  de  x  
•  np.abs(x)  :  renvoie  la  valeur  absolue  de  x  
2                                                      Chapitre  6  :  Outils  graphiques  et  numériques  de  Python  

Numpy  permet  d’utiliser  les  fonctions  mathématiques  usuelles  :  

•  np.exp(x)  :  fonction  exponentielle  
•  np.log(x)  :  fonction  logarithme  népérien  
•  np.sin(x)  /  np.cos(x)  :  fonctions  sinus  /  cosinus    
•  np.tan(x)  :  fonction  tangente  
•  np.arcsin(x)  /  np.arccos(x)  :  fonctions  inverses  de  sinus  /  cosinus    
•  np.arctan(x)  :  fonction  inverse  de  tangente    
•  np.sinh(x)  /  np.cosh(x)  :  fonctions  sinus  hyperbolique  /  cosinus  hyperbolique    
•  np.tanh(x)  :  fonction  tangente  hyperbolique  
Numpy  contient  également  des  fonctions  permettant  les  calculs  usuels  sur  les  nombres  complexes  :  
•  np.real(x)  :  renvoie  la  partie  réelle  du  nombre  complexe  x  
•  np.imag(x)  :  renvoie  la  partie  imaginaire  du  nombre  complexe  x  
•  np.abs(x)  :  renvoie  le  module  du  nombre  complexe  x  
•  np.angle(x)  :  renvoie  l’argument  (en  radians)  du  nombre  complexe  x  
•  np.conj(x)  :  renvoie  le  complexe  conjugué  du  nombre  complexe  x  

Les   fonctions   mathématiques   contenues   dans   le   module   Numpy   sont   redondantes   avec   celles   du  
module  math  (elles  généralisent  en  fait  les  fonctions  du  module  math  pour  tous  les  types,  y  compris  les  
tableaux)  :  il  est  donc  inutile  d’importer  le  module  math  dès  que  l’on  importe  Numpy.  

1.3.  Fonctions  de  Numpy  pour  créer  des  tableaux  1D  

Numpy  permet  cependant  de  créer  des  tableaux  1D  (ou  vecteurs)  avec  les  fonctions  suivantes  :  
•  la  fonction  np.array(a,b,c,d,e)  renvoie  un  tableau  1D  dont  les  valeurs  sont  a,  b,  c,  d  et  e.  
•   la   fonction   np.arrange(a,b,c)  renvoie   un   tableau   1D   dont   la   borne   inférieure   est   a,   la   borne  
supérieure  est  b  et  l’intervalle  entre  les  différentes  composantes  du  tableau  est  c.    
•   la   fonction   np.linspace(a,b,c)  renvoie   un   tableau   1D   dont   la   borne   inférieure   est   a,   la   borne  
supérieure  est  b  et  contenant  c  termes  équirépartis.  
•    la  fonction  np.zeros(n)  renvoie  un  tableau  1D  contenant  n  termes  égaux  à  0.    
•    la  fonction  np.ones(n)  renvoie  un  tableau  1D  contenant  n  termes  égaux  à  1.    
Exemples  :    
import  numpy  as  np  
np.arrange(3,15,2)         np.linspace(2,10,5)  
   Résultat  :  [3  ,  5  ,  7  ,  9  ,  11  ,  13]          Résultat  :  [2  ,  4  ,  6  ,  8  ,  10]  

Notons   que   dans   la   fonction   np.arrange   la   borne   supérieure   de   l’intervalle   est   exclue   du   tableau,  
alors   que   dans   la   fonction   np.linspace   la   borne   supérieure   de   l’intervalle   est   incluse   dans   le  
tableau.  

2. Le  module  Matplotlib  
Le   module   Matplotlib   de   Python   contient   des   fonctions   pour   réaliser   des   graphiques   2D   et   3D  
(tracé  de  fonctions,  de  courbes  de  points,  d’histogrammes,  d’images  en  fausses  couleurs…).  
L’ensemble  de  la  documentation  sur  le  module  Matplotlib  est  accessible  sur  le  site  :  
http://matplotlib.org/  
  Chapitre  6  :  Outils  graphiques  et  numériques  de  Python                          3  

2.1.  Importation  du  module  Matplotlib  

L’importation   du   module   Matplotlib   se   réalise   en   important   pyplot,   qui   est   un   sous-­‐module   de  
Matplotlib  qui  fournit  une  interface  très  similaire  à  Matlab  et  Scilab  (logiciels  de  simulation  numérique  
très  utilisés  dans  le  monde  scientifique).  L’importation  utilise  alors  la  syntaxe  suivante  :  
from matplotlib.pyplot import pl

Remarque  :  le  module  Matplotlib  contient  également  le  sous-­‐module  pylab,  qui  combine  les  fonctions  de  
tracé  du  module  pyplot  et  les  fonctions  de  Numpy,  permettant  ainsi  de  ne  réaliser  qu’une  importation.    

2.2.  Tracé  de  courbes  avec  la  fonction  plot  

La   fonction   plot   du   module   pyplot   permet   de   tracer   des   fonctions.   Elle   possède   deux   arguments  
d’entrée  :  
1  -­‐  un  tableau  1D  contenant  les  valeurs  des  abscisses  
2  -­‐  un  tableau  1D,  de  même  longueur,  contenant  les  valeurs  des  ordonnées.  
La  fonction  plot  seule  ne  permet  pas  l’affichage  de  la  courbe  à  l’écran.  Il  faut  lui  ajouter  à  la  suite  la  
fonction  show,  fonction  similaire  dans  son  principe  à  la  fonction  print.  

Exemple  :  tracé  de  la  fonction  cosinus  

import numpy as np # on importe le module Numpy
import matplotlib.pyplot as pl # on importe le sous-module pyplot
x = np.linspace(0,2*pi,100) # on définit ici le vecteur des abscisses x
y = np.cos(x) # on définit ici le vecteur des ordonnées y
pl.plot(x,y) # on réalise le tracé de la courbe y en fonction de x
pl.show() # on demande à Python d’afficher la courbe à l’écran

2.3.  Mise  en  forme  des  graphiques    

•  Définition  du  domaine  des  axes  
Si   rien   n’est   précisé,   la   fonction   plot   règle   automatiquement   le   domaine   des   axes   des   abscisses   et   des  
ordonnées  pour  qu’ils  couvrent  le  domaine  de  variation  défini  par  les  vecteurs  x  et  y.  Il  est  cependant  
possible  de  fixer  manuellement  ces  domaines  en  utilisant  les  fonctions  xlim  et  ylim.  
4                                                      Chapitre  6  :  Outils  graphiques  et  numériques  de  Python  

Exemple  :  
import numpy as np
import matplotlib.pyplot as pl
x = np.linspace(0,2*pi,100)
y = np.sin(x)
pl.plot(x,y)
pl.ylim(-2,2) # l’axe des ordonnées sera affiché entre -2 et 2
pl.show()

•  Ajout  de  titres  

Il  est  possible  d’ajouter  un  titre  au  graphique  grâce  à  la  fonction  title,  ainsi  que  des  titres  aux  axes  
grâce  aux  fonctions  xlabel  et  ylabel.  
Exemple  :  
import numpy as np
import matplotlib.pyplot as pl

x = np.linspace(0,2*pi,100)
y = np.sin(x)

pl.plot(x,y)
pl.ylim(-2,2)
pl.title(‘Tracé de la fonction sinus’) # on ajoute un titre au graphique
pl.xlabel(‘Angle (en radians)’) # on ajoute un titre à l’axe x
pl.show()

•  Couleur  et  style  des  courbes  

Il   est   possible   de   préciser   la   couleur,   le   style   de   ligne   et   le   symbole   (marqueur)   en   ajoutant   une  
chaîne  de  caractère  dans  la  fonction  plot,  selon  la  syntaxe  suivante  :  
pl.plot(x,y,’r’-o’)

Choix  des  couleurs  :                  Choix  des  marqueurs  :        

Couleur   Syntaxe     Marqueur   Syntaxe  

Rouge     ‘r’     Cercle   ‘o’  
Vert     ‘g’   Triangle  vers  le  bas  /  haut   ‘v’    ou    ‘^’  
Bleu   ‘b’   Triangle  vers  la  gauche  /    droite   ‘<’    ou    ‘>’  
Cyan   ‘c’   Carré     ‘s’  
Magenta   ‘m’   Etoile    ‘*’  
Jaune   ‘y’   Signe  +    ‘+’  
Noir   ‘k’   Croix   ‘x’  
 
Choix  du  style  de  ligne  :        

Style   Syntaxe  
Ligne  en  traits  pointillés    ‘-­‐-­‐’  
Lignes  en  pointillés   ‘:’  
Succession  traits/points   ‘-­‐.’  

   
  Chapitre  6  :  Outils  graphiques  et  numériques  de  Python                          5  

2.4.  Tracé  multiple  

•  Tracé  multiple  sur  la  même  figure  

Pour   tracer   plusieurs   courbes   dans   le   même   graphique,   on   utilise   la   syntaxe   de   l’exemple   ci-­‐dessous.  
On  peut  également  ajouter  une  légende  avec  la  commande  label,  à  insérer  dans  la  fonction  plot.  
Exemple  :  
import numpy as np
import matplotlib.pyplot as pl
x = np.linspace(0,2*pi,100) # on définit ici le vecteur des abscisses x
y1 = np.cos(x) # on définit ici le 1er vecteur des ordonnées
y2 = np.sin(x) # on définit ici le 2nd vecteur des ordonnées
pl.plot(x,y1,’b’,label=’cos(x)’) # on réalise le tracé de cosinus en bleu
pl.plot(x,y2,’g’ ,label=’sin(x)’) # on réalise le tracé de sinus en vert
pl.legend() # on demande à Python d’afficher les légendes sur la courbe
pl.show() # on demande à Python d’afficher les courbes à l’écran
pl.save(‘mafigure.bmp’) # on enregistre la figure dans le dossier courant

•  Tracé  multiple  sur  des  figures  différentes  

On  peut  également  souhaiter  tracer  plusieurs  figures,  sur  des  graphiques  différents  mais  s’affichant  
dans   la   même   fenêtre.   On   utilisera   alors   la   fonction   subplot   du   module   pyplot,   qui   affichent   les  
graphiques  sous  la  forme  d’une  matrice  𝑁!  lignes  ×  𝑁!  colonnes  de  graphiques.    
La   fonction   subplot   s’appelle   autant   de   fois   qu’il   y   a   de   figures   à   réaliser,   donc   𝑁! ×𝑁!   fois.   Elle  
possède  un  unique  argument  d’entrée  :  un  nombre  à  3  chiffres  
-­‐  le  premier  chiffre  valant  𝑁!  (nombre  de  lignes)  
-­‐  le  second  chiffre  valant  𝑁!  (nombre  de  colonnes)  
-­‐  le  dernier  chiffre  faisant  référence  à  la  position  de  la  figure  que  l’on  va  tracer  (il  est  donc  compris  
entre  1  et  𝑁! ×𝑁! ).  

 
6                                                      Chapitre  6  :  Outils  graphiques  et  numériques  de  Python  

Exemple  :  
import numpy as np
import matplotlib.pyplot as pl

def f(t)
return np.exp(-t)*np.cos(2*np.pi*t)

t = np.arrange(0,5,0.1) # on définit ici le vecteur des abscisses

y1 = f(t) # on définit ici le 1er vecteur des ordonnées
y2 = np.cos(2*np.pi*t) # on définit ici le 2nd vecteur des ordonnées

pl.subplot(211) # on crée le graphique de la 1ère ligne

pl.plot(t,y1,’bo’) # on réalise le tracé de la fonction f

pl.subplot(212) # on crée le graphique de la 2ème ligne

pl.plot(t,y2,’r--’ ) # on réalise le tracé de la fonction cos

pl.show() # Python d’afficher les courbes à l’écran

3. Le  module  Scipy  
Le   module   Scipy   est   un   ensemble   de   fonctions   mathématiques   avancées   (résolution   d’équations  
différentielles,  méthodes  de  calcul  intégral,  calcul  de  transformées  de  Fourier,  traitement  d’images…).  
L’ensemble  de  la  documentation  sur  le  module  Numpy  est  accessible  sur  le  site  :  
http://scipy.org/  
L’importation  du  module  Scipy  peut  se  réaliser  selon  la  syntaxe  suivante  :  
import scipy as sp

3.1.  Interpolation  
En   analyse,   l’interpolation   est l’opération   permettant   de   construire   une   courbe   à   partir   de   la  
donnée  d'un  nombre  fini  de  points,  ou  une  fonction  à  partir  de  la  donnée  d'un  nombre  fini  de  valeurs.  
Sous   Python,   cette   opération   est   réalisée   à   l’aide   du   module   scipy.interpolate.   Nous   utiliserons   en  
particulier  la  fonction  interp1d  qui  permet  d’interpoler  des  courbes  à  une  dimension,  c’est-­‐à-­‐dire  des  
  Chapitre  6  :  Outils  graphiques  et  numériques  de  Python                          7  

nuages   de   points   dont   on   connaît   les   valeurs   des   abscisses   et   des   ordonnées.   Cette   fonction   possède  
deux  arguments  d’entrée  obligatoires  :  
1  -­‐  un  tableau  1D  contenant  les  abscisses  des  points  à  interpoler  
2  -­‐  un  tableau  1D,  de  même  longueur,  contenant  les  ordonnées  des  points  à  interpoler  
Attention  !  Le  résultat  de  la  fonction  interp1d  est  lui-­‐même  une  fonction  et  s’appelle  donc  avec  un  
argument  d’entrée  (cf.  exemples  ci-­‐dessous).  
Plusieurs  types  d’interpolation  sont  possibles  :  
-­‐   l’interpolation   linéaire,   qui   est   l’interpolation   par   défaut   (c’est-­‐à-­‐dire   celle   qui   est   employée  
lorsqu’aucune   argument   n’est   spécifié   lors   de   l’utilisation   de   la   fonction   interp1d).   L’interpolation  
linéaire  relie  simplement  les  différents  points  par  des  segments.  
-­‐   l’interpolation   quadratique,   qui   s’utilise   par   l’argument   kind=’quadratic’   en   argument   de   la  
fonction  interp1d.  Cette  interpolation utilise  une  équation  quadratique  pour  modéliser  localement  la  
courbe.  
-­‐l’interpolation   cubique,   qui   s’utilise   par   l’argument   kind=’cubic’   en   argument   de   la   fonction  
interp1d.  Cette  interpolation utilise  une  équation  cubique  pour  modéliser  localement  la  courbe.  

Exemple  :  
import scipy.interpolate as sp # on importe le sous-module Interpolate
import numpy as np # on importe le module Numpy
import matplotlib.pyplot as pl # on importe le sous-module pyplot

x = np.linspace (0,1,10) # on crée un vecteur définissant 10

points sur l’intervalle [0,1],
correspondant aux abscisses des points
à interpoler
y = np.sin(2*np.pi*x) # on crée un vecteur correspondant au
sinus des points de x, correspondant
aux ordonnées des points à interpoler
linear = sp.interp1d(x,y) # interpolation linéaire des points
cubic = sp.interp1d(x,y,kind=’cubic’) # interpolation cubique des points

pl.plot(x,y,’bo’,label=’points originaux’)
pl.plot(x,linear(x),’g’,label=’interpolation linaire’)
pl.plot(x,cubic(x),’r’ ,label=’interpolation cubique’)
pl.show()
pl.legend()

 
8                                                      Chapitre  6  :  Outils  graphiques  et  numériques  de  Python  

3.2.  Résolution  d’équations  différentielles  du  premier  ordre  

Le   module   scipy.integrate   contient   la   fonction   odeint,   qui   résout   numériquement   des   équations  
différentielles  du  premier  ordre,  de  la  forme  (cf.  Projet  1)  :  
𝑑𝑦
𝑦! =
= 𝑓(𝑦 𝑡 , 𝑡)  
𝑑𝑡
La  fonction  odeint  possède  trois  arguments  d’entrée  :  
1  -­‐  une  fonction  traduisant  l’équation  différentielle  
2  -­‐  un  nombre,  traduisant  la  condition  initiales  𝑦! = 𝑦(𝑡 = 0)  
3  -­‐  un  tableau  1D  contenant  les  valeurs  de  temps  sur  lequel  on  résout  l’équation  différentielle  

Exemple  :  
On  souhaite  résoudre,  avec  la  condition  initiale    𝑦! = 𝑦 𝑡 = 0 = 1,  l’équation  différentielle  :  
𝑑𝑦
= −2𝑦  
𝑑𝑡
 
import scipy.integrate as integrate # on importe le module scipy.integrate
import numpy as np # on importe le module Numpy
import matplotlib.pyplot as pl # on importe le sous-module pyplot
def equation(y,t) # fonction traduisant le second membre
return -2*y
t = np.linspace(0,10,100) # vecteur temps (100 points entre 0 et 10 s)
y0 = 1 # spécification de la valeur de y en t = 0 s
y = integrate.odeint(equation,y0,t)
pl.plot(t,y,’b’)
pl.show()

3.3.  Résolution  d’équations  différentielles  du  premier  ordre  

La  fonction  odeint  permet  également  de  résoudre  des  équations  différentielles  d’ordre  2  de  la  forme  :  
𝑦 !! = 𝑓(𝑦 ! 𝑡 , 𝑦 𝑡 , 𝑡)  
La  résolution  de  cette  équation  différentielle  passera  par  la  résolution  du  système  différentiel  :  
𝑦!! 𝑡 = 𝑦! 𝑡                                            
   
𝑦!! 𝑡 = 𝑓 𝑦! 𝑡 , 𝑦! 𝑡 , 𝑡
Dans  le  résultat  (qui  est  un  tableau  à  deux  dimensions)  :  
-­‐ les  premières  composantes  (c’est-­‐à-­‐dire  la  première  colonne  du  tableau)  représentent  les  valeurs  
prises  par  𝑦(𝑡)    
-­‐ les  secondes  composantes  (c’est-­‐à-­‐dire  la  seconde  colonne  du  tableau)  représentent  les  valeurs  
prises  par  𝑦 ! (𝑡).  
Cela  permet  (au  choix)  de  représenter  𝑦(𝑡)  en  fonction  du  temps  ou  bien  𝑦 ! 𝑡  en  fonction  de  𝑦(𝑡),  
c’est-­‐à-­‐dire  le  portrait  de  phase  du  problème.  

 
  Chapitre  6  :  Outils  graphiques  et  numériques  de  Python                          9  

Exemple  :  
On   souhaite   résoudre,   avec   les   condition   initiales     𝜃! = 𝜃 𝑡 = 0 = 𝜋/4  et  𝜃! = 𝜃 𝑡 = 0 = 0,  
l’équation  différentielle  :  
𝜃 + sin 𝜃 = 0  
 
import scipy.integrate as integrate # on importe le module scipy.integrate
import numpy as np # on importe le module Numpy
import matplotlib.pyplot as pl # on importe le sous-module pyplot
def pendule(coord,t) # fonction traduisant l’équation différentielle
Theta = coord[0] # 𝜃 est dans l’élément 1 du vecteur coord
Theta_point = coord[1] # 𝜃 est dans l’élément 2 du vecteur coord
Theta_pointpoint = -np.sin(Theta) # définition de l’équation différentielle
return ([Theta_point,Theta_pointpoint])

t = np.linspace(0,10,100) # vecteur temps de 100 points entre 0 et 10 s

Theta0 = np.pi/4 # on spécifie la valeur de 𝜃 en t = 0 s
Theta_point0 = 0 # on spécifie la valeur de 𝜃 en t = 0 s
coord0 = [Theta0,Theta_point0] # tableau contenant les conditions initiales
solution = integrate.odeint(pendule,coord0,t)
pl.plot(t,solution[:,0]) # tracé de 𝜃 en fonction du temps
pl.show()

3.4.  Calcul  intégral  

Le   module   scipy.integrate   permet   également   de   réaliser   du   calcul   intégral   numérique.   En  
particulier,  la  fonction  quad  permet  d’intégrer  une  fonction  𝑓  d’une  variable  entre  deux  points  𝑎  et  𝑏  :  
!

𝐼= 𝑓(𝑥) 𝑑𝑥  
!
La  fonction  quad  possède  trois  arguments  d’entrée  :  
1  -­‐  la  fonction  que  l’on  souhaite  intégrer  
2  -­‐  la  borne  inférieure  de  l’intégrale  
3  -­‐  la  borne  supérieure  de  l’intégrale  
Cette   fonction   renvoie   en   argument   de   sortie   un   nombre   complexe,   de   partie   imaginaire  
négligeable.   Pour   récupérer   la   partie   réelle   de   cet   argument   de   sortie,   correspondant   à   la   valeur   de  
l’intégrale,  on  prend  sa  première  composante.    
 
Exemple  :  
import scipy.integrate as integrate
import numpy as np
a = integrate.quad(np.sin,0,np.pi)
print a[0]

Le   module   scipy.integrate   contient   également   les   fonctions   dblquad   et   tplquad,   qui   permettent  
respectivement  d’intégrer  des  fonctions  de  deux  et  trois  variables.  
10                                                    Chapitre  6  :  Outils  graphiques  et  numériques  de  Python  

4. Pour  s’entraîner  
4.1.    Tracé  de  fonctions  trigonométriques  
1)   Ecrire   un   programme   Python   qui   permettent   de   tracer   dans   une   fenêtre   les   fonctions   sinus   et  
cosinus  sur  l’intervalle   – 𝜋, 𝜋 .  
On  donnera  un  nom  à  l’axe  des  abscisses  et  on  fera  apparaître  une  légende  sur  le  graphique.  
2)   Ecrire   un   programme   Python   qui   permettent   de   tracer   dans   une   fenêtre   les   fonctions   sinus   et  
cosinus  hyperboliques  sur  l’intervalle   – 𝜋, 𝜋 .  
On  donnera  un  nom  à  l’axe  des  abscisses  et  on  fera  apparaître  une  légende  sur  le  graphique.  
3)   Ecrire   un   programme   Python   qui   permettent   de   tracer   dans   une   fenêtre   la   fonction   arctan   sur  
l’intervalle   – ∞, +∞ .  
On  donnera  un  nom  à  l’axe  des  abscisses  et  on  fera  apparaître  une  légende  sur  le  graphique.  

4.2.  Loi  de  Malus  

Lors   d’un   TP   de   physique,   on   réalise   une   expérience   pour   vérifier   la   loi   de   Malus   et   on   obtient   les  
résultats  suivants  :  
𝜃  (°)   0   10   20   30   40   50   60   70   80   90  
𝐼(mW)   150   144   134   112   88   61   40   17   5   1  
𝜃  représente  l’angle  entre  le  polariseur  et  l’analyseur  et  𝐼  l’intensité  lumineuse  en  sortie  de  l’analyseur.  
1)  Rappeler  la  loi  de  Malus.  
2)     Ecrire   un   programme   Python   qui   trace   le   nuage   de   points   expérimentaux   et   en   réalise   une  
interpolation  cubique.  
3)  Cette  interpolation  permet-­‐elle  de  vérifier  la  loi  de  Malus  ?  
3)  Plutôt  que  de  tracer  𝐼(𝜃),  on  souhaite  pouvoir  réaliser  un  ajustement  linéaire  qui  discriminera  si  la  
loi  de  Malus  a  été  vérifiée.  Qu’est-­‐il  judicieux  de  représenter  en  abscisses  et  en  ordonnées  ?  
4)   Ecrire   un   programme   Python   qui   détermine   les   tableaux   1D   associés   aux   abscisses   et   ordonnées   de  
la  question  précédente,  trace  le  nuage  de  points  expérimentaux  et  en  réalise  une  interpolation  linéaire.  
5)  Cette  nouvelle  interpolation  permet-­‐elle  de  vérifier  la  loi  de  Malus  ?  

4.3.  Calculs  d’intégrales  

1)  Calculer  numériquement  à  l’aide  de  Python  l’intégrale  de  la  fonction  cos ! (𝑥)  sur  l’intervalle   0,2𝜋 .  
Vérifier  le  résultat  obtenu  par  un  calcul  analytique.  
2)   Calculer   numériquement   à   l’aide   de   Python   l’intégrale   de   la   fonction   exp(−𝑡)   sur   l’intervalle  
0, +∞ .  Vérifier  le  résultat  obtenu  par  un  calcul  analytique.