py010918

Initiation à l’utilisation du logiciel Python en sciences physiques
I
Introduction
Python est un langage de programmation dont le développement a commencé dans les années
90 avec le hollandais Guido van Rossum. Python est un langage qui peut être utilisé dans le domaine
du traitement de l’information.
Quelques avantages de python :
- Python est gratuit, téléchargeable sur internet : http ://www.pyzo.org/downloads.html
- Python est multiplate-forme : il fonctionne sous Windows, Mac OS, Linux, Android, ...
- Python permet de faire du calcul scientifique (bibliothèque Scipy), du calcul matriciel (bibliothèque Numpy), le tracé de graphiques (bibliothèque Matplotlib), etc.. Il permet de faire du traitement d’image (bibliothèque PIL) et du traitement de son.
II
Installation et lancement de Python
II.1. Installation de Python
1. Sous windows ou Mac OS : copier le dossier PyzoScilab sur votre ordinateur (depuis la clé
USB, ou le CD). Il contient les dossiers pyzo2014a, windows 64(32), Mac etc.
2. Double-cliquer sur le dossier (copié) PyzoScilab puis sur l’un des sous dossiers : Windows
64 (ou 32), ou sur Mac (cliquer sur pyzo-distro... .dmg).
3. Installer le logiciel Python à l’aide du dossier : pyzodistro2014awin32, et se laisser guider...
II.2. Lancement d’une session Python (sous pyzo)
On clique sur l’application pyzo (raccourci sur le bureau ou dans le dossier Pyzo2014a). On
obtient la page d’accueil (de travail) qui contient les (trois) éléments suivants :
Figure 1 – Page d’accueuil Python
D.Belkheiri C.C.I.R en s.physiques
1 / 16
Tournez la page SVP
Initiation à l’utilisation du logiciel Python en sciences physiques
1. Barre de menus (et sous menus) : File (new, Open, Save...)-Edit( Copy, Paste....)-...-Run ( Run
file as script,... )
2. La fenêtre shell, elle contient deux éléments :
- Le texte (version, messages d’erreurs.....) : Python 3.4.1 |Continuum Analytics, ...Error...
- Les lignes d’invites In[i] : taper ici l’instruction du programme, numéro i=1,2..., demandée
à python puis valider par enter.
- Chaque ligne est suivie d’une ligne de résultat Out[i] :résultat de l’instruction i.
3. La fenêtre script : c’est un texte-programme (langage Python) formé d’instructions écrites
sur des lignes ; après écriture, on l’enregistre ( Ctrl+S) le fichier sous la forme : nomfichier.py
(chemin...). On l’exécute à l’aide de l’icone Exécuter (ou Ctrl+Maj+E) de la barre des menus
et les résultats s’affichent dans le shell. On pourra ouvrir un (ce) fichier à l’aide de File de la
barre des menus.
Dans la suite, on préfère travailler (et sauver) les scripts écrits dans les lignes de l’éditeur ; car ce qui
est écrit dans le shell (fenêtre du dessus) est exécuté mais ne pourra être sauvé pour les utilisations
ultérieures. Les scripts sont proposés en texte de format (verbatim) différent de celui du texte, ces
exemples peuvent être copiés puis améliorés...
II.3. Quelques règles de syntaxe et d’utilisation de Python
— Les types de bases de Python sont les nombres (entiers : int, réels : float, ...), les listes (array,
lists, tuples...) et les mots (string : str)...
— Python fait les opérations de calculs usuelles (sur les réels) : +, -, * , /, et a//b (ex :10 // 3 =
3, et le modulo a%b (ex : 10%3 = 1) . La virgule est notée par un point ’.’ (exemple : 3.14).
— Avec Python, les opérateurs de comparaison (supérieur, inférieur,etc...) sont : < , > <=, >=,
== (égal), x !=y (x différent de y). L’affectaion est : nom-de-la-variable = valeur.
— Les nombres complexes, j est l’imaginaire tel que j2 = −1. On écrit : z=3+5j et non z=3+5*j.
— Les mots-clés réservés de Python sont : and, as, break, class, del, else, for, if, etc...
— Les commentaires sont débutés par le caractère # (dièse : #) et se terminent par un saut de
ligne : ce sont des textes explicatifs ignorés par Python.
— Les blocs sont identifiés par l’indentation, au lieu d’accolades comme en C/C++, ou de Begin
... End comme en Pascal.
— La fonction print(...) permet d’afficher .... : on peut lui demander d’afficher une ou plusieurs
variables et aussi du texte et celui-ci est écrit entre deux quotes ’texte’.
— La fonction y=input(quelqueChose) : cette instruction interrompt le programme et attend
que l’utilisateur saisisse (tape),dans le shell : quelqueChose ( ’texte’ ou variable), puis il valider en appuyant sur entrée, alors Python affecte quelqueChose à y.
— Pour exécuter une partie du script, on la sélectionne, puis on appuie sur alt+enter.
III
Exemples élémentaires d’utilisation de Python
III.1. Premier exemple d’écriture directe dans le shell
Uniquement dans cet exemple, on écrit les instructions élémentaires directement dans les lignes du shell et on
obtient les résultats après enter.
In [1]: 45/7
Out[1]: 6.428571428571429
D.Belkheiri C.C.I.R en s.physiques
2 / 16
Tournez la page SVP
Initiation à l’utilisation du logiciel Python en sciences physiques
In [2]: (5+3)*5-3.14/21
Out[2]: 39.85047619047619
Dans la suite on écrira les exemples étudiés (copier et améliorer) sous forme de scripts (fenêtre
du bas) ; après sauvegarde (sous nom.py) et exécution (ctrl +E) les résultats seront affichés dans le
shell avec print ou par appel de la variable à afficher : x,t etc.. Pour obtenir de l’aide : help (mot),
et sur internet, www.python.org/doc.
III.2. L’affectation et la commande print (... )
x=2 # on affecte à x la valeur 2
print (x) # affiche la valeur de x.
# Opérations de calculs : +,-,*, /, //, %, * * (puissance)
print('division dans R : 45/7=',45/7,'...Partie entière : 45//7=',45//7,'...
reste de la division : 45%7=',45%7)
print("calcul1 : (5+3)*5-3.14/21 = ", (5+3)*5-3.14/21)
print("calcul2 : 10**(-3)=",10**(-3),'----2**100= ', 2**100,'----3**(0.5)= ', 3**(0.5))
III.3. La commande input (... ) : Python attend qu’on tape (saisisse) quelque chose au clavier dans
le shell, et qu’on valide par enter.
x=5
y = float (input ("taper la valeur de y dans le shell+enter :"))
print ("x =", x, "
y =", y, "et le produit x*y=",x*y)
#print((3+17)*2-3.14/21)
print("---------------------------------")# pour tracer une ligne en pointillés
#Exercice : refaire la même chose en enlevant float et la parenthèse (
IV
).
Quelques bibliothèques : numpy, scipy, simpy,...
IV.1. Fonctions mathématiques usuelles : log, sin ...et bibiothèque numpy
# Observer les réponses de Python à ces instructions : log, , sin, sqrt, etc...?
print (log(10)) # fonction log
print(sqrt(2)) # fonction racine carré
Problème ! Python affiche le message : NameError : log, sqrt, .. not defined !
Pour utiliser ces fonctions usuelles et d’autres utilisations, il est nécessaire d’importer la bibliothèque numpy ( à suivre ).
Dans la première ligne du script on écrit l’instruction : import numpy as np et alors il faut précéder ( ) la fonction souhaitée par le préfixe np.NomDeLaFonction, par exemple : np.cos(np.pi).
Remarque : si on utilise l’instruction from numpy import *, on peut utiliser directement cos(3.14)
IV.2. Exemples de fonctions usuelles sur les réels et les complexes
D.Belkheiri C.C.I.R en s.physiques
3 / 16
Tournez la page SVP
Initiation à l’utilisation du logiciel Python en sciences physiques
import numpy as np #on importe
#On importe la bibliothèque numpy qu'on note np,
# from numpy import *
ou ecrire :
#1-Calculs sur les réels et les complexes
a=np.sqrt(2)# np.sqrt(2)
b=np.exp(-1)
c=np.log(10)
d=np.log10(10)
print("a =",a,"---b =",b,"---c =",c,"---d=",d,"---sin(pi/6)=", sin(pi/6))
print("---------------------------")
z=3+5j
u=2j
t=4
b=np.real(z)
print ("module de z = ", abs(z), "--conjugé de z=
",conj(z),"---angle de z en radian=
print("---------------------------------Fin" )
Résultats affichés :
a = 1.41421356237 ; b = 0.367879441171 ; c = 2.30258509299 ;sin(pi/6)= 0.5
--------------------------------module de z = 5.83095189485 ; conjugé de z= (3-5j) ; angle de z en rad= 1.03037682652
---------------------------------Fin
IV.3. Manipulation de listes et tuples
Les listes et les tuples sont vus comme des tableaux : les éléments d’une liste sont écrits entre
crochets [a,b], alors que ceux d’un tuple sont écrits entre parenthèses (a,b).
import numpy as np
L1=[5,4,1,2,3] # liste
L2=[8,7,6,9,0] # liste
a = np.array([5,4,1,2,3]) # vecteur
b = np.array([8,7,6,9,0]) # vecteur
print(L1+L2, a+b)# comparer les deux additions !
IV.4. Manipulation de vecteurs (array) et matrices
#2-a-Opérations vectorielles
a = np.array([1,2,3], float)
b = np.array([5,4,6], float)
c= np.linspace(-10,10,100)
d= np.arange(-10,10,0.10)
e= np.array([[1,2,3],[5,4,6]]) #
# Faire des exemples d'opérations : a + b, a*b, b/a, np.sqrt(a), a.mean(), a.min(), ...
print ('a+b=',a+b,'---racine de a',np.sqrt(a))
len(a) # nombre d'éléments de a
u=np.ones(3)# que represente u=np.ones(len(c))?
print(np.dot(a, b),np.cross(a,b)) # produit scalaire et produit vectoriel de a et b...
D.Belkheiri C.C.I.R en s.physiques
4 / 16
Tournez la page SVP
Initiation à l’utilisation du logiciel Python en sciences physiques
print(c[1]) # extraction d'un élément de c par c[i] : i=0,1,...., len(c)-1.
c**2# c au carré.
print(e[:,0])
IV.5. Création d’une fonctions de variable(s) f ( x )
— Syntaxe d’écriture (à respecter), avec l’indentation (décalage de la 2eme ligne)
def
nomdefonction (x1, x2,...,xn) :
return expression en fonction de x1,...,xn
— Exemple
import numpy as np
def f(x):
return np.exp(-x)-1+x/5
print(f(4),f(5))
IV.6. Bibliothèque scipy : résolution d’équation f ( x ) = 0. Exemple : loi de Wien.
On a choisi d’utiliser le programme brentq(f,xi ,x f ) qui permet de déterminer x0 vérifiant f ( x0 =
0 sachant que x0 est compris entre xi et x f .
from scipy import * #Pour utiliser les fonctions mathématiques de scipy
from scipy.optimize import brentq # Résolution via brentq
x0 = brentq(f,1,10)# la solution se trouve entre 1 et 10
print("racine pour x=",x0)
#résultat : racine pour x= 4.965114231744277
c,h,kB=3*(10**8),6.63*(10**(-34)), 1.38*10**(-23)
print("loi de Wien : lamda*T=",c*h/(x0*kB))
print("--------------------- Fin de cet exemple")
Résultat : lamda*T=0.0029
Remarque : on peut aussi faire une résolution graphique par détermination du point d’intersection avec l’axe X’X de f ( x ) = e− x − 1 + 5x
IV.7. Bibliothèque sympy (calculs symboliques)
1. Exemple 1 : résolution de systèmes d’équations.
import numpy as np
from sympy import *
x, y, z, sol3 = symbols('x y z sol3')
sol3 =solve([x - y +2*z + 2, x + y-np.sqrt(2)*z - 3,2*x-3*y+z-5], [x, y,z])#print(sol
Exercice
On étudie la mise en solution d’un acide faible AH dans l’eau. Faire l’inventaire des espèces
présentes dans l’eau et écrire le système d’équations permettant de déterminer les différentes
concentrations. En déduire la valeur du pH. Données : concentration c, constante d’acidité
Ka et produit ionique de l’eau Ka .
2. Exemple 2 : le développement limité de sin(x) (ou de log(1+x)) pour x voisin de 0.
D.Belkheiri C.C.I.R en s.physiques
5 / 16
Tournez la page SVP
Initiation à l’utilisation du logiciel Python en sciences physiques
from sympy import series, sin, cos, log, symbols
import numpy as np
import matplotlib.pyplot as pt
#Exemple
x=symbols('x')
d=series(sin(x),x,0,8)#f=series(cos(x),x,0,8)
print(d)
#Résultat : x - x**3/6 + x**5/120 - x**7/5040 + O(x**8)
Exemple :
Déterminons l’expression du champ magnétique dans les bobines de Helmhotz. On prendra
l’origine à mi-distance entre les centres des deux spires...
def h(x):
return 1/(1+(x-0.5)**2)**(3/2)+1/(1+(x+0.5)**2)**(3/2)
B=series(h(x),x,0,5)
print('Helmholtz -- B ~ ',B)
X=linspace(-1,1,100)
H=h(X)
pt.plot(X,H)
# Résultat : 1.43108350559987 - 1.58882185807826e-17*x**2 - 1.64860819845105*x**4...
V
Bibliothèque matplotlib.pyplot et tracés de graphiques
V.1. Graphiques usuels (matplotlib.pyplot) : instruction plot(x,y)
1. Graphe de la fonction : exemple u(t) = (1 + 0.5 ∗ cos(t)).cos(10t) de 0 à 10 ∗ pi.
import numpy as np , matplotlib.pyplot as pl
t = np.linspace(0, np.pi*10,1000)
# vecteur des abscisses t de 0 à pi/10 formé de N=1000 points
u= (1+0.5*np.cos(t))*np.cos(10*t) # vecteur des ordonnées : N valeurs u(t).
pl.plot(t,u,) # ajouts : pl.xlabel(' t (en s)'),pl.ylabel('u(en V)') etc
On obtient le graphique ci-dessous.
On pourra utiliser le menu de la fenêtre du graphique pour des modifications (couleurs,
styles) , sauvegarde du graphe (format png,...), etc....
2. Représentation de graphes séparés.
import numpy as np, matplotlib.pyplot as pl
t = np.linspace(0, np.pi*10,1000)
v= (1+0.5*np.cos(t))
w= np.cos(10*t)
s =v*w # on veut tracer s(t)=v(t)*w(t)
D.Belkheiri C.C.I.R en s.physiques
6 / 16
Tournez la page SVP
Initiation à l’utilisation du logiciel Python en sciences physiques
Figure 2 – Graphe d’une fonction
pl.subplot(221)
pt.clf()#efface les courbes précédentes
pl.plot(t,v,label="v(t)")
pl.subplot(222)
pl.plot(t,w,label="w(t)")
pl.subplot(223)
pl.plot(t,s,label="s(t)")
pl.subplot(224)
pl.plot(w,s,label="s(p)")
3. Graphes superposés : si on veut superposer les graphes de u(t), v(t) et w(t) : plot(t,u,t,v,t,w).
Exemple : chute libre parabolique (influence de la vitesse initiale, de l’angle de tir...)
import numpy as np
import matplotlib.pyplot as pt
x=np.linspace(0,1000,100)
a= np.pi/3# angle fixe, on modifie la vitesse initiale notée i.
for i in range(10,15) :
pt.plot(x,i*np.tan(a)*x-0.5*(x/(np.cos(a)*i))**2)
pt.grid()
pt.show()
Exercice : pour une vitesse initiale constante, tracer les trajectoires pour différents angles.
V.2. Graphique à partir de ’couples’ de données ( xi , yi )
# Graphe à partir de données (expérimentales, par exemple : chute libre)
import matplotlib.pyplot as plt
z=np.array([0,0.5,1,1.5,1.8,2])
t=np.array([0,0.319,0.451,0.553,0.606,0.638])
t2=t*t#[0,0.102,0.203,0.306,0.307,0.407]
plt.plot(t2,z,"b:o",label="chute libre z($ t^{2} $")
#plt.plot(t,z,"b:o",label="chute libre")
plt.xlabel(' ($ t^{2}$ (ou t(s)) ')
plt.ylabel('z(m)')
#plt.show()
D.Belkheiri C.C.I.R en s.physiques
7 / 16
Tournez la page SVP
Initiation à l’utilisation du logiciel Python en sciences physiques
Exercice : tracer (ou superposer) le graphe d’une fonction f (t) = cte = 1, par exemple.
V.3. Autres exemples de graphiques (trajectoires )
import numpy as np
import matplotlib.pyplot as pt
t=np.linspace(0,10,1000)
x=np.sin(5*t)
y=5*np.cos(5*t)
pt.plot(x,y)# tracé du graphe d'une ellipse, par élimination de t (temps)....
Exercice : tracer le graphe d’un cercle et d’une spirale
V.4. Graphiques logarithmiques : diagramme de Bode
V.4.1. Graphe de Bode pour un filtre passe bas du 1er ordre.
import numpy as np , matplotlib.pyplot as plt
def f(x):
return 20*np.log(1/np.sqrt(1+x**2))
x=np.linspace(0.01,1000,10000)
plt.semilogx(x,f(x))
plt.grid()
plt.show()
Résultat :
Figure 3 – Diagramme de Bode du gain d’un filtre
V.5. Lignes d’un champ de vecteur.
−−→
−
→
Exemple : traçons l’allure des lignes du champ V = − gradφ , dérivant du potentiel φ( X, Y ) =
−k.X.Y, (k = 1) .
import numpy as np ,matplotlib.pyplot as plt
coords = np.linspace(-1, 1, 11)
X, Y = np.meshgrid(coords, coords)
Vx, Vy = -Y,-X
plt.quiver(X, Y, Vx, Vy)# essayer aussi : plt.streamplot(X, Y, Vx, Vy)
Résultat
Autre exemple : équipotentielles d’un dipôle électrostatique.
D.Belkheiri C.C.I.R en s.physiques
8 / 16
Tournez la page SVP
Initiation à l’utilisation du logiciel Python en sciences physiques
Figure 4 – Lignes d’un champ de vecteurs
# Equipotentielles d'un dipôle électrostatique
t = np.linspace(0, 2*np.pi, 100)
for k in range(1,10):
plt.polar(t, k*np.sqrt(np.abs(cos(t))))
plt.show()
Exercice : superposer au graphe précédent les lignes de champ du dipôle électrostatique.
V.6. Graphes tridimensionnels
Visualisation d’une trajectoire hélicoïdale à l’aide du script ci-dessous.
import matplotlib as mpl ,numpy as np, matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D
fig = plt.figure()
ax = fig.gca(projection='3d')
theta = np.linspace(0, 8 * np.pi, 100)
x = 1 * np.cos(theta)
y = 1* np.sin(theta)
z = 1*theta
ax.plot(x, y, z, label='helice')
ax.legend()
plt.show()
VI
Intégrales et équations différentielles
VI.1. Le module scipy.integrate permet de réaliser du calcul intégral numérique. En particulier, la
fonctionnalité quad (f,a,b) permet d’intégrer une fonction f entre les bornes a et b.
#1-Exemple 1
from scipy.integrate import quad
import numpy as np
I = quad(np.cos, 0, np.pi/2)
print(I)
# On obtient la valeur numérique de I et l'erreur sur ce calcul.
#(0.9999999999999999, 1.1102230246251564e-14)
D.Belkheiri C.C.I.R en s.physiques
9 / 16
Tournez la page SVP
Initiation à l’utilisation du logiciel Python en sciences physiques
#2-Exemple 2 : loi de Stefan
from scipy.integrate import quad
import numpy as np
def g(x) :
return x**3/(np.exp(x)-1)
I2 = quad(g, 0, np.Infinity)
print(I2)
print((np.pi)**4/15)
Des problèmes de sciences physiques font appel à des intégrales ou des équations différentielles de
1er et 2d ordre, avec des conditions initiales données : mécanique, électricité, chimie...A l’aide de
Python, on utilise le module scipy qui est un ensemble de fonctions mathématiques avancées (résolution d’équations différentielles, méthodes de calcul intégral, transformées de Fourier, traitement
d’images. . .).
VI.2. Équation différentielle d’ordre 1 : fonctionnalité odeint (f,condInit,variable)
dy
Ramener l’équation différentielle, dx = f ( x, y), sous la forme : derivee (membre de gauche) =
f(x,y) (expression ecrite au membre droit).
VI.2.1. Syntaxe générale :
from scipy import ∗,
from scipy.integrate import odeint
def derivee (y , x ) :
return f(x,y)
x = linspace (x0 , xmax , npoints )
y0 = 1 #Condition initiale
sol = odeint ( derivee , y0 , x)
y = sol [:, 0]
VI.2.2. Exemples : tension v(t) d’un circuit RC en charge (sous fém E) ou de décharge (fem E=0) : dv
dt =
( E−v)
R.C ,
avec condition initiale 0 ou E.
import numpy as nm, import matplotlib.pyplot as pt, import scipy.integrate as intg
#Exemple de la charge
R=10**4
C=10**(-8)
tau=R*C
E=5
def g(v,t):
return((E-v)/(R*C))
listet=nm.arange(0,10*tau,tau/10)
listev=intg.odeint(g,0,listet)
pt.plot(listet,listev,label="v(t)")
pt.xlabel("t (s)")
pt.ylabel("v (V)")
pt.grid()
pt.show() # afficher la courbe.
D.Belkheiri C.C.I.R en s.physiques
10 / 16
Tournez la page SVP
Initiation à l’utilisation du logiciel Python en sciences physiques
VI.2.3. Exercice : déterminer v(t) lors de la décharge de C à partir de v(t = 0) = E et tracer les
deux graphes de charge et de décharge (voir ci-dessous).
Figure 5 – Charge d’un condensateur dans un résistor
VI.3. Résolution d’équation différentielle de second ordre
On essaie de se ramener à la fonctionnalité de résolution d’une équations d’ordre 1 ; pour cela on
va considérer une variable vectorielle (matricielle) Y (t) = ( x (t), ẋ (t)) de dérivée Ẏ = ( ẋ (t), ẍ ).
Alors on se serait ramené à considérer l’équation différentielle Ẏ = f (Y, t) de 1er ordre.
Exemple : pour l’oscillateur (ressort) amorti, on a (x’(t),x"(t))=(x’(t),− ωQ0 x’(t)-−ω02 x(t)) , avec
condition(s) initiale(s) Y0 = [x0= ?, x’0= ?].
L’instruction intr.odeint(f,y0,listet) renverra alors une matrice possédant deux colonnes, la première (resp. seconde) colonne contenant les valeurs approchées de x (resp. x0 ) aux instants spécifiés par listet.
import math as ma
import matplotlib.pyplot as plt, scipy.integrate as intr
m = 10**(-1)#masse en kg
h=10**(-1)#frottt fluide
k=10 #raideur N/m
w0=ma.sqrt(k/m)
Q=ma.sqrt(k*m)/h
tau=2*Q/w0
x0=0.05#m
# Résolution de l'équation 2 ordre.
def f(y,t):
return([y[1],-w0**2*y[0]-(w0/Q)*y[1]])
Y0=[x0,0]#condinit
listet=np.arange(0,10*tau,tau/100)
liste_x_xprime=intr.odeint(f,Y0,listet)#matrice
listex=liste_x_xprime[:,0]#1ere colonne
listexprime=liste_x_xprime[:,1]#2eme colonne
#3. Tracé de la solution
plt.clf()#efface les courbes précédentes
plt.plot(listet,listex,label="x(t)")
plt.xlabel("t (s)")
D.Belkheiri C.C.I.R en s.physiques
11 / 16
Tournez la page SVP
Initiation à l’utilisation du logiciel Python en sciences physiques
plt.ylabel("x (m)")
plt.title("Oscillateur libre amorti")
plt.grid()
plt.legend(loc=5)
Figure 6 – Oscillateur amorti
VI.4. Autres exemples
Exercice 1 : oscillateur amorti x(t).
Écrire un script Python permettant l’étude des trois régimes.
Tracer les graphes x(t) ainsi que leurs portraits de phase sur des graphes séparés.
Exercice 2 : résolution de systèmes d’équations différentielles.
Exercice 3 : étude du tir parabolique dans l’air avec frottements visqueux et tracé de trajectoire.
Exercice 4 : exemples de cinétique chimique...
VII
Exemple de programmation : if-then-else
On considère un exemple utilisant des conditions, il s’agit ici de la résolution de l’équation de
2eme degré : on utilise if..else..elif.
import numpy as np
print ("ax2+bx+c=0 : taper les valeurs de a, b et c dans la fenêtre du shell")
# On saisi les valeur de a,b et c dans la zone du shell.
a = float(input('entrer le coef a:'))
b = float(input('entrer le coef b:'))
c = float(input('entrer le coef c:'))
print ("résolution de :",a,"*x2+", b,"*x+",c,"=0")
d = b*b-4*a*c
if d > 0: # Si d est positif
x1=(-1*b+np.sqrt(d))/(2*a)
x2=(-1*b-np.sqrt(d))/(2*a)
print ("x1=",x1,"x2=",x2)
elif d < 0: # d est négatif
x1=complex(-1*b/(2*a), + np.sqrt(-1*d))/(2*a)
x2=complex(-1*b/(2*a), -np.sqrt(-1*d))/(2*a)
D.Belkheiri C.C.I.R en s.physiques
12 / 16
Tournez la page SVP
Initiation à l’utilisation du logiciel Python en sciences physiques
print ("x1=",x1,"x2=",x2)
else :
print ("x1=x2=",-b/(2*a))
Résultat
ax2+bx+c=0 : taper les valeurs de a, b et c dans la fenêtre du shell
entrer le coef a:1
entrer le coef b:2
entrer le coef c:3
résolution de : 1.0 *x2+ 2.0 *x+ 3.0 =0
x1= (-0.5+1.4142135623730951j) x2= (-0.5-0.9142135623730951j)
VIII
Notions sur les signaux numériques
VIII.1. Exemple d’illustration du théorème de Shannon
import numpy as np
import matplotlib.pyplot as pl
T=1
def s(t):
return np.sin(2*np.pi*t/T)#+np.sin(5*np.pi*t/T)
D=5
fe=10
N=int(D*fe)+1
te=np.linspace(0,(N-1)/fe,N)
tp=np.linspace(0,D,1000)
#pl.plot(te,s(te),'vg--',tp,s(tp),'vyg--')
pl.plot(te,s(te),'vg--',label= "signal échantillonné")
pl.plot(tp,s(tp),'b-',label= "signal réel")
pl.xlabel("temps $t(en s)$")
pl.ylabel("Signal $s(en V)$")
pl.grid()
pl.show()
Figure 7 – Illustration du théorème de Shannon
D.Belkheiri C.C.I.R en s.physiques
13 / 16
Tournez la page SVP
Initiation à l’utilisation du logiciel Python en sciences physiques
VIII.2. Filtrage numérique.
Dans un filtre passe bas du 1er ordre le signal d’entrée du filtre e(t) et le signal de sortie s(t) sont
ds(t)
liés par l’équation différentielle suivante : τ.
+ s(t) = e(t)
dt
en = e(t = n.Te) et sn = s(t = n.Te) et avec Te : période d’échantillonnage, on peut supposer
s
− sn
ds
= n +1
.
que
dt
Te
s
− sn
d’où la relation de récurrence : τ. n+1
+ sn = en
Te
Exemple : prendre comme signal d’entrée la superposition de deux sinusoïdes de fréquence f et
20f (par exemple) et effectuer un filtrage passe bas de fréquence de coupure f c (entre f et 20f).
IX
Échanges entre Python et d’autres programmes : excel, txt, autres
Il est possible d’exporter des données (data) et fichiers vers Python et de les traiter.
— Depuis arduino (biblio pyserial) : résultats sous le format str ;
— Le fichier excel ex1.xls (biblio xlrd) ;
— le fichier ex1.txt (ci-dessous), et tracer le graphe R x (t).
import matplotlib.pyplot as pt; import numpy as np
pt.plotfile("C:\\chemin...\\ex1.txt", delimiter=', ', cols=(2, 6))
# tracé du graphe y(x) : col2=x,col6=y.
Remarque :
Python peut, ainsi, tracer des graphes à partir de données collectées par des appareils en recherches et analyses scientifiques, par exemple : en diffraction par les rayons X, spectroscope
infrarouge, DSC, TDA, TG, etc.
X
Aperçu sur un traitement d’image
Une image (numérique) peut être considérée comme une matrice de pixels n × m (à valeurs
quantifiées). On utilise ici le module imageio qui est fourni en standard avec Pyzo et qui permet
très simplement de charger une image et de la traiter : agir sur la valeur d’un pixel, agir sur le
contraste etc...
import imageio , matplotlib.pyplot as plt
from pylab import *
im = imageio.imread('maroc.png')
imageio.imwrite('maroc-gray.jpg', im[:, :, 0])
imageio.imsave('maroc-gray.jpg', im[:, :, 0])
subplot(121)
imshow(imageio.imread("maroc.png"))
subplot(122)
imshow(imageio.imread("maroc-gray.jpg"))
Résultat : image couleur traitée.
D.Belkheiri C.C.I.R en s.physiques
14 / 16
Tournez la page SVP
Initiation à l’utilisation du logiciel Python en sciences physiques
Figure 8 – Image traitée
XI
Exercices
XI.1. Paramétrer le calcul du pH d’une solution d’acide faible AH (Ka , c a )
import numpy as np
ka,ke,c=10**(-5.8), 10**(-14), 10**(-4)
eq=[1,ka,-(c*ka+ke),-ka*ke]#polynome en h=concentration de H3O+
sol=np.roots(eq)
ph=-np.log10(np.real(sol[1]))
print('La solution a un pH=',ph)#4.9
XI.2. Exercice : position d’équilibre stable
→
→
Un cerceau de rayon a, tourne avec une vitesse angulaire −
ω = ω.−
u z , avec ω constante autour
de son diamètre vertical OZ . Un anneau, de masse m, peut coulisser sans frottement sur ce
cercle On se place dans le référentiel R0 (OX 0 Y 0 Z ) tournant lié au cercle.
Déterminer l’énergie potentielle E p du mobile dans R’. A l’aide de python, tracer l’allure du
graphe E p (θ, ω ) et déterminer les positions d’équilibre par rapport au cercle ; discuter leur stabilité. Discuter selon ω.
from numpy import *
import matplotlib.pyplot as pt
def ep(t):
return -cos(t)-1*(sin(t))**2
t=linspace(-pi,pi,100)#angle theta
pt.clf()
pt.plot(t,ep(t))
pt.grid()
pt.show()
#Angle d'équilibre
tmin=t[( (ep(t)).tolist()).index(min(( (ep(t)).tolist())))]
print(' ep minimale pour l angle t=',tmin)
D.Belkheiri C.C.I.R en s.physiques
15 / 16
Tournez la page SVP
Initiation à l’utilisation du logiciel Python en sciences physiques
XI.3. Un ressort de raideur k et de longueur à vide l0 a une extrémité fixe en A( x = 0, y = h = cte),
l’autre extrémité est liée à un anneau M qui glisse sans frottement sur une tige horizontale X’OX,
OM = x (t). Tracer le graphe de l’energie potentielle E p ( x ) et étudier les positions d’équilibre.
from numpy import *
import matplotlib.pyplot as pt
#anneau-barreHorizontale-ressortInclineSurVerticale
k,l0=20,2#h parametre.
def ep(x):
return k*h*((1/2)*x**2-l0*sqrt(x**2+h**2))
x=linspace(-5,5,100)#e=ep(t)
l=[1,2,4]#plusieurs valeurs de h paramètre
m=[k*h*((1/2)*max(x)**2-l0*sqrt(max(x)**2+h**2)) for h in l]
#m1=[ep(x) for h in l]#epmax pour écrire texte sur graphe
#mx=[max(m[i]) for i in range(0,len(m))]
pt.clf()
for h in l:
pt.plot(x,ep(x))
pt.xlabel('Angle(rad)')
pt.ylabel('Ep(J)')
pt.text(max(x), m[0], r'h=1')
pt.text(max(x), m[1], r'h=2')
pt.text(max(x), m[2], r'h=4')
pt.grid()
pt.show()
mi=[min(k*h*((1/2)*x**2-l0*sqrt(x**2+h**2))) for h in l]#minimasde ep
b=[ (k*h*((1/2)*x**2-l0*sqrt(x**2+h**2))) for h in l]#
c=[(b[i].tolist()).index(min(b[i].tolist())) for i in range(0,len(l))]
xmin=[x[c[i]] for i in range(0,len(l))]
#xmin=x[( ep(x).tolist()).index(min(( ep(x).tolist())))]#ecriture condensée.
print('l abscisse correspondant a ep minimale est +- :',xmin)
liavart noB Bon travail.
D.Belkheiri C.C.I.R en s.physiques
16 / 16
Fin