Chap XIII : calcul scientifique avec python

from turing_machine import TuringMachine
initial_state = "init",
accepting_states = ["final"],
transition_function = {("init","0"):("init", "1", "R"),
("init","1"):("init", "0", "R"),
("init"," "):("final"," ", "N"),
}
final_states = ["final"]
t = TuringMachine("010011 ",
initial_state = "init",
final_states = final_states,
transition_function=transition_function)
print("Input on Tape:")
t.show_tape()
while not t.final():
t.step()
print("Result of the Turing machine calculation:")
t.show_tape()
Version
3.1.0
Université de Béchar
Laboratoire des Études Énergétiques en Zones Arides
Équipe Modélisation & Simulation des Systèmes
Cours réalisé par : Pr. TAMALI Mohammed,
http://mtamali.wordpress.com/
Université de Béchar | FS&T
(ENERGARID Lab./SimulIA)

Presentation
The University of Bechar was born in 1986 as the National Institutes of Higher
Education (INES) in 1992 it becomes University Center and on January 07, 2007, it
was officially declared as a University. Since then, many Research Teams have seen
the day. In 2011, The Laboratory for Energy Systems Studies Applied to Arid Zones
was run by a group of young and well motivated researchers (7 Research teams) to
solve real problems affecting arid zones, SimulIA Team is one of them in the same
laboratory. The Workload of SimulIA concern studies and applications of modeling
and simulation of systems in Arid Areas.
Research areas:
 Energy & Environment (Modeling & Simulation)
 Application of heat in arid zones
 Energy economy.
 Mapping and development of resources in arid zones.
 SIMULIA for the task in the short term, to develop the computer code for
modeling and simulation which can be accessed online.
Website of the laboratory team: http://energarid.wordpress.com/
2

 Introduction (Généralités & Historique).
 Elaboration d’un environnement logiciel Python
 (Installation, Personnalisation & Utilisation).
 Domaines d’utilisation
 Outils d’élaboration de code Python (IDE)
 Base de représentation des données (Eléments de base)
 Structure algorithmique du langage Python
 Matrices & Systèmes linéaires
 Systèmes non-linéaires
 Interpolation & approximation
 Intégration & Différentiation numérique
 Calcul parallèle
 Conclusion
Plan
3

Introduction (Généralités).
Les mathématiques appliquées et le calcul scientifique jouent un rôle croissant comme outils non
évitables pour l’élaboration de recherches scientifiques et dans la conception de processus
industriels. Le calcul scientifique reste pour toujours l’étape première de la voie du
développement culturel et technique d’un pays donné.
Par ailleurs, le niveau de complexité des systèmes, généralement manipulés par les êtres
humains que nous sommes, est très élevé à un niveau où toute avancée intellectuelle engendrera
des retombés au niveau industriel tant que tous les processus de l’économie en dépendent.
En contre partie, la majorité des produits technologiques sont juste la solution immédiate de bon
nombre de résolutions de requête de la vie courante. L'avènement de l'informatique et de ses
produits, les langages de programmation de tout bord, de l'Internet et des télécommunications, à
chacun ses infrastructures et ses protocoles, a révolutionné les méthodologies de travail des
équipes et laboratoires de recherches. Les langages de développement informatique des outils
et suites logiciels sont d’un grand secours aux travaux de modélisation et de simulation des
processus.
Les mathématiques appliquées et l'informatique sont les moyens de conception (Modélisation et
Simulation), plus encore, ils sont les vecteurs qui ont provoqué une amélioration nette dans les
pratiques de tous les jours et aussi dans la vitesse de mise en œuvre de moyens exploitables.
Les langage de programmation, comme le C/C++, le FORTRAN ou le Python ont joué un grand
rôle dans le cours de développement de beaucoup de procédés (Modélisation) et ont facilité la
compréhension de beaucoup phénomènes (Simulation). 4

Introduction (Historique).
Python est un langage intéressant pour sa facilité et sa richesse en possibilités d’utilisation. En
version de base, Python dispose de nombreuses fonctionnalités intégrées en standard.
Autour des aptitudes de base standard, Il est extensible par des modules de tout bord, qui sont
les contributions de développeurs dévoués à la cause de l’Open Source. Ce sont des
bibliothèques qui aident le développeur à travailler sur des projets particuliers. Plusieurs
bibliothèques peuvent ainsi être installées pour, par exemple, développer des interfaces
graphiques en Python (cas de tkinter).
Python est un langage de programmation, dont la première version est sortie en 1991. Créé par
Guido van Rossum, il a été porté du Macintosh, de son développeur, qui travaillait à cette époque
au Centrum voor Wiskunde en Informatica aux Pays-Bas, jusqu'à se voir associer une
organisation à but non lucratif particulièrement dévouée, la PSF (Python Software Foundation),
créée en 2001. Ce langage a été baptisé ainsi en hommage à la troupe de comiques les «Monty
Python».
5
Développeur Informaticien
Néerlandais (langage Python)
Guido van Rossum
31 janvier 1956 Monty Python est le nom d'une troupe célèbre
d'humoristes britanniques (1969).

