Programmation Scientifique Python Partie I Et II

Programmation et techniques scientiques
exploitation du langage et des modules Python
jlo@univ-jfc.fr
INU ChampollionL2 PC-EEA
v2023.1.v1
jlo@univ-jfc.fr Programmation et techniques scientiques 1 / 205

Sommaire
Ö Partie I : Généralités de la démarche en programmation scientique
Ö Partie II : Utilisation des bibliothèques usuelles pour la programmation

scientique
Ö Partie III : Outils de base en analyse numérique

Leitmotiv et objectifs de la programmation scientique
Généralités sur le langage Python
Stratégies et démarche de résolutions de problème
Méthodologie du ux de développement en V
Bilan & Take home message
Première partie I
Généralités de la démarche en
programmation scientique

Leitmotiv et objectifs de la programmation scientique Besoins
Généralités sur le langage Python Préoccupations
Stratégies et démarche de résolutions de problème Connaissances et compétences
Méthodologie du ux de développement en V Déroulement de l'UE
Outline
1 Leitmotiv et objectifs de la programmation scientique

2 Généralités sur le langage Python
3 Stratégies et démarche de résolutions de problème
4 Méthodologie du ux de développement en V
5 Bilan & Take home message

Outline

Besoins
Préoccupations
Connaissances et compétences
Déroulement de l'UE

Pourquoi devons nous nous intéresser à la programmation scientique ?

Besoins en analyse de données

La réalité ̸= les mesures
mais les mesures =⇒ un reet de la réalité nécessaire pour :
=⇒ pour décrire la réalité : DESCRIPTIVE
=⇒ pour comprendre la réalité : ANALYSE a.k.a. diagnostic
=⇒ pour prédire la future de la réalité ou interpoler d'autres réalités
non mesurables : PREDICTIVE par modélisation
=⇒ apporter des solutions pour amener d'autres réalités :
PRESCRIPTIVE. E.g. problème optimisation
La réalité des mesures =⇒ données numériques
Faire parler les données numériques =⇒ REPRESENTATION
GRAPHIQUE
Trouver des messages/motifs cachés des données numériques
=⇒ ANALYSE NUMERIQUE (implementation des outils
mathématiques par un langage de programmation)
Postulat du cours : réalité = grandeurs physiques
Besoins supplémentaires en modélisation numérique
Un modèle = un set de lois/équations décrivant au plus près la

réalité
Un modèle numérique
Transcription d'un modèle analytique =⇒ APPROXIMATION
NUMERIQUE
=⇒ implémentation du modèle =⇒ données numériques
La prédiction de la réalité =⇒ modélisation numérique
Validation du modèle = comparer les données numériques modèle vs
mesures
Faire parler les données numériques =⇒ REPRESENTATION
GRAPHIQUE
Trouver des messages/motifs cachés des données numériques
=⇒ ANALYSE NUMERIQUE (implementation des outils
mathématiques par un langage de programmation)

Programmation applicative vs. programmation scientique

Préoccupation :
Applicative =⇒ faire interagir diérentes ressources entre elles pour
accomplir une tâche
Utilisateurs (front-end user )
Les appareils (hardware )
Les logiciels (software )
Les bases de données
etc.
Scientique =⇒ s'assurer que les calculs numériques eectués sont
les plus justes possibles
Données de mesures vs donnée calculé vs ordre de grandeur
Application scientique =⇒ Applicative + scientique
E.g. suivi d'un temps réel de risque d'avalanche
appareils de mesure (température, hygrométrie etc.)
calcul et analyse prédictive en fonction de la base de données des
caractéristiques des lieux de prélèvement
achage aux utilisateurs
Programmation applicative vs. programmation scientique

Programmation
applicative scientique
exemple application Google cinétique de réduction chimique
Map
besoins & ça fonctionne ça fonctionne
préoccupa-
tions
en temps voulu en temps voulu
sans erreur de com- sans erreur de comportement (bugs )
portement (bugs )
erreur numérique limité (calcul juste)
rapidité de convergence/calcul (ré-
ponse temporelle)

Connaissances et compétences exigibles S3

Les bases
Utilisation des modules NumPy, Matplotlib et scipy

Génération, importation et exportation des données numériques
Opérations arithmétiques sur les tableaux/vecteurs/matrices
Exploitation (analyse) et représentation graphique des données
numériques


Niveau L2 attendu
Transcription d'un calcul analytique à un calcul numérique
dérivée & intégration
autres calculs par récurrence limitée
Implémentation des algorithmes de résolution de problème par
approche numérique
notions de convergence
notions d'existence et unicité de solution
dichotomie
Newton-Raphson
Regula-Falsi
Implémentation des modèles simples de prédiction
interpolation polynomiale (de Lagrange, de Newton)
approximation par une fonction (méthode moindres carrés)
Cas général
Cas linéaire/linéarisé moindres carrés ordinaires

Méthodologie et démarche attendue
Démarche à priori des résultats attendus (types, ordre de grandeurs,

etc.)
Démarche analyse d'applicabilité des méthodes numériques a priori
Validation a posteriori des calculs eectués (achage, comparaison,
etc.)
Notions des provenances des erreurs numériques et les démarches de
les réduire

Déroulement et planning
En présentielle :
10 h de cours magistraux
22 h de travaux pratiques (dont évaluations)
En autonomie :
1h présence ≈ 1 2 h en autonomie (condition nécessaire de
résussite)
Quizs à domicile (Moodle) de préparation et de révision (aide à la
résussite)
Devoirs maisons (aide à la résussite)
Relecture et reproduction autonome de solutions types fournies

Déroulement et planning
Evaluation pour l'obtention de 3 ECTS :
20 % quizs
40 % projet
40 % évaluation TP
TP :
TP 1 : introduction spyder + numpy + matplotlib
TP 2 : Révision structure while dichotomie
TP 3 : Révision structure for calcul récurrence à indice
TP 4 : Intégrale numérique
TP 5 : Dérivée numérique
TP 6 & 7 : Projets
TP 8 : Méthode de Newton-Raphson
TP 9 &10 : interpolation et approximations
TP évaluation
Letitmotiv et objectifs de la programmation scientique

Programmation applicative vs. Programmation scientique
Population
Country Change (%)
2016 2017
China 1,403,500,365 1,409,517,397 +0.4%
India 1,324,171,354 1,339,180,127 +1.1%
United States 322,179,605 324,459,463 +0.7%
Indonesia 261,115,456 263,991,379 +1.1%
Brazil 207,652,865 209,288,278 +0.8%

Leitmotiv et objectifs de la programmation scientique Shell & interpréteur
Généralités sur le langage Python Scripts & IDE
Stratégies et démarche de résolutions de problème Processus de compilation & interprétation
Méthodologie du ux de développement en V Structuration d'un script
Bilan & Take home message Bilan & Take home message
Outline


Outline

Shell & interpréteur
Scripts & IDE
Processus de compilation & interprétation
Structuration d'un script
Sommaire

Scripts & IDE
Fonctionnement général de Python

Shell
Rôle =⇒ sur-couche permettant l'interaction avec le coeur d'interpréteur.

C'est l'interface entre l'environnement de développement et l'interpréteur
du langage Python (noyau ).
Deux sur-couches (shells ) répandues

Python Shell =⇒ sur-couche de base
iPython Shell =⇒ sur-couche plus évoluée

Python shell
Exemple Python shell sous invité de commande Windows cmd
1 C: \ Users \ username>python
2 Python 3 . 1 0 . 7 ( t a g s /v3 . 1 0 . 7 : 6 cc6b13 , xxxxx , xx : xx : xx ) [
xxx v .1933 64 b i t (AMD64) ]
3 >>> 8+5
4 13
5 >>> a , b , c =7+13, 2 * * 3 , 2 * * 0.5
6 >>> a
7 20
Fonctions natives importantes :

dir(<nomModule>) =⇒ liste des fonctions/méthodes disponibles
help(<nomModule>.<nomFonction>) =⇒ aide à l'utilisation
quit()

iPython shell
Exemple iPython shell sous invité de commande Windows
1 C: \ Users \ username>i p y t h o n
2 Python 3 . 1 0 . 7 ( t a g s /v3 . 1 0 . 7 : 6 cc6b13 , xxxxx , xx : xx : xx ) [
MSC v .1933 64 b i t (AMD64) ]
3 IPython 7 . 3 4 . 0 == An enhanced I n t e r a c t i v e Python . Type
' ? ' for help .
4 I n [ 1 ] : a , b , c = 7 , 9 , 10
5 I n [ 1 ] : %whos
6 Variable Type Data/ I n f o
7 =============================
8 a int 7
9 b int 9
10 c int 10
Instructions magiques natives
%whos ou !whos=⇒ liste des variables
%reset ou !reset =⇒ libérer toutes les variables
Fonctionnement interactif du Python shell
Principe de fonctionnement simplié (Read, Evaluate, Print, Loop) :

1 while True :
2 code = i n p u t ( ">>>" )
3 exec ( code )
1 lire l'instruction donnée par l'utilisateur
2 l'envoie au noyau Python qui traduit l'instruction sous une forme
exécutable par la machine
(texte =⇒ byte-code=⇒ langage machine =⇒ exécution)
3 reçoit le retour du noyau et acher sur la console
4 attend une autre instruction...

Tâches annexes du shell
1 auto-complétion de l'instruction
2 gestion des erreurs
3 envoie un message d'erreur.

Sommaire
Scripts & IDE
Présentation d'un script
Script vs commande en ligne
Environnement de développement intégré - IDE
Présentation visuelle
Options d'exécution
Console iPython
Présentation d'un script

c'est un chier de texte avec l'extension .py !
éditable par notepad, bloc-notes... n'importe quel programme
d'éditeur de texte.
#calcul approximation de la fonction exp
def exp_app(x):
res = 0
for i in range(0, 100):
res = res + x**i
return res
#recherche brute x > exp (x) dans [0, b] avec pas 0.01
xSol = 0
counter = 0
iterMax = 5000
while xSol <= exp_app(xSol) and counter < iterMax:
xPrec = xSol
xSol = xPrec+0.01
counter = counter + 1
xSol = (xSol+ xPrec)/2 #solution trouvee
Scripts vs commande en ligne
Script commandes en ligne

interprétation et exécution de interprétation et exécution à
toutes les lignes d'instructions chaque retour à la ligne
par bouton s'exécution (F5) instructions non sauvegardée
Plusieurs instructions par défaut
sauvegardées dans un chier Pas de réutilisation possible
texte au format .py. Vérication d'une unique
Réutilisation facilitée instruction rapidement
Organisation des instructions
possibles et requises !

Environnement de développement intégré - IDE
IDE (Integrated Development Environment ) ore un ux continu

(aller-retour) :
Édition de chier script
Lecture et exécution de la totalité du chier script.
Visualisation d'erreurs (déboggage)
Parcours de variables existantes dans l'espace des noms
etc.
IDE utilisé pour ce cours : Spyder
D'autres IDE :
sur poste xe : Visual Studio, IDLE,
D'autres environnements :
Jupyter notebook
sur Cloud : google Colab etc.

IDE Spyder
Environnement à multi-fenêtres :
zone d'édition de texte fenêtre console (iPython)

Options d'exécution
Exécution du script actif (F5) :
Options à cocher :
purge des variables =⇒
évite l'eet mémoire
(risque de faux bon
fonctionnement)
choix du console =⇒
une console
active/nouvelle

Console iPython
Sur la console active :

Achage des prompts print()
Achage des prompts input()
Achage des messages d'erreur

Sommaire
Scripts & IDE
Illustration du langage machine
Ordre de grandeurs
Limitation du langage machine
Phases de compilation
Compilateur vs interpréteur
Particularité Python

Exemple d'une ampoule contrôlable par un processeur qui exécute un
programme dans la mémoire principale. Le jeu d'instructions machines
codé en 1 octet :
Code machine Opération
0000 0000 Arrêt du programme
0000 0001 Allumer l'ampoule à plein puissance
0000 0010 Eteindre l'ampoule
0000 0100 Réduire l'intensité de 10%
0000 1000 Augmenter l'intensité de 10%
0001 0000 Si l'ampoule est à 100% intensité, sauter l'instruc-
tion suivante
0010 0000 Si l'ampoule est à 0% intensité, sauter l'instruction
suivante
0100 0000 Aller au début du programme (adresse 0)
Comment faire fonctionner l'ampoule avec une ambiance disco ?

Comment faire fonctionner l'ampoule avec une ambiance disco ?

Contraintes et possibilités :
Les liaisons physiques réalisées telle qu'à l'allumage, l'instruction à
l'adresse 0 est lue et exécutée
les instructions dans les adresses suivantes sont exécutées de
manière séquentielle (l'une après l'autre)
le contrôleur plante s'il rencontre un code d'instruction
non-déni ou tente de lire une adresse inexistante.
Il existe une instruction Go back qui force le processeur de
redémarrer a l'adresse 0.


