Calcul Scientifique

Calcul Scientifique
October 8, 2014
0.0.1 Journ´ee `a la d´ecouverte de Python
1 Python pour le Calcul Scientique
Dev@LR - R´emy Mozul
2 Sommaire
•Introduction
•Plus de python
•Numpy
•Scipy
•Matplotlib
•Code compil´e
2.1 Introduction
•Ipython
•R`egles de d´eveloppement
•Documentations existantes
2.1.1 ipython
•Interactive python
•Surcouche `a l’interp´eteur python classique
•Compl´etion automatique
•Aide interactive
•Support des commandes shell (pour les Unixiens)
•Meilleure gestion de l’historique des commandes
In [1]: import math
math?
!ls -l #unix
#! dir #dos
total 616
-rw-r--r-- 1 mozul staff 219706 8 oct 10:49 Calcul Scientifique.ipynb
-rw-r--r--@ 1 mozul staff 856 8 sep 16:47 fixed mathjax.tpl
-rw-r--r--@ 1 mozul staff 2515 1 oct 10:35 latex-to-slide-patch.tar.gz
-rw-r--r--@ 1 mozul staff 72229 22 sep 17:56 numpy indexing.png
1

-rw-r--r-- 1 mozul staff 97 1 oct 10:41 run slides.sh
-rw-r--r--@ 1 mozul staff 5095 8 sep 16:47 slides.tpl
2.1.2 R`egles de d´eveloppement
•Python offre beaucoup de libert´es
•Peut-ˆetre trop parfois !
•Important de se fixer des r`egles :
–Conventions de nommage
–Toujours documenter ses fonctions/classes (docstring)
–Tests
Les conseils officiels : http://legacy.python.org/dev/peps/pep-0008/
In [2]: import this
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 at first unless you’re Dutch.
Now is better than never.
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!
2.1.3 Documentation
•Enorm´ement de documentation en ligne : https://docs.python.org/3/
–Tutoriaux
–Documentation des modules/fonctions
–Code sources des modules
•Recherche internet
–De module existant
–De r´esolution de probl`eme
2.2 Plus de python
•Indexation des listes
•List comprehension et lambda functions
•Filter, map
2