Introduction (Logiciel Open Source vs. Propriétaire).
La PSF (Python Software Foundation), créée en 2001, appartient à Open Source Initiative, et à la
FSF (Free Software Foundation)
Un logiciel propriétaire, appelé parfois de manière militante logiciel privateur, ou encore logiciel
non libre, est un logiciel dont la duplication, la modification ou l'usage est limité.
La désignation Open Source ou ‘Code Source Ouvert’, s'applique aux logiciels dont la licence
respecte des critères précisément établis par l'Open Source Initiative, c'est-à-dire les possibilités
de libre redistribution, d'accès au code source et de création de travaux dérivés. Mis à la
disposition du grand public, ce code source est généralement le résultat d'une collaboration
entre développeurs.
6

Elaboration d’un environnement logiciel Python
Installation
Beaucoup de méthodologies sont valable pour développer un environnement compatible pour une programmation avec le
langage Python (Celui-ci est téléchargeable sous deux version 2.X ou 3.X, version de base qui ne sont pas forcement
totalement compatible). Le langage Python est utilisable sous différent système d’exploitation (Win, Linux/UNIX ou Mac OS).
Une autre alternative, encore plus interessante que la première
est d’installer le logiciel ANACONDA.
Avec l’un des éditeurs de scripts
7
Notre choix
Environnement
Notre choix
IDE

Installation
La plateforme ANACONDA installe tout le nécessaire (l’environnement PYTHON 3.X/2.X) et donnera accès aux possibilités
d’étendre l’installation aux modules PYTHON nécessaires pour le développement de calcul scientifique de l’ingénieur ou du
chercheur.
Les différents modules (librairies) nécessaire sont :
NUMPY : Analyse numérique & Matrices
SCIPY : Extension pour calcul scientifique
MATPLOTLIB : Dessin de courbe
SYMPY : calcul symbolique
NETWORKX : manipulation et gestion des graphes
PLOTLY : Librairie en ligne pour dessin de courbes
EVENTLET :
TKINTER : Librairie pour manipulation d’interface graphique
IPYTHON : Bibliothèque pour calcul scientifique
CYTHON : Interface pour environnement C/C++
JPYTHON : Interface pour environnement JAVA
JUPYTER : Editeur orienté navigateur
DJANGO-CMS : System de gestion de contenus
WIDGY : CMS utilisant le Framework Django.
…encore des milliers de modules.
8
Notre choix
Environnement
Notre choix
IDE

Installation : Assistant de l’installation de ANACONDA et de PYCHARM
La plateforme ANACONDA = {Python, Modules} L’IDE de programmation PYTHON, PyCharm
9
Notre choix
Environnement
Notre choix
De l’IDE

Personnalisation : Sous PyCharm, en mode TEREMINAL, nous ajoutons
les modules nécessaires à la plateforme ANACONDA .
Dans la fenêtre TERMINAL, nous utiliserons CONDA
H:PycharmProjectsessai>conda install mpi4py
Using Anaconda Cloud api site
https://api.anaconda.org
Fetching package metadata: ....
Solving package specifications: ..........
Package plan for installation in environment
h:Anaconda325:
The following packages will be downloaded:
package | build
mpi4py-2.0.0 | py35_0 264 KB
The following NEW packages will be INSTALLED:
mpi4py: 2.0.0-py35_0 (copy)
Proceed ([y]/n)? Y
Fetching packages ...
mpi4py-2.0.0-p 100% |###| Time: 0:00:01 169.26 kB/s
Extracting packages …
[COMPLETE]|##################################| 100%
Linking packages ...
[mpi4py]| | 0%
[COMPLETE]|##################################| 100%10
Fenêtre ABOUT
de PyCharm
Idée du jour
Commande
installation modules