Adresse Code machine Opération
0 0000 0001 Allumer l'ampoule à plein puissance
1 0000 0010 Eteindre l'ampoule
5 0000 0100 Réduire l'intensité de 10%
9 0000 0000 Arrêt du programme
A VOUS : Modier les instructions (en code machine) en commençant

à l'adresse 0 pour que l'ampoule clignote en permanence.

Adresse Code machine Opération

5 0100 0000 Aller au début du programme (adresse 0)

Ordre de grandeurs
Processeur moderne :
composé de millions transistors d'instructions machine par seconde
exécute milliards d'instructions machine par seconde
exécute une instruction machine à la fois
Une instruction machine :
typiquement 1 octet (8 bits) à 8 octets (64 bits).
processeur Intel-x86 : → 120 bits =⇒ 2120 instructions machines
microcontrolleur : < 1 octet.

Limitation du langage de machine

Est-il facile pour vous d'identier à quoi correspond l'instruction
0001 0000 ?


0001 0000 ?
Limitations du langage machine :
dicilement compréhensible par l'humain
dépendance de l'architecture du CPU (Intel x-86) et du système
d'opération (Windows, Linux, Android, Apple, etc.) code native à
la machine/PC .exe vs


0001 0000 ?
Réalités du langage machine :
Un processeur a typiquement des milliers (voire plus) d'instructions
machines
instructions sont de bas niveau et n'aecte pas directement les
périphériques de sortie, eg. l'ampoule.


0001 0000 ?
Réalités du langage machine :
Un processeur a typiquement des milliers (voire plus) d'instructions
machines
instructions sont de bas niveau et n'aecte pas directement les
périphériques de sortie, eg. l'ampoule.
=⇒ INTERPRETEUR ou COMPILATEUR
Rôle : traduire un langage plus évolué ↔ au langage machine.
Du code source (script ) au code native de la machine

Phases d'une compilation
Phase analyse : lexical,

grammaire (syntaxe),
sémantique
=⇒ génération d'un arbre de
syntaxe
Phase synthèse : génération
d'un code machine optimisée
Phase exécution :
=⇒ la machine (système opératoire
charge le code machine dans la
mémoire et le CPU exécute les
instructions.
Compilateur vs interpréteur
Compilateur Interpréteur
traduit toute la code source traduit et exécute ligne par
(script ) au code native de la ligne
machine cible (architectures : aucun chier exécutable
x86, ARM, etc.) autonome & séparé
produit un chier de sortie interprétation et exécution à
autonome (stand-alone ) ne temps réel
nécessite pas logiciels tiers pour temps d'exécution plus long
son exécution dans la machine processus de développement
cible rapide étape compilation omis
temps d'exécution réduit (code E.g. Matlab, Scilab, Pyhon,
optimisé) PhP, Ruby, Javascript
Chaque ligne modiée nécessite
une recompilation totale !
E.g. C, Fortran, Pascal, ADA,
Swift (Apple)... jlo@univ-jfc.fr Programmation et techniques scientiques 41 / 205
Particularités du langage python

