Accueil Python

Presentation et utilisation du language Python

-- Simulation numérique en mécanique des fluides --

Eléments de Python

Introduction au python scientifique

-

simon.marie@lecnam.net

Exécution d'un script Python

Le langage Python est un langage précompilé ne nécessitant donc aucune compilation. Il y a 3 façons principales d'utiliser Python:

  1. Ecrire un script dans un fichier .py et le lancer en ligne de commande
  2. Utiliser directement Python en ligne de commande avec Ipython ou Spyder
  3. Utiliser un Notebook Jupyter (C'est ce moyen qui est utilisé ici)

Pour un projet largre Pour exécuter un script Python, il suffit de lancer la commande suivante dans un terminal:

 

$> python script.py

 

Dans le cadre de ce TP, on pourra utiliser un script python à éditer avec un éditeur au choix (notepad++, emacs, vi, gedit...).

Importation des modules

Les premères lignes d'un script Python sont consacrées à l'appel des modules nécessaires aux calculs. On utilise pour cela la commande import. Pour les besoins du TP, les modules numpy, matplotlib et math seront nécessaires. Le début du script ressemblera donc à:

In [4]:
import numpy as np # contitent des fonctions utiles pour le traitement des matricesimport matplotlib.pyplot as plt # contitent des fonctions utiles pour la representation graphique%matplotlib inline
 

Les lignes ci-dessus importent le module numpy en le nommant np. Ainsi tous les appels à des fonctions propres aux modules numpy seront précédés de np.:

In [5]:
y=np.sin(np.pi) # calcul sin(pi)print y
 
1.22464679915e-16
 

Manipulation des vecteurs / matrices

Le module $\textit{numpy}$ permet la manipulation des matrices dans python. Ainsi pour initialiser et créer une matrice on utilisera la fonction $\textit{zeros}$ de $\textit{numpy}$. La fonction arange(n) de $\textit{numpy}$ sert a créer une liste d'entier allant de $0$ à $n-1$.

In [7]:
nx=10ny=10A=np.zeros((nx,ny)) # Matrice de nx*ny elements nulsB=np.arange(nx) # Vecteur de nx elements allant de 0 à 9print Aprint B
 
[[ 0.  0.  0.  0.  0.  0.  0.  0.  0.  0.] [ 0.  0.  0.  0.  0.  0.  0.  0.  0.  0.] [ 0.  0.  0.  0.  0.  0.  0.  0.  0.  0.] [ 0.  0.  0.  0.  0.  0.  0.  0.  0.  0.] [ 0.  0.  0.  0.  0.  0.  0.  0.  0.  0.] [ 0.  0.  0.  0.  0.  0.  0.  0.  0.  0.] [ 0.  0.  0.  0.  0.  0.  0.  0.  0.  0.] [ 0.  0.  0.  0.  0.  0.  0.  0.  0.  0.] [ 0.  0.  0.  0.  0.  0.  0.  0.  0.  0.] [ 0.  0.  0.  0.  0.  0.  0.  0.  0.  0.]][0 1 2 3 4 5 6 7 8 9]
 

Attention, en python les indices commencent à 0 ! On peut ainsi sélectionner ou modifier une partie de matrice en sélectionnant ses indices comme présenté ci-dessous:

In [10]:
print B[:] # Tous les elements de la matriceprint B[0] # La premiere ligne de la matriceprint B[-1] # La derniere ligne de la matriceprint B[-2] # L'avant derniere ligne de la matrice...print B[0:5,] # Lignes 1 a 5 et toutes les colonnes.print B[0:-1] # Attention ici on ne va que jusqu'à n-1print B[0:]  # Equivalent à B[:]# A[n1:n2,:] # selection de n1 a n2-1 donc ligne n1+1 a n2
 
[0 1 2 3 4 5 6 7 8 9]098[0 1 2 3 4][0 1 2 3 4 5 6 7 8][0 1 2 3 4 5 6 7 8 9]
 

Pour créer des vecteurs contenant des suites de nombres régulièrement espacés (par exemple pour des maillages) on peut utiliser la fonction $\textit{arange(start,end,step)}$ de $\textit{numpy}$:

In [11]:
A=np.arange(-2,2,0.5) # Vecteur contenant tous les nombres entre -2 et 1.5 par pas de 0.5print A
 
[-2.  -1.5 -1.  -0.5  0.   0.5  1.   1.5]
 

Pour créer une matrice diagonale on utilise la fonction $\textit{eye(nx,ny)}$ de $\textit{numpy}$:

In [12]:
B=np.eye(3,3) # Matrice identite de 3*3 elementsprint B
 
[[ 1.  0.  0.] [ 0.  1.  0.] [ 0.  0.  1.]]
 

Les boucles python

L’ensemble de la syntaxe python est basée sur l'indentation du texte. Ainsi toutes les lignes devront commencer au même endroit. Le début et la fin d'une boucle (for, if, while...) sera repérée par une indentation différente. C'est une syntaxe propre au Python qui permet de s'affranchir des syntaxe de type end for mais qui impose d'être rigoureux ! Par convention on utilise une indentation de 4 espaces. Ainsi, une boucle for s'écrira de la façon suivante:

In [16]:
A=np.arange(10)for i in A:    print i,i**2,i**3
 
0 0 01 1 12 4 83 9 274 16 645 25 1256 36 2167 49 3438 64 5129 81 729
 

Attention a ne pas oublier le signe $:$ à la fin de la première ligne de boucle.

 

Représentation graphique

Le module matplotlib permet l'utilisation des fonctions graphiques de type plot() et pcolormesh():

In [3]:
x=np.arange(-10,10,0.5)y=np.arange(-10,10,0.5)z=np.exp(-x**2/16)z2=np.einsum('i,j->ij',np.exp(-x**2/16),np.exp(-y**2/16))print z2.shapefig=plt.figure(1) # Creation de l'objet figure 1plt.plot(x,z) # Courbe de y en fonction de xplt.xlabel('On peut etiqueter les axes $\epsilon$',fontsize=16.)plt.ylabel('Utiliser des symboles: $\sum_\infty \epsilon$',fontsize=16.)plt.title('Titre du graphique',fontsize=16.)
 
(40, 40)
Out[3]:
<matplotlib.text.Text at 0x7f2c6c5daf50>