Utilisation : Sous PyCharm, en mode TEREMINAL, nous ajoutons les
modules nécessaires à la plateforme ANACONDA .
Caractéristiques du langage script Python :
Avantages :
• Très riches librairies pour le calcul scientifique.
• Langage bien structuré, permettant d’écrire des
programmes lisibles ‘we code what we think’.
• D’autres librairies hors le cadre du calcul scientifique
(Gestion des services Web, Accès aux ports série, etc.)
• Graticiel ‘Open Source’, derrière une large communauté.
• Compacité du programme développé.
• Beaucoup d’alternatives pour l’édition (IDE).
Inconvénients:
• Environnement de développement moins.
• Pas tous les algorithmes qui peuvent être trouvés dans le
logiciel.
Python peut être utiliser sous deux modes, selon
l’interactivité escomptée.
1. Commande en ligne
2. Exécution de fichier script .py
11
Fenêtre ABOUT
de PyCharm

Utilisation : Sous PyCharm,.
Caractéristiques du langage script Python :
Python est un langage script informatique générique et
moderne.
• Langage Python intègre tous les types de données
(chaîne, réel, int), les contrôles, des collections de
données (listes, dictionnaires), et des modèles de flux,
etc.
• La bibliothèque standard intègre plusieurs Modules.
• Un grand nombre de modules spécialisés ou des
applications sont écrites en Python: protocoles web,
framework web, etc ... Ainsi que le calcul scientifique.
- Outils de développement (test automatique, génération de
documentation).
- et encore plus…
Python peut être utiliser sous deux modes, selon
l’interactivité escomptée.
1. Commande en ligne
2. Exécution de fichier script .py
12
Mode console
Python
Mode
programme (.py)

Utilisation : Sous Jupyter, Interface WEB pour Python.
Cette interface Web est facilement mise en œuvre par son
installation :
conda install jupyter (si Anaconda est installé)
Ou
pip install jupyter
Le lancement de l’interface est fait en invoquant :
Jupiter notebook
Ouvrir le navigateur et entrer l’adresse
http://127.0.0.1:8888.
Pour utiliser un autre PORT autre que 8888
On note : http://127.0.0.1:Nouveau_Port.
L’interface JUPITER est intuitive et facile à utiliser, ses
fonctionnalités sont :
• Déploiement sous protocole Internet d’aptitude de calcul
Python.
• Toute les possibilités de gestion des documents ‘Notebook’
sont offertes.
• Possibilités d’édition non limitées (LaTeX, HTML, Code, …)
• Exécution immédiate.
• Compatibilité avec la plupart des langages et scripts de
programmation (C/C++, Java, JavaScript, Julia, Python, R,
Octave, …)
• Offre accessibilité à Jupyter Drive via Google Drive.
• Options de Reporting avancées (HTML, LaTeX, PDF).
13
Exemple de
code avec son
exécution
Menu et barre
d’outils

Utilisation : Sous Jupyter, Interface WEB pour Python.
Les notebooks sont accessibles à partir de PyCharm.
Les notebooks sont des solutions de collaboration de préférences,
ils intègrent toute les fonctionnalités exigées par un chercheur
dans le domaine des sciences, humaines ou technologiques.
Organisation des documents, leur ouverture, édition ou mise à
jours se fait dans le même endroit sans aucune dépendance par
rapport à la machine, puisque les notebooks sont accessible en
ligne (Serveur, Ordinateur de bureau ou Périphérique mobile).
Les possibilités sont étendues ainsi qu’une documentation
abondante.
14
Graphique
3D
Exemple de Code
Python

Les domaines utilisant le langage script Python sont nombreux :
Calcul scientifique de base (Modèle (Non-) linéaire)
Python pour traitement du signal
Calcul de probabilité et statistiques
Développement de graphiques interactive avec Plotly
Visualisation des données avec Lightning
Lissage et régression non Paramétrique
Solveur d’équations différentielles partielles
Librairie Python d’analyse des données (Panda)
Analyse de Big-Data en python
Machine Learning sous Python avec le package scikit-learn
Econométrie sous Python avec le package StatsModels
Introduction à la programmation parallèle avec MPI Python
Théorie des graphes
Commande de processus et systèmes embarqués
Plateforme CAD 2D/3D
Bioinformatique et manipulation du génome
Développement de sites Web (Framework Django)
Domaines d’utilisation
15

import numpy as np
systeme = np.array([[1,2],[3,-4]])
valeur=np.array([[3],[1]])
sol=np.linalg.solve(systeme,valeur)
print("x=",sol[0,0]," et y=",sol[1,0])
x= 1.4 et y= 0.8
# Résolution de système linéaire A.X=b
>>> import numpy as np
>>> from scipy import linalg
>>> A = np.array([[1, 2], [3, 4]])
>>> A
array([[1, 2],[3, 4]])
>>> b = np.array([[5], [6]])
>>> b
array([[5],[6]])
>>> linalg.inv(A).dot(b) # slow
array([[-4. ],[ 4.5]])
>>> A.dot(linalg.inv(A).dot(b)) - b # Vérification
array([[8.88178420e-16],[2.66453526e-15]])
>>> np.linalg.solve(A, b) # fast
array([[-4. ],[ 4.5]])
>>> A.dot(np.linalg.solve(A, b)) - b # Vérification
array([[ 0.],[ 0.]])
Importation de la
librairie Numpy
16