Python : un langage semi-interprété
1 lire ligne par ligne =⇒ Python Shell
2 vérier le syntaxe =⇒ interpreteur Python
3 traduire au byte-code =⇒ pre-COMPILATION =⇒ interpreteur
Python
4 interprétation & exécution du byte-code =⇒ Python Virtual
Machine
Cas de l'exécution d'un script .py =⇒ génération du chier (.pyc) pour
les modules importés
=⇒ Proter de l'avantage du langage interprété (temps de
développement réduit, portabilité) et du langage compilé (temps
d'exécution optimisé)
Sommaire
Scripts & IDE
Contraintes de la programmation impérative
Structuration de base
Convention PEP
Explicite vs implicite
Une expression par ligne
Initialiser un tableau
Factorisation/regroupement des instructions
Un return par fonction
Convention des noms de variables
Typage dynamique
Pour aller plus loin

Pourquoi devons nous structurer un script ?


Pourquoi devons nous structurer un script ?
Caractéristiques de la programmation impérative :
Instructions pas-à-pas : Séquences d'instructions que le processeur
doit suivre
Mutabilité des variables : modication explicite de l'état des
variables au cours du temps par le programme.
Flux de contrôle : par des structures de contrôle d'itération/boucle
(while, for ) et conditionnels (ifelse ) pour déterminer l'ordre
d'exécution des instructions
Focalise sur le processus nécessaire pour atteindre l'objectif
agencement des étapes et séquences.
m
=⇒ S'assurer que les séquences imaginées par le programmeur
correspondent à celles implémentées.
Structuration de base d'un script
1 Importations des modules

import NomModule
from NomModule import NomFonction
2 Declaration des constantes

PI = 3.14159
name = "John"
3 Dénitions des fonctions/procédures

def calculate_area(radius):
return PI * radius ** 2

resume Programme principal

if __name__ == "__main__":
radius = float(input("Inserer le rayon: "))
area = calculate_area(radius)
print(f"L'aire du cercle est: {area}")
NB : est une variable native qui

__name__
stocke la chaîne "__main__" si le chier source est exécuté en
tant que programme principal
stocke le nom du module exécuté sinon.
La structure conditionnelle if __name__ == "__main__": émule
articiellement la fonction principale main() car la partie de code au
niveau 0 d'identation est exécuté en premier par l'interpréte


Aperçu du script en totalité
import NomModule
from NomModule import NomFonction
PI = 3.14159
name = "John"
if __name__ == "__main__":
radius = float(input("Inserer le rayon: "))
area = calculate_area(radius)
print(f"L'aire du cercle est: {area}")
STRUCTURATION ↔ CRITERE D'EVALUATION de l'UE

Conventions en structuration & codage

Besoins :
Lisibilité
Pour d'autres développeurs
Pour soi-même
Reprise du code facilitée
Amélioration de performances
Extension en fonctionnalités
Prévention des bugs
Correction des bugs
Analyse sémantique par l'interpréteur =⇒ optimisation (accrue)
Recommendation de la communauté : Guide du style PEP-8 (Python
Enhanced Proposal )
Leitmotiv : Un code est plus souvent lu qu'écrit =⇒ augmenter

lisibilité.
Explicite est mieux qu'implicite
Implicite mauvaise Explicite OK

def make_complex(*args): def make_complex(x, y):
x, y = args return {'x': x, 'y': y}
return dict(locals()) myComplexDict = make_complex(6,
7)
Les deux codes renvoient la même chose : un dictionnaire dont deux

éléments sont étiquettés par les clés 'x' et 'y'.
=⇒ print(myComplexDict['x'], myComplexDict['y']) ache la
même chose.
Exemple explicite : Le développeur qui doit utiliser cette fonction
sait exactement ce qu'il doit faire en lisant la première et dernière
lignes, ce qui n'est pas le cas pour la mauvaise exemple.

Une expression / instruction par ligne
Mauvaise OK
print('one'); print('two') print('one')
print('two')
if x == 1: print('one')
if x == 1:
if <boolean complexe> and < print('one')
boolean complexe>:
# instruction a eectuer cond1 = <boolean complexe>
cond2 = <autre boolean complexe>
if cond1 and cond2:
# instruction a eectuer

Initialiser un tableau au lieu de copier

Initialiser = créer une nouvelle & aecter des valeurs
Mauvaise OK
# Incrementer de 3 tous les elements # Incrementer de 3 tous les elements
. .
a = [3, 4, 5] a = [3, 4, 5]
b = a # a et b pointe sur le meme b = a[:] # une nouvelle liste
# objet liste # est cree
for i in range(len(a)): for i in range(len(a)):
a[i] += 3 # b[i] modiee a[i] += 3 # b[i] non modiee
print('a :', a) print('a :', a)
print('b :', b) print('b :', b)
a : [6 , 7 , 8] a : [6 , 7 , 8]
b : [6 , 7 , 8] b : [3 , 4 , 5]
Lorque deux variables pointent sur le même objet (mémoire), la
modication de l'une impliquer aussi celle de l'autre.
Factorisation et regroupement
OK Mieux
resultat = a * - (b + c) t1 = (b + c)
t2 = -t1
resultat = a * t2
Avantage : regroupement des opérations du même ordre de grandeur

=⇒ éviter les erreurs numériques
Désavantage : le code peu devenir moins explicite.
OK Mieux
resultat = a ** (- (exp((b+a)/c) t1 = (b + c)
)) t1 = t1/c
t1 = -exp(t1)
resultat = a ** t1

Un point de sortie return par fonction

Mauvaise
def racines_simples_polynome2_bad(a, b, c):
if not a:
return None # Lever une exception est mieux!
delta = b**2 - 4*a*c

if delta<0:
return None # Lever une exception est mieux!
x1 = (-b + delta**0.5)/2/a
x2 = (-b - delta**0.5)/2/a
return x1, x2 # Le point de sortie nale si tout va bien
Dicile d'identier le point de sortie eectif.

Un point de sortie return par fonction

OK
def racines_simples_polynome2_good(a, b, c):
if not a:
raise ValueError('a est nul')
delta = b**2 - 4*a*c

if delta<0:
raise ValueError('le determinant negative')
x1 = (-b + delta**0.5)/2/a
x2 = (-b - delta**0.5)/2/a
return x1, x2 # Le point de sortie unique pour retourner

#la valeur de x permet de faciliter la maintenance
du code.
La levée d'exception lors d'un dysfonctionnement permet de mieux
identier l'emplacement des erreursProgrammation
jlo@univ-jfc.fr
et les corriger.
et techniques scientiques 54 / 205
Les identiants Python sont sensibles aux cases ; les variables nommées
age and Age sont dierentes.
Les classes doivent être nommées selon la convention TitleCase.
commençant parla case Majuscule e.g. MyClass, Employee, Person.
Les fonctions doivent être en case minuscule. Des mots mutiples sont
séparées par des underscores , e.g. add(num),
calculate_tax(amount).
Les variables locales dans une fonction doivent être en case minuscule ;
e.g., x, num, salary.
Les module et packages doivent être en case minuscule e.g., mymodule,
tax_calculation.

Les variables constantes doivent être en case majuscule ; e.g., RATE,

TAX_RATE.
Les attributs d'une classe d'objets et nommée avec un ou deux
symboles underscore .
Deux symbôles underscore au début et à la n sont utilisée sous
Python avec un but précis, e.g. __add__, __init__, etc.

Palier la faiblesse des typage dynamique
MAUVAIS OK
a = 1 count = 1
a = 'a string' msg = 'a string'
def a(): def func():
pass # Do something pass # Do something
Python adopte une stratégies de typage dynamique où le type de la

variable n'est pas statique et peut évoluer selon le besoin.
Pour éviter des confusions, le même nom de variable ne doit pas être
utilisée pour des données qui n'ont pas les mêmes rôles ou type.


https ://docs.python-guide.org/writing/style/
The Zen of Python, by Tim Peters
Beautiful is better than ugly.

Explicit is better than implicit.
Simple is better than complex.
Complex is better than complicated.
Flat is better than nested.
Sparse is better than dense.
Readability counts.
Special cases aren't special enough to break the rules.
Although practicality beats purity.
Errors should never pass silently.
Unless explicitly silenced.
In the face of ambiguity, refuse the temptation to guess.
There should be one-- and preferably only one --obvious way to do
it.
Although that way may not be obvious
jlo@univ-jfc.fr
at first unless you're Dutch
Programmation et techniques scientiques 58 / 205
https ://docs.python-guide.org/writing/style/
The Zen of Python, by Tim Peters
...
Although never is often better than *right* now.

If the implementation is hard to explain, it's a bad idea.
If the implementation is easy to explain, it may be a good idea.
Namespaces are one honking great idea -- let's do more of those!
Recommendation de la communauté : Guide du style PEP-8 (Python

Enhanced Proposal )
modules : Pylint, Pyakes
en ligne : https ://www.pythonchecker.com/


§ Un script est un chier text !
§ Sa structuration est importante pour
garantir une lisibilité est prévenir des erreurs.
faciliter la correction des bug par soi même/autrui
faciliter l'amélioration et l'extension de fonctionnalités
§ ∃ une succession d'étapes permettant de traduire un script au
langage machine (architecture & SE dépendant).
§ Python est un langage semi-interprété nécessitant la présence de son
interpréteur dans la machine.
§ ∃ d'autres langage dont sa traduction adaptée à l'architecture
de la machine cible est eectuée en amont. Il s'agit de l'étape
compilation=⇒ aucun interpréteur est requis sur la machine.
§ Python console est une interface d'interaction avec l'interpréteur en
ligne de commande.
§ L'environnement de développement intégré (IDE) est un
environnement graphique permettant de
Créer un chier script
Interagir avec l'interpréteur
Leitmotiv et objectifs de la programmation scientique Principe de base
Généralités sur le langage Python Caractéristiques des problèmes élémentaires
Stratégies et démarche de résolutions de problème Analogie simple
Méthodologie du ux de développement en V Exemple simple
Outline


Outline

Approche modulaire
Principe de base
Caractéristiques des problèmes élémentaires
Analogie simple
Exemple simple
Approche modulaire
Découpage de problème en problèmes élémentaires
input output
GROS PROBLEME
output 1
input output 2 output

Sous- Sous- Sous- ···
problem 1 problem 2 problem 3

Facile à résoudre =⇒ outils issus de cas d'école transposé au

problème élémentaire
Entrées/paramètres et sorties bien dénies =⇒ vérication du bon
fonctionnement aisée
Peuvent être imbriqués et agencés pour

Facile à résoudre =⇒ outils issus de cas d'école transposé au

problème élémentaire
Entrées/paramètres et sorties bien dénies =⇒ vérication du bon
fonctionnement aisée
Peuvent être imbriqués et agencés pour
Analogie : Préparer une pizza

Analogie simple
input output
Préparer une pizza
Processus de développement
Préparer
la pâte
input Achats des Former Cuisson output

ingrédients la pâte au four
avec sauce
Préparer
la sauce
Exemple simple
calcul du volume d'eau dans une citerne cylindrique
input output
Déterminer le volume eau
Processus de développement
rciterne
calcul aire d'un
cercle de rayon r
Aciterne
input Prendre des me-

hciterne Calcul volume output
sures : heau , rciterne d'aire A invariante
sur hauteur h

Exemple simple
PI = 3.14159
def calculate_volume_invariant(area, h):

print area*h
if __name__ == "__main__":
rCiterne = float(input("Inserer le rayon: "))
hCiterne = float(input("Inserer la hauteur de l'eau: "))
areaCiterne = calculate_area(rCiterne)
volumeEau = calculate_volume_invariant(areaCiterne, rCiterne)

Leitmotiv et objectifs de la programmation scientique Démarche de résolution et de validation
Généralités sur le langage Python Graphe du développement en V
Stratégies et démarche de résolutions de problème Démarche en cas d'échec
Méthodologie du ux de développement en V Exemple simple implémentation
Outline


Outline

Démarche de résolution et de validation
Graphe du développement en V
Démarche en cas d'échec
Exemple simple implémentation

Processus de résolution du problème et sa validation

1 Identication des entrées et des sorties globales exigées types et
valeurs attendues
2 Découpage en problème modulaire (qu'on sait
résoudre/calculer) :
Identication des entrées et des sorties attendues de chaque
sous-problème types et valeurs attendues
Les sorties d'un sous-problème peut être exigibles en entrées d'autres
sous-problèmes.
Conception de l'architecture du code composé de sous-systèmes
permettant de résoudre le problème.
Élaboration du plan de tests
3 Implémentation de résolution de sous-problèmes
4 Vérication (par tests unitaires) du bloc de sous-problème.
Une entrée imposée ↔ sa sortie correcte obtenue
5 Intégration de blocs de résolution =⇒ système complète de
résolution
6 Validation du système complet.
Méthodologie du développement en V
1. Spécication
des exigences 9. Livraison et
exploitation
2. Conception système 8. Validation sys-
& de la validation tème usagers
3. Codage et im- 7. Vérication
plémentation des exigences
6. Tests de validation
4. Tests unitaires système complet
5. Intégration
Démarche en cas de dysfonctionnement
Que faire en cas d'échec ?

Démarche en cas de dysfonctionnement
Que faire en cas d'échec ?

1 Identier l'étape dans laquelle se situe la source du problème
2 Itérer toutes les phases en aval

Exemple simple
PI = 3.14159

print(area*h)
if __name__ == "__main__":
#test fonction volume
vol_A2_h2 = calculate_volume_invariant(2, 2)
print('volume', vol_A2_h2 == 2*2)
#test fonction aire

rtest = 2
aire_rtest = calculate_area(rtest)
print('Aire :', rtest**2 *3 <= vol_A2_h2 <= rtest**2 *4)
Exemple simple
Volume : F a l s e
A i r e : True

Exemple du processus de re-vérication

1. Spécication
exploitation
5. Intégration
Exemple simple
PI = 3.14159

return area*h
if __name__ == "__main__":
#test fonction volume
vol_A2_h2 = calculate_volume_invariant(2, 2)
print('volume', vol_A2_h2 == 2*2)
#test fonction aire

rtest = 2
aire_rtest = calculate_area(rtest)
print('Aire :', rtest**2 *3 <= vol_A2_h2 <= rtest**2 *4)
Exemple simple
Console :
Volume : True
A i r e : True
Plusieurs tests unitaires peuvent être nécessaire pour vérier un
sous-module/programme
La détection des erreurs facilitée par :
La structuration du code
L'expérience ...
Message d'erreur sur la console


1. Spécication
exploitation
5. Intégration

1. Spécication
exploitation
5. Intégration

1. Spécication
exploitation
5. Intégration
Outline


Outline


§ Résoudre un problème ≡ identier les sous-problèmes simples à

résoudre.
§ Approche de développement en V =⇒ problèmes à contraintes
critiques où la précision est de mise.
§ Méthodologie de vérication par tests unitaires :
Listes de plusieurs entrées et leurs sorties attendues pour chaque
module/procédure
sortie attendue : valeur /intervalles de valeurs / type etc.
Vérication de concordance entre sorties attendues & sorties
obtenues.

Gestion du ux d'information
Bibliothèque os
Bibliothèque numpy
Bibliothèque matplotlib
Bilan
Deuxième partie II
Utilisation des bibliothèques usuelles

pour la programmation scientique

Gestion du ux d'information Présentation simplié d'un processeur
Bibliothèque os Principe du ux de données
Bibliothèque numpy Flux de données standard
Bibliothèque matplotlib Gestion d'autres types de périphériques et de données
Bilan
Outline
6 Gestion du ux d'information

7 Bibliothèque os
8 Bibliothèque numpy
9 Bibliothèque matplotlib
10 Bilan

Bilan
Outline

Présentation simplié d'un processeur
Principe du ux de données
Flux de données standard
Gestion d'autres types de périphériques et de données
7 Bibliothèque os
10 Bilan

Bilan
Rôles simpliés d'un processeur

Un ordinateur : gère et manipule des informations
Données
Adresses
Signaux de commande/contrôle
Pré-occupations principales :
1 Où se trouve l'information/les données
=⇒ Emplacement :
interne : mémoires, registres
externe : disque-dûr (chiers), port (périphériques)
2 Comment elle est codée ?
=⇒ Structuration : type, taille, etc.
3 Comment y accéder ?
=⇒ Accès : clés, adresse, permission
4 Sa transformation/manipulation : =⇒ calculs . . .
Bilan
Flux de données
Flux de données : une séquence de données (octets) ordonnées qui peut
être lue jusqu'à la condition EOF remplie
Accès direct par des canaux
Aucun besoin de connaître les détails matériels des périphériques
(provenance et destination)
Création et gestion conée à des bibliothèques (native ou externe).
Schéma d'interactions avec les
périphériques par des ux
output
input
ABSTRACTION
input Processeur output
du concept du
device central device
ux de données

Bilan
Flux d'informations standard stdin, stdout, stderr

Gestion du ux standard
Python shell
Utilisation des
stdout
stdin
fonctions natives
keyboard Processeur monitor et/ou issues d'une
central bibliothèque
ux standard associé au processus en cours

=⇒ provenance et direction par défaut : écran & clavier
permet l'interaction entre le programme en cours avec
l'environnement

Bilan
Utilisation du ux d'informations standard stdin, stdout,

stderr
stdout stdin
print('Hello world') msg = input('Inserer un str : ')
print('voici le str : ', msg)
H e l l o world
une autre façon de le faire I n s e r e r un s t r : pythonGo
v o i c i l e s t r : pythonGo
import sys
sys.stdout.write('Hello world\n') une autre façon de le faire
import sys
H e l l o world msg = sys.stdin.read()
16 print('voici le str : ', msg)
pythonGo
^Z
v o i c i l e s t r : pythonGo
Bilan
Gestion d'autres types de périphériques et de données

Gestion du ux standard
Database graphics
col1 col2 col3...
24.5 28.2 10.6 ...
network : Python shell
...
stdout
stdin
serial port
sensors : metadata ... ...
keyboard Processeur monitor
metadata ... ...
central
bluetooth control system
ASCII les actuator
Ici est un text
...
hard drive :
...
Protocoles & formats de données bien dénies selon les

périphériques.

Bilan
Tout n'est que du text
une entrée par clavier ⇐⇒ lire caractère par caractère (séquence)

d'un chier de texte.
Clavier : un caractère saisi à chaque appui d'un bouton
Fichier : un caractère stocké dans la mémoire buer à chaque
itération
=⇒ ou plusieurs caractères selon la taille de mémoire buer
allouée.

Bilan
Lecture d'un chiers de données sans outils spécialisé
text file
# my data
7.83E-02 1.52E-01 6.00E-02 3.78E-02 1.97E-01
2.35E-02 4.55E-02 1.80E-02 1.13E-02 5.90E-02
6.04E-01 1.17E+00 4.63E-01 2.92E-01 1.52E+00
2.24E-01 4.35E-01 1.72E-01 1.08E-01 5.64E-01
5.72E-01 1.11E+00 4.38E-01 2.76E-01 1.44E+00
2.86E-02 5.54E-02 2.19E-02 1.38E-02 7.18E-02
7.20E-01 1.40E+00 5.52E-01 3.48E-01 1.81E+00
5.23E-01 1.02E+00 4.01E-01 2.53E-01 1.32E+00
2.23E-01 4.32E-01 1.71E-01 1.07E-01 5.60E-01

Bilan
Lecture d'un chiers de données sans outils spécialisé
fName = 'myZData.dat'
Syntaxes
f = open(fName, 'r') #ouvrir un Ouverture du ux :
ux open(<nomFichier>, <mode>)
a = f.read(20) 'r' (mode lecture),
print(type(a)) 'w' (mode écriture avec
print(a) suppression),
f.close() #fermer le ux f 'a' (mode écriture en n du ux)
'x' (mode création du ux)
Seulement les 20 caractères (précisé Lecture du ux read() :
en paramètre) sont lus. ( \t <nomFlux>.read() tout jusqu'à
correspond à l'espace tabulation) EOF. .Attention à la taille de
la mémoire
<c l a s s ' s t r '> <nomFlux>.readline() jusqu'à
# my data \ t7 . 8 3 E=02\ t1 la n de la ligne ('\n' ou '\r')
Fermeture obligatoire du ux
<nomFlux>.close()
Bilan
Limitation du concept du ux
fName = 'myZData.dat' Conséquence concept clé du

f = open(fName, 'r') ux :
for i in range(2): Suite de lecture au dernier
a = f.read(20) point précédent)
print(a) Ecriture possible
print('--new read--')
f.close() Soit en écrasant toutes les
données présentes du ux
(mode 'w')
# my data \ t7 . 8 3 E=02\ t1 Soit à la n du ux (mode
==new read == 'a')
.52E=01\ t6 .00E=02\ t3 . 7 Les données sont considérées
==new read == comme des chaînes de
caractères non numéraires

Bilan
Limitation du concept du ux

en opérations numériques
Tentative d'opération a2 :
print(a**2)
TypeError : unsupported operand t y p e ( s ) f o r

** or pow ( ) : ' s t r ' and ' i n t '
Aucune possibilité d'opérer directement sur les

données du chiers
=⇒ données numériques lue en tant que chaîne de
caractères

Bilan
Transformation nécessaire du type str au oat

Solution fastidieuse : 1 lecture d'une ligne complète se
f= open(fName, 'r'): terminant par EOL (\n ou \r ). → a
a = f.readline() 2 séparation de tous les éléments par le
while a != '': #not EOF token \n et \t dans une liste. →
aSplit = a.split( '\n') aSplit_bis
#list str avec separateur \t
aSplit_bis=aSplit[0].split('\t')
3 Transformer élément par élément au
#transforme en liste de oats type ottant par la fonction float()
aSplit_float = [] et les stocker dans une liste →
for el in aSplit_bis: aSplit_float
try: 4 Opérer (arithmétique ou stockage) sur
aSplit_float.append(float(el)) la liste de données d'une ligne .
except ValueError:
pass
5 Lecture d'une autre ligne et
print(aSplit_float) recommencer tant que la n du chier
# relire la ligne suivante n'est pas détecté.
a = f.readline() 6 Fermeture du ux → f.close()
f.close() jlo@univ-jfc.fr Programmation et techniques scientiques 97 / 205
Bilan
Outils sophistiqués dans un langage de haut niveau
Langage de bas niveau =⇒ codage proche du fonctionnement de la

