Institut d’innovation et de conception en

aérospatial de Polytechnique

KOJTYCH Python 3 :
calcul scientifique
et manipulation de données

Solène Kojtych

Hiver 2020
Installation Éléments de syntaxe Calcul scientifique Gestion de données Conclusion

Pourquoi s’intéresser à Python ?

I Mon expérience :

2012 Matlab lors de mon diplôme d’ingénieur en France :

coûteux pour avoir une version personnelle
2014 nécessité d’apprendre Python pour un stage car le

KOJTYCH
logiciel de CAO et maillage Salomé possédait une
interface Python
2016 maîtrise puis doctorat à Polytechnique : Python est le
langage pour le calcul scientifique au laboratoire

Et vous, pourquoi venir à l’atelier ?

1 / 71
Installation Éléments de syntaxe Calcul scientifique Gestion de données Conclusion

Retours d’expérience

Qu’est-ce qui vous a amené à utiliser Python ?

I « portabilité des codes, pas de problèmes de licence »
I « c’est gratuit contrairement à Matlab »
I « exigence de l’entreprise »

disponibles »
KOJTYCH
I « communauté active sur internet et ressources facilement

I « dans ma carrière j’ai dû plusieurs fois traduire des codes Matlab

en Python pour faire le lien entre des labos et des entreprises »
I « permet de gérer des matrices de grande taille correspondant
aux modèles industriels »
I « intérêt pour le machine learning »
I « plus durable et flexible que Matlab »

2 / 71
Installation Éléments de syntaxe Calcul scientifique Gestion de données Conclusion

Caractéristiques du langage Python 3

I de plus en plus populaire : le plus utilisé pour 41% des
utilisateurs du site Stack Overflow selon leur sondage 1
• autant de communautés offrant du support
I polyvalent : les modules forment une vraie boîte à outils pour
faire des graphiques, du calcul scientifique, de l’analyse de
données, de l’optimisation, etc...

KOJTYCH
I facile à prendre en main de par sa syntaxe simple
I hybride : orienté objet mais utilisable facilement en procédural,
gestion de la mémoire automatique
I gratuit et open-source : le code de chaque fonction peut être
consulté (et compris !)
I interprété : ne nécessite pas de compilation pour être exécuté
I utilisations principales : langage de script (automatisation),
calcul scientifique, prototypage d’applications
1. https ://insights.stackoverflow.com/survey/2019
3 / 71
Installation Éléments de syntaxe Calcul scientifique Gestion de données Conclusion

Un bref aperçu...

KOJTYCH
graphique
analyse de données

interface graphique (source :

calcul scientifique Y.Colaïtis) 4 / 71
Installation Éléments de syntaxe Calcul scientifique Gestion de données Conclusion

But de l’atelier aujourd’hui

Prendre en main Python 3 et faire un tour d’horizon des
possibilités du langage

I mots-clés, modules courants, bonnes pratiques et ressources,

plutôt que des détails techniques sur quelques aspects
I matériel disponible sur git

KOJTYCH
• présentation avec matériel supplémentaire en annexe
• codes python enrichis pour le notebook jupyter
I structure
• petits blocs relatifs à une problématique
• atelier interactif : vous pourrez compléter/exécuter les codes en
même temps que moi

N’hésitez pas à interrompre et poser des questions ! ?

5 / 71
Installation Éléments de syntaxe Calcul scientifique Gestion de données Conclusion

1 Installation

2 Éléments de syntaxe

KOJTYCH
3 Python pour le calcul scientifique

4 Gestion de données en python

5 Conclusion

6 / 71
Installation Éléments de syntaxe Calcul scientifique Gestion de données Conclusion

Sommaire

1 Installation

2 Éléments de syntaxe

KOJTYCH
3 Python pour le calcul scientifique

4 Gestion de données en python

5 Conclusion

7 / 71
Installation Éléments de syntaxe Calcul scientifique Gestion de données Conclusion

Où trouver de l’aide ? 1

I documentation officielle de python (LA référence)

https://www.python.org/doc/

I forum d’entraide

KOJTYCH
« Si je me pose une question, il est "extrêmement"
(doux euphémisme) probable qu’un autre être humain
se la soit déjà posée, donc je visite sagement
https://stackoverflow.com/ »
• je peux même oser poser une nouvelle question !
I révision (ou découverte) des concepts algorithmiques
http://www.france-ioi.org/

1. des ressources supplémentaires se trouvent en annexe !

7 / 71
Installation Éléments de syntaxe Calcul scientifique Gestion de données Conclusion

Installation de Python - interpréteur

1 télécharger et installer la dernière version de Python 3 à partir
du site officiel de la fondation Python
• disponible pour Linux, Windows, Mac... (souvent installée par
défaut)
2 lancer l’interpréteur de commandes
• Linux : commande python3.X dans un terminal
• Windows : Démarrer>Tous les programmes>Python 3.x>Python

3
KOJTYCH
(Command Line) (ou taper python dans le terminal Anaconda)
• Mac : Applications>Python>IDLE
tester l’interpréteur : entrer 5+13 puis entrée

interpréteur python sous linux

8 / 71
Installation Éléments de syntaxe Calcul scientifique Gestion de données Conclusion

Installation de Python - IDE

I interpréteur (indispensable) : ne fait qu’interpréter les
commandes...
• utile pour débuter et jouer avec python,
• pas adapté pour sauvegarder les codes
I environnement de développement (indispensable) (IDE ) :
indispensable pour l’écriture efficace de scripts .py
• interpréteur interactif IPython, outils pour la syntaxe...

KOJTYCH
• Spyder : interface semblable à Matlab, PyCharm : plus adapté aux
gros projets de développements, gère les versions, etc...

9 / 71
Installation Éléments de syntaxe Calcul scientifique Gestion de données Conclusion

Installation de Python - notebook

I notebook (facultatif) : interface de programmation interactive
combinant code exécutable, visualisation et langage textuel
• utile pour l’apprentissage, tutoriels, présentation de résultats avec
les codes associés
• Jupyter : application web pour Python à la base, évolution du
projet IPython, utilisable en ligne ou en local
• ce qu’on va utiliser aujourd’hui !

KOJTYCH

notebook Jupyter
10 / 71
Installation Éléments de syntaxe Calcul scientifique Gestion de données Conclusion

Installation simplifiée de Python chez soi

I distribution Anaconda 1 pour python : installation de toutes

les briques de base en une seule fois ! Contient entre autres :
• interpréteur et langage python
• IDE Spyder
• notebook Jupyter
•
KOJTYCH
les modules de base de python
I installation recommandée pour les débutants !
I précision : Python fonctionne avec des modules, certains sont
installés par défaut, les autres doivent être installés

Tout cet atelier est basé sur Python 3 qui n’est pas
vraiment rétro-compatible avec Python 2

1. https://www.anaconda.com/distribution/
11 / 71
Installation Éléments de syntaxe Calcul scientifique Gestion de données Conclusion

Fonctionnement pour l’atelier

1 télécharger le matériel sur git
https://gitlab.meca.polymtl.ca/iicap/ateliers/python
2 décompresser le matériel dans VOTRE session (lecteur Y)
3 lancer le notebook
• dans le terminal Anaconda, faire glisser le fichier
lancement_jupyter.bat

4
KOJTYCH
• ouvrir code > notebook_jupyter > notebook_atelier.ipynb
• Fichier > Faire une copie (backup !)
utiliser le notebook
• exécution du code en cliquant sur la section (bord bleu) puis Run
• double-clic pour modifier une section (bord vert)
• si vous éditez par mégarde une cellule de texte en Markdown :
shift + enter pour quitter l’édition
• Aide > Raccourcis clavier
• sauvegarder régulièrement : Fichier > Créer une nouvelle
sauvegarde
• complétion automatique avec la touche : tab
12 / 71
Installation Éléments de syntaxe Calcul scientifique Gestion de données Conclusion