17
import numpy as np
from scipy import signal, misc
import matplotlib.pyplot as plt
image = misc.face(gray=True).astype(np.float32)
derfilt = np.array([1.0, -2, 1.0], dtype=np.float32)
ck = signal.cspline2d(image, 8.0)
deriv = (signal.sepfir2d(ck, derfilt, [1]) +signal.sepfir2d(ck, [1], derfilt))
laplacian = np.array([[0,1,0], [1,-4,1], [0,1,0]], dtype=np.float32)
deriv2 = signal.convolve2d(ck,laplacian,mode=‘same',boundary='symm')
plt.figure()
plt.imshow(image)
plt.gray()
plt.title(‘Image original')
plt.show()
plt.figure()
plt.imshow(deriv)
plt.gray()
plt.title(‘sortie avec filtre spline')
plt.show()

from matplotlib.pyplot import figure, hold, plot, legend, draw
from numpy import linspace
import scipy.stats as stats
from numpy.random import randn
x = randn(100)
fig = figure()
ax = fig.add_subplot(111)
ax.hist(x, bins=30, label=’Empirical’)
xlim = ax.get_xlim()
ylim = ax.get_ylim()
pdfx = linspace(xlim[0], xlim[1], 200)
pdfy = stats.norm.pdf(pdfx)
pdfy = pdfy / pdfy.max() * ylim[1]
hold(True)
plot(pdfx, pdfy, ’r-’, label=’PDF’)
ax.set_ylim((ylim[0], 1.2 * ylim[1]))
legend()
hold(False)
draw()
18

Librairie Python d’analyse des données (Panda, QtGraph)
19

Librairie Python d’analyse sonore du coran
%matplotlib inline
from pylab import plot, show, title, xlabel, ylabel, subplot, savefig
from scipy import fft, arange, ifft
from numpy import sin, linspace, pi
from scipy.io.wavfile import read,write
def plotSpectru(y,Fs):
n = len(y) # lungime semnal
k = arange(n)
T = n/Fs
frq = k/T # two sides frequency range
frq = frq[range(n/2)] # one side frequency range
Y = fft(y)/n # fft computing and normalization
Y = Y[range(n/2)]
plot(frq,abs(Y),'r') # plotting the spectrum
xlabel('Freq (Hz)')
ylabel('|Y(freq)|')
Fs = 44100; # sampling rate
rate,data=read('fatiha.wav')
y=data
lungime=len(y)
timp=len(y)/44100.
t=linspace(0,timp,len(y))
subplot(2,1,1)
plot(t,y)
xlabel('Time')
ylabel('Amplitude')
subplot(2,1,2)
plotSpectru(y,Fs)
show()
20
Lecture de la
sourah
Code du traitement
audio
Spectre Amp|Fréq

Introduction à la programmation parallèle (MPI Python)
Théorie des graphes (Networkx)
21Exemple
de graphe
Fenêtre Aperçu
du bloc-note
Importation de la
librairie NetworkX

import RPi.GPIO as GPIO
GPIO.setmode(GPIO.BCM) # set board mode to Broadcom
GPIO.setup(17, GPIO.OUT) # set up pin 17
GPIO.setup(18, GPIO.OUT) # set up pin 18
GPIO.output(17, 1) # turn on pin 17
GPIO.output(18, 1) # turn on pin 18
Importation
librairie GPIO
Module
Galileo Gen 2
Module
RaspBerry PI 3
22

Plateforme CAD 2D/3D (Python CAD, FreeCAD)
23
from OCC.STEPControl import STEPControl_Reader
from OCC.IFSelect import IFSelect_RetDone, IFSelect_ItemsByEntity
from OCC.Display.SimpleGui import init_display
step_reader = STEPControl_Reader()
status = step_reader.ReadFile('./models/wind_turbine.stp')
if status == IFSelect_RetDone: # check status
failsonly = False
step_reader.PrintCheckLoad(failsonly, IFSelect_ItemsByEntity)
step_reader.PrintCheckTransfer(failsonly, IFSelect_ItemsByEntity)
ok = step_reader.TransferRoot(1)
_nbs = step_reader.NbShapes()
aResShape = step_reader.Shape(1)
else:
print("Error: can't read file.")
sys.exit(0)
display, start_display, add_menu, add_function_to_menu = init_display()
display.DisplayShape(aResShape, update=True)
start_display()
Importation
librairie OCC
Maillage Dauphin
Rendu du mât d’un
aérogénérateur

POO avec Python (Programmation
Orientée Objet)
class Rocket():
# Rocket simule une roquette pour un jeu,
# ou une simulation de physique.
def __init__(self):
# Each rocket has an (x,y) position.
self.x = 0
self.y = 0
def move_up(self):
# Incrémentation de la position y de la roquette.
self.y += 1
# Définir une ensemble de 5 roquettes, les stocker dans une liste.
my_rockets = []
for x in range(0,5):
new_rocket = Rocket()
my_rockets.append(new_rocket)
# A remarquer que chaque roquette est un objet à part entière.
for rocket in my_rockets:
print(rocket)
Définition d’une
nouvelle Classe
Instantiation
Méthode Constructeur
__init__
24

Bioinformatique et manipulation
du génome
25
from Bio import SeqIO
for seq_record in SeqIO.parse("ls_orchid.gbk", "genbank"):
print(seq_record.id)
print(repr(seq_record.seq))
print(len(seq_record))
Z78533.1
Seq('CGTAACAAGGTTTCCGTAGGTGAACCTGCGGAAGGATCATTGATGAGACCGTGG...CGC',
IUPACAmbiguousDNA())
740
...
Z78439.1
Seq('CATTGTTGAGATCACATAATAATTGATCGAGTTAATCTGGAGGATCTGTTTACT...GCC',
IUPACAmbiguousDNA())
592
Sinon dans une Terminal Python
>>> from Bio.Seq import Seq
>>> from Bio.Alphabet import generic_dna
>>> gene = Seq("GTGAAAAAGATGCAATCTATCGTACTCGCACTTTCCCTGGTTCTGGTCGCTCCCATGGCA" +
... "GCACAGGCTGCGGAAATTACGTTAGTCCCGTCAGTAAAATTACAGATAGGCGATCGTGAT" +
... "AATCGTGGCTATTACTGGGATGGAGGTCACTGGCGCGACCACGGCTGGTGGAAACAACAT" +
... "TATGAATGGCGAGGCAATCGCTGGCACCTACACGGACCGCCGCCACCGCCGCGCCACCAT" +
... "AAGAAAGCTCCTCATGATCATCACGGCGGTCATGGTCCAGGCAAACATCACCGCTAA",
... generic_dna)
>>> gene.translate(table="Bacterial")
Seq('VKKMQSIVLALSLVLVAPMAAQAAEITLVPSVKLQIGDRDNRGYYWDGGHWRDH...HR*',
HasStopCodon(ExtendedIUPACProtein(), '*')
>>> gene.translate(table="Bacterial", to_stop=True)
Seq('VKKMQSIVLALSLVLVAPMAAQAAEITLVPSVKLQIGDRDNRGYYWDGGHWRDH...HHR',
ExtendedIUPACProtein())
Logo de
BioPython Séquence d’ADN
Importation
librairie BIO

26
# Installer à partir de PyPI
$ pip install mezzanine
# Instantier un projet
$ mezzanine-project monproject
$ cd monproject
# Instantier une Base de données
$ python manage.py createdb
# Lancer le serveur Web
$ python manage.py runserver
Installation en mode
commande
URL du site instantié
Version Mobile, Menu
Version Administration
Sites Web fait avec
Mezzanine
Version Normal

Les environnements de développement intégrés de code Python sont nombreux, des solutions propriétaires à celles portant le
label GPL.
Ils sont de trois grandes catégories :
Les applications bureaux (Desktop)
Les consoles de commande en ligne
Les interfaces orientées Web
Outils d’élaboration de code Python (IDE)
27

label GPL.
28

label GPL.
29

Nom de Symbole : Les noms de variables en Python peuvent contenir des caractères alphanumériques a-z, A-Z, 0-
9 et certains caractères spéciaux tel que _. Les noms de variables normales doivent commencer par une lettre.
Par convention, les noms de variables commencent par une lettre minuscule, et les noms de classe commencent par
une lettre majuscule. En outre, il y a un certain nombre de mots-clés Python qui ne peuvent pas être utilisés comme
noms de variables. Ces mots-clés sont les suivants:
and, as, assert, break, class, continue, def, del, elif, else, except, exec, finally, for, from, global, if, import, in,
is, lambda, not, or, pass, print, raise, return, try, while, with, yield
Affectation :
# assignment de variable
x = 1.0
my_variable = 12.2
type(x) #fonction TYPE retourne le type de la variable entre parenthèse
builtins.float
Verification de type :
x = 1.0
# vérifier si la variable est réelle
type(x) is float
isinstance(x, float)
True
z = complex(x)
print(z, type(z))
(1+0j) <class 'complex‘>
Base de représentation des données
31

Operateurs et comparaisons
Opérateurs arithmétiques +, -, *, /, // (division entière), '**' puissance.
3.0 // 2.0
1.0
# NB: operators puissance en python n’est pas ^, mais **
2 ** 2
4
Les opérateurs de comparaison sont >,<,>=,<=,==.
# objects identiques ?
x1 = x2 = [1,2]
x1 is x2
True
2 >= 2, 2 <= 2
(True, True)
Chaines de caractères, les liste et les dictionnaires
s = "Hello world"
type(s)
builtins.str
# length of the string: the number of characters
len(s)
11
# replace a substring in a string with somethign else
s2 = s.replace("world", "test")
print(s2)
Hello test
s[0]
'H'
32

Chaines de caractères, les liste et les dictionnaires
s = "Hello world“
# replace a substring in a string with somethign else
s2 = s.replace("world", "test")
Hello test
print(s2)
s[0:5]
'Hello‘
s[0:5]
'Hello‘
s[:]
'Hello world‘
print("value = %f" % 1.0) # Formatage C des variables
value = 1.000000
s2 = "value1 = %.2f. value2 = %d" % (3.1415, 1.5)
print(s2)
value1 = 3.14. value2 = 1
Listes
l = [1,2,3,4]
print(type(l))
print(l)
<class 'list'>
[1, 2, 3, 4]
l = [1, 'a', 1.0, 1-1j] # peuvent être hétérogène
print(l)
[1, 'a', 1.0, (1-1j)]
33

Listes
start = 10
stop = 30
step = 2
range(start, stop, step)
range(10, 30, 2)
list(range(start, stop, step))
[10, 12, 14, 16, 18, 20, 22, 24, 26, 28]
s2 = list(s)
S2
['H', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd']
# Tri de la liste
s2.sort()
print(s2)
[' ', 'H', 'd', 'e', 'l', 'l', 'l', 'o', 'o', 'r', 'w']
l = []
l.append("A")
l.append("d")
l.append("d")
print(l)
['A', 'd', 'd']
Tuples
Ce sont des variables comme les listes mais pas altérables
point = (10, 20)
print(point, type(point))
(10, 20) <class 'tuple'>
34

Tuples
x, y = point
print("x =", x)
print("y =", y)
x = 10
y = 20
Dictionaries
params = {"parameter1" : 1.0, "parameter2" : 2.0, "parameter3" : 3.0,}
print(type(params))
print(params)
<class 'dict'>
f'parameter2': 2.0, 'parameter3': 3.0, 'parameter1': 1.0}
params["parameter1"] = "A"
params["parameter2"] = "B"
# Ajouter une nouvelle entrée
params["parameter4"] = "D"
print("paramètre = " + str(params["parameter1"]))
paramètre = A
paramètre = B
paramètre = 3.0
paramètre = D
35

Affectation & Contrôle conditionnel de flue
statement1 = False # C’est une affectation
statement2 = False
if statement1: # Test validé condition (statement1) est VRAIE
print("statement1 is True")
elif statement2: # Exécutée condition (statement2) est VRAIE
print("statement2 is True")
else: # Exécutée sinon
print("statement1 and statement2 are False")
Boucles
for x in [1,2,3]: # [1,2,3] peut être désigné par range(3) avec print(x+1)
print(x)
1
2
3
for word in ["scientific", "computing", "with", "python"]:
print(word) # condition de répétition dépendante du contenu de la liste
scientific
computing
with
python
l1 = [x**2 for x in range(0,5)] # à remarquer la compacité du Python
print(l1)
[0, 1, 4, 9, 16]
37

Boucles
var = 0
while var != 1:
print " .... " # j‘écris mon programme ici
choix = raw_input("voulez vous recommencer ? ( o/n ) : ")
if choix == "n":
var = 1
else:
‘vous allez être renvoyé au début du programme’
X = y / 2
while x > 1:
If y % x == 0:
print y, ‘ est facteur de ’, x
break
x -= 1
else:
print y, ‘ est premier‘
L’utilisation de zip et map, peut s’avérée encore plus efficace
l1 = [1, 2, 3]
l2 = [4, 5, 6]
for (x, y) in zip(l1, l2):
print x, y, '--', x + y
1 4 -- 5
2 5 -- 7
3 6 -- 9
38
s='0123456789'
print map(int, s)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
Utilisation et
puissance de MAP
Utilisation de ZIP

Intervales
range(start, stop, step)
range(5, 10)
5 jusqu’à 10 (exclue) avec un pas de 1
range(0, 10, 3)
0, 3, 6, 9
range(-10, -100, -30)
-10, -40, -70
Test conditionnel binaire
x = 5
y = 10
if x > y:
print('x est grand que y')
else:
print(“x n’est pas grand que y”)
# Dans Python, on peut compliquer les chose
x = 5
y = 10
Z = 12
if z > x > y:
print(‘y est petit que x, et x est petit que z')
39

Boucle avec test conditionnel binaire
# break, continue et else dans une boucle for
for n in range(2, 10):
for x in range(2, n):
if n % x == 0:
print(n, ‘est égal à', x, '*', n//x)
break
else:
print(n, ‘est premier')
# Utilisation de l’instruction continue
for num in range(2, 10):
if num % 2 == 0: # le symbole % désigne l’opération RESTE de la division
print(“Nombre paire trouvé ", num)
continue
print(“Nombre non premier ", num)
40

Définition de fonction (procédure avec retour)
def fib(n): # Ecrire la suite de Fibonacci jusqu’à n
a, b = 0, 1
while a < n:
print(a, end=' ')
a, b = b, a+b
print()
fib(2000)
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597
f = fib # désignation par référence f à la fonction fib
f(100)
0 1 1 2 3 5 8 13 21 34 55 89
# autre type de définition de fonction
def ask_ok(prompt, retries=4, complaint="Oui or Non, s’il vou plait !"):
while True:
ok = input(prompt)
if ok in (‘o', ‘oui', ‘Oui'):
return True
if ok in (‘n', 'no', 'non', ‘Non'):
return False
retries = retries - 1
if retries < 0:
raise OSError(‘Utilisateur non coopératif')
print(complaint)
41

L’instruction lambda
def make_incrementeur(n):
return lambda x: x + n
f = make_incrementeur(42)
f(0)
42
f(1)
43
# un autre cas d’utilisation
pairs = [(1, 'one'), (2, 'two'), (3, 'three'), (4, 'four')]
pairs.sort(key=lambda pair: pair[1])
pairs
[(4, 'four'), (1, 'one'), (3, 'three'), (2, 'two')]
Les annotations dans une fonction
# Les annotations définissent des messages de présentation
def f(chiken: str, eggs: str = 'eggs') -> str: # remarquer que la fonction est de type STR
print("Annotations:", f.__annotations__)
print("Arguments:", chiken, eggs)
return chiken + ' and ' + eggs
f('spam')
Annotations: {'chiken': <class 'str'>, 'return': <class 'str'>, 'eggs': <class 'str'>}
Arguments: spam eggs
'spam and eggs‘
42

Les décorateurs python
# Notre décorateur
def decorate(func):
print u"Je suis dans la fonction 'decorate' et je décore '%s'." % func.__name__
print u"Exécution de la fonction '%s'." % func.__name__
return func
# Fonction cible utilisée avec DECORATOR
@decorate
def foobar(*args):
print ", ".join(args)
# Exemple d’appel de la fonction
foobar("A", "B", "C", "D")
Je suis dans la fonction 'decorate' et je décore 'foobar'.
Exécution de la fonction 'foobar'.
A, B, C, D
# Il est posible d’attribuer plusieurs décorateurs à une seule fonction.
@decorateur1
@decorateur2
def ma_fonction():
instructions
43

Manipulation des listes
a = [66.25, 333, 333, 1, 1234.5]
print(a.count(333), a.count(66.25), a.count('x'))
2 1 0
a.insert(2, -1)
a.append(333)
a
[66.25, 333, -1, 333, 1, 1234.5, 333]
a.index(333)
1
a.remove(333)
a
[66.25, -1, 333, 1, 1234.5, 333]
a.reverse()
a
[333, 1234.5, 1, 333, -1, 66.25]
a.sort()
a
[-1, 1, 66.25, 333, 333, 1234.5]
a.pop()
1234.5
a
[-1, 1, 66.25, 333, 333]
44

Puissance du langage Python
# L’ensemble des lignes suiantes peut être compacté par ce qui suit
combs = []
for x in [1,2,3]:
for y in [3,1,4]:
if x != y:
combs.append((x, y))
Combs
# Ou bien
[(x, y) for x in [1,2,3] for y in [3,1,4] if x != y]
# Donne le même résultat
[(1, 3), (1, 4), (2, 3), (2, 1), (2, 4), (3, 1), (3, 4)]
# Calcul de la valeur de PI arrondie
from math import pi
[str(round(pi, i)) for i in range(1, 6)]
['3.1', '3.14', '3.142', '3.1416', '3.14159']
# Générateur avec utilisation de YIELD
def generateur():
yield "a"
yield "b"
yield "c“
i=generateur()
for v in i:
print v
a
b
c
45

Les expressions régulières en python
# Les expressions régulière sont utilisées pour vérifier la conformité des expressions de
# chaines de caractères par rapport à un motif. Les symboles suivants sont utilisés :
# . ^ $ * + ? { } [ ] | ( )
# . Le point correspond à n'importe quel caractère.
# ^ Indique un commencement de segment mais signifie aussi "contraire de"
# $ Fin de segment
# [xy] Une liste de segment possible. Exemple [abc] équivaut à : a, b ou c
# (x|y) Indique un choix multiple type (ps|ump) équivaut à "ps" OU "UMP"
# d le segment est composé uniquement de chiffre, ce qui équivaut à [0-9].
# D le segment n'est pas composé de chiffre, ce qui équivaut à [^0-9].
# s Un espace, ce qui équivaut à [ tnrfv].
# S Pas d'espace, ce qui équivaut à [^ tnrfv].
# w Présence alphanumérique, ce qui équivaut à [a-zA-Z0-9_].
# W Pas de présence alphanumérique [^a-zA-Z0-9_].
# Est un caractère d'échappement
# T{2} Le T soit répété 2 fois
# TA{1,9} La séquence TA doit être présente de 1 à 9 fois
# TAM{,10} La séquence TAM n’existe pas ou répétée 10 fois
# LI{1,} La séquence LI doit être répétée au moins une fois.
46

Les expressions régulières en python
# Utilisation des expressions régulière
import re
print re.match(r"GR(.)?S", "GRIS")
<_sre.SRE_Match object at 0x02019DE0>
Une utilisation fréquente, consiste en la validation des valeurs des emails saisis.
import re
mails = [‘mtamali@gmail.com’,’utmb@univ-bechar.dz’, ‘8@free.fr’, ‘@univ-bechar.dz’, ‘tamali@cdta’]
regex = re.compile(r’^[a-z0-9._-]+@[a-z0-9._-]+.[(com|fr|dz)]+’
for mail in mails:
if regex.match(mail) is not None:
print "Ce mail : %s est valide" % mail
else:
print "Erreur ce mail : %s est non valide" % mail
Ce mail : mtamali@gmail.com est valide
Ce mail : utmb@univ-bechar.dz est valide
Ce mail : 8@free.fr est valide
Erreur ce mail : @univ-bechar.dz est non valide
Erreur ce mail : tamali@cdta est non valide
47

Les fichiers, Créer lire et écrire dans un fichier en python
fichier = open("donnees.txt", "r")
print fichier
<open file ‘donnees.txt', mode 'r' at 0x7ff6cf3fe4b0>
Le descripteur permet de renseigner la machine sur la manière avec laquelle le fichier est utilisé.
r, pour ouverture en mode READ.
w, pour ouverture en mode WRITE, chaque fois, le contenu du fichier est écrasé sinon python le crée.
a, pour ajout ‘APPEND’. Si le fichier n'existe pas python le crée.
b, Ouverture en mode Binaire.
t, Ouverture en mode Texte.
x, crée un nouveau fichier et l'ouvrir pour écriture
# procédure générale pour l’utilisation d’un fichier
fichier = open(‘donnees.txt’, "r")
print fichier.read()
fichier.close()
# L’instruction WITH peut être utilisée sans besoin de la fonction CLOSE
with open("data.txt", "r") as fichier:
print fichier.read()
48

Le langage Python, est un langage script interprété. Le programme, portant l’une des extension .py, .pyw ou .pwc est
structuré selon le canevas suivant :
Les codifications
#!/usr/bin/python2.7
# -*-coding:encodage -*
Les imports des librairies
Les instructions
Le langage Python passe, pour être exécuté sur deux étapes, la première UNE PRECOMPILATION génération du code
machine et finalement un écriture en code machine exécutable (selon la machine).
L’environnement d’exécution des scripts écrits en Python, regroupe les avantages des TRADUCTEURS (travaille en ligne par
ligne) et les COMPILATEURS (puissance de la structure algorithmique).
La bibliothèque cx_Freeze sert à transformer les fichiers scripts Pyhon .py en exécutable .exe.
Structures algorithmique du python
50

Matrices & Systèmes linéaires
52

Références
L.-V. Bertallanfy, ‘General System Theory’, Edition MASSON, 1972.
58

Chap XIII : calcul scientifique avec python

Contenu connexe

Tendances

En vedette

Similaire à Chap XIII : calcul scientifique avec python

Plus de Mohammed TAMALI

Dernier

Chap XIII : calcul scientifique avec python