machine (gestion d'instructions arithmétique et logique dans les
mémoires).
Langage de programmation de haut niveau =⇒ proche du langage
humain.
une instruction dans un langage évolué ≈ dizaine voire centaine
instructions en langage de bas niveau.
des outils sophistiqués (bibliothèques, fonctions natives etc)
Bibliothèques pour la programmation scientique sous Python :
os navigation dans l'arborescence des chier
NumPy manipulation des tableaux numériques
Matplotlib représentation graphique
SciPy calcul numérique poussé

Bibliothèque os Généralités sur les bibliothèques
Bibliothèque numpy Cadre d'utilisation
Bilan
Outline

7 Bibliothèque os
10 Bilan

Bilan
Outline

7 Bibliothèque os
Généralités sur les bibliothèques
Cadre d'utilisation
10 Bilan

Bilan
Objectifs d'une bibliothèque
Database libraries
output stream
graphics
input stream
col1 col2 col3...
network : 24.5 28.2 10.6 ...
Python shell
...
serial port
sensors : metadata ... ... Processeur
metadata ... ...
central
bluetooth control system
ASCII les actuator
Ici est un text
...
hard drive :
...
FACILITE
la réception et le traitement des informations contenues dans un
ux de données
l'envoi des données aux périphériques
en suivant le protocole de jlo@univ-jfc.fr
transfert et leProgrammation
format deet techniques
donnéesscientiques
imposées.101 / 205
Bilan
Exemples des bibliothèques

Pour des périphéries externes
Réception et envoi des données en externe :

Type port bibliothèque
réseau TCP & UDP socket import socket
bluetooth bluetooth import bluetooth
USB pyusb import usb.core
serial pyserial import serial
web API requests import requests

Bilan
Principe d'utilisation d'une bibliothèque

paradigme programmation impérative
import <nomBibliotheque> : importer la bibliothèque

<nomBibliotheque> et toutes les fonctions propres dans l'espace de
travail.
e.g import sys
<nomBibliotheque>.<nomFonction>() : appeler la fonction
<nomFonction> de la bibliothèque <nomBibliotheque>
en présence de sous-bibliothèque=⇒
<nomBibliotheque>.<nomSousBibliotheque>.<nomFonction>()
e.g sys.stdout.write('un text')

Bilan
Aide d'utilisation d'une bibliothèque

dir() & help()
Comment savoir les fonctions disponibles et la façon de les

utiliser ?
=⇒ fonctions natives dir() & help()

Bilan
Rappel dir() & help()
import sys help(sys.stdout.write)

for elt in dir(sys.stdout):
print (elt)
Help on b u i l t = i n f u n c t i o n
write :
_CHUNK_SIZE
__class__ w r i t e ( text , /) method of
__del__ _io . TextIOWrapper
__delattr__ instance
__dict__ Write s t r i n g to stream .
__dir__ Returns the number of
... characters written (
... which i s always
writable e qu al to
write the l e n g t h of the
writelines string ) .
Bilan
Bibliothèque os Cadre d'utilisation
Database
matplotlib
libraries
output stream
col1 col2 col3...
graphics
input stream
24.5 28.2 10.6 ...
...
Python shell
network
serial port
metadata ... ... Processeur
bluetooth
metadata ... ...
central
ethernet control system
metadata ... ... actuator
sensors
hard drive :
numpy Ici est un text
...
scipy
...
os
ASCII les
Bilan
Stockage et lecture des données

Présentation de l'arborescence du système de chiers
Stockage de données localement :
Les données transitent nécessairement par un stockage local
(temporaire ou permanent) pour
Accès direct selon hiérarchie du système de chiers du système
d'exploitation
sous Windows :
C :\\Users\Jonathan\Documents \monRepertoirePython
Jonathan Documents monProjetPython
Users
C user
Programmes
MaMusique
home
/ monProjetPython
sous Linux etc
Bilan
Chemin d'accès à un chier
Sous Python, les noms des chiers et le chemin d'accès sont

représentés au format chaîne de caractères (string). Il en est de
même pour les variable d'environnement et les arguments des
commandes.
e.g. sous Windows :
C :\\Users\Jonathan\Documents \monRepertoirePython
e.g. sous Linux :
/home/monProjetPython
Les diérents systèmes d'exploitation utilise des conventions de
noms de chemins diérentes
=⇒ nécessité d'une façon d'indiquer le chemin du chier,
indépendamment du système d'exploitation.

Bilan
Présentation de la bibliothèque os
=⇒ Bibliothèque os permet d'utiliser les fonctionnalités dépendantes du
système d'exploitation :
os.getcwd() → renvoie le chemin complet du répertoire actif (de
travail) avec la convention de nom du système d'exploitation. get
current working directory
os.path.basename(<chemin>) → renvoie le nom du répertoire de
base. (e.g. 'monProjetPython')
os.path.join(<chemin1>, <chemin2>) → renvoie joindre deux
chemin en utilisant la convention du système d'exploitation utilisé.
Cela permet d'aller dans des sous dossiers.
os.path.dirname(<chemin>) → renvoie le nom du répertoire parent.
(e.g. 'Documents' de './'Documents/monProjetPython')
os.chdir(<chemin>) → changer le repertoire de travail actif.

Bilan
Utilisation os en chemin absolu

os.getwcd() & os.path.join()
myPath_init = os.getcwd() /
myFilesubPath = 'sousDossier/text.txt'
myFilePath = os.path.join(myPath_init,
myFilesubPath) etc home
f = open(myFilePath, 'r')
msg = f.readline()
pDossier
print(myFilePath) monProjetPython
print(msg) text.txt
f.close()
script.py sousDossier
C\ Users \ Jonathan \home\ monProjetPython \
sousDossier / text . txt
j e s u i s un f i c h i e r dans l e sous d o s s i e r text.txt
sousDossier

Bilan
Utilisation os en chemin absolu

os.dirname()
parentPath = os.path.dirname(myPath_init) #
remonte
myFilesubPath = 'pDossier/text.txt' etc home
myFilePath = os.path.join(parentPath,
myFilesubPath) pDossier
f = open(myFilePath, 'r') monProjetPython
msg = f.readline()
print(myFilePath) text.txt
print(msg) script.py sousDossier
f.close()
C\ Users \ Jonathan \home\ p D o s s i e r \ t e x t . t x t text.txt

j e s u i s un f i c h i e r dans l e d o s s i e r p ar e n t
pDossier
AUCUN CHANGEMENT DU REPERTOIRE ACTIF
Bilan
Changement du repertoire actif

os.chdir('..')
os.chdir('..') #remonte et activer
myPath_actuel = os.getcwd()
etc home
print('Actuel : ', myPath_actuel )
f = open('pDossier/text.txt', 'r') pDossier
msg = f.readline() monProjetPython
print(myFilePath)
print(msg) text.txt
f.close() script.py sousDossier
Actuel : C\ Users \ Jonathan \home
j e s u i s un f i c h i e r dans l e d o s s i e r p ar e n t text.txt
pDossier
AVEC CHANGEMENT DU REPERTOIRE ACTIF
Bilan
Remonter l'arborescence en chemin relatif

../
myPath_actuel = os.getcwd() /
f = open('../pDossier/text.txt', 'r') etc home
msg = f.readline()
print(myFilePath) pDossier
print(msg) monProjetPython
f.close()
text.txt
Actuel : C:\\ Users \ Jonathan \home\ script.py sousDossier
monProjetPython
j e s u i s un f i c h i e r dans l e d o s s i e r p ar e n t
pDossier text.txt
AUCUN CHANGEMENT DU REPERTOIRE ACTIF
Bilan
Descendre l'arborescence en chemin relatif

chemin relatif direct
myPath_actuel = os.getcwd() /
f = open('sousDossier/text.txt', 'r')
msg = f.readline() etc home
print(myFilePath)
print(msg) pDossier
f.close() monProjetPython
Actuel : C:\\ Users \ Jonathan \home\ text.txt
monProjetPython script.py sousDossier
j e s u i s un f i c h i e r dans l e sous d o s s i e r
sousDossier
text.txt

Gestion du ux d'information Cadre d'utilisation
Bibliothèque os Contraintes des structures natives de tableaux numériques
Bibliothèque numpy Utilisation arithmétique de la bibliothèque NumPy
Bibliothèque matplotlib Syntaxes de base
Bilan Importation & exportation simpliée chier ↔ tableau numérique
Take home message
Outline

7 Bibliothèque os
10 Bilan

Take home message
Outline
7 Bibliothèque os
Cadre d'utilisation
Contraintes des structures natives de tableaux numériques
Utilisation arithmétique de la bibliothèque NumPy
Syntaxes de base
Importation & exportation simpliée chier ↔ tableau numérique
Take home message
10 Bilan
Take home message
Database
matplotlib
libraries
output stream
col1 col2 col3...
graphics
input stream
24.5 28.2 10.6 ...
...
Python shell
network
serial port
bluetooth
metadata ... ...
central
sensors
hard drive :
numpy 7.8 9.5 6.5 9.6
9 ..
scipy → tabulated numerics
...
os
ASCII les
Take home message
Représentation des valeurs numériques tabulées

Possibilités natives sous Python : type liste
En math, ∃ = ̸ objets associés aux Tentative de l'écriture sous Python
valeurs tabulées : avec une variable type liste :
2 liste de 3 listes à 1 élément :
 
vecteurs : e.g. A = 
5
 e.g. A = [ [2], [5], [1] ]
1 liste de 3 éléments : e.g.
B = [ 6, 3, 1 ]
vecteurs : e.g. B = 6 3 1 ,

liste de 3 listes à 3 éléments :
dim (1 × 3) e.g. : e.g.
matrices
 : e.g.  P = [
2 4 7 [2 , 4 , 7] ,
P = 5 8 1 dim. (3 × 3) [5 , 8 , 1] ,
 
1 0 0 [1 , 0 , 0]
]

Take home message
Opérations sur des valeurs numériques tabulées ⌢ T

En math, des opérations Tentative native sous Python
arithmétiques possibles : Multiplication d'une liste par un
multiplication avec un scalaire
scalaire
β ∈ R e.g. B = [6, 3, 1]
B = 6 3 1 , et β = 2 print(2*B)
=⇒ C = 2 · B =
12 6 2 [6 , 3 , 1 , 6 , 3 , 1]

addition
de deux vecteurs : Addition de deux listes
B1 = 6 3 1 , et B2 =
B_1 = [6, 3, 1]
1 4 6

B_2 = [1, 4, 6]
=⇒ print(B_1 + B_2)
C =B
1 + B2 =
7 7 7 [6 , 3 , 1 , 1 , 4 , 6]
⌢ Les opérateurs arithmétiques usuels ne fonctionnent pas sur des
listes comme sur les vecteurs/matrices.
Take home message
Opérations arithmétiques par itérations 9Ì

Méthode de bas niveau (par itérations) possible :
Multiplication avec un scalaire Addition de deux tableaux
B = [6, 3, 1] B_1 = [6, 3, 1]
beta = 2 B_2 = [1, 4, 6]
n = len(B) n = len(B)
# initialisation C par des zeros # initialisation C par des zeros
C = [] C = np.zeros(n)
for i in range(0,n): for i in range(0,n):
C.append(0) C.append(0)
for i in range(0,n): for i in range(0,n):
C[i] = B[i]*beta C[i] = B_1[i]+B_2[i]
print(C) print(C)
[12 , 6 , 1] [7 , 7 , 7]
Rappel accès en lecture et écriture d'un élément d'une liste par
indice :
A[O] accéder à l'élément indice 0 de la liste A
Take home message
Présentation de la bibliothèque numpy

Bibliothèque NumPy (numerical python) :
destinée à manipuler des matrices ou tableaux multidimensionnels
ainsi que des fonctions mathématiques opérant sur ces tableaux.
créé et manipule des objets/variables de type ndarray
(n-dimensional array) ̸= type liste.
collection de données dans un ndarray sont homogènes (éléments
de même taille et même type)
création de ndarray par plusieurs façons :
En transformant une liste par la fonction array :
e.g. B = numpy.array( [6, 3, 1])
Avec une fonction initialistrice à n × m éléments
fonction numpy.zeros()
fonction numpy.ones()
fonction numpy.full())
Avec une fonction générateur d'éléments réguliers :
fonction numpy.arange()
fonction numpy.linspace()
Take home message
Simplication des opérations arithmétique par Numpy

Multiplication ndarray par un scalaire
. . .Ó
import numpy as np
#creation de variable type
ndarray . . .û
SIMPLIFICATION
B = np.array([6, 3, 1])
lmd = 2 import numpy as np
n = np.size(B) B = np.array([6, 3, 1])
# initialisation C par des zeros C = B*2
C = np.zeros(n) print(C)
for i in range(0,n): [12 , 6 , 2]