Sommaire

1 Installation

2 Éléments de syntaxe

KOJTYCH
3 Python pour le calcul scientifique

4 Gestion de données en python

5 Conclusion

13 / 71
Installation Éléments de syntaxe Calcul scientifique Gestion de données Conclusion

Exemple d’introduction - à compléter

# -*- coding: utf-8 -*-

### Mon premier script !
# Les commentaires sont précédés d’un #
# Import du module math en début de script

KOJTYCH
# Déclaration de variables x et y entiers positifs

# Déclaration d’une variable pour la somme de x et y

# Affichage de la somme

# Affichage de la somme

# Calcul de la racine de x si x >0

13 / 71
Installation Éléments de syntaxe Calcul scientifique Gestion de données Conclusion

Exemple d’introduction - solution

# -*- coding: utf-8 -*-

### Mon premier script !
# Les commentaires sont précédés d’un #
# Import du module math en début de script
import math as mt # matériel spécialisé pour opérations mathématiques
# Déclaration de variables x et y entiers positifs
x = 5
y = 7
KOJTYCH
# Déclaration d’une variable pour la somme de x et y
somme = x+y
# Affichage de la somme
print(somme) # print permet d’afficher àl’écran
help(print) # IMPORTANT : commande d’aide
# Calcul de la racine de x si x >0
if (x < 0):
print("La racine carrée n’est pas définie pour x")
else:
racine = mt.sqrt(x) # utilisation de la fonction racine du module math
print("La racine de x est {}".format(racine))
# l’indentation est obligatoire pour la syntaxe en python 3
14 / 71
Installation Éléments de syntaxe Calcul scientifique Gestion de données Conclusion

Déclaration de variables

I langage typé mais sans déclaration préalable du type

I les variables peuvent changer de type après création

# Les noms de variables sont sensibles àla casse

x = 9
X = 13

KOJTYCH
print("x = {}, X = {}".format(x, X))

# Le type des variables n’a pas àêtre déclaré avant

entier = 9
reel = 3.5
caractere = ’s’
chaine = "hello world"
booleen = True # True ou False

# Affichage d’une variable

chaine # valide dans l’interpreteur
print(chaine) # instruction print pour que ça apparaisse dans l’exécution

I utiliser print(objet) pour afficher

15 / 71
Installation Éléments de syntaxe Calcul scientifique Gestion de données Conclusion

Opérations de base

# Opérations mathématiques usuelles

1 + 2
4 - 6
9 * 7 # Multiplication
5 / 2 # Division
2**3
9//4
9 % 4
# Exposant

KOJTYCH
# Division entiere
# Modulo
# Conversions de type
type_variable = type(chaine) # renvoie le type de la variable
chaine = "9.6"
nombre = float(chaine) # de chaine vers reel/entier
# nombre = int(entier)
chaine = str(entier) # de reel/entier vers chaine

16 / 71
Installation Éléments de syntaxe Calcul scientifique Gestion de données Conclusion

Tableaux

I en Python les tableaux sont des listes

I l’indexage commence à 0

KOJTYCH
# listes et indices (commence à0)
liste = [5, 6, 8, ’a’] # peuvent contenir des éléments de types différents
print(liste[0], liste[3]) # renvoie le premier et dernier élément
liste[-1] = 2
l’avant-dernier...)
# remplace le dernier élément (-2 serait

print(liste[0:2]) # renvoie les 2 premiers éléments

# 0:2 = 0,1 (indice de fin non inclus)

# manipulation des chaînes de caractères comme les listes

chaine = "hello world"
print(chaine[0:5])

17 / 71
Installation Éléments de syntaxe Calcul scientifique Gestion de données Conclusion

Variables booléennes et tests logiques

x = 12
# tests logiques
condition1 = (x > 10) # condition est un booléen valant True ici
not(condition1) # négation d’une condition, équivaut àx<=10
x <= 10 # inégalité large
x == 10
x != 10
# conditions
condition2 =
condition1 &
KOJTYCH
# égalité
# non égalité
de plusieurs propositions
(x < 15)
condition2 # (x>10) ET (x<15), se note aussi "and"
condition1 | condition2 # (x>10) OU (x<15), se note aussi "or"

# utilisation d’une condition dans une structure conditionelle

if(condition1):
print("x supérieur à10")
else:
print("x inférieur ou égal à10")

18 / 71
Installation Éléments de syntaxe Calcul scientifique Gestion de données Conclusion

Structures conditionnelles

x = 5
# Condition
if(x > 7):
print("x > 7")
elif(x < 7):
print("x < 7")
else:
print("x = 7")

# Boucle "pour" KOJTYCH

for i in range(10): # range commence par défaut à0 : range(10) = range(0,10)
print(i)
print() # saut de ligne
liste = ["ananas", "pomme", "fraise", "orange"]
for element in liste: # on peut boucler sur différents objets
print(element)

# Boucle "tant que"

x = 0
while(x < 2):
print(x)
x += 0.7 # x = x + 0.7

19 / 71
Installation Éléments de syntaxe Calcul scientifique Gestion de données Conclusion

Fonctions

# création de fonction
def f(u): # def est le mot réservé pour déclarer des fonctions
’’’cette fonction renvoie 5+ max(u,0).
(ceci est un commentaire sur plusieurs lignes) !’’’

KOJTYCH
v = 5 + max(u, 0)
return v

# appel de la fonction
x = -5
y = f(x)
# return est le mot réservé pour renvoyer le résultat

print(y)

I les variables créées dans une fonction ont une portée locale

20 / 71
Installation Éléments de syntaxe Calcul scientifique Gestion de données Conclusion

Spécificités sur les variables locales et globales

I attention à l’espace local ou global de définition des variables

def f():
# A partir d’ici on se trouve dans l’espace local de la fonction
a = 10
f()
# print(a)
a = 15
def g():
a = 10
KOJTYCH
# appel de la fonction f
# cette ligne renvoie une erreur car a est définie localement
# variable a au niveau principal

# création d’une variable a locale dans la fonction

print(a) # priorité àla variable locale de même niveau
#print(locals()) # donne la liste des variables locales
g()
print(a) # ici la variable a de la fonction n’est pas visible, on considère
la variable de même niveau

21 / 71
Installation Éléments de syntaxe Calcul scientifique Gestion de données Conclusion

Spécificités sur les variables locales et globales

I modification de variables globales dans une fonction

a = 25 # variable de plus haut niveau (globale)
print(a)

def f():

KOJTYCH
# je veux modifier la variable globale "a"
global a # j’indique que "a" se réfère au niveau global
a = 20
print(a)
# print(locals()) # on n’a pas de variable globale
# print(globals()) # on a bien a variable globale

f()
print(a)

22 / 71
Installation Éléments de syntaxe Calcul scientifique Gestion de données Conclusion

Dictionnaires

# Dictionnaires = couples clé - valeur sans ordonnancement,clés uniques

dictionnaire_fruits = {} # initialisation d’un dictionnaire vide
dictionnaire_fruits = {’ananas’: 3, ’tomates’: 2, ’oranges’: 6}

KOJTYCH
# ou directement avec des couples clés - valeurs

dictionnaire_fruits[’poires’] = 5 # ajout d’un clé

dictionnaire_fruits[’poires’] = 0 # modification d’une valeur
del dictionnaire_fruits[’oranges’] # suppression d’une clé
# del permet aussi de supprimer des variables
dictionnaire_fruits

23 / 71
Installation Éléments de syntaxe Calcul scientifique Gestion de données Conclusion

Ensembles

# Ensembles : les éléments sont uniques dans le set, sans ordonnancement

