""" Exemple de programme python générique
"""
# Pour creer un fichier htlm avec la documentation:
# pydoc -w PythonGenerique
__authors__ = ("Georges Landa")
__contact__ = ("georges.landa@laas.fr")
__version__ = "1.0"
__copyright__ = "G. Landa"
__date__ = "01/02/2021"
Les bibliothèques importées
import sys
import numpy as np
A quoi sert le : if __name__ == '__main__': ...
En fait, si on structure le code comme indiqué, il peut être directement interprété par python comme programme principal,
mais il peut aussi être importé dans un autre programme auquel cas les fonctions seront importées comme bibliothèque et exécutées au fur et à mesure des besoins.
Le programme complet
#!/usr/bin/env python3
# -*- coding: UTF8 -*-
""" Exemple de programme python générique
"""
# Pour creer un fichier htlm avec la documentation:
# pydoc -w PythonGenerique
__authors__ = ("Georges Landa")
__contact__ = ("georges.landa@laas.fr")
__version__ = "1.0"
__copyright__ = "G. Landa"
__date__ = "01/02/2021"
import sys
import numpy as np
# Création d'une classe d'objets
class MaClasse:
""" Quelques mots sur la classe """
def __init__(self, Nom, Valeur):
self.Nom = Nom
self.Valeur = Valeur
def GetMaClasseNom(self):
"""Quelques mots sur cette propriété"""
return self.Nom
def GetMaClasseValeur(self):
"""Quelques mots sur cette propriété"""
return self.Valeur
# Fonction d'utilisation
def Usage():
""" Les consignes d'utilisation """
print("USAGE: %s N (N est un entier) " % sys.argv[0])
return()
# Création d'une fonction
def Fonction(x):
""" Infos sur la fonction """
return(np.sin(x), np.cos(x))
# Fonction principale
def Main():
""" Ce programme fait ceci cela ... """
if len(sys.argv) != 2:
print("Mauvais nombre d'arguments.\n")
Usage()
sys.exit()
N = int(sys.argv[1])
x = 1.
y = 1.
z = 1.
print("Nombre de points : %d" % N)
print("Affichage :")
for i in range(N):
x = float(i)*np.pi/N
y, z = Fonction(x)
print("Valeur de i : %d\t\tCoord. : %8.3f %8.3f %8.3f\t " %\
(i, x, y, z))
# Utilisation de la classe
x = MaClasse("jojo", 61)
print(x.GetMaClasseNom())
print(x.GetMaClasseValeur())
if __name__ == '__main__':
Main()
Quelques bibliothèques
L'objectif est de remplacer tous les logiciels "classiques" comme Scilab, Matlab, Comsol ...
Il existe une très grande variété de bibliothèques couvrant à peu près tous les domaines !
Calculs en général
Numpy
Scipy
Matplotlib
Calcul différentiel
Fipy
Utilisation de Numpy
Création d'un tableau
import numpy as np
a=np.zeros(10)
a
Propriété d'un objet
la commande :
dir(a)
permet d'avoir toutes les méthodes définies pour l'objet a
Modification de la forme d'un tableau
on peut modifier la forme d'un tableau avec l'instruction reshape
import matplotlib.pyplot as plt
import numpy as np
def f(x):
return (x**3)-2*(x**2)
x=np.linspace(-1,3,100)
plt.plot(x,f(x))
from scipy.optimize import newton
x1=newton(f,x0=1.)
x2=newton(f,x0=3.)
print(x1)
print(x2)
plt.annotate('racine1',xy=(x1,0), xytext=(x1,2),arrowprops=dict(facecolor='black',shrink=0.05),)
plt.annotate('racine2',xy=(x2,0), xytext=(x2,2),arrowprops=dict(facecolor='black',shrink=0.05),)
plt.show()
On obtient :
Tracer une fonction
#!/usr/bin/env python
# -*- coding: utf8 -*-
import numpy as np
import matplotlib.pyplot as pl
# on définit ici le vecteur des abscisses x
x = np.linspace(0,2*np.pi,100)
# on définit ici le 1er vecteur des ordonnées
y1 = np.cos(x)
# on définit ici le 2nd vecteur des ordonnées
y2 = np.sin(x)
# On définit la figure
fig = pl.figure(figsize=(6, 3), dpi=150)
# on réalise le tracé de cosinus en bleu
pl.plot(x,y1,"b",label="cos(x)")
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
fig.savefig("mafigure.jpg") # on enregistre la figure dans le dossier courant
On obtient :
Dériver une fonction
#!/usr/bin/env python
# -*- coding: utf-8 -*-
from scipy.misc import derivative
import numpy as np
import matplotlib.pyplot as plt
f = lambda x : np.exp(-x)*np.sin(x)
x = np.arange(0,10, 0.1)
first = derivative(f,x,dx=1,n=1)
second = derivative(f,x,dx=1,n=2)
fig, ax = plt.subplots(3,1,sharex = True)
ax[0].plot(x,f(x))
ax[0].set_ylabel(r'$f(x)$')
ax[1].plot(x,first)
ax[1].set_ylabel(r'$f\/\prime(x)$')
ax[2].plot(x,second)
ax[2].set_ylabel(r'$f\/\prime\prime(x)$')
ax[2].set_xlabel(r'$x$')
plt.show()
On obtient :
Un peu de géométrie ...
#! /usr/bin/python
# -*- coding: utf8 -*-
import math
class Point(object):
def __init__(self, x, y):
self.x = x
self.y = y
def __str__(self):
return "Point({}, {})".format(self.x, self.y)
def distance(self, other):
return math.sqrt((self.x-other.x)**2 + (self.y-other.y)**2)
# Créer une classe mère Polygone permet de factoriser les attributs et méthodes en commun.
class Polygone(object):
def __init__(self, points):
self.points = list(points)
# fait une copie de la liste
def get_nb_sommets(self):
return len(self.points)
def perimetre(self):
res = 0
if(self.get_nb_sommets() > 0):
for i in range(self.get_nb_sommets()-1):
res += self.points[i].distance(self.points[(i+1)])
res += self.points[-1].distance(self.points[0])
return res
def aire(self):
return # Calcul d'aire indisponible à ce niveau
# Nos types Triangle et Carre peuvent maintenant hériter du type Polygone pour profiter du code factorisé
class Triangle(Polygone):
def __init__(self, p1, p2, p3):
super().__init__([p1, p2, p3])
class Carre(Polygone):
def __init__(self, p1, p2, p3, p4):
super().__init__([p1, p2, p3, p4])
# On sait calculer l’aire d’un triangle et d’un carré, on peut donc surcharger cette méthode
class Triangle(Polygone):
def aire(self):
''' Calcul d aire par la formule de Héron '''
(a, b, c) = (self.points[i].distance(self.points[(i+1) % 3]) for i in range(3))
s = (a + b + c)/2
return math.sqrt(s * (s-a) * (s-b) * (s-c))
class Carre(Polygone):
def aire(self):
print self.points[0],self.points[2]
return 0.5*self.points[0].distance(self.points[2])**2
A = Point(0,0)
B = Point(2,0)
C = Point(2,2)
D = Point(0,2)
print "point A",A.__str__()
print "point B",B.__str__()
print "point C",C.__str__()
print "point D",D.__str__()
print "distance A,B",A.distance(B)
print "distance A,C",A.distance(C)
print "distance A,D",A.distance(D)
print "distance B,D",B.distance(D)
print "Triangle"
tri = Triangle([A,B,D])
print "sommets",tri.get_nb_sommets()
print "périmètre",tri.perimetre()
print "aire",tri.aire()
print "Carré"
carre = Carre([A,B,C,D])
print "sommets",carre.get_nb_sommets()
print "périmètre",carre.perimetre()
print "aire",carre.aire()