C[i] = B[i]*lmd
print(C)
[12 , 6 , 1]

Take home message
Addition des tableaux ndarray
. . .Ó
import numpy as np
ndarray . . .û
SIMPLIFICATION
B_1 = np.array([6, 3, 1])
B_2 = np.array([1, 4, 6]) B_1 = np.array([6, 3, 1] )
n = np.size(B_1) B_2 = np.array([1, 4, 6])
# initialisation C par des zeros C = B_1 + B_2
C = np.zeros(n)
for i in range(0,n): [7 , 7 , 7]
C[i] = B_1[i]+B_2[i]
print(C)
[7 , 7 , 7]

Take home message
Produit élément-par-élément sous NumPy
. . .Ó
import numpy as np
ndarray . . .û
SIMPLIFICATION
B_1 = np.array([6, 3, 1])
# initialisation C par des zeros C = B_1 * B_2
C = np.zeros(n)
for i in range(0,n): [ 6 , 12 , 6 ]
C[i] = B_1[i]*B_2[i]
print(C)
[ 6 , 12 , 6 ]

Take home message
Produit scalaire des vecteurs sous NumPy
. . .Ó
import numpy as np
ndarray . . .û
SIMPLIFICATION
B_1 = np.array([6, 3, 1])
# initialisation C par des zeros C = np.dot(B_1 , B_2)
C = np.zeros(n)
for k in range(0,n): 24
C[k] = B_1[k]*B_2[k]
print(C)
24

Take home message
Produit matriciel sous NumPy

import numpy as np
B_1 = np.array([[6, 3, 1],
[1, 2, 3]])
B_2 = np.array([[1, 1],
[4, 2], . . .û
[6, 6]])
#nb de lignes et colonne B1 B_1 = np.array([[6, 3, 1],
SIMPLIFICATION
n1 = np.size(B_1, 0) [1, 2, 3]])
m1 = np.size(B_1, 1) B_2 = np.array([[1, 1],
n2 = np.size(B_2, 0) [4, 2],
m2 = np.size(B_2, 1) [6, 6]])
C = np.zeros((n1,m2)) #init C = np.dot(B_1 , B_2)
for i in range(0,n1):
for j in range(0,m2): [ [ 2 4 18]
for k in range(m1): [27 2 3 ] ]
C[i,j]=(B_1[i, k]*
B_2[k, j]+C[i,j])
print(C)
Take home message
Images d'une fonction sous NumPy

. . .Ó n→+∞
xi
Rappel : 1+
X
import numpy as np exp(x) =
i!
def factor(n): i=1
res=1 . . .û
for i in range(1,n+1):
import numpy as np
SIMPLIFICATION
res = res*i
c = np.exp(-3)
return res
print(c)
def myExp(x):
res = 0 0.049787068367863944
for i in range(30):
res = res+x**i/factor(i) ∃ d'autres fonctions usuelles :
return res np.sin(), np.cos(), np.tan()
, np.log10(), np.log(), np.
c = myExp(-3) power()
print(c)
opération sur des tableaux
0.049787068367863986 ndarray possible
Take home message
Syntaxes de base
Importation et génération basique
importation avec alias : import numpy as np
génération en précisant tous éléments par une liste et la fonction
array() : tabA = np.array(<liste>)
e.g. np.array([7,6,4,9]) →
array ([7. , 6. , 4. , 9.])
ou tabA = np.array(<liste de listes>)
e.g. np.array([[1, 0],[0, 1]]) →
array ([[1 , 0] ,
[0 , 1]])
Génération par création d'une copie par la fonction copy() :
A = np.array([7., 6., 4., 9.])
B = np.copy(A)
print(B)
array ([7. , 6. , 4. , 9.])

Take home message
Génération données régulières par des fonctions génératrices