ensemble_A = {1, 3, 5, 5} # le 5 n’apparaîtra qu’une fois
ensemble_B = {2, 6, 7, 5}
{2, 1, 15} == {15, 1, 2} # l’ordonnancement n’importe pas

KOJTYCH
ensemble_C = set("Monty Python’s Flying Circus") # lettres uniques
for element in ensemble_A:
print(element) # on peut boucler aussi bien sur les ensembles

# Opérateurs ensemblistes
ensemble_A.union(ensemble_B) # A union B
ensemble_A.intersection(ensemble_B) # A inter B
ensemble_A.difference(ensemble_B) # A sans B

24 / 71
Installation Éléments de syntaxe Calcul scientifique Gestion de données Conclusion

Python comme langage orienté objet

# la plupart des types sont en fait des objets

liste = [] # une liste en un objet
liste.append(2) # possible d’appeler des méthodes spécifiques aux listes
print(liste)
dir(liste)
liste.clear() KOJTYCH
# append permet d’ajouter un élément en fin de liste
# dir donne la liste des méthodes accessibles pour un objet

# modules = espaces dans lesquels sont rangés des objets

import math as mt
constante_pi = mt.pi
dir(mt) # dir liste les noms qu’un module définit

25 / 71
Installation Éléments de syntaxe Calcul scientifique Gestion de données Conclusion

Utilisation des modules

# Options d’importation
import math # importe tous les objets comme math.objet
print(math.pi)
import math as mt # en général on utilise un alias

print(pi) KOJTYCH
from math import pi # importe l’objet dans l’espace de nom courant
# plus besoin de l’antécédent math
# peut interférer avec des fonctions du même nom déjà définies
from math import * # tous les noms de fonctions importés , assez lourd

# Lister les objets d’un module

# dir(mt) # retourne tous les attributs d’un objet, ici de mt

26 / 71
Installation Éléments de syntaxe Calcul scientifique Gestion de données Conclusion

Règles générales de syntaxe et d’écriture

I indentation à 4 espaces = élément syntaxique obligatoire !

I sensibilité à la casse → adopter une convention de nommage

des variables

KOJTYCH
I le code est « plus fait pour être lu que pour être écrit »
→ recommandations PEP8 1
• principes : import des modules en début de script, espace autour
des opérandes, maximum 79 caractères par lignes...
• un bon IDE permet de prendre en compte le PEP8 efficacement !

I commenter !

1. https://www.python.org/dev/peps/pep-0008/
27 / 71
Installation Éléments de syntaxe Calcul scientifique Gestion de données Conclusion

Récapitulatif de la partie I

I langage orienté objet

I concepts
• variables, types

KOJTYCH
• conditions (if) et boucles (for, while)
• structure de données : tableaux(listes), dictionnaires, ensembles
I à retenir
• commande help(objet)
• module math pour les opérations mathématiques

28 / 71
Installation Éléments de syntaxe Calcul scientifique Gestion de données Conclusion

Sommaire

1 Installation

2 Éléments de syntaxe

KOJTYCH
3 Python pour le calcul scientifique

4 Gestion de données en python

5 Conclusion

29 / 71
Installation Éléments de syntaxe Calcul scientifique Gestion de données Conclusion

Exemple d’introduction - à compléter

# Import des modules

import numpy as np # matrices et vecteurs
import matplotlib.pyplot as plt # graphiques
import math as mt

# Déclaration d’un vecteur temps

KOJTYCH
# Déclaration d’un vecteur sin(2pi*temps)

# Représentation graphique

# Dérivation numérique de la sinusoide

# Affichage de la dérivée

29 / 71
Installation Éléments de syntaxe Calcul scientifique Gestion de données Conclusion

Exemple d’introduction - solution

# Import des modules

import numpy as np # matrices et vecteurs
import matplotlib.pyplot as plt # graphiques
import math as mt

# Déclaration d’un vecteur temps

temps = np.linspace(0, 5, 100) # 100 valeurs de 0 à5 secondes

KOJTYCH
# Déclaration d’un vecteur sin(2pi*temps)
sinusoide = np.sin(2*mt.pi*temps)
# Représentation graphique
plt.figure()
plt.plot(temps, sinusoide)

# Dérivation numérique de la sinusoide

derivee = np.gradient(sinusoide, temps)
# Affichage de la dérivée
plt.plot(temps, derivee)
plt.show()

30 / 71
Installation Éléments de syntaxe Calcul scientifique Gestion de données Conclusion

Écriture des mathématiques

import cmath # module pour les opérations sur des nombres complexes
import math as mt # module pour opérations mathématiques
# Nombres complexes (type complex)
# en coordonnées cartésiennes
z1 = 4+3j # j est la notation du nombre imaginaire
z2 = complex(4, 3) # z1=z2

KOJTYCH
print(" {} a pour partie reelle {} et pour partie imaginaire {}".format
(z1, z1.real, z1.imag))
# une commande peut aller sous plusieurs lignes ainsi si a (), {} ou []
print(z2.real)
# en coordonnées polaires
module, phase = cmath.polar(z1) # phase en radian
# Fonctions du module math => dir(mt)
racine = mt.sqrt(2) # racine(2)
mt.factorial(5) # 5!
mt.cos(mt.pi/2) # cos(pi/2)

# NB : fonctions trigonometriques en radians

31 / 71
Installation Éléments de syntaxe Calcul scientifique Gestion de données Conclusion

Vecteurs et matrices - 1

I le module numpy propose des tableaux spécifiques pour le calcul

matriciel
I création de vecteurs

c
a
b
KOJTYCH
import numpy as np # module de calcul matriciel et vectorisation

# Création de vecteurs
= np.zeros([2])
= np.array([2,3,4])
= np.ones([3])
# vecteur nul de 2 termes
# vecteur de 1 à3 termes
d = np.arange(1,10,1.5) # vecteur de 1 à10 par pas de 2.5
e = np.linspace(1,10,25) # vecteur de 25 valeurs réparties de 1 à10
# Indexage commence à0 (identique aux listes)
print("Le premier élément de {} est {}".format(a,a[0]))

32 / 71
Installation Éléments de syntaxe Calcul scientifique Gestion de données Conclusion

Vecteurs et matrices - 2
I création de matrices
# Création de matrices
g = np.ones([2, 3]) # matrice 2 par 3
k = np.diag(a) # matrice avec vecteur a sur la diagonale
f = np.array([[2, 3, 4],
[7, 1, 6]]) # matrice 2 lignes par 3 colonnes
h = np.array([[[111, 112], # matrice de dimension 3
[121, 122]], # h a trois indices : i,j,k

KOJTYCH
[[211, 212],
[221, 222]]])
# ASTUCE DE LECTURE :
# les colonnes correspondent àla variation du dernier indice,
# les lignes correspondent àla variation de l’avant-dernier indice,
# les blancs séparent les autres indices
Id = np.eye(3) # matrice identité de taille 4x4
l = np.zeros((3, 4, 5))
# Indexage de matrices
f[0, 2] # élément indice i=0,j=2
f[0] # première ligne, peut s’écrire f[0,:]
# conseil : plus lisible de faire apparaitre les deux indices pour matrices
f[:, 1] # deuxième colonne
h[0, 0, 1] # élément aux indice i=0,j=0,k=1
h[1, 0, 1] # quel élément est renvoyé ici ?
f[0:2, 1] # sous matrice : ligne 0 à2 non incluse, colonne 1
33 / 71
Installation Éléments de syntaxe Calcul scientifique Gestion de données Conclusion

Vecteurs et matrices - 3

I opérations sur des vecteurs de même taille

# Manipulation de vecteurs
nb_elements = f.size # nombre d’éléments