2.2.1 Indexation des listes
•indexation commence `a 0
•op´erateur d’indexation [debut:fin:pas]
•end est non inclus dans la selection
•si l’index iest n´egatif, il est interpr´et´e comme n+j (o`u nest la taille)
•si les entiers entre les :sont omis, les valeurs par d´efaut 0, taille de la liste et 1 sont utilis´ees
•syntaxe utilisable avec le constructeur range(debut,fint,pas)
Exercice :
•G´en´erer une liste allant de 0 `a 9 (avec la fonction range et le constructeur de list)
–Afficher le premier ´el´ement, le dernier, l’avant dernier
•A partir de celle-ci, cr´eer une liste
–allant de 0 `a 4
–allant de 4 `a 9
–contenant les nombres pairs
–contenant les nombres impairs dans l’ordre d´ecroissant jusqu’`a 3
•G´en´erer une liste de nombre pairs allant de 2 `a 10
In [3]: #python 2
#l = range(10)
#l = list(xrange(10))
#python 3
l=list(range(10))
print(l[0]); print(l[-1]); print(l[-2])
a=l[:]; print(a)
a=l[:5]; print(a)
b=l[4:]; print(b)
c=l[::2]; print(c)
d=l[9:2:-2]; print(d)
l2=list(range(10,1,-2)); print(l2)
0
9
8
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
[0, 1, 2, 3, 4]
[4, 5, 6, 7, 8, 9]
[0, 2, 4, 6, 8]
[9, 7, 5, 3]
[10, 8, 6, 4, 2]
2.2.2 List comprehension et lambda function
•Mani`ere classique de g´en´erer une liste : avec une boucle for et la m´ethode append
•List comprehension : mani`ere compacte de g´en´erer des listes en une ligne
–Utilise une sequence ou un it´erateur
–Syntaxe : [ ] contenant une expression suivi de 0 ou plus for ou if mots-clef
•Lambda function : mani`ere compacte de g´en´erer des petites fonctions anonyme en une ligne (utile
quand une fonction est un param`etre d’une autre)
3

–Syntaxe : lambda args : expression(args)
Exercice :
•Cr´eer, avec une boucle, une liste contenant sin(x) pour des valeurs xparcourant 0 `a 1 par pas de 0.1
•Cr´eer la mˆeme liste en une seule ligne
•Cr´eer une fonction fr´ef´erencant une lambda function faisant sin(x2)
•Cr´eer une liste contenant sin(x2) pour des valeurs xparcourant 0 `a 1 par pas de 0.1 en utilisant f
In [4]: import math
s=[]
for xin range(11):
s.append(math.sin(x*0.1))
s2 =[math.sin(x*0.1)for xin range(11)]
print(s == s2)
f=lambda x : math.sin(x*x)
s3 =[f(x*0.1)for xin range(11)]
True
2.2.3 filter et map
2 fonctions qui prennent en entr´ee une fonction et une liste. En python 3, la valeur de retour est un objet
permettant de cr´eer des liste. En python 2, la valeur de retour est un objet list.
•Filter : retourne la liste des ´el´ements d’entr´ee dont l’´evaluation par la fonction est vraie ->le r´esultat
de la fonction est interpr´et´e comme un bool´een
•Map : retourne l’´evaluation par la fonction de chaque ´el´ement de la liste d’entr´ee
Note : En g´en´eral, quand il existe des syntaxes ´equivalentes, la list comprehension est plus rapide que les
filter/map/, qui sont plus rapide que les boucles
Exercice : Tester les 2 fonctions :
•r´ecup´erer une liste d’entier dont tout les ´el´ements sont divisibles par 3
•r´ecup´erer une liste correspondant `a sin(x) o`u x est une autre liste.
In [5]: l1 =list(filter(lambda x: x%3==0,range(15)))
print(l1)
l2 =list(map(math.sin,l1))
print(l2)
[0, 3, 6, 9, 12]
[0.0, 0.1411200080598672, -0.27941549819892586, 0.4121184852417566, -0.5365729180004349]
2.3 Numpy
•Introduction
•Tableau : type, attribut, m´emoire
•Indexing/Slicing
•Vue : r´ef´erence/copy
•Constructeurs, IO
•Manipulation
4

2.3.1 Introduction
•Package pour le traitement de tableau `a n-dimensions
•Pens´e pour le calcul scientifique
•Efficace
Restrictions :
•Taille totale du tableau fixe
•Type des ´el´ements homog`ene
•Type statique
Site officiel (avec documentation et tutoriaux) : http://docs.scipy.org/doc/numpy/user/
2.3.2 Type
Les tableaux numpy sont optimis´es pour le traitement de valeurs num´eriques :
•bool´eens (32/64)
•entiers non sign´es (32/64)
•entiers sign´es (32/64)
•r´eels (32/64)
•complexes (32/64 bits)
Lors de la cr´eation d’un tableau, le type des ´el´ements peut ˆetre :
•choisi ou inf´er´e par le constructeur
•sp´ecifi´e
L’attribut de la classe array qui stocke le type est dtype.
Exercices :
•Utiliser le constructeur de la classe array pour cr´eer
–une vecteur d’entiers
–un vecteur de r´eels.
•V´erifier le type du contenu du chacun des tableaux grˆace `a la l’attribut dtype.
In [6]: import numpy as np
np?
In [7]: a=np.array([1,2,3])
print(a)
print(a.dtype)
[1 2 3]
int64
In [8]: b=np.array( [[1.2,2.3,3.4],[4.5,5.6,6.7]])
print(b)
print(b.dtype)
[[ 1.2 2.3 3.4]
[ 4.5 5.6 6.7]]
float64
5