initialization par des zéros d'un tableau ndarray de dimension n × 3
par la fonction zeros() : tabA = np.zeros(<tupleDimension>)
e.g. np.zeros((5,1)) →
array ( [ [ 0 . , 0. , 0. , 0. , 0 . ] ] )
=⇒ similaire avec ones(), full()
générer un vecteur de n éléments espacé régulièrement dans [a, b]
par linspace() : v = np.linspace(a,b,n)
e.g. np.linspace(0, 1, 9) →
array ([0. , 0.125 , 0.25 , 0.375 , 0.5 , 0.625 ,
0.75 , 0.875 , 1 . ])
générer un vecteur espacé régulièrement par un pas constant step
dans [a, b[ par arange() : v = np.arange(a,b,step)
e.g. np.arange(0, 2, 0.5) →
array ([0 , 0.5 , 1 , 1.5])
Take home message
Accéder aux contenus d'un tableau ndarray existant
Informations sur les dimensions du tableau tabA par size() et

shape() :
le nombre total des éléments du tableau : np.size(tabA)
Obtenir le nombre des lignes : np.size(tabA, 0)
Obtenir le nombre des colonnes : np.size(tabA, 1)
Obtenir la dimension du tableau (m × n) : np.shape(tabA)
Informations sur les contenues du tableau tabA :
Récupérer les éléments d'indice iDeb à l'indice iFin par slicing :
v_coupe = v[iDeb : iFin +1]
Créer une nouvelle copie d'un tableau existant :
tabA_copy = tabA[: ] ou
tabA_copy = np.copy(tabA)

Take home message
Autres
Créer un alias d'un tableau existant (sans créer une copie

indépendante) : tabA_alias = tabA.
.ATTENTION, la modication de l'un modie aussi l'autre !
Calculer l'image par la fonction <nomFonction> à l'ensemble des
éléments du tableau x et renvoyer un tableau de même dimension :
v = np.<nomFonction>(x)
Générer une série de données aléatoire :
numpy.random.<nomLoiProba>(<infoCaracteristiques>)
Maillage des deux vecteurs (dim. n × 1 et m × 1 ) en une matrice de
dimension n × m np.meshgrid(A)
Histogramme (compter le nombre de fois les données apparaissent
dans un/des intervalle(s)) :
hist, bord = np.histogram(<donnees>, bin = <tabIntervalles>)

Take home message
Fonctions mathématiques usuelles
Rappel d'une fonction en math :

∀x ∈ E, la fonction x 7→ y , y ∈ F
une valeur dans le domaine de dénition (antécédent)

une valeur dans le domaine d'arrivée (image)
lien d'association déni par une fonction.
lien d'association peut être nommée f , auquel cas : antécédent
y = f (x)
f peut être des associations des fonctions usuelles.

Take home message
Rappel d'une fonction en programmation (Python) :
xb0 nomFonction yb0
C'est une séquence d'instructions regroupée sous un nom

<nomFonction> dénie avec :
une variable d'argument/paramètre d'entrée (ou plusieurs)
une valeur à retourner à la n de son exécution.
Son exécution est réalisée en précisant la valeur que doit prendre
la/les variables d'argument xb0 en faisant un appel de fonction :
sortie = <nomFonction>(<valeurParametre>)
.Son utilisation doit suivre la syntaxe imposée avec les
paramètres et arguments nécessaires injectés lors de son appel.
Take home message

Les fonctions mathématiques dénies sous NumPy retourne une
approximation numérique de la valeur exacte de l'image par la
fonction en math.
Exemples :
en math NumPy description
exp() np.exp()
sin() np.sin()
cos() np.cos()
tan() np.tan()
an np.power(a, n) exposant n
ln() np.log() logarithme népérien
log10 () np.log() logarithme base 10
√
np.sqrt() racine carrée
π np.pi constante π dénie nativement
Take home message
Importation simplié d'un chier à tableau numérique
Database
matplotlib
libraries
output stream
col1 col2 col3...
graphics
input stream
24.5 28.2 10.6 ...
...
Python shell
network
serial port
bluetooth
metadata ... ...
central
sensors
hard drive :
numpy 7.8 9.5 6.5 9.6
9 ..
...
os
ASCII les
Take home message
text file
# my data
7.83E-02 1.52E-01 6.00E-02 3.78E-02 1.97E-01
2.35E-02 4.55E-02 1.80E-02 1.13E-02 5.90E-02
6.04E-01 1.17E+00 4.63E-01 2.92E-01 1.52E+00
2.24E-01 4.35E-01 1.72E-01 1.08E-01 5.64E-01
5.72E-01 1.11E+00 4.38E-01 2.76E-01 1.44E+00
2.86E-02 5.54E-02 2.19E-02 1.38E-02 7.18E-02
7.20E-01 1.40E+00 5.52E-01 3.48E-01 1.81E+00
5.23E-01 1.02E+00 4.01E-01 2.53E-01 1.32E+00
2.23E-01 4.32E-01 1.71E-01 1.07E-01 5.60E-01

Take home message

Fonction numpy.genfromtxt() Fonction numpy.loadtxt()
import os import os
import numpy import numpy
currentPath = os.getcwd() currentPath = os.getcwd()
fileName = 'data.dat' fileName = 'data.dat'
tab = np.genfromtxt(fileName, tab = np.genfromtxt(fileName,
skip_header=1, delimiter='\t skiprows=1, delimiter='\t')
') print("Ligne 1 : ", tab[1,:])
print("Ligne 1 : ", tab[1,:])
Ligne 1 : [ 0 . 0 2 3 5 0.0455
Ligne 1 : [ 0 . 0 2 3 5 0.0455 0.018 0.0113 0.059 ]
0.018 0.0113 0.059 ]
Accès à toute la j -ème colonne des données importées :
<nomTab>[:,j]
Accès à toute la i -ème ligne des données importées : <nomTab>[i,:]
=⇒ Paramètres d'organisation du chier : skip_header, delimiter
Take home message
Exportation simpliée d'un tableau numérique à un chier

ASCII
ASCII : encodage historique des Diérents extensions possibles :
caractères à 8 bits (256 caractères). .txt Text le
.dat Data le in special format
or ASCII
.csv Comma Separated Values
text le format (ASCII)
binaire ↔ caractère etc.

Take home message
Exportation simpliée d'un tableau numérique à un chier

ASCII
ASCII : encodage historique des Diérents extensions possibles :

caractères à 8 bits (256 caractères). .txt Text le
.dat Data le in special format
or ASCII
.csv Comma Separated Values
text le format (ASCII)
binaire ↔ caractère etc.
Les tableaux numériques générés temporairement sous NumPy peuvent
être stocké de manière permanent dans un disque dûr.
np.savetxt(<nomFichier>, <nomArray>, <ParametresOptionnels>...)
L'encodage par défaut lors de la sauvegarde est celui d'ASCII

(indépendamment de l'extension du chier).
Take home message
Les paramètres/arguments optionnels d'exportation

delimiter : chaîne de caractères séparant les colonnes
delimiter = '\t' : espace tabulation
fmt : formattage des nombres en ASCII
'%.#f' : exportation virgule ottant avec # chires après la virgule.
e.g. avec fmt='%.2f'
0.0000788 → 0.00 Oups ! ! !
'%#.#e' : exportation avec notation ingénieur.
e.g. avec fmt='%.3E'
0.0000788 → 7.880 × 10−5 → 7.880E − 05
Le premier # (chire) avant la virgule peut être utilisé pour indiquer
l'espace de caractères minimal à allouer.
'%.#d' : exportation entier avec # nombres de chires.
e.g. avec fmt='%.3d'
0.0000788 → 000
78.8 → 078
header : l'entête mise à la première ligne du chier (utile pour
décrire les données date, type etc.)
Take home message
Concaténation ou empilement des vecteurs numpy.column_stack()
xVect yVect Nécessité de concaténation quand :

∃ lien relationnel xi ↔ yi ∀i
x0 y0
on veut regrouper les données de même nature
x1 routine de y1
dans un même chier.
.. calculs... ..
. . Empilement colonne par colonne :
xn−1 yn−1
concaténation xyTab = np.column_stack((xVect,yVect))
Empilement ligne par ligne :

x0 y0
x1 y1 xyTab = np.row_stack((xVect, yVect))
.. Exportation du tableau avec 2 chires après la
.
xn−1 yn−1 virgule :
xyTab np.savetxt('monData.dat', xyTab,fmt ='%.2e')

Take home message
Exemple concaténation et exportation

import numpy as np
PI = np.pi
step = PI/100
xVect = np.arange(0, 4*PI,step)
yVect = np.sin( xVect)*np.exp(-0.1*xVect)
xyTab = np.column_stack((xVect, yVect))
msgEntete = 'sinus attenuee\ndonnee x \t donnee y'
np.savetxt('myData.dat',xyTab,delimiter='\t', fmt = '%.2e',
header = msgEntete)
text file Données générées au cours de

# sinus attenuee l'exécution du code stockées en
# donnee x donnee y un seul chier
0.00e+00 0.00e+00
3.14e-02 3.13e-02 Re-emploi de données facilité.
6.28e-02 6.24e-02
9.42e-02 9.32e-02
1.26e-01 1.24e-01
1.57e-01 1.54e-01
Take home message
Bilan & § Take home message
§ importation ASCII → vecteur/matrice ( genfromtxt(), loadtxt())

ndarray
§ génération vecteur ndarray :
à la main : array()
régulier : arange(), linspace(), zeros(), ones(), fill()
en calculant l'image par une fonction d'un vecteur ndarray.
(opérations arithmétiques, fonctions usuelles, etc.)
§ accès aux éléments d'un vecteur ndarray par adressage indiciel /
slicing → en écriture et en lecture
§ exportation vecteur/matrice → concaténation ( column_stack()) →
ASCII ( savetxt())
§ Informations de base du tableau ndarray : forme ( shape()), nb.
d'éléments ( size())

Take home message
. A savoir les arguments nécessaires & la syntaxe pour les

comportements souhaités.

Bibliothèque os Bases en représentation graphique des données ordonnées
Bibliothèque numpy Représentation graphique des données réparties par catégories
Bibliothèque matplotlib Représentation graphique des données 2D
Bilan Pour aller plus loin
Take home message
Outline

7 Bibliothèque os
10 Bilan

Take home message
Outline
7 Bibliothèque os
Cadre d'utilisation
Bases en représentation graphique des données ordonnées
Représentation graphique des données réparties par catégories
Représentation graphique des données 2D
Take home message
10 Bilan
Take home message
Bibliothèque matplotlib Cadre d'utilisation
Database matplotlib
libraries
output stream
col1 col2 col3...
graphics
input stream
24.5 28.2 10.6 ...
...
Python shell
network
serial port
metadata ... ... Processeur seaborn
bluetooth
metadata ... ...
central
sensors
hard drive :
numpy 7.8 9.5 6.5 9.6
9 ..
...
os
ASCII les
Take home message
Diérentes représentations graphiques
import matplotlib.pyplot as pl
Données ordonnées ; Données non-ordonnées ;

courbes : pl.plot() des nuages de points :
=⇒ décrit mieux les changement pl.scatter(<x>, <y>, marker = <
d'évolution des données ordonnées forme>, s=<taille>)
diagrammes en bâtons . : =⇒ montre la relation des données
pl.bar(<x>, <y>, width = < non ordonnées
largeurBaton>)
Données ordinales par catégories ;

diagrammes circulaire (de camembert) =⇒ montre les diérences de
proportion : pl.pie(<donnee>, labels=<legend>, autopct="%1.1f%%")
boîtes à moustaches ou à violon =⇒ montre l'étalement/la dispersion des
données : pl.boxplot(<donnees>)
Take home message
Représentation graphique des données ordonnées

yVect = y1 , y2 , y3 , y4

Chaque k -ème donnée est associée à une
coordonnée (xk , yk )
Tracer ≡ relier ces points de données.
y4
y3 Séparation de données :
(x2 , y2 ) vecteur d'abscisses/antécédents xVect
y2 vecteur d'ordonnées/images yVect
xVect & yVect :
y1 sont ordonnées selon xVect strictement
x1 x2 x3 x4 croissant/décroissant
=⇒ permet l'utilisation plot() de la
bibliothèque matplotlib.pyplot
xVect = x1 , x2 , x3 , x4

Take home message
Les étapes successives de plot()

1 Importation de la sous 3 Création d'un canvas de gure
bibliothèque pyplot avec un alias : en sauvegardant son identiant
(handle ) :
import numpy as np h = pl.figure()
2 Génération des vecteurs 4 Tracer sur le canvas actif en

d'abscisses et d'ordonnées : précisant la type de la ligne :
PI = np.pi pl.plot(xVect, yVect, '-')
step = PI/100
xVect = np.arange(0,4*PI, step) 5 Activer
yVect = np.sin(xVect) * np.exp(
-0.1*xVect) pl.show()
Si besoin, on peut sauvegarder le canvas actif :

pl.savefig(<nomFichierFigure.png>, dpi=<resolution>)
Take home message
Options pour des gures de qualité

Tracer brut obtenu : Activation des grillages de lecture :
pl.grid()
Paramètres optionnels dans plot() pour
l'apparence du tracer :
type de ligne : ls=<str>
e.g. ls='--' ou '-.' ou ':'
type de point marqueur :
marker=<str>
e.g. marker='s' ou 'o' ou '^'...
taille de marqueur : ms = <int>
Autres paramètres pour une gure e.g. ms=5
de qualité : fréquence de marqueur :
Titre de la gure : markevery=<int>
pl.title(<titre>) e.g. markevery = 10
Annotation des axes : label du tracer : label =<>
pl.xlabel(<str>), Activation des legendes des courbes :
pl.ylabel(<str>) pl.legend()
Take home message
import numpy as np
PI = np.pi
step = PI/100
xVect = np.arange(0, 4*PI, step)
yVect = np.sin(xVect)*np.exp(-0.1*xVect)
h1=pl.figure()
pl.plot(xVect, yVect, ls = '--', marker='s', ms = 5, markevery=10
, label = 'donnee')
pl.xlabel('x abscisse (unite)')
pl.ylabel('y ordonnee (unite)')
pl.title('Mon premier tracer')
pl.legend() #activation des labels des tracer
pl.grid()
pl.savefig('monpremierFIg.png', dpi = 150) #sauvegarde la gure
active
pl.show()
Take home message

Take home message
Superposition des tracers à abscisses partagés

1 Génération des données supplémentaires
yVectTendance1 = np.exp(-xVect/10)
yVectTendance2 = -np.exp(-xVect/10)
2 Activer le canvas à superposer
pl.figure(h1)
3 Tracer les données :
pl.plot(xVect,yVectTendance1, ls = '--', color = 'k', label
= 'tendance')
pl.plot(xVect,yVectTendance2, ls = '-.', color = 'k', label
= 'tendance')
4 Mise à jour des légendes :
pl.legend()

Take home message

Take home message
Données avec incertitudes
pl.errorbar(xVect, yVect, yerr = errorVect, capsize=6)

Take home message
Représentation des données paramétriques

Représentation équivalente :
(
x = g (ti )
y = f (x) ⇐⇒
y = h(ti )
=⇒ permet de révéler la dépendance des données à une autre

cause (paramètres).
C'est une autre façon de représentée des données ordonnées
e.g. équation de la trajectoire d'une projectile :
(
x = V0 cos θt
∀t ∈ [0, tlim ], g
y = − t 2 + V0 sin θt
2
est équivalent à :
g
y = −ax 2 + bx, t.q. a = , b = V0 tan θ
2 (V0 cos θ)2
Take home message
Représentation des données ordonnées à paramètres

On peut souhaiter de visualiser :
la variation de y (x)
et/ou la variation de x(t) et y (t)
Visualisation simultannée possible en créant plusieurs zones dans le
canvas de de gure subplot() :
pl.figure()
pl.subplot(<nbLignes>,<nbColonnes>,<numCase>)
Exemple avec 3 × 1 :
pl.figure()
pl.subplot(3,1, 1)
pl.plot(tVect, yVect)
pl.subplot(3,1, 2)
pl.plot(tVect, xVect)
pl.subplot(3,1, 3)
pl.plot(xVect, yVect)
pl.tight_layout()
Take home message
Pour ajuster l'espacement entre les subplot

pl.tight_layout()

Take home message
Interdépendance des données tabulées

xVect tVect yVect
x0 t0 y0
x1 t1 y1
& y = y (t)
x = x(t)
.. .. .. . génération en respectant l'in-
. . . terdépendance
xn−1 tn−1 yn−1
x0 t0 y0
x1 t1 y1 m Interdépendance entre
.. chaque élément au même indice
.
xn−1 tn−1 yn−1
m ordonnancement identique
xytTab

Take home message
tVectBis yVect
xVect tVect ∗
t0 y0
x0 t0 t1∗ y1
.. .. x = x(t) & y = y (t)
x1 t1 . .
.. .. . génération sans
. .
∗
tn−1 yn−1
.. .. respect de l'interdé-
xn−1 tn−1 . . pendance
∗
tm−1 tm−1
x0 t0 t0∗ y0
t1∗
x1
..
t1 y1
l Interdépendance entre
. les éléments rompue (partiel-
xytTab
xn−1 tn−1 ∗
tn−1 yn−1 lement) !!!
.. l Ordonnancement partielle-
. ment identique
∗
tm−1 ym−1
Take home message
Autres types de tracés Données par catégories

Take home message
Autres types de tracés Représentation 2D
xTab, yTab = np.meshgrid(xVect, yVect)

zTab = <donnee correspondant chaque maille>
pl.contourf(xTab, yTab, zTab)

Take home message
Aide sur la console : dir(<nomBibliotheque>) et

help(<nomBibliotheque>.<nomFonction>)
Memento sur matplotlib → Moodle
Aide et exemples en ligne : https ://matplotlib.org
Bibliothèque seaborn plus évoluée : https ://seaborn.pydata.org/

Take home message
§ multitudes de types de graphiques à choisir selon la pertinence des

informations à visualiser/extraire.
§ l'interdépendance des données tabulées doivent être conservée pour
leur représentation.
§ importation de la bibliothèque pyplot :
§ création et activation d'un canvas pour représenter graphiquement
des données en tableau → h = pl.figure()
§ création et activation des sous-zones pour tracer →
pl.subplot(<nLignes>, <nColonne>, <num>)
§ sauvegarde de la gure générée →
pl.savefig(<strNomFichier.png>, dpi =<int>)
achage de la fenêtre gure à la n : pl.show()

Take home message
§ identication des informations essentielles dans une gure :

arguments optionnels de la fonction plot() :
label : label = <str>
style de ligne : ls = <str>
type de marqueur : marker = <str>
fréquence de marqueur : markevery = <int>
titre, label des axes :
title(<str>), xlabel(<str>), ylabel(<str>)
annotation sur le canvas :
pl.text(<xCoor>, <yCoor>, <strComment>),
pl.annotate(<strComment>, <setXYCoordinate>, <
setTextCoordinate>,arrowprops={"arrowstyle" :"->"})

Bibliothèque os
Bibliothèque numpy
Bilan
Outline

7 Bibliothèque os
10 Bilan

Bibliothèque os
Bibliothèque numpy
Bilan
Outline

7 Bibliothèque os
10 Bilan

Bibliothèque os
Bibliothèque numpy
Bilan
Bilan
Modélisation numérique Montage expérimentale

hypothèses & modélisation : hypothèses & modélisation :
sets de variables d'états →
grandeur non observable grandeur observable ↔
souhaitée grandeur non observable
modèle d'évolution capteurs ↔ grandeur
analytique observable
stdout/numpy... ASCII les CAN + stdin + protocols

Prescriptive : 7.8 9.5 6.5 9.6
actuator hard drive : 9 ..
...
graphics
Autres info
ANALYSE : pour la com- DESCRIPTIVE
préhension ?

Notions des erreurs numériques
Dérivées & intégrales numériques
Résolution numérique des équations algébriques non linéaires
Approximation et interpolation par une fonction
Troisième partie III
Outils de base en analyse numérique

Sources des erreurs numériques
Notions des erreurs numériques Erreurs d'arrondi & troncature des nombres
Dérivées & intégrales numériques Propagation des erreurs d'arrondi et de troncature des nombres
Résolution numérique des équations algébriques non linéaires Erreurs d'approximation
Approximation et interpolation par une fonction Démarche de contrôle des erreurs numériques
Bilan mTake home message
Outline
11 Notions des erreurs numériques

12 Dérivées & intégrales numériques
13 Résolution numérique des équations algébriques non linéaires
14 Approximation et interpolation par une fonction

Outline

Erreurs d'arrondi & troncature des nombres
Propagation des erreurs d'arrondi et de troncature des nombres
Erreurs d'approximation
Démarche de contrôle des erreurs numériques


Exemple introductive :
On sait que mais :
PI = np.pi
π
sin = sin (30◦ ) = 0.5
6 print(np.sin(PI/6))
0.49999999999999994
On sait que mais :
0.1 + 0.1 + 0.1 = 0.3 testCompare = 0.1 + 0.1 + 0.1 == 0.3
print(testCompare)
False
Erreurs d'arrondi & de troncature de nombres
Erreurs d'approximation
Erreurs de propagation (approximation & arrondi)
Dénitions
TRONCATURE à m chires ARRONDI à m chires
X = ±.d1 d2 d3 . . . dm dm+1 × b e
X = ±.d1 d2 d3 . . . dm dm+1 × b e X∗ = ±.d1 d2 d3 . . . dm × b e
tronc(X ) = ±.d1 d2 d3 . . . dm × be ±.00 . . . 00vm+1 × b e
X − tronc(X ) = ±.dm+1 b e+m

avec v = b/2
Xe = tronc(X ∗ )
e.g. b = 10, m = 3, X = 1237. e.g. b = 10, m = 3, X = 1237.

=⇒ X ∗ = (0.1237 + 0.0005) × 104
=⇒ X = 0.1237 × 104 ⇐⇒ X̃ = 0.124 × 104
⇐⇒ tronc(X ) = 0.123 × 104
=⇒ Erreurs fortement liés au codage des nombres : b, m, e

Codage binaire des nombres ottants en 32 bits

norme IEEE 754
n = (−1) 1.Mt |2 × 2E −127

S d
S est le bit de signe

Mt la mantisse tronquée sur 23 bits
Ed est l'exposant décalé sur 8 bits
E.g. S = 0, Mt = 112 , Ed = 128

n = (−1)0 1.112 × 2128−127 = 1.112 × 2 = 11.12 = 21 + 21 + 2−1
s exposant décalée mantisse

0 10000000 00000000000000000000011

Principes de codage binaire en 32 bits

Quelques principes de codage :
La partie entière en valeur absolue codée en binaire naturelle : e.g.
1027|10 = 210 + 21 + 20 = 0100 0000 0011|2
La mantisse et l'exposant sont obtenus par normalisation d'écriture
où la virgule est décalée à droite du premier chire 1 en binaire :
1027|10 = 01.00 0000 0011 × 210 2
Dans ce cas, l'exposant étant E = 10, l'exposant décalé en 32 bits
est par convention Ed = E + 127.
Les chires après les virgules sont codés en exposant négatif. e.g.
0.625|1 0 = 2−1 + 2−3 0.101|2
=⇒ certains nombres à virgule simple ne peut jamais être codée sans
erreur. e.g. 0.3 → δX
X
≈ 10−7
s exposant décalée mantisse

0 01111101 00110011001100110011001
Limites du codage binaire selon norme IEEE 754
Illustration pour 32 bits :
Codage exposant min. max. précision machine

16 bits 5 bits ±6.1031 × 10−5 ±65504 εm ≈ 10−3
32 bits 8 bits ±1.1754944 × 10−38 ±3.4028235 × 1038 εm ≈ 10−7
64 bits 11 bits ±2.225 × 10−308 ±1.797 × 10308 εm ≈ 10−16
128 bits 15 bits ±3.362 × 10 −4932
±1.189 × 104932 εm ≈ 10−34

Exemples de dépassement overow & underow

Dépassement overow Dépassement underow
# Floating=point overow example # Floating=point overow example
x = 1.0e308 # A very large positive x = 1.0e-308 # A very small
number positive number
y = x * 2.0 # Doubling the large # Multiply the small number by a
number constant
print(y) y = x * 1.0e-16
print(y)
inf
0.0
.
∃ un intervalle où le nombre ottant n'est pas représentable.
valeur trop grande =⇒ overow
valeur trop petite =⇒ underow

Epsilon machine
EPSILON le plus petit nombre tel que :
MACHINE :
(EPS) 1 + EPS ̸= 1
C'est la plus petite valeur dont l'opération addition n'est pas neutre, sa
valeur dépend de bits d'exposant.
import sys import numpy as np
sys.float_info.epsilon np.finfo(np.float32).eps
2.220446049250313 e =16 1.1920929 e =07

Pour un nombre x quelconque, la valeur minimale où l'opération addition
n'est pas neutre :
εx εx
1+ ̸= x ⇐⇒ εx ≥ EPS · x ⇐⇒

x + εx ̸= x ⇐⇒ x ≥ EPS
x x
.les opérations entre deux nombres dont l'écart est plus petit que la
précision machine est assujettie à des erreurs. .
Exemple limitation due à la précision de la machine

a = 1.0e308 # Un nombre tres grand
b = 1.0e-6 # Un nombre relativement petit, mais signicatif dans la
precision du codage
res = a+b
print('a+b =' , res, '\n a =', a)
print( 'Test egalite : ", a+b == a)
a+b = 1e+308
a = 1e+308
Test e g a l i t e : True
.
Les opérations des nombres dont l'ordre de grandeurs dièrent
grandement induit des erreurs.
L'opération entre deux nombres est limitée par la précision de la
machine (bits d'exposant), et donnée par l'epsilon machine.
Propagation des erreurs d'arrondi

Quelques exemples simples où le résultat/nombre n'a pas besoin
d'une précision de 10−16 mais. . .
exacte calculée numériquement par Python
sin(30◦ ) = sin π/6 0.5 0.49999999999999994
cos(60 ) = cos π/3
◦
0.5 0.50000000000000001
tan(45 ) = tan π/4
◦
1 0.9999999999999999
4

1−3 −1 0 2.220446049250313e-16
3
√
1 − (4√− 3) 0 0
2× 2−2 0 4.440892098500626e-16
(4095.1 + 1)1 − 4095.1 1 1.0000000000004547
® Que se passe-t-il ? ®
Transformation des opérations arithmétiques simples

^ ^
X +Y =⇒ Xe + Ye X ∗Y =⇒ Xe ∗ Ye
^ ]
X −Y =⇒ Xe − Ye X /Y =⇒ Xe /Ye
Pour une suite d'opérations, il faut arrondir et tronquer à chaque

résultat intermédiaire.


^ ^
X +Y =⇒ Xe + Ye X ∗Y =⇒ Xe ∗ Ye
^ ]

Exemple (b = 10, m = 3) : X = (1/3) × 3 Erreur relative :

^ δX 0.001 × 100 = 0.001 = 0.1%
=⇒ X = 1/e3) × e3
(^ =
1 × 100
e
X
= 1g
/3 × e
^
3
= (0.333 × 10
^0 ) (0.3 × 101 ) . Perte de la précision accrue si
= (0.0999 × 101 )
^ l'exposant de chaque nombre est
0.999 × 100 diérent à cause de l'erreur de

=
décalage. E.g. (1/3) × 31

^ ^
X +Y =⇒ Xe + Ye X ∗Y =⇒ Xe ∗ Ye
^ ]

Exemple (b = 10, m = 3) : X = (1 × 3)/3 Erreur relative :
^ δX 0 = 0%
=⇒ X = 1^
(e ×e3)/e3 X
=
1 × 100
= 3/e3
g
e
= (0.300 × 101^) /(0.300 × 101 ) . Pour une suite d'opérations,
= (1.000 × 10 )
^ 0 l'ordre dans lequel sont eectuées
0.100 × 101 les opérations est très important !

=
=⇒ perte de l'associativité des
opérations.
Exemples pertes d'associativité

Pertes d'associativité des opérations
(a ∗ b) ∗ c ̸= a ∗ (b ∗ c)
a = (1 + 1e-16) -1 a = 0.1+0.2+0.3
b = 1 + (1e-16 -1) b = 0.2+0.3+0.1
print('a =', a, '\n b =', b) print('a =', a, '\n b =', b)
a = 0.0 a = 0.6000000000000001
b = 1.1102230246251565 e =16 b = 0.6
m
Due à la limite de précision du codage IEEE 754 des nombres ottants,
l'associativité des opérations n'est plus garantie. Les opérations font
gurer des arrondis et des troncatures intermédiaires qui peuvent avoir
des conséquences négatives sur les calculs.
Propagation divergente des erreurs d'arrondi

b=4095.1
a = b+1
x = 1
x = a*x - b
® Que vaut en théorie x ? ®


b=4095.1
a = b+1
x = 1
x = a*x - b
® Que vaut en théorie x ? ®

® Que vaut en théorie x si on
répète la même opération
x = a*x - b plusieurs fois ? ®


b=4095.1 Résultat sur la console :
a = b+1 iter 0 x = 1.0000000000004547
x = 1 iter 1 x = 1.0000000018631
x = a*x - b iter 2 x = 1.0000076314440776
iter 3 x = 1.0312591580864137
® Que vaut en théorie x ? ® iter 4 x = 129.04063743775941
iter 5 x = 524468.2550088064
® Que vaut en théorie x si on iter 6 x = 2148270324.241572
répète la même opération iter 7 x = 8799530071030.805
x = a*x - b plusieurs fois ? ®
. Résultat divergent au bout de
b=4095.1 quelques itérations ! ! !
a = b+1
x = 1
for i in range(8):
x = a*x - b
print('iter ', i, 'x = ', x)

Ordre de grandeur des erreurs propagatives d'arrondi

Exemple d'opération de multiplications
Soit un nombre X issu de n multiplications
X = x · x · x · . . . · x = xn
Calcul variationnel du premier ordre :
xn dX dx
dX = n · x n−1 dx = n · dx ⇐⇒ n = n ·
x x x
Estimation d'erreurs au premier ordre (grossière) :
dX dx
∆r X = =n· avec dx/x : erreur relative de l'arrondi
X x
Exemple
Exemple avec une représentation simple des ottants avec εm = 10−7 . Avec 100
millions de multiplications par seconde pendant 24 heures, l'estimation grossière de
l'erreur d'arrondi sur le résultat vaut :
dX
= 108 × 24 × 3600 × 10−7 = 8.6 × 105 IMPORTANT ! !
X
Ordre de grandeur des erreurs propagatives

Exemple d'opération de multiplications
Opération erreur estimée
dX dx
multiplications X = xn =n· ≈ n · εm
successives X x
1 dX dx
divisions succes- X = = −n · − ≈ n · εm
xn
sives X x
dX dx
additions succes- X =n·x = ≈ εm
sives X x

Démarche de limitation des erreurs d'arrondi
Quelques règles pour limiter les erreurs d'arrondi :

Utiliser un système d'unités tel que les valeurs utilisées soient de
l'ordre de l'unité.
.ATTENTION aux opérations sur des petits nombres. Exemple
pour θ ≈ 10−14 , il vaut mieux transformer le système d'équation et
θ
eectuer l'ensemble des calcus numériques sur θn = −14 .
10
Éviter de soustraire des nombres comparables.
Minimiser les soustractions.
Chercher le plus possible à sommer par paquet les quantités de
même ordre de grandeur.
Toujours contrôler et surveiller les erreurs. (cf. section Démarche
de contrôle des erreurs)

Généralités d'un schéma numérique
paramètres Procédure xbn : résultat obtenu

de calculs de calculs
Méthodes numériques reposant sur des schémas approximatifs

. Méthodes itératives (en général) .
=⇒ Erreurs indépendantes de la précision machine (en plus).
Provenance des erreurs d'approximation
Modèle physique simplié
Equations analytiques tronquées

Erreurs d'approximation d'un modèle simplié/tronqué
Un problème bien posé mais avec des

hypothèses idéalisées.
Exemple du modélè pendulaire en l'absence de L
friction visqueux : θ
d 2θ dθ
+mg sin θ = 0
mL + fv L

dt 2 dt m
| {z }
fv : frottement≈0
Solution si frottement visqueux est négligé :
θ(t) ≈ α sin (ω (t − t0 ))

dθ
g
où α = α ω, et ω = g sin θ
dt t=0 L
m Certains calculs sont pourvue d'erreur par construction car on ne peut

tenir compte de tous les paramètres d'un phénomène physique. m
Erreurs d'approximation par troncature de développement

analytique
Exemple d'un développement Taylor :
h h2 h3 hn (n)
f (x + h) = f (x) + f ′ (x) + f ” (x) + f (3) (x) + . . . + f (x) + o (hn )
1! 2! 3! n!
Estimation de la dérivée par taux d'accroissement
f (x + h) − f (x) h h2 (3) hn−1 (n)
= f ′ (x) + f ” (x) + f (x) + o hn−1

f (x) + . . . +
h 2| ! 3! {z
n!
}
o(h)
.
Estimation d'une dérivée par taux d'accroissement est pourvue d'une
erreur d'approximation due à la troncature du développement :
df (x) f (x + h) − f (x)
≈ avec une erreur de surestimation de o (h)
dx h
Exemples de calculs par approximations analytiques
calcul analytique approximation

100
x2 x 100
+∞ N=
xk xk
=1+x + = 1 + x + ... +
X X
exp(x) ...
k=0
k! 2! k=0
k! 100!
10
π2
+∞
1 1 1 N=
1 1 1 1
= 1 + + ... =1+
X X
+ + . . . + 10
6 k2 2 4 k2 2 4 2
k=1 k=0
 >0
x0
1 2

√

√

2 2

xn+1 = xn + x10 ≈
2 √ un
lim xn = 2




n→∞

Ordre de convergence d'un schéma numérique
paramètres Procédure xbk : résultat intermédiare

de calculs de calculs obtenu
. Méthodes itératives .
Lors d'une procédure de calculs successifs/itératifs, on génère une suite

numérique :
xb1 , xb2 , xb3 , . . . , xbk , . . . , xd
n−1 , xbn tel que lim xbn = xsol
n→+∞
où xsol est la solution exacte.

L'erreur de l'itéré k :
errk = xbk − xsol
Ordre de convergence d'un schéma numérique

On dit que la méthode est de
convergence d'ordre p si l'erreur
varie comme 1/k p . Càd selon
l'inverse en puissance p du nombre
d'itération k .
Plus rigoureusement l'ordre de
convergence p est dénie par :
 p=1 linéaire

|errk+1 |

∃α ∈ R∗+ ∖ {+∞} lim
k→+∞ |errk |
p =α avec p=2 quadratique
p=3 cubique


mAu nombre d'itérations k identique, l'erreur est plus petit avec un

ordre p plus élevé m
mOrdre de convergence élevée =⇒ vitesse de convergence élevée m
Bilan des erreurs
Soit la procédure de calculs itératifs appelée F suivant un schéma

numérique (algorithme) donné) :
. ∃ accumulation des erreurs d'arrondi (antécédent et image), ainsi que

des erreurs de propagation . =⇒ Il est toujours nécessaire de contrôler
et surveiller les erreurs à n d'évaluer la pertinence du résultat obtenu.

Dénition des erreurs et diérences d'incrément

Procédure valeur attendue : X
paramètres de calculs
de calculs valeur obtenue : X∗
Erreur absolue Erreur relative

∗
∆X = |X − X |
X − X∗
∆r X = × 100(%)
X
Lorsque la valeur exacte attendue X est inconnue, mais son calcul fait
intervenir une succession des valeurs intermédiaire (suite) X0 , X1 , X2 , . . .,
Xk , Xk+1 , . . ., Xn−1 , Xn → Xsol :
Diérence d'incrément à Diérence relative d'incrément à
n→+∞
l'itération k + 1 l'itération k + 1
dik+1 = Xk+1 − Xk Xk+1 − Xk
di(rk+) 1 =
Xk
Critère de convergence et tolérance résiduelle
Si on suppose que la série des valeurs intermédiaire converge vers le

résultat théorique X0 , X1 , X2 , . . ., Xk , Xk+1 , . . ., Xn−1 , Xn 7→n→+∞ X ,
on peut dénir une tolérance résiduelle tol<1 qui permet d'indiquer le
critère d'arrêt :
Xk+1 − Xk
< tol
Xk
A ne pas confondre avec l'erreur absolue err à l'itération k qui ne peut

être déterminée de manière exacte :
errk = Xk − X
m La tolérance résiduelle est toutefois un indicateur des erreurs
numériques engendrée. m

Calcul d'une grandeur conservative

En math, soit la fonction f dénie par :
∀x ∈ E, la fonction f : x 7→ y , y ∈ F
Si xc est une grandeur conservative :
f (xc ) = yc = xc =⇒ f (xc ) − xc = 0
Application à l'estimation des erreurs numériques :
xbc
Procédure xc∗
de calculs c
Evaluation de la précision des calculs par :

∗
c − xbc
∆xc = xc
m Toute variation des valeurs numériques de cette grandeur permet

d'estimer la précision de la méthode. m
Evaluation de l'inuence de la discrétisation

Pour les méthodes qui reposent sur une discrétisation de l'espace et/ou
du temps, on peut voir l'inuence d'une diminution du pas.
paramètre de : h1 Procédure xb1

discrétisation de calculs
∆(h) x = |xb1 − xb2 |
paramètre de : h2 Procédure xb2
discrétisation de calculs
Si les solutions sont proches, on peut penser que la méthode est able ;
l'écart entre les deux solutions donne alors un ordre de grandeur de
l'erreur produite. À l'inverse, si une diminution du pas donne une solution
radicalement diérente de la précédente il est hautement probable que
l'on se trouve dans une région d'instabilité .

§ Aucun calcul numérique n'est exact.
§ Vérication des erreurs en l'absence de la vraie valeur par évaluation
de :
diérence relative dik vs. tolérance résiduelle critère d'arrêt/de
(r )
convergence
calcul d'une grandeur conservative
évaluation de la sensibilité à la discrétisation (ou autres paramètres
de calculs).
Les erreurs
sont liés à la convention de codage des nombres arrondi
sont liés à la méthode de calculs approximation
se propage et peuvent s'amplier
Il existe des démarches pour éviter les erreurs :
regroupement de calcul des nombres du même ordre de grandeur
Éviter les opérations dont les opérandes sont des ordres de grandeurs
diérentes pour les opérations multiplication, addition et division.
Eviter les opérations dont les opérandes sont de même ordre de
grandeur pour la soustraction.
Outline


Outline

Dérivées numériques
Intégrations numériques

Outline


Outline


Outline


Outline


Programmation Scientifique Python Partie I Et II

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Programmation Scientifique Python Partie I Et II

Transféré par

Droits d'auteur :

Formats disponibles

Programmation et techniques scientiques

 exploitation du langage et des modules Python 

jlo@univ-jfc.fr Programmation et techniques scientiques 1 / 205

Ö Partie I : Généralités de la démarche en programmation scientique

Ö Partie II : Utilisation des bibliothèques usuelles pour la programmation

Ö Partie III : Outils de base en analyse numérique

jlo@univ-jfc.fr Programmation et techniques scientiques 2 / 205

jlo@univ-jfc.fr Programmation et techniques scientiques 3 / 205

1 Leitmotiv et objectifs de la programmation scientique

jlo@univ-jfc.fr Programmation et techniques scientiques 4 / 205

1 Leitmotiv et objectifs de la programmation scientique

jlo@univ-jfc.fr Programmation et techniques scientiques 5 / 205

Leitmotiv et objectifs de la programmation scientique

Pourquoi devons nous nous intéresser à la programmation scientique ?

jlo@univ-jfc.fr Programmation et techniques scientiques 6 / 205

Besoins en analyse de données

Besoins supplémentaires en modélisation numérique

Un modèle = un set de lois/équations décrivant au plus près la

jlo@univ-jfc.fr Programmation et techniques scientiques 8 / 205

Programmation applicative vs. programmation scientique

Programmation applicative vs. programmation scientique

jlo@univ-jfc.fr Programmation et techniques scientiques 10 / 205

Connaissances et compétences exigibles S3

Utilisation des modules NumPy, Matplotlib et scipy

jlo@univ-jfc.fr Programmation et techniques scientiques 11 / 205

Connaissances et compétences exigibles S3

Connaissances et compétences exigibles S3

Démarche à priori des résultats attendus (types, ordre de grandeurs,

jlo@univ-jfc.fr Programmation et techniques scientiques 13 / 205

jlo@univ-jfc.fr Programmation et techniques scientiques 14 / 205

Letitmotiv et objectifs de la programmation scientique

jlo@univ-jfc.fr Programmation et techniques scientiques 16 / 205

1 Leitmotiv et objectifs de la programmation scientique

jlo@univ-jfc.fr Programmation et techniques scientiques 17 / 205

1 Leitmotiv et objectifs de la programmation scientique

1 Leitmotiv et objectifs de la programmation scientique

Fonctionnement général de Python

Rôle =⇒ sur-couche permettant l'interaction avec le coeur d'interpréteur.

Deux sur-couches (shells ) répandues

jlo@univ-jfc.fr Programmation et techniques scientiques 20 / 205

Fonctions natives importantes :

jlo@univ-jfc.fr Programmation et techniques scientiques 21 / 205

Fonctionnement interactif du Python shell

Principe de fonctionnement simplié (Read, Evaluate, Print, Loop) :

jlo@univ-jfc.fr Programmation et techniques scientiques 23 / 205

Tâches annexes du shell

jlo@univ-jfc.fr Programmation et techniques scientiques 24 / 205

Présentation d'un script

Scripts vs commande en ligne

Script commandes en ligne

jlo@univ-jfc.fr Programmation et techniques scientiques 27 / 205

Environnement de développement intégré - IDE

IDE (Integrated Development Environment ) ore un ux continu

jlo@univ-jfc.fr Programmation et techniques scientiques 28 / 205

jlo@univ-jfc.fr Programmation et techniques scientiques 29 / 205

jlo@univ-jfc.fr Programmation et techniques scientiques 30 / 205

Sur la console active :

jlo@univ-jfc.fr Programmation et techniques scientiques 31 / 205

Illustration du langage machine

Illustration du langage machine

Comment faire fonctionner l'ampoule avec une  ambiance disco  ?

jlo@univ-jfc.fr Programmation et techniques scientiques 34 / 205

Illustration du langage machine

Programmation et techniques scientiques

exploitation du langage et des modules Python

jlo@univ-jfc.fr Programmation et techniques scientiques 1 / 205

Ö Partie I : Généralités de la démarche en programmation scientique

jlo@univ-jfc.fr Programmation et techniques scientiques 2 / 205

jlo@univ-jfc.fr Programmation et techniques scientiques 3 / 205

1 Leitmotiv et objectifs de la programmation scientique

jlo@univ-jfc.fr Programmation et techniques scientiques 4 / 205

1 Leitmotiv et objectifs de la programmation scientique

jlo@univ-jfc.fr Programmation et techniques scientiques 5 / 205

Leitmotiv et objectifs de la programmation scientique

Pourquoi devons nous nous intéresser à la programmation scientique ?

jlo@univ-jfc.fr Programmation et techniques scientiques 6 / 205

jlo@univ-jfc.fr Programmation et techniques scientiques 8 / 205

Programmation applicative vs. programmation scientique

Programmation applicative vs. programmation scientique

jlo@univ-jfc.fr Programmation et techniques scientiques 10 / 205

jlo@univ-jfc.fr Programmation et techniques scientiques 11 / 205

jlo@univ-jfc.fr Programmation et techniques scientiques 13 / 205

jlo@univ-jfc.fr Programmation et techniques scientiques 14 / 205

Letitmotiv et objectifs de la programmation scientique

jlo@univ-jfc.fr Programmation et techniques scientiques 16 / 205

1 Leitmotiv et objectifs de la programmation scientique

jlo@univ-jfc.fr Programmation et techniques scientiques 17 / 205

1 Leitmotiv et objectifs de la programmation scientique

1 Leitmotiv et objectifs de la programmation scientique

jlo@univ-jfc.fr Programmation et techniques scientiques 20 / 205

jlo@univ-jfc.fr Programmation et techniques scientiques 21 / 205

Principe de fonctionnement simplié (Read, Evaluate, Print, Loop) :

jlo@univ-jfc.fr Programmation et techniques scientiques 23 / 205

jlo@univ-jfc.fr Programmation et techniques scientiques 24 / 205

jlo@univ-jfc.fr Programmation et techniques scientiques 27 / 205

IDE (Integrated Development Environment ) ore un ux continu

jlo@univ-jfc.fr Programmation et techniques scientiques 28 / 205

jlo@univ-jfc.fr Programmation et techniques scientiques 29 / 205

jlo@univ-jfc.fr Programmation et techniques scientiques 30 / 205

jlo@univ-jfc.fr Programmation et techniques scientiques 31 / 205

Comment faire fonctionner l'ampoule avec une ambiance disco ?

jlo@univ-jfc.fr Programmation et techniques scientiques 34 / 205

Comment faire fonctionner l'ampoule avec une ambiance disco ?

jlo@univ-jfc.fr Programmation et techniques scientiques 34 / 205

A VOUS : Modier les instructions (en code machine) en commençant

jlo@univ-jfc.fr Programmation et techniques scientiques 36 / 205

jlo@univ-jfc.fr Programmation et techniques scientiques 37 / 205

jlo@univ-jfc.fr Programmation et techniques scientiques 38 / 205

jlo@univ-jfc.fr Programmation et techniques scientiques 39 / 205

jlo@univ-jfc.fr Programmation et techniques scientiques 39 / 205

jlo@univ-jfc.fr Programmation et techniques scientiques 39 / 205

jlo@univ-jfc.fr Programmation et techniques scientiques 44 / 205

3 Dénitions des fonctions/procédures

jlo@univ-jfc.fr Programmation et techniques scientiques 45 / 205

jlo@univ-jfc.fr Programmation et techniques scientiques 46 / 205

jlo@univ-jfc.fr Programmation et techniques scientiques 47 / 205

Implicite mauvaise Explicite OK

jlo@univ-jfc.fr Programmation et techniques scientiques 49 / 205

jlo@univ-jfc.fr Programmation et techniques scientiques 50 / 205

jlo@univ-jfc.fr Programmation et techniques scientiques 52 / 205

delta = b**2 - 4ac

return x1, x2 # Le point de sortie nale si tout va bien

Dicile d'identier le point de sortie eectif.

jlo@univ-jfc.fr Programmation et techniques scientiques 53 / 205

delta = b**2 - 4ac

jlo@univ-jfc.fr Programmation et techniques scientiques 55 / 205

jlo@univ-jfc.fr Programmation et techniques scientiques 56 / 205

jlo@univ-jfc.fr Programmation et techniques scientiques 57 / 205

Although never is often better than right now.

jlo@univ-jfc.fr Programmation et techniques scientiques 59 / 205

1 Leitmotiv et objectifs de la programmation scientique