KOJTYCH
taille = a.shape # vecteur sont des colonnes par défaut
taille = f.shape # taille dans chaque dimension
# Opération sur vecteurs de même taille
a - b # addition terme àterme
a * b # multiplication terme àterme
a/b # division terme àterme
a**b # puissance terme àterme...
np.dot(a, b) # produit scalaire
np.cross(a, b) # produit vectoriel

34 / 71
Installation Éléments de syntaxe Calcul scientifique Gestion de données Conclusion

Vecteurs et matrices - 4

I opérations sur des matrices de même taille

# Manipulations de matrices
determinant = np.linalg.det(k) # déterminant
f_transpose = f.transpose() # transposée
f_trace = f.trace() # trace
valeurs_propres, vec_propres = np.linalg.eig(k) # valeurs et vecteurs propres

f + g
f*g
f/g
f**g
KOJTYCH
# Opérations sur matrices de même taille
# addition terme àterme
# multiplication terme àterme
# division terme àterme
# puissance terme àterme
np.dot(g, a) # produit matriciel de g par a (vecteur)
np.dot(f, g.transpose()) # produit matriciel de f par g transposée

I python gère aussi astucieusement les opérations sur des

vecteurs et matrices de tailles différentes avec le broadcasting
(voir en annexe)

35 / 71
Installation Éléments de syntaxe Calcul scientifique Gestion de données Conclusion

Vecteurs et matrices - vectorisation

I privilégier les opérations sur les vecteurs plutôt que les boucles
pour diminuer les temps de calcul
# Fonctions dédiées pour vecteurs
np.cos(a) # applique cos àchaque terme du vecteur a

KOJTYCH
valeur_min = np.min(a)
indice_min = np.argmin(a)
# valeur min le long d’un axe (0 par défaut)

max_par_colonnes = np.max(f, axis=0) # on regarde max le long de l’axe 0

max_par_lignes = np.max(f, axis=1)
# Conditions et masques
M = np.array([[4, 1, 8],
[5, 2, 1]])
a > 1 # vecteur de booléen avec condition vérifiée terme àterme
condition = (M < 5) # condition terme àterme
f[condition] = 1 # masque booléen

36 / 71
Installation Éléments de syntaxe Calcul scientifique Gestion de données Conclusion

Résolution de systèmes linéaires

I on évite d’inverser des matrices pour résoudre des systèmes

linéaires ! ! !
# %% Résolution du système linéaire
# 8x0 + 2x1 +5x2 = 9
# 7x0 + 3x1 + x2 = 5
# 4x0 + 9x1 + 6x2 = 3

import numpy as np KOJTYCH

import scipy.linalg # scipy est le module pour le calcul scientifique

# Ecriture sous la forme Mx = b, x inconnu

M = np.array([[8, 2, 5],
[7, 3, 1],
[4, 9, 6]])
b = np.array([9, 5, 3])

# La BONNE façon => non on n’inversera pas la matrice M c’est MAL

x = np.linalg.solve(M, b) # on préfère résoudre Mx = b (/ en matlab)
print(x)
np.allclose(np.dot(M, x), b) # compare Mx et b àune tolérance près

37 / 71
Installation Éléments de syntaxe Calcul scientifique Gestion de données Conclusion

Inversion de matrice (si nécessaire !)

I s’il est nécessaire tout de même d’inverser une matrice...

# calcul de l’inverse
inverse_M = np.linalg.inv(M)

KOJTYCH
np.allclose(np.dot(M, inverse_M), Id) # on compare le produit matriciel de M
# et son inverse àla matrice identité
# stockage éventuel de la factorisation de M pour réutilisation avec diff b
# M = P L U (P : permutation, L :triangulaire inf, U : triangulaire sup)
matrice_LU, indices_pivot = scipy.linalg.lu_factor(M)
b = np.array([1, 2, 3])
x = scipy.linalg.lu_solve((matrice_LU, indices_pivot), b)
np.allclose(np.dot(M, x), b)

38 / 71
Installation Éléments de syntaxe Calcul scientifique Gestion de données Conclusion

Graphiques - 1
I graphique 2D
import matplotlib.pyplot as plt # module graphique
import math as mt
import numpy as np
# Données
t = np.arange(0, 3, 0.001) # vecteur temps
f0 = 2 # frequence Hz

KOJTYCH
signal1 = np.cos(2*mt.pi*f0*t) # sinusoide de frequence f0
signal2 = 2*np.cos(2*mt.pi*0.5*f0*t+0.5*mt.pi)
# Courbes
plt.figure()
plt.plot(t, signal1, label="$\cos(2\pi*{}*t)$".format(f0))
plt.plot(t, signal2, ’r--’, label="$\cos(\pi*{}*t +0.25\pi)$".format(f0))
# la legende peut être écrite en latex
# Mise en forme
plt.legend() # ajoute la légende
plt.xlabel("temps (s)")
plt.ylabel("signal normalisé")
plt.title("Sublime graphe avec pyplot")
plt.show() # affiche le graphe

plt.savefig(’ma_sublime_figure.png’) # sauvegarde
#plt.close() # pour fermer toutes les figures : plt.close(’all’)
39 / 71
Installation Éléments de syntaxe Calcul scientifique Gestion de données Conclusion

Graphiques - 2
I sortie obtenue

KOJTYCH

un graphique 2D avec le module matplotlib 40 / 71

Installation Éléments de syntaxe Calcul scientifique Gestion de données Conclusion

Graphiques - 3
I sous-graphiques
# Sous graphes : chacun a son système d’axes
fig = plt.figure()
ax1 = fig.add_subplot(121) # 1 ligne - 2 colonnes - axe du graphe 1
ax1.plot(t, signal1, label="$\cos({} x)$".format(f0))
ax2 = fig.add_subplot(122) # 1 ligne - 2 colonnes - axe du graphe 1
signal3 = np.exp(2*t)
ax2.plot(t, signal3, color=’r’, linestyle=’--’, label="$\cos({} x)$"

KOJTYCH
.format(f0))
ax2.set_yscale(’log’) # echelle logarithmique
plt.show()

I sortie obtenue

deux sous-graphiques 41 / 71
Installation Éléments de syntaxe Calcul scientifique Gestion de données Conclusion

Graphiques - 4

I exemple d’un autre type de graphe : histogramme

# Données
groupes = [’G1’, ’G2’, ’G3’, ’G4’, ’G5’]
nb_hommes = [20, 34, 30, 35, 27]
nb_femmes = [25, 32, 34, 20, 25]

# Figure
KOJTYCH
pos_groupes = np.arange(1, 6) # positions des différents groupes sur axe des x
largeur_barres = 0.35

fig, axes = plt.subplots()

# largeur des barres

# subplot pour accéder àl’objet axes

p1 = plt.bar(pos_groupes, nb_hommes, largeur_barres) # barres bleues
p2 = plt.bar(pos_groupes, nb_femmes, largeur_barres, bottom=nb_hommes,
color=’orange’)
plt.xticks(pos_groupes, groupes) # gradation x
axes.set_xlim([0, 6]) # limites sur l’axe des abscisses
plt.legend((p1[0], p2[0]), (’Hommes’, ’Femmes’))
plt.show()

42 / 71
Installation Éléments de syntaxe Calcul scientifique Gestion de données Conclusion

Graphiques - 5
I sortie

KOJTYCH

histogramme
43 / 71
Installation Éléments de syntaxe Calcul scientifique Gestion de données Conclusion

Graphiques - 6
I graphique 3D
from mpl_toolkits.mplot3d import axes3d # module pour graphes 3D
from matplotlib import cm # color map
# Données
x = np.linspace(-3, 3, 100)
y = np.linspace(-3, 3, 100)
X, Y = np.meshgrid(x, y) # maillage en fonction de x y

KOJTYCH
Z = np.sin(X)*np.sin(Y) # fonction analytique
# Représentation 3D
figure3D = plt.figure()
ax = figure3D.add_subplot(111, projection=’3d’)
# Filaire
ax.plot_wireframe(X, Y, Z, rstride=10, cstride=10, color=’#F68712’)
# ou Surface
# ax.plot_surface(X, Y, Z, rstride=5, cstride=8, alpha=0.3, cmap=cm.viridis,
# linewidth=0, antialiased=False)
# help(ax.plot_surface) pour les arguments
# Courbes de niveau
ax.set_xlim(-4, 4)
ax.set_zlim(-1.5, 1)
#contourZ = ax.contourf(X, Y, Z, zdir=’z’, offset=-1.5, cmap=cm.viridis)
#contourX = ax.contourf(X, Y, Z, zdir=’x’, offset=-4, cmap=cm.viridis)
plt.show()
44 / 71
Installation Éléments de syntaxe Calcul scientifique Gestion de données Conclusion

Graphiques - 7

I sorties

KOJTYCH
avec la fonction plot_wireframe avec les fonctions plot_surface et
contourf

45 / 71
Installation Éléments de syntaxe Calcul scientifique Gestion de données Conclusion

Graphiques - 8

I animation
import matplotlib.animation as animation
# Fonction de rotation par rapport àun angle
def rotate(angle):
ax.view_init(azim=angle, elev=15)

KOJTYCH
# Création de l’animation
rot_animation = animation.FuncAnimation(figure3D, rotate,
frames=np.arange(0, 362, 5),
interval=200)
#interval : vitesse du gif, frames : discrétisation des rotations
# Sauvegarde
rot_animation.save(’rotation.mpg’, dpi=80, writer=’imagemagick’)
# quelques extensions possibles: mp4, mpg, gif
# Affichage dans le notebook jupyter (prend un certain temps)
from IPython.display import HTML
HTML(rot_animation.to_html5_video())

46 / 71
Installation Éléments de syntaxe Calcul scientifique Gestion de données Conclusion

Outils d’interpolation et lissage - 1

I interpolation polynomiale
from scipy.interpolate import interp1d
import numpy as np
import matplotlib.pyplot as plt
# Points de données

KOJTYCH
temps = np.linspace(0, 45, num=10, endpoint=True) # en secondes
vitesse = np.array([55, 60, 58, 54, 55, 60, 54, 57, 52, 49]) # en km/h
vitesse = vitesse * (1000/3600) # conversion en m/s
# Interpolation
f1 = interp1d(temps, vitesse) # c’est une fonction
f2 = interp1d(temps, vitesse, kind=’quadratic’) # ’cubic’ possible
temps2 = np.arange(0, 45, 0.5) # vecteur temps plus discrétisé
plt.plot(temps, vitesse, ’ro’, label=’donnees’)
plt.plot(temps2, f1(temps2), ’b’, label=’interp. lineaire’)
plt.plot(temps2, f2(temps2), ’g’, label=’interp. quadra’)
# r: rouge, o : décorateur de courbe points
plt.legend()
plt.show()

47 / 71
Installation Éléments de syntaxe Calcul scientifique Gestion de données Conclusion

Outils d’interpolation et lissage - 2

I sortie

KOJTYCH

interpolations linéaires et quadratiques

48 / 71
Installation Éléments de syntaxe Calcul scientifique Gestion de données Conclusion

Outils d’interpolation et lissage - 3

I régression linéaire
import scipy.stats
# Données
plt.figure()
plt.plot(temps, vitesse, ’ro’, label=’donnees’)
# Régression
KOJTYCH
pente, ordonnee_origine = np.polyfit(temps, vitesse, 1)
# 1= degré du fit polynomial
plt.plot(temps2, pente*temps2+ordonnee_origine, ’m’,
label=’regression linéaire’)
plt.legend()
plt.show()
# Indicateurs statistiques de la régression
pente, ordonnée_origine, coeff_R, p_value, ecart_type =
scipy.stats.linregress(
temps, vitesse)

49 / 71
Installation Éléments de syntaxe Calcul scientifique Gestion de données Conclusion

Intégration et dérivation numériques

I intégration
from scipy.integrate import simps
import numpy as np

# Exemple: calculer l’aire sous la courbe de la fonction f2

vitesse_lissee = f2(temps2) # conversion en m/sec
integrale_trapeze = np.trapz(vitesse_lissee, temps2) # attention ordre !
integrale_simpson = simps(vitesse_lissee, temps2)

KOJTYCH
print(" La distance parcourue est environ {:.2f} m".format(integrale_simpson))

I dérivation
from scipy.misc import derivative
import matplotlib.pyplot as plt
# Exemple : estimer l’accélération
# En un instant
derivative(f2, 2.0, dx=1e-6)
# dérivée de f2 au temps t=2.0sec par différences finies centrées de pas dx
# Dérivée du vecteur complet
pas = temps2[1] # pas de temps entre deux valeurs de vitesse_lissee
acceleration = np.gradient(vitesse_lissee, pas)
plt.plot(temps2, acceleration)
plt.show()
50 / 71
Installation Éléments de syntaxe Calcul scientifique Gestion de données Conclusion

Résolution d’équations différentielles - 1

I ordre 1
from scipy.integrate import odeint
import numpy as np
import matplotlib.pyplot as plt
# Équation d’ordre 1 : y’= a*y
a = -1 # constante a
temps = np.linspace(0, 10, 1000) # vecteur de pas de temps pour integration

return a*y
y0 = 5
KOJTYCH
# Définition de l’équation comme une fonction renvoyant y’
def equation(y, temps):

# condition initiale
solution_y = odeint(equation, y0, temps) # calcul de la solution
plt.figure()
plt.plot(temps, solution_y)
plt.show()

I sortie
51 / 71
Installation Éléments de syntaxe Calcul scientifique Gestion de données Conclusion

Résolution d’équations différentielles - 2

I équation d’ordre supérieur : pendule
# theta’’(t) + b*theta’(t) + c*sin(theta(t)) = 0, theta est la position
angulaire
# Paramètres fixés
b = 0.25
c = 5

# Mise sous forme de systeme de l’équation avec y = [y0,y1] = [theta, theta’]

KOJTYCH
def pendule(y, t, b, c): # la fonction doit renvoyer y’
theta, omega = y # y0=theta, y1=theta’=omega
dydt = [omega, # y0’ = omega
-b*omega - c*np.sin(theta)] # y1’ = theta’’=-b*theta’(t) +
c*sin(theta(t))
return dydt
# Calcul de la solution
y0 = [np.pi - 0.1, 0.0] # conditions initiales déplacement, vitesse
solution_y = odeint(pendule, y0, temps, args=(b, c)) # contient depl, vitesse
plt.figure()
plt.plot(temps, solution_y[:, 0], label=’theta (rad)’) # affichage déplacement
plt.xlabel("temps (s)")
plt.ylabel("déplacement (s) ")
plt.legend()
plt.show()

52 / 71
Installation Éléments de syntaxe Calcul scientifique Gestion de données Conclusion

Résolution d’équations différentielles - 2

I sortie

KOJTYCH

déplacement angulaire du pendule

53 / 71
Installation Éléments de syntaxe Calcul scientifique Gestion de données Conclusion

Récapitulatif de la partie II

I outils
• calcul matriciel
• graphiques, outils d’interpolation et de lissage
• résolution de systèmes d’équations linéaires
• intégration et différentiation numériques
•
KOJTYCH
résolution d’équations différentielles

I modules à retenir
• numpy : matrices et vecteurs
• scipy : calcul scientifique
• matplotlib.pyplot : graphiques

54 / 71
Installation Éléments de syntaxe Calcul scientifique Gestion de données Conclusion

Sommaire

1 Installation

2 Éléments de syntaxe

KOJTYCH
3 Python pour le calcul scientifique

4 Gestion de données en python

5 Conclusion

55 / 71
Installation Éléments de syntaxe Calcul scientifique Gestion de données Conclusion

Exemple d’introduction - à compléter

# Import des modules

import os # commandes du système d’exploitation
import pandas as pd # module d’analyse de données

# Affichage du répertoire courant

KOJTYCH
# Création d’un fichier .csv

# Ajout du texte dans le fichier .csv

# Fermeture du fichier

# Import de ce fichier avec panda

# Analyse de données

55 / 71
Installation Éléments de syntaxe Calcul scientifique Gestion de données Conclusion

Exemple d’introduction - solution

# Import des modules

import os # commandes du système d’exploitation
import pandas as pd # module d’analyse de données
# Affichage du répertoire courant
print(os.getcwd())

# Création d’un fichier .csv

KOJTYCH
fichier = open(’temp.csv’, ’w’) # ouverture en écriture "w"

# Ajout du texte dans le fichier .csv

fichier.write("Temps,Amplitude\n")
fichier.write("0,10\n")
fichier.write("1,15\n")
# Fermeture du fichier
fichier.close()

# Import de ce fichier avec panda

donnees = pd.read_csv("temp.csv", sep=’,’)
# Analyse de données
donnees.describe()

56 / 71
Installation Éléments de syntaxe Calcul scientifique Gestion de données Conclusion

Sorties et entrées à l’écran

I sortie avec print
import math as mt
# Sortie avec print : gestion des formats
print("une tabulation \t, un caractère échappé \" et un saut de ligne \n")
print(" $\pi$ {1} et $\pi/2$ {0} ".format(mt.pi/2, mt.pi)) # ordre des
variables
print(" Arrondi à3 décimales : {:.3f}".format(mt.pi), end=’!!\n’)
print(" Notation scientifique à2 décimales : {:.2e}".format(mt.pi))

KOJTYCH
# %[flags][width][.precision]type
# type : f = flottant, e = notation scientifique

I entrée avec input

entree_utilisateur = input("Rentrez une phrase : \n >> ")
# input convertit en chaine de aractères
print(entree_utilisateur)
print("Rentrez un entier : \n ")
# Controle de la forme de l’entree
condition = True
while condition:
try: # on tente de convertir en entier
entree_utilisateur = int(input(">> "))
condition = False
except ValueError: # génère une erreur si conversion impossible
print("Ce n’est pas un entier, réessayez.") 57 / 71
Installation Éléments de syntaxe Calcul scientifique Gestion de données Conclusion

Manipulation de dossiers et fichiers - 1

I création de dossier

import os # commandes du systèmes d’exploitation

import sys # informations sur l’interpréteur python
import shutil # suppression violente de dossiers
# dossier courant
KOJTYCH
chemin_courant = os.getcwd() # chemin courant
print(chemin_courant)
os.listdir() # liste tous les éléments du dossier
sys.argv[0] # nom du script exécuté (hors interpreteur interactif)

# création d’un nouveau dossier

nom_dossier = "alain"
if not os.path.exists(nom_dossier):
os.mkdir(nom_dossier)

58 / 71
Installation Éléments de syntaxe Calcul scientifique Gestion de données Conclusion

Manipulation de dossiers et fichiers - 2

I manipulation et suppression de dossier

# placement dans le nouveau dossier
chemin_nouveau_dossier = os.path.join(chemin_courant, nom_dossier)
# concatenation des chemins

KOJTYCH
os.chdir(chemin_nouveau_dossier) # changement de dossier

# ajout d’un fichier dans le nouveau dossier

open(’resultats_intermediaires.txt’, ’w’).close() # ouverture en écriture "w"
os.chdir(chemin_courant)

# suppression d’un dossier avec gestion d’erreur

try:
shutil.rmtree(nom_dossier) # Attention : supprime dossier et son contenu !
except OSError: # dans le cas où le dossier n’existe pas
pass # instruction pour "ne rien faire"

59 / 71
Installation Éléments de syntaxe Calcul scientifique Gestion de données Conclusion

Manipulation de dossiers et fichiers - 3

I création et lecture de fichier

import re # module pour remplacement d’expressions

nom_fichier = "simpson.txt"
# Création d’un fichier
fichier = open(nom_fichier, "w") # ouverture en ecriture (’w’)
for i in range(3):

fichier.closed KOJTYCH
fichier.write("C’est la ligne %d\r\n" % (i+1)) # ecriture dans le fichier
fichier.close() # fermeture du fichier
# vérification
# NB : instruction with recommandée pour éviter de laisser des fichiers
# ouverts en cas d’erreurs

# Lecture
with open(nom_fichier) as fichier: # ouverture en lecture par défaut (’r’)
contenu_fichier = fichier.readlines() # stockage de toutes les lignes
# parcout toutes les lignes et s’arrete àla fin
fichier.seek(0) # retourne au début du fichier
for ligne in fichier:
print(ligne) # affichage des lignes une àune

60 / 71
Installation Éléments de syntaxe Calcul scientifique Gestion de données Conclusion

Manipulation de dossiers et fichiers - 4

I modification et suppression de fichier

# Ajout en fin de fichier
with open(nom_fichier, "a") as fichier: # mode "append" avec ’a’
fichier.write(’J\’aime les Simpson.’)

KOJTYCH
# Modification : remplacement d’une chaîne de caractères
with open(nom_fichier, "r") as fichier: # lecture du contenu
contenu_fichier = fichier.readlines()
with open(nom_fichier, "w") as fichier: # réécriture avec modification
for ligne in contenu_fichier:
fichier.write(re.sub(r’Simpson’, ’blagues’, ligne))
# Suppression de fichier
if os.path.exists(nom_fichier): # vérifie existence
os.remove(nom_fichier)

61 / 71
Installation Éléments de syntaxe Calcul scientifique Gestion de données Conclusion

Gestion de données numériques - 1

I import à partit d’un fichier .csv par exemple

import pandas as pd # Module pour le traitement de données de grande taille

KOJTYCH
# Import d’un fichier csv : poids et IMC d’étudiants
donnees = pd.read_csv("fichier_test.csv", sep=’,’, skipinitialspace=True) #
dataframe
# enleve les espaces inutiles
donnees # Affichage global
donnees.head() # Affichage partiel // donnees.tail()
list(donnees) # en-tetes des colonnes
donnees[["Sex", "BMI (Sep)", "BMI (Apr)"]] # certaines colonnes
donnees.iloc[:, 0:2] # toutes les lignes, colonnes 0 et 1

62 / 71
Installation Éléments de syntaxe Calcul scientifique Gestion de données Conclusion

Gestion de données numériques - 2

I analyse et sauvegarde
# Analyse des données
#donnees.hist() # histogramme
print(donnees.describe()) # indicateurs statistiques (pour colonnes
numériques)

categorie
KOJTYCH
donnees["Sex"] = donnees["Sex"].astype(’category’) # déclaration variable

print(donnees.describe(include=[’category’]))
# IMC par catégorie
donnees.groupby(’Sex’)[’BMI (Sep)’].mean().to_frame() # moyenne
donnees.groupby(’Sex’)[’BMI (Sep)’].hist() # répartition

# Sauvegarde d’un data frame

donnees.to_csv("etudiants.csv") # csv
donnees.to_latex("etudiants.tex") # en latex directement !

63 / 71
Installation Éléments de syntaxe Calcul scientifique Gestion de données Conclusion

Lancement de programmes externes

I utile pour faire des campagnes de simulation, des tests répétés...

import os # module avec commandes relatives au système d’exploitation

# Commande du système d’exploitation

resultat_commande = os.popen("ls").read() # recupere resultat de la commande
print(resultat_commande)

KOJTYCH
# NB : commande "dir" sur windows
# Programmes externes
# statut = os.system("jupyter notebook &") # lance un programme externe
# statut stocke les erreurs potentielles, 0 = pas d’erreur
# caractere & pour exécuter en arriere plan

# Lancement d’un autre script python (utile pour gérer les simulations)
with open("hello.py", "w") as fichier:
fichier.write(’print("hello world")’)

os.system("python hello.py") # sans retour de sortie

resultat_commande = os.popen("python hello.py").read() # avec retour sortie
print(resultat_commande)

64 / 71
Installation Éléments de syntaxe Calcul scientifique Gestion de données Conclusion

Gestion de données numériques - 1

I à partit d’un fichier .csv par exemple

import pandas as pd # Module pour le traitement de données de grande taille

KOJTYCH
# Import d’un fichier csv : poids et IMC d’étudiants
donnees = pd.read_csv("fichier_test.csv", sep=’,’, skipinitialspace=True) #
dataframe
# enleve les espaces inutiles
donnees # Affichage global
donnees.head() # Affichage partiel // donnees.tail()
list(donnees) # en-tetes des colonnes
donnees[["Sex", "BMI (Sep)", "BMI (Apr)"]] # certaines colonnes
donnees.iloc[:, 0:2] # toutes les lignes, colonnes 0 et 1

65 / 71
Installation Éléments de syntaxe Calcul scientifique Gestion de données Conclusion

Récapitulatif de la partie III

I outils
• entrées et sorties à l’écran
• manipulation de dossiers et fichiers
• analyse de données numériques
•
KOJTYCH
lancement de programmes externes

I modules à retenir
• os : exploitation des commandes du système d’exploitation
• pandas : analyse de données numériques
• sys : informations sur le script courant

66 / 71
Installation Éléments de syntaxe Calcul scientifique Gestion de données Conclusion

Sommaire

1 Installation

2 Éléments de syntaxe

KOJTYCH
3 Python pour le calcul scientifique

4 Gestion de données en python

5 Conclusion

67 / 71
Installation Éléments de syntaxe Calcul scientifique Gestion de données Conclusion

Récapitulatif de l’atelier
I points abordés
• syntaxe de base : variables, boucles, structures de données
• réalisation de graphiques
• outils de calcul scientifique
• gestion de données et lancement de programmes
I modules à retenir
•
•
•
•
KOJTYCH
math : opérations mathématiques
numpy : matrices et vecteurs
scipy : calcul scientifique
matplotlib.pyplot : graphiques
• os : exploitation des commandes du système d’exploitation
• pandas : analyse de données numériques
• sys : informations sur le script courant
I commandes à retenir
help() # commande d’aide
dir() # liste des attributs et méthodes d’un objet

67 / 71
Installation Éléments de syntaxe Calcul scientifique Gestion de données Conclusion

Bonnes pratiques de programmation

1 être curieux ! essayer, essayer, essayer... :)

2 avant d’implémenter une fonction, vérifier qu’elle n’existe pas
déjà !
3 commenter (non, vous ne vous en souviendrez pas...)
4

5
KOJTYCH
utiliser les bons outils (IDE, auto-complétion, raccourcis clavier...)
respecter une syntaxe propre et homogène (PEP8, nommage
explicite...)
6 optimiser son code (vectoriser !)
7 gérer ses versions (avec Git par exemple)
8 aller chercher l’information ! (forum, questions...)

68 / 71
Installation Éléments de syntaxe Calcul scientifique Gestion de données Conclusion

Ressources supplémentaires

I outil de calcul en ligne Wolfram, bien utile pour vérifier des

simplifications, des dérivées... :
https://www.wolframalpha.com/

KOJTYCH
I tutoriel Python très complet sur OpenClassroom :
https://openclassrooms.com/fr/courses/
235344-apprenez-a-programmer-en-python

I wikibook sur l’utilisation de Python pour le calcul scientifique :

https://fr.wikibooks.org/wiki/Python_pour_le_calcul_
scientifique

69 / 71
Installation Éléments de syntaxe Calcul scientifique Gestion de données Conclusion

Autres ateliers de l’IICAP

I Langages de programmation C et C++

• 20 mars, 9h à 11h

KOJTYCH I Salomé et Salomé-MECA

• 25 mars, 13h à 15h
• 9 avril, 17h30 à 19h30 (anglais)

I Latex : introduction et approfondissement

• débutants : 25 mars 10h30 à 12h30
• approfondissement : 31 mars 10h30 à 12h30

Inscriptions sur le site de l’IICAP :

https://www.polymtl.ca/iicap/ateliers
70 / 71
Installation Éléments de syntaxe Calcul scientifique Gestion de données Conclusion

Merci de votre attention !

Envie de pratiquer ?
I matériel de l’atelier :
https://gitlab.meca.polymtl.ca/iicap/ateliers/python

KOJTYCH
I ou lien direct vers le notebook Jupyter en ligne (sans
installation, sans sauvegarde, un peu de patience pour le chargement)

Suggestions ? Remarques ? Avis ?

socrative > login : student > room : KOJTYCH
( ou envoyez un message à : [email protected]) ?
71 / 71
Annexes

Calcul symbolique

import sympy as sp # module de calcul symbolique

# Variables symboliques
u, v = sp.symbols("u v")
expr1 = u**2+3*v++4*u*v+5 # definition d’une expression avec nombres
expr2 = sp.sympify("u**2+3*v+4*u*v+5") # ou par une chaîne
expr1 == expr2

expr1.subs(u, 1)
KOJTYCH
# Evaluation d’une expression avec l’opérateur de substitution
# remplacement d’une variable
expr2.subs([(u, 3), (v, 2)]) # evaluation en u = 3, v = 2
# Dérivation symbolique
sp.diff(expr1, u) # derivation ordre1 par rapport àune variable
sp.diff(expr1, u, u) # dérivée d’ordre 2
sp.diff(expr1, u, v) # dérivée croisée
# Intégration symbolique
sp.integrate(expr1, u) # sans bornes sur u seulement
sp.integrate(expr1, u, v) # sans bornes sur u et v
sp.integrate(expr1, (u, 0, 1), (v, 3, 8)) # avec bornes : 0 <u<1, 3<v<8
sp.integrate(u**2, (u, 0, 1)) # vérification

I possible de tester sympy en ligne : https://live.sympy.org/

72 / 71
Annexes

Statistiques et nombres aléatoires

import random as rd # module pour l’aléatoire

# Nombres aléatoires
rd.randint(2, 9) # entier aléatoire entre 2 et 9
rd.seed(3) # graine aleatoire (par défaut = temps courant du système)

ma_liste = [1, 2, 3, 4, 5]

KOJTYCH
print(rd.sample(ma_liste, 2)) # extrait au hasard 2 éléments de la population
# Echantillonnage selon une loi de probabilite
print(np.random.uniform(0, 1)) # echantillon sur loi uniforme entre 0 et 1
moyenne = 2
ecart_type = 0.5
print(np.random.normal(moyenne, ecart_type, size=5))
# 15 échantillons d’une loi normale
# Matrice ou vecteur aléatoire
vecteur = np.random.rand(3, 2) # taille 3 X 2
vecteur

73 / 71
Annexes

Résolution de problèmes d’optimisation - 1

I minimiser sans contraintes une fonction d’une variable

from scipy import optimize # module d’optimisation

import numpy as np
import matplotlib.pyplot as plt

def f(x):
KOJTYCH
# minimiser f(x)= exp**((x-0.7)**2) sans contraintes
return np.exp((x - 0.7)**2)

# plt.plot(np.linspace(-1, 3), f(np.linspace(-1, 3)))

resultats = optimize.minimize_scalar(f) # possible d’ajouter des bornes sur x
x_min = resultats.x # solution trouvée
# note : utilise une méthode locale de minimisation
print(resultats)

74 / 71
Annexes

Résolution de problèmes d’optimisation - 2

I minimiser sans contraintes une fonction de plusieurs variables
from mpl_toolkits.mplot3d import axes3d # module pour graphes 3D
from matplotlib import cm # color map
def rosen(x): # fonction de Rosenbrock àminimiser
return (1 - x[0])**2 + 100*(x[1] - x[0]**2)**2

# Graphique de la fonction

KOJTYCH
figure3D = plt.figure()
ax = figure3D.add_subplot(111, projection=’3d’)
X, Y = np.meshgrid(np.linspace(-2, 2, 100), np.linspace(-1, 3, 100))
Z = rosen([X, Y])
ax.plot_surface(X, Y, Z, cmap=cm.viridis, linewidth=0, alpha=0.7)
plt.show()

# Optimisation avec estimation numérique du gradient

resultats = optimize.minimize(rosen, [2, -1], method="CG")
# point de départ(2,1)
# Optimisation avec expression analytique du gradient => a utiliser si
disponible !
def gradient(x):
return np.array([2*(200*x[0]**3-200*x[0]*x[1]+x[0]-1),
200*(x[1]-x[0]**2)])

x0 = [-6, -1] # solution intiale

resultats = optimize.minimize(rosen, x0, method="CG", jac=gradient) 75 / 71
Annexes

Résolution de problèmes d’optimisation - 3

I minimiser avec contraintes une fonction de plusieurs variables

# Minimiser la fonction de Rosenbrock f(x,y) sous la contrainte x < 0.5

KOJTYCH
# Les contraintes doivent être définies sous la forme contrainte(x)>=0
def contrainte(x):
return 0.5-x[0]
resultats = optimize.minimize(rosen,
x0,
constraints={"fun": contrainte,
"type": "ineq"},
method=’SLSQP’, # choix de la methode
options={’disp’: True})

76 / 71
Annexes

Résolution de problèmes d’optimisation - 4

I résolution de problèmes de moindres carrées pour trouver les
paramètres d’un modèle qui correspondent le mieux aux données
from scipy.optimize import curve_fit # module pour les problèmes de moindre
carrés
# Données : gaussienne bruitée
[data_x, data_y] = np.load(’data1.npy’) # import de données numpy
plt.plot(data_x, data_y, label=’données’)

KOJTYCH
# Modèle de gaussienne
def modele_gaussienne(x, amp, mu, sigma):
return amp * np.exp(-(x-mu)**2 / sigma)
# paramètres : amp = amplitude, mu = moyenne, sigma = ecart type

# Problème de moindres carrés pour trouver les paramètres du modèle

valeurs_initiales = [1, 0, 1] # amplitude, moyenne
param, covariance = curve_fit(modele_gaussienne,
data_x, data_y, p0=valeurs_initiales)
# param contient : ampl,mu,sigma
# Verification modele
x = np.linspace(data_x[0], data_x[-1], 1000)
modele = modele_gaussienne(x, param[0], param[1], param[2])
plt.plot(x, modele, label=’modèle’, color=’r’)
plt.legend()
plt.show() 77 / 71
Annexes

Optimiser son code - 1

I contrôler le temps d’exécution des instructions

import numpy as np

# Contrôler le temps d’exécution des instructions :

# "%timeit instruction et pas "tic-toc" comme l’horloge de ton grand-père"
a
b
#
#
KOJTYCH
= np.random.rand(10**6)
= np.random.rand(10**6)
%timeit 2*a + 3*b # raccourci utilisable avec ipython, calcule une moyenne
du temps sur plusieurs exécutions sur une durée de 2 secondes

# Le "%" précèdeune instruction ipython magic

# NB : Sans ipython, utiliser le module timeit
import timeit
timeit.timeit(’2*np.random.rand(10**6) + 3*np.random.rand(10**6) ’,
number=100,
setup=’import numpy as np’)
# execute 100 fois instructions

78 / 71
Annexes

Optimiser son code - 2

I exploiter les vecteurs
# Utiliser la vectorisation
vec_a = np.array([[5, 6, 9]])
vec_b = np.array([10, 25, 3])
vec_somme = vec_a*vec_b
matrice_a = np.random.randint(15, size=(3, 3)) # matrice aléatoire d’entiers
de 0 à15

KOJTYCH
# Maîtriser les changements de formes (1 "axis" = 1 dimension = 1 série
d’indices)
vecteur = np.reshape(matrice_a, (1 ,9)) # change forme de la matrice en 1 par
12
vecteur_transpose = vecteur.transpose()
vecteur_axes_permute = np.swapaxes(vecteur, 0, 1) # permute les indices i et j
matrice_b = np.zeros((3, 4, 5))
matriceb_modifiee = np.moveaxis(matrice_b, 1, 2)
# change numérotation des indices (axis) 1 va en 2
matriceb_modifiee.shape
# Utiliser les fonctions dédiées pour manipuler les vecteurs et matrices
np.sum(matrice_a, axis=0) # dans la direction 0 (= somme selon colonnes)
np.einsum(’ii’, matrice_a) # sum a[ii]

79 / 71
Annexes

Optimiser son code - 3

I exploiter les matrices creuses

from scipy.sparse import csr_matrix # module d’objets creux

from scipy.sparse.linalg import spsolve # résolution de systèmes creux
# matrice dense avec des zeros
A = np.array([[1, 0, 0, 1],
[0, 0, 2, 0],

print(A) KOJTYCH
[0, 0, 0, 5],
[0, 4, 0, 5]])
# conversion en matrice sparse (méthode CSR)
S = csr_matrix(A)
print(S)
# opération sur la matrice creuse
b = np.random.rand(4)
x1 = spsolve(S, b) # resolution avec matrice creuse
# reconstruction en matrice dense
B = S.todense()
x2 = np.linalg.solve(A, b)

80 / 71
Annexes

Optimiser son code - 4

I utiliser des accélérateurs

# Accélération sur les fonctions comportant des boucles avec le module numba,
# un ompilateur just-in-time qui traduit les expressions en codes équivalents
machine
import numba
from numba import jit

KOJTYCH
# Tutoriel explicatif : voir le lien ci-dessous

# Accélération sur l’évaluation d’expressions sur les tableaux avec le module

# numexpr :
import numexpr as ne
a = np.random.rand(10**6)
b = np.random.rand(10**6)
# %timeit 2*a + 3*b

I exemple d’utilisation de numba : https:

//numba.pydata.org/numba-doc/dev/user/5minguide.html

81 / 71
Annexes

Python orienté objet - 1

I génération de classes et création d’objets

# Création d’une classe "individu" avec 2 attributs et 1 méthode

class individu:
# Fonction pour créer un objet de la classe individu (constructeur)
def __init__(self, nom, prenom):

KOJTYCH
self.nom = nom # initialisation des attributs passes en paramètres
self.prenom = prenom
def affiche(self):
print("Nom : ", self.nom, ", Prénom : ", self.prenom)

# Déclaration d’un objet "individu"

moi = individu("Kojtych", "Solène")
moi.prenom # appel d’un attribut
moi.affiche() # appel d’une méthode
#dir(moi) # voir les attributs et methodes

82 / 71
Annexes

Python orienté objet - 2

I héritage
# Classe "étudiant" qui hérite de la classe individu
class etudiant(individu):

# Fonction d’initialisation d’un objet "etudiant" (constructeur)

KOJTYCH
def __init__(self, nom, prenom, matricule):
individu.__init__(self, nom, prenom) #appel au constructeur de
"individu"
self.matricule = matricule
# Redéfinition des méthodes possible
def affiche(self):
print("Nom : ", self.nom, ", Matricule: ", self.matricule)

un_etudiant = etudiant("un_nom", "un_prenom", "000000")

un_etudiant.affiche()

83 / 71