programmation scientifique avec pythonfaure/enseignement/python/cour… · base de python 1...
TRANSCRIPT
Programmation Scientifique avec Python
[email protected](légèrement modifié par F.Faure)
23 octobre 2016
Table des matières
I Base de Python 3
1 Introduction 3
2 Installation de Python 4
3 Programmer avec Python 43.1 Ligne de Commande ou éditeur ? . . . . . . . . . . . . . . . . . . . . . . . . . . 43.2 Documentation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
3.2.1 Aide en ligne . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53.2.2 Livres . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
3.3 Environnement de programmation . . . . . . . . . . . . . . . . . . . . . . . . . 53.4 Variables et types de données . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
3.4.1 Variables simples . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 63.4.2 Opérations : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 73.4.3 Nombres complexes . . . . . . . . . . . . . . . . . . . . . . . . . . . . 73.4.4 Chaînes de caractères . . . . . . . . . . . . . . . . . . . . . . . . . . . . 83.4.5 Listes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 93.4.6 Vecteurs de nombres . . . . . . . . . . . . . . . . . . . . . . . . . . . . 103.4.7 Matrices de nombresimporter le m . . . . . . . . . . . . . . . . . . . . . 103.4.8 Tuple [Facultatif] . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 113.4.9 Dictionnaires [Facultatif] . . . . . . . . . . . . . . . . . . . . . . . . . 113.4.10 Conversion de variables entre différents types . . . . . . . . . . . . . . . 12
3.5 Boucles et opérateurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 123.5.1 opérateurs ==,and, or , not . . . . . . . . . . . . . . . . . . . . . . . . 123.5.2 L’instruction if...elif..else . . . . . . . . . . . . . . . . . . . . . . 133.5.3 La boucle while . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 143.5.4 Les boucles for . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
1
3.5.5 Exercice : la conjecture de Syracuse . . . . . . . . . . . . . . . . . . . . 153.6 Fonctions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 153.7 Portée des objets : variables locales et globales . . . . . . . . . . . . . . . . . . 163.8 Exercice . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
4 Classes et Objets 174.1 Présentation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 174.2 Exemple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 184.3 Variables membre . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 184.4 Fonctions membres . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 194.5 Fonctions membres spéciales [Facultatif] . . . . . . . . . . . . . . . . . . . . . 20
4.5.1 Constructeur __init__ . . . . . . . . . . . . . . . . . . . . . . . . . . 204.5.2 Destructeur __del__ . . . . . . . . . . . . . . . . . . . . . . . . . . . . 204.5.3 Opérateurs __add__, __sub__, __mul__, __div__, __pow__ . . . . . . 20
4.6 Héritage [Facultatif] . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 214.7 Attention : opérateur “==”, différence entre égalité et identité, copie et réfé-
rence... [Facultatif] . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 214.8 Exercice . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22
5 Lecture et écriture de fichiers 235.1 Exercice . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24
II Modules scientifiques 24
6 Utilisation de “modules” (standards et librairies extérieures) 246.1 math . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 246.2 Scipy (scientific python, http ://www.scipy.org) . . . . . . . . . . . . . . . . . . 25
6.2.1 Exemples . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 256.2.2 Sous-modules de scipy . . . . . . . . . . . . . . . . . . . . . . . . . . . 266.2.3 Extensions ou applications de scipy . . . . . . . . . . . . . . . . . . . . 27
6.3 Tracé de données scientifiques (1D, 2D) avec matplotlib/pylab . . . . . . . . . . 276.3.1 Courbe 1D . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 276.3.2 Courbe 2D . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28
6.4 Autres modules scientifiques . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28
7 Performance et interface C/C++ <-> Python [Facultatif] 297.1 Performance : C/C++ vs Python . . . . . . . . . . . . . . . . . . . . . . . . . . 29
7.1.1 Utilisation de scipy.weave . . . . . . . . . . . . . . . . . . . . . . . . . 307.2 Interface C/C++ <-> Python avec SWIG . . . . . . . . . . . . . . . . . . . . . . 31
2
8 Fenêtres et graphiques avec wxPython 328.1 Animation : corde pendante . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 338.2 Animation et calcul . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34
Première partie
Base de Python1 Introduction
Il existe déjà un grand nombre de langages utilisés pour le calcul scientifique (C/C++/fortran),stabilisés et développés depuis de nombreuses années. Pourquoi développer (et donc apprendre !)un nouveau langage ? Il s’avère que les langages traditionnels sont soit inadaptés à une utilisa-tion généraliste (calculs et création d’un interface graphique - ex : fortran), ou ont une syntaxesuffisamment complexe ou rigide pour rendre difficile son utilisation par un utilisateur occasion-nel (c++). C’est ce qui a permis le succès de logiciels commerciaux spécialisés dans le calcul(Mathematica, Maple, Mathlab,...), et de langages (IDL,...), qui associent une syntaxe relative-ment simple avec des fonctionnalités (représentation graphique, librairies de calcul) étendues, etutilisables directement à partir d’une ligne de commande (sans compilation préalable).
C’est pour pallier ce manque que le langage Python (http ://www.python.org) a été développé.Il présente de multiples avantages par rapport aux langages traditionnels :
— naturel (utilisation de l’indentation, typage dynamique)— utilisable en ligne de commande (donc interactif )— moderne (orienté objet)— extensible (modules externes de calcul et de visualisation écrites en C/C++/fortran)— très utilisé pour le calcul scientifique (grâce à la réutilisation de librairies de calculs déjà
existantes)— libre (“open-source”) et multi-plateforme (Linux, windows, MacOS,...)
Python est un langage compilé “au dernier moment”, et donc plus lent qu’un langage compilé(fortran/c/c++). Ce n’est en fait pas un inconvénient, car chaque fois qu’un calcul “intensif” estnécessaire, il est possible de l’effectuer dans un module externe écrit dans un autre langage, plusefficace. En général seule une petite partie d’un programme a besoin d’être vraiment optimisée(en général moins de 5% du code représente 95% du temps de calcul !).
En outre, il s’avère que l’on passe souvent plus de temps à écrire un programme qu’à l’utili-ser, ce qui relativise l’importance de la “performance pure” du programme. L’intérêt de pythonest justement d’accélérer le développement d’un programme par sa syntaxe simple, et par sa ca-pacité à réutiliser des librairies existantes.
Les différences fondamentales par rapport au C++ avec lesquelles il faut se familiariser
3
sont :— C’est un langage interprété (en fait, “compilé au dernier moment”), utilisable avec une
ligne de commande— Les “blocs” de code (ex : intérieur d’une boucle) sont identifiés par l’indentation (nombre
d’espaces en début de ligne), et non par des acollades {...}— Le type des objets (’int’, ’float’, ’string’) est dynamique, ç.à.d. qu’il n’a pas besoin d’être
déclaré à l’avance et qu’il peut être modifié au cours du programme.
2 Installation de PythonSous Linux : Python est installé sur toutes les distributions, en standard - il est par contre
nécessaire d’ajouter des modules tels que SciPy et matplotlib, suivant le type de programmesouhaité.
Sous Windows : la distribution standard de python est disponible sur http ://www.python.org,mais il est recommandé d’installer la version de python de la société Enthought (Enthought Py-thon = Enthon), qui inclut les modules de calculs scientifique les plus utiles http ://code.enthought.com/enthon/.
3 Programmer avec Python
3.1 Ligne de Commande ou éditeur ?Python peut être utilisé à partir d’une ligne de commande (langage interprété). Pour lancer
l’interpréteur, taper “python” dans une console linux, puis à l’invite de commande (“>�>�>”), taper“print �toto�”. Cela donne
>�>�> print "toto"
toto
>�>�>
Dans un autre langage, il aurait fallu écrire le texte du programme dans un fichier, puis le com-piler avant de l’éxécuter. En fait il est également possible d’écrire le programme dans un fichier.Pour cela ouvrir un éditeur de texte (par exemple kwrite, nedit ou kate), écrire le programme(print �toto�), et le sauvegarder sous le nom toto.py. Ensuite, éxécuter le programme avec lacommande “python toto.py” à partir d’une console Linux (il est également possible d’utiliser“python -i toto.py” afin de rester dans l’interpréteur après éxécution du programma). Defait, écrire un programme sur la ligne de commande ou le taper au préalable dans un fichier avantde l’exécuter est rigoureusement équivalent.
Pour l’utilisation en ligne de commande, il est encore plus avantageux d’utiliser ipython :“ipython toto.py” - c’est une version plus interactive de python, qui se souvient des instruc-tions tapées lors de la dernière session ipython (utiliser les flèches haute et basse pour naviguer
4
dans l’historique des commandes), et qui sait “compléter” les commandes (pour utiliser une fonc-tion ou un objet, taper le début du nom et appuyer sur la touche tabulation - le nom sera complétéou différents choix seront proposés).
Voilà ! Vous savez programmer en Python. Dans la pratique, les tests rapides sont faits avecla ligne de commande, et les programmes longs sont écrits dans un fichier avant d’être exécutés.
Remarques :— pour sortir de l’interpréteur Python, taper ctrl-d— le symbole # sert à commencer un commentaire en python. Tout ce qui se trouve sur une
ligne après un # n’est pas interprété par python :>�>�> print �toto� # ceci est mon premier programme en python !
toto
— pour éxécuter des commandes dans un fichier texte depuis l’interpréteur python, il faututiliser la fonction execfile (e.g. execfile(�toto.py�))
— pour pouvoir utiliser des accents dans Python, il faut préciser l’encodage que nous utili-sons, en mettant au début du fichier python la ligne suivante :# -*- coding: iso-8859-15 -*-
3.2 Documentation3.2.1 Aide en ligne
Tous les objets standards (de même que les modules correctement conçus) possèdent une aideen ligne, qui peut ête invoquée avec la fonction help(). Par exemple help(str), help(list),permettent d’accéder à l’aide sur les chaînes de caractère et sur les listes. Lorsqu’un moduleest importé (e.g. ’import math’), il est possible de lire l’aide correspondant à ce module (e.g.’help(math)’) ou à une fonction de ce module (e.g. ’help(math.sin)’).
Lorsque ipython est utilisé, c’est encore plus simple, il suffit de taper la commande sui-vie de un ou deux points d’interrogations (suivant le détail de la documentation souhaitée), parexemple : 'list?'.
3.2.2 Livres
Un tutorial sur le web (et autres documents) :http ://www.python.org/
3.3 Environnement de programmationEn anglais : Integrated Development Environment (I.D.E.).C’est un logiciel qui contient un éditeur afin d’écrire les commnades pythons, mais qui pro-
pose aussi beaucoup de fonctionnalités spécifiques à la programmation (recherche d’erreurs,...).Il existe de nombreux IDE, nous recommandons par exemple : eric
5
3.4 Variables et types de données3.4.1 Variables simples
Pour créer une variable, il suffit de lui affecter une valeur :>�>�> x=1
>�>�> print x
1
On voit ici une différence importante avec d’autres langages : il n’est pas nécessaire de dé-clarer a priori le type de la variable x (entier ’int’, nombre flottant ’float’, chaine de caractère’string’,...). Pourtant ce type existe bien, si vous demandez ensuite :
>�>�> print type(x)
<type 'int'>
Python a donc automatiquement décidé que x était un entier (int = integer). Essayez avecd’autres initialisations : “x=1.0” (nombre flottant ou float), “x=�bonjour�” (chaine de caractèreou string),...
On peut affecter plusieurs variables à la fois :>�>�> x,y=1,2
>�>�> print x,y
1 2
>�>�> x=y=1
>�>�> print x,y
1 1
Pour demander une variable :>�>�> x=input(�x=?�)
x=? 2
>�>�> print x
2
Si on veut que x soit une chaine de caractère, et ne soit pas convertit il faut écrire plutot :>�>�> x=raw_input(�x=?�)
x=?2
>�>�> print type(x)
<type 'str'>
Il est à noter qu’il est possible de changer le type de x en lui affectant des valeurs différentes :>�>�> x=57
>�>�> type(x)
<type 'int'>
>�>�> x="Astérix"
>�>�> type(x)
<type 'str'>
>�>�> x=3.14159263
>�>�> type(x)
6
<type 'float'>
Bien que cela soit pratique, cela peut entraîner des erreurs de programmation, donc dans lamesure du possible il faut toujours utiliser des noms de variables explicites (age sera un en-tier, nom une chaîne de caractères, etc...), et ne pas changer de type en cours de programme.
Attention : majuscules et minuscules sont différenciées par python, i.e. mavariable,MAVARIABLE et MaVariable sont trois variables distinctes. Il en va de même pour tous les mot-clefs et les fonctions en python.
3.4.2 Opérations :
>�>�> print 7/2, 7./2 # division
3 3.5
Noter que le premier résultat a donné la partie entière de la division (division euclidienne).Avec le point, la deuxième division a été effectuée avec les nombres à virgule.
>�>�> print 3**2 # puissance
9
>�>�> print 4%3, -1%3 # renvoit 4 modulo 3 et -1 modulo 3
1 2
Rappel : n%q est le reste de la division euclidienne de n par q :n : −2 −1 0 1 2 3 4 5
n%3 1 2 0 1 2 0 1 2
Pour calculer une racine carrée :>�>�> from math import * # cela importe le module de math
>�>�> sqrt(2.)
1.4142135623730951
Utiliser “help(math)” pour avoir la liste des fonctions disponibles.Remarque : pour importer un module (tel que math), il y a deux manières de le faire, avec
(a) “import math” ou (b) “from math import *”. Dans le cas (a), les fonctions du modulemath s’utiliseront en les faisant précéder de “math.” (exemple : “math.sin(math.pi/3.0)”).Dans le cas (b), il n’est pas nécessaire d’utiliser le préfixe, i.e. python comprendra directement“sin(pi/3.0)”. A priori, la première notation n’est à utiliser que si il y a un risque de conflit denoms entre fonctions, si par exemple vous souhaitez redéfinir la fonction sin()...
3.4.3 Nombres complexes
Il est possible de manipuler des nombres complexes en Python, le nombre complexe “i” étantnoté j :
>�>�> a=2+1j
7
>�>�> type(a)
<type 'complex'>
>�>�> b=3.5+4j
>�>�> print a+b
(5.5+5j)
>�>�> print a*b
(3+11.5j)
Pour utiliser des fonctions mathématiques sur des complexes, il faudra importer le module cmathen plus du module math (voir la section sur l’utilisation de modules), ou bien le module scipy
qui inclut également les tableaux.
3.4.4 Chaînes de caractères
Outre l’attribution simple (maChaine=�Toto�), il est possible d”’écrire” une chaîne de ca-ractère (de la même manière qu’avec la fonction printf en langage C), c’est à dire en insérantdes codes dans la chaîne (%s pour une chaîne de caractères„ %d pour un entier, %f pour unnombre réel, avec éventuellement le nombre de caractère total et après la virgule : %4.2f veutdire ’nombre réel représenté sur 4 caractères, avec 2 chiffres après la virgule’), suivie de % avecentre parenthèses toutes les variables dont les valeurs sont à insérer :
>�>�> age=5
>�>�> nom="Vincent"
>�>�> taille=1.73
>�>�> maChaine="%s a %d ans et mesure %4.2f m"%(nom,age,taille)
>�>�> print maChaine
Vincent a 5 ans et mesure 1.73 m
Il est possible d’extraire des caractères d’une chaîne :>�>�> print maChaine[2:6] # extrait les caractères 2 (inclu) à 6 (exclu)
ncen
Par contre il n’est pas possible de modifier de cette manière une sous-chaîne de caractère :maChaine[2:6]=�tapl� génère une erreur. Au passage on voit que la numérotation commenceà zéro - le premier caractère est maChaine[0].
Il est possible d’additionner des chaînes de caractères :>�>�> print "Programmation" + " Scientifique"
Programmation Scientifique
On peut obtenir la longueur d’une chaîne de caractère avec la fonction len().>�>�> len("toto")
4
help(str) donne la liste des fonctions utilisables avec des chaînes de caractères.
8
3.4.5 Listes
Un type particulièrement intéressant est la liste :>�>�> x=[1,4,32]
>�>�> print x
[1, 4, 32]
>�>�> print type(x)
<type 'list'>
>�>�> print x[2]
32
Attention ! On voit ici que la numérotation des objets de la liste commence à 0 (i.e. si il y an éléments dans liste , ils sont accessibles par liste[0] ...liste[n-1] ).
Une liste peut contenir des objets de types différents, contrairement à un tableau :>�>�> MaListe=[1,"Obélix",57.0]
>�>�> print MaListe[0]
1
>�>�> print MaListe[1]
Obélix
>�>�> print MaListe[2]
57.0
>�>�> print type(MaListe[0]),type(MaListe[1]),type(MaListe[2])
<type 'int'> <type 'str'> <type 'float'>
Il est possible de modifier une liste existante :(le texte après le signe # est un commentaire)MaListe[1]=42 # le 2ème élément de MaListe vaut maintenant 42
MaListe.append(45) # ajoute l'objet �42� à la fin de la liste
MaListe.insert(i,x) # insère l'élément x à l'indice i dans MaListe
MaListe.reverse() # inverse l'ordre des éléments de la liste
MaListe.sort() # trie les éléments de la liste par ordre croissant
On peut obtenir la longueur d’une liste (le nombre d’objets dans la liste) avec la fonctionlen() : len(MaListe).
Il est possible de concaténer deux listes avec l’opérateur + :>�>�> liste1=[1,"ab",3.5]
>�>�> liste2=["toto",57]
>�>�> print liste1+liste2
[1, 'ab', 3.5, 'toto', 57]
On peut également supprimer un élément d’une liste avec la fonction del() :>�>�> MaListe=[1, 'ab', 3.5, 'toto', 57]
9
>�>�> print MaListe
[1, 'ab', 3.5, 'toto', 57]
>�>�> del(MaListe[1])
>�>�> print MaListe
[1, 3.5, 'toto', 57]
Pour créer des listes de nombres :>�>�> range(2,5) # liste des entiers de 2 (inclu) à 5 (exclu)
[2, 3, 4]
>�>�> range(5) # liste de 0 (inclu) à 5 (exclu)
[0, 1, 2, 3, 4]
Les listes sont des objets particulièrement importants. Nous verrons que les boucles utilisentsouvent une itération sur des éléments d’une liste. La liste complète des fonctions utilisablespour une liste peut être obtenue avec l’aide help(list). Il existe en particulier une fonction detri sort() : essayez-la sur une liste de nombres (entiers et réels mélangés).
3.4.6 Vecteurs de nombres
C’est un type non élémentaire qui utilise des modules scientifiques (qu’il faut importer aupréalable).
>�>�> from pylab import *
>�>�> from numpy import *
>�>�> X=arange(0,6,0.1) # crée un vecteur de nombres xi de 0 à 6 (exclu) par
pas de 0.1>�>�> print X
>�>�> Y=sin(X) # crée un vecteur où chaque élément est yi = sin(xi)>�>�> plot(Y) # dessin des valeurs de Y>�>�> show() # montre le dessin (il faut ensuite fermer la fenetre pour continuer)
Autre possibilitées :>�>�> X=linspace(0,1,10) # 10 nombres de 0 à 1 compris
>�>�> Y=sin(X)
>�>�> plot(Y,marker='o',linestyle=�) # options pour le dessin
>�>�> show()
>�>�> zeros(10) # vecteur de 10 nombres égaux à zéro
3.4.7 Matrices de nombresimporter le m
>�>�> from pylab import *
>�>�> from numpy import *
>�>�> A=zeros([3,3]) # matrice 3×3 remplit de zeros
>�>�> A[1,1]=2 # on modifie un élément
>�>�> print A
>�>�> contourf(A) # dessin des contours des valeurs
>�>�> show()
10
>�>�> B=random.uniform(-1,1,size=(5,5)) # éléments aléatoires dans [−1,1]>�>�> contourf(B)
>�>�> show()
3.4.8 Tuple [Facultatif]
Un tuple est un objet similaire à une liste, la principale différence étant qu’un tuple ne peutpas être modifié comme une liste. C’est une liste d’objets séparés par des virgules ; on peut (maisce n’est pas obligatoire) encadrer ces objets par des parenthèses pour mieux délimiter le tuple :
>�>�> monTuple=('a',"toto",54.2)
>�>�> type(monTuple)
<type 'tuple'>
Il est possible d’extraire un ou plusieurs objets d’un tuple :>�>�> print monTuple[1]
toto
>�>�> print monTuple[1:3]
('toto', 54.200000000000003)
>�>�> a,b,c= monTuple
>�>�> print b
toto
Par contre il n’est pas possible de modifier un objet dans un tuple (monTuple[1]=�tata� estune instruction illégale), ou d’ajouter des éléments dans un tuple.En général on ne crée pas explicitement de variable de type tuple, mais ce sont des variables quiaparaissent de manière temporaire, lorsqu’on veut manipuler ensemble plusieurs objets :
>�>�> a,b=5,3 #création de deux variables en une seule ligne
>�>�> print a,b
5 3
>�>�> a,b=b,a # échange de deux variables
>�>�> print a,b
3 5
3.4.9 Dictionnaires [Facultatif]
Un dictionnaire est également un type de liste d’objet, mais au lieu de repérer les objetspar un indice commençant à 0, les différents objets sont accessible à l’aide d’une clef, qui peutêtre un objet quelconque. (pour les personnes familières avec la librairie standard du C++, c’estl’équivalent de std::map<>).
>�>�> fra_deu={"un":"ein","trois":"drei","deux":"zwei"} # Création
>�>�> fra_deu["trois"] # Accès à un élément du dictionnaire
'drei'
>�>�> fra_deu["quatre"] # Clef n'existant pas !
Traceback (most recent call last):
11
File "<stdin>", line 1, in ?
KeyError: 'quatre'
>�>�> fra_deu["quatre"]="vier" # Ajout de l'entrée manquante
>�>�> fra_deu["quatre"]
'vier'
Vous pouvez obtenir les différentes fonctions disponibles pour un dictionnaire avec la comandehelp(dict).
3.4.10 Conversion de variables entre différents types
On peut convertir une variable d’un type à un autre :>�>�> x=float(1) # nombre réel à partir d'un entier
>�>�> print type(x)
<type 'float'>
>�>�> x=float("1.0") # nombre réel à partir d'une chaîne de caractère
>�>�> print type(x)
<type 'float'>
>�>�> print x
1.0
3.5 Boucles et opérateurs3.5.1 opérateurs ==,and, or , not
L’opérateur == permet de comparer deux objets :>�>�> 1==2 # est-ce que 1 est égal à 2 ?
False
>�>�> 1==1
True
Les autres opérateurs de comparaison sont <, >, <=, >=, != (ce dernier signifie différent).
Notez qu’en python tout nombre non nul est interprété comme True, i.e. if(n), où n est unnombre, sera toujours vrai sauf si n est égal à zéro.
L’opérateur not(x) renvoie la négation (au sens booléen, vrai/faux) d’une expression :>�>�> not(True)
False
>�>�> not(0)
True
and et or permettent de réaliser les opérations logiques usuelles (attention il ne s’agit pas d’opé-rations bit à bit, il ne faut donc utiliser and et or que pour des tests booléens vrai/faux) :
>�>�> 1 and 0
12
0
>�>�> 1 and 1
1
>�>�> 1 or 0
1
3.5.2 L’instruction if...elif..else
Note : “elif” signifie “else if”.On peut éxécuter une instruction conditonnelle avec if :>�>�> x=1
>�>�> if x==2: # est-ce que x est égal à 2 ?
... print "x est égal à 2" # notez les espaces en début de ligne (indentation)
... elif x==3:
... print "x est égal à 3"
... else:
... print "x n'est pas égal à 2"
... print "ni à 3"
...
x n'est pas égal à 2
ni à 3
Les espaces en début de ligne (indentation) jouent un rôle important : tant que l’espace restele même en début de ligne, on reste dans le même “niveau” d’éxécution, de même que dansd’autres langages on utilise des accolades {} pour délimiter les instructions à réaliser. On peutainsi réaliser des instructions imbriquées en augmentant le niveau d’indentation :
>�>�> x=12
>�>�> if (x%2)==0: # est-ce que x modulo 2 est égal à 0 ?
... if (x%3)==0:
... if (x%7)==0:
... print "x est multiple de 2,3 et 7 !"
... else:
... print "x est multiple de 2 et 3, mais pas de 7..."
... else:
... print "x est multiple de 2 mais pas de 3"
...else:
... print "x n'est pas multiple de 2"
...
x est multiple de 2 et 3, mais pas de 7...
13
3.5.3 La boucle while
On peut réaliser une série d’instructions tant qu’une condition est réalisée :>�>�> x=7
>�>�> while x>=1:
... print x,">=1 ! On continue..."
... x = x-1 # on pourrait aussi écrire x -= 1
7 >=1 ! On continue...
6 >=1 ! On continue...
5 >=1 ! On continue...
4 >=1 ! On continue...
3 >=1 ! On continue...
2 >=1 ! On continue...
1 >=1 ! On continue...
3.5.4 Les boucles for
Une boucle for s’écrit de la manière suivante :>�>�> for i in [2,3,7]: # De manière générale : for variable in liste:
... print i
...
2
3
7
Comme il est fastidieux d’écrire un grand nombre de valeurs, on peut utiliser la fonctionrange() qui renvoie une liste d’entiers :
>�>�> range(5) # renvoie une liste de 5 entier en partant de 0
[0, 1, 2, 3, 4]
>�>�> range(2,5) # renvoie une liste d'entiers, de 2 à 5 (exclu)
[2, 3, 4]
>�>�> for i in range(2,5):
... print i
...
2
3
4
Note : la fonction range() crée une liste de nombres qui va servir pour l’itération ; on peuts’en servir pour créer une liste sans que cela soit pour une boucle. Pour une boucle, il vaut en faitmieux utiliser la fonction xrange(), qui ne crée pas une ’vraie’ liste en mémoire mais seulementun itérateur sur une liste d’entiers qui permettra à la boucle de se réaliser.
14
3.5.5 Exercice : la conjecture de Syracuse
(voir Wikipedia)On considère la suite (un)n définit par récurrence de la façon suivante. u0 ≥ 1 est un entier
donné. Si un est pair alors un+1 = un/2, sinon un+1 = 3un+1. La conjecture de Syracuse est quepour tout entier u0 la suite aboutit à . . . ,4,2,1,4,2,1, . . . à partir d’un certain rang.
Ecrire une boucle qui, à partir d’un entier u0, dresse la liste des entiers un suivants jusqu’àce que 1 soit atteint. Afficher la liste obtenue.
3.6 FonctionsIl est possible d’utiliser des fonctions en Python. Nous avons déjà utilisé print() et type().
De manière générale, une fonction s’utilise de la manière suivante : NomDeLaFonction(paramètres)ou (si la fonction renvoie une valeur) : VariableRenvoyée=NomDeLaFonction(paramètres)
Pour définir une nouvelle fonction, il faut utiliser le mot-clef “def” :>�>�> def MaFonction(nom,age):
... print nom,"a",age,"ans" #noter les espaces en début de ligne
...
>�>�> MaFonction("Obélix",5)
Obélix a 5 ans
nom et age sont les paramètres de la fonction ; là encore il n’est pas nécessaire de déclarer letype de ces paramètres. En fait on peut très bien utiliser une chaine de caractère pour age :
>�>�> MaFonction("Obélix","cinq")
Obélix a cinq ans
Par contre si la déclaration de la fonction n’impose pas un contrôle sur les types de para-mètres, il faut néanmoins qu’ils soient compatibles pour l’éxécution. Essayer :
>�>�> def Addition(a,b):
... return a+b # Renvoie une valeur avec �return�
...
>�>�> print Addition(1,2) #deux entiers
3
>�>�> print Addition(1,3.0) #un entier plus un flottant= un flottant
4.0
>�>�> print Addition(1,"toto") # entier+chaîne de caractères = erreur !
Traceback (most recent call last):
File "<stdin>", line 1, in ?
File "<stdin>", line 2, in Addition
TypeError: unsupported operand type(s) for +: 'int' and 'str'
>�>�> print Addition("tata","toto") # deux chaînes de caractères
tatatoto
15
Note : comme pour les boucles c’est l’indentation (le nombre d’espaces en début de ligne)qui définit quelles sont les instructions qui font partie de la fonction. Cela remplace l’utilisationd’accolades {} dans d’autres langages.
Exercice : réutiliser le code écrit pour la suite de Syracuse ci-dessus : Ecrire une fonctionappelée suite qui prend comme argument u0 et renvoit la suite de Syracuse jusqu’à ce que 1soit atteint. Ecrire une autre fonction appelée longueur utilisant la précédente fonction, quirenvoit dans une liste la longueur des suites obtenues pour u0 variant de 1 à 100.
3.7 Portée des objets : variables locales et globalesEn python, les variables sont locales (par défaut), ce qui signifie qu’elles n’existent qu’au
niveau où elles ont été définies. Exemple :>�>�> x=12.3 # Première variable �x�
>�>�> def fonction1():
... x=1 # Deuxième variable �x�
... print x
...
>�>�> def fonction2():
... x="Toto" # Troisième variable �x�
... print x
...
>�>�> print x
12.3
>�>�> fonction1()
1
>�>�> fonction2()
Toto
Dans l’exemple ci-dessus, les 3 variables ont le même nom mais sont complètement indé-pendantes. On dit qu’elles sont locales. Il est à noter qu’un niveau d’indentation ne peut pasmodifier les variables du niveau au-dessus (contrairement à ce qui se passe en C/C++). Essayerpar exemple :
>�>�> compte=0
>�>�> def compteur():
... print compte
... compte+=1
... return compte
...
>�>�> compteur()
0
16
Traceback (most recent call last):
File "<stdin>", line 1, in ?
File "<stdin>", line 2, in compteur
UnboundLocalError: local variable 'compte' referenced before assignment
Par contre, il est parfaitement possible de lire la variable compte, sans la modifier.
Pour pouvoir utiliser une variable à différents endoits (autrement qu’en la passant commeparamètre à une fonction), il faut utiliser le mot-clef global :
>�>�> compte=0
>�>�> def compteur():
... global compte
... compte+=1
... return compte
...
>�>�> compteur()
1
Note : en général, il vaut mieux éviter d’utiliser des variables globales, en passant des va-riables par paramètre aux fonctions.
3.8 ExerciceEcrire une fonction qui prend comme argument deux listes représentant des positions ato-
miques dans l’espace (e.g. [”C1”, 0, 0.5 , 0.7]), et qui renvoie leur distance interatomique avecune ligne du type :
“La distance entre l’atome C1 et l’atome H3 est de 3.5 A”
4 Classes et Objets
4.1 PrésentationHistoriquement se sont succédées plusieurs manières de programmer :Dans l’approche procédurale, un seul programme exécute séquentiellement une suite d’ins-
tructions. Ce fonctionnement convenait bien à des programmes courts, écrits par une seule per-sonne .
Avec des programmes plus longs (et l’intervention de plusieurs personnes, en parallèle ou sesuivant dans le temps), il est devenu nécessaire de séparer les différentes tâches du programmeavec plusieurs fonctions : c’est l’approche structurée.
17
L’approche la plus moderne est la Programmation Orientée Objet (POO) : les données trai-tées dans le programme sont stockée dans des “objets”, qui comprennent à la fois les donnéesainsi que des fonctions qui servent à utiliser l’objet. Par exemple un objet Molécule pourra conte-nir une liste d’atome, leurs positions, mais également des fonctions pour calculer l’énergie, lacharge totale, le moment dipolaire, ... de la molécule. En outre on peut créer des hiérarchiesd’objets, qui “héritent” des propriétés de leur ancêtres, etc...
Attention : bien que la programmation Objet soit la plus moderne des approches, les deuxautres restent parfaitement valables, en particulier pour de petits projets. Rien ne sert de créerdes objets pour des calculs ne prenant que quelques lignes ! ! !
4.2 ExempleConstruisons par exemple une classe d’objets de type “polygone” :>�>�> class Polygone: # Déclaration de la classe
... circ=1.0 # Une variable membre de la classe, pour stocker la
circonférence
... def Circonference(self): # fonction renvoyant la valeur de la circonférence
... return self.circ
...
>�>�> a=Polygone() # Création d'un objet de type Polygone
>�>�> print a.circ # Que vaut sa circonférence (accès direct) ?
1.0
>�>�> print a.Circonference() # Que vaut sa circonférence (par la fonction) ?
1.0
>�>�> a.circ=12.3 # Modification de la circonférence
>�>�> print a.Circonference() # Vérification de la modification
12.3
Dans la déclaration ci-dessus, on voit aparaître le mot-clef “self” : c’est ce qui désigne,dans le corps de la classe, l’objet lui-même. Par exemple, “self.circ” veut dire “la variablecirc dans l’objet Polygone où le code est exécuté” (si on est dans le Polygone “a”, cela seraa.circ).
4.3 Variables membreUne variable stockée dans un objet, comme la variable “circ” ci-dessus. Il peut y en avoir au-
tant que l’on veut. Il est même possible (contrairement au C++) d’ajouter des variables membresaprès avoir déclaré une classe : à la suite du code ci-dessus, essayer :
>�>�> Polygone.surface=45.6 # Ajout de la variable membre 'surface'
>�>�> b=Polygone()
>�>�> print b.circ,b.surface,a.circ,a.surface
1.0 45.6 12.3 45.6
18
La variable membre est accessible dans tous les objets Polygone, même “a” qui a été crééavant.
4.4 Fonctions membresUne fonction membre est une fonction qui est définie dans la déclaration de la classe, et a
accès aux attributs de la classe, comme la fonction Circonférence(self) définie dans l’objetPolygone. Elle prend au moins un argument, “self”, qui désigne l’objet lui-même (c’est l’équi-valent du pointeur this en C++) et permet à la fonction d’accéder aux attributs. Là encore, onpeut utiliser autant de fonctions membre que nécessaire.
Dans une fonction membre, il est très important de distinguer les variables membre(celles précédées de “self.”) des variables locales. Les variables membres sont les seulesqui ne sont pas détruites à la fin de l’éxécution d’une fonction membre et qui permettentde ’stocker’ des informations dans l’objet, et donc de les passer de fonction en fonction.
>�>�> class Objet:
... var1=1.0 # variable membre déclarée à la base de la classe
... def __init__(self): # Constructeur
... varlocale=1.0 # Variable locale
... self.var1=2.4 # Changement de la valeur de la variable membre self.var1
... self.var2="toto" # Ajout d'une seconde variable membre self.var2
... def Fonction1(self):
... print self.var1,self.var2
... varlocale="tata" # Cette variable est locale
...
>�>�> a=Objet()
>�>�> a.var1
2.3999999999999999
>�>�> a.var2
'toto'
>�>�> a.Fonction1()
2.4 toto
>�>�> a.varlocale # erreur car varlocale n'est pas une variable membre
Traceback (most recent call last):
File "<stdin>", line 1, in ?
AttributeError: Objet instance has no attribute 'varlocale'
Pour chaque objet, il faut avoir le réflexe “self .nomVariable”, de manière à systématique-ment distinguer les variables membre des variables locales.
19
4.5 Fonctions membres spéciales [Facultatif]Certaines fonctions membre sont prédéfinies dans python car elles permettent d’effectuer des
opérations prédéfinies. Le nom de ces fonctions commence et finit par deux traits soulignés.
4.5.1 Constructeur __init__
Un constructeur est une fonction membre d’un type spécial, qui sert à initialiser un nouvelobjet, en général en utilisant des arguments :
>�>�> class Polygone:
... circ=1.0
... def __init__(self,circ0): # Prend comme argument la circonférence
initiale
... self.circ=circ0 # Initialise la circonférence
.. def Circonference(self):
... return self.circ
...
>�>�> a=Polygone(10.5) # Crée un polygone de circonférence 10.5
>�>�> print a.Circonference()
10.5
4.5.2 Destructeur __del__
Le destructeur est la fonction qui est appelée lors de la destruction de l’objet. Il ne prendqu’un argument (self). Il peut servir à ’nettoyer’ des données créées par l’objet.
4.5.3 Opérateurs __add__, __sub__, __mul__, __div__, __pow__
Ce sont les opérateurs (+, -, *, /, **) qui permettent des opérations arithmétiques. Ils prennentdeux arguments, self et un argument désignat le second membre de l’opération :
>�>�> class Polygone:
... circ=1.0
... def __add__(self,poly): # addition
... somme=Polygone() # objet à renvoyer
... somme.circ=self.circ+poly.circ
... return somme
...
>�>�> a=Polygone()
>�>�> b=Polygone()
>�>�> b.circ=3.5
>�>�> print (a+b).circ # Circonférence de la somme de a et b
4.5
Redéfinir ces opérateurs standard peut être intéressant.
20
4.6 Héritage [Facultatif]L’héritage permet de créer des classes qui héritent tout ou partie des propriétés de la ou les
classes parentes. On peut ainsi dériver une classe rectangle de la classe Polygone :>�>�> class Polygone:
... def __init__(self,circ0=2.1): # On utilise ici un argument par défaut
... self.circ=circ0
... def Circonference(self):
... return self.circ
...
>�>�> class Rectangle(Polygone): # Hérite de la classe Polygone
... def __init__(self,x0=2.5,y0=3.5):
... self.x=x0
... self.y=y0
... self.circ=2.0*(x0+y0)
...
>�>�> a=Rectangle(3.0,4.0)
>�>�> print a.Circonference() # La fonction est héritée de Polygone
14.0
Il est possible de dériver une autre classe, et également de remplacer la fonction Circonfe-rence() de la classe de base par une nouvelle fonction :
>�>�> class Carre(Rectangle): # Hérite de la classe Rectangle
... def __init__(self,x0):
... self.x=x0
... def Circonference(self): # On réécrit la fonction Circonference()
... return 4*self.x
...
>�>�> a=Carre(4.0) # Carré de coté 4.0
>�>�> print a.Circonference()
16.0
L’héritage peut être très utile lorsque l’on génère de multiples classes ayant des propriétéssimilaires. Par contre il ne faut pas en abuser, cela peut amener à une programmation inutilementcomplexe ! Ce n’est en général utile que pour des projets de taille suffisament grande (> 1000lignes), mais cela peut être aussi utile pour ré-utiliser du code (provenant par exemple d’unelibrairie développée par quelqu’un d’autre), en ajoutant quelques fonctions à une classe pré-existante.
4.7 Attention : opérateur “==”, différence entre égalité et identité, copie etréférence... [Facultatif]
Utilisons les classes définies précédemment, et essayons de comparer des objets :
21
>�>�> a=Carre(4.0)
>�>�> b=Carre(4.0)
>�>�> c=a
>�>�> print a==b, a==c, b==c
False True False
Que s’est-il passé ? Clairement les trois carrés sont égaux et on s’attendrait à lire True True
True comme réponse... En fait l’opérateur == n’a pas comparé les valeurs (est-ce que les carréssont égaux), mais les adresses, pour tester l’identité des carrés. Ce qui se comprend mieux si onteste le code suivant :
>�>�> print a.x,c.x
4.0 4.0
>�>�> c.x=5.7
>�>�> print a.x,c.x
5.7 5.7
Ce qui se passe donc lorsqu’on écrit “c=a” n’est pas la création d’un nouveau carré distinctde a, mais un carré dont l’attribut “x” pointe vers la même case mémoire que celle de a... Ce quifait que c et a représentent rigoureusement le même objet.
L’idée derrière ce comportement qui peut souvent induire en erreur est de minimiser l’espacemémoire en faisant par défaut un passage par référence (i.e. en pointant la nouvelle variable versla même case que la variable originelle) plutôt qu’une copie.
Afin d’éviter cela, il est possible d’effectuer une véritable copie avec la fonction copy.copy()
ou copy.deepcopy() :>�>�> import copy
>�>�> a=Carre(4.0)
>�>�> b=Carre(4.0)
>�>�> c=copy.copy(a) # en fait il vaut mieux utiliser c=copy.deepcopy(a)
>�>�> print a==b, a==c, b==c
False False False
4.8 ExerciceCréer une classe Atome qui a 4 attributs : le nom, et les 3 coordonnées x,y,z, avec des fonc-
tions permettant de créer la classe, et d’accéder aux 4 attributs (Nom(), X(), Y() Z()).Créer une fonction calculant la distance entre deux atomes.Ensuite créer une classe Molécule, qui a comme attribut une liste d’atomes, et qui a des
fonctions membre permettant de :— Ajouter un atome— Accéder à un des atomes— Afficher la liste de toutes les distances interatomiques dans la molécule.
22
5 Lecture et écriture de fichiersOn crée un objet fichier Python avec la fonction open() :>�>�> MonFichier = open(�NomDuFichier�,'r')
Le mode peut être ’r’ (read, en lecture seule), ’w’ (en écriture seule), ’a’ pour rajouter à la findu fichier, ... D’autres modes (mixte lexture/écriture, etc...) existent.
La lecture des fichiers texte (i.e. non binaires) se fait avec les fonctions read(), readline() etreadlines() :
>�>�> MonFichier.read() # Lit la totalité du fichier sous forme d'un chaîne
de caractères
>�>�> MonFichier.readline() # Lit la ligne suivante du fichier, sous forme
d'une chaîne de caractères
>�>�> MonFichier.readlines() # Lit toutes les lignes du fichier sous forme
d'une liste de chaînes de caractères
>�>�> Monfichier.write('toto') # écrit
Pour lire une liste de nombres contenu dans une ligne, il suffit de lire cette ligne avec lafonction readline(), puis de séparer les nombres avec la fonction split(). Par exemple :
>�>�> f=open("tmp0",'r')
>�>�> ligne=f.readline() # lecture d'une ligne
>�>�> print ligne # Ecriture de la ligne sous forme d'une chaîne de caractères
Toto 1.8 9.2
>�>�> print ligne.split() # On sépare les éléments -> liste
['Toto', '0.2', '9.2']
>�>�> print float(ligne.split()[1]) # Conversion en nombre réel 0.2
>�>�> f.close() # referme le fichier
help(file) permet de lister l’aide sur l’utilisation des fichiers.
Ecriture/Lecture de données formatées : On utilise le module pickle. Cela permet d’écriredes données et lire des données en conservant leur type (nombre, liste, chaine de caractère etc...).
Pour écrire :>�>�> import pickle
>�>�> x=2
>�>�> f=open("fichier",'w')
>�>�> pickle.dump(x,f) #écrit x
>�>�> f.close()
Pour relire :>�>�> f=open("fichier",'r')
>�>�> x=pickle.load(f) #lit x
>�>�> f.close()
>�>�> print x
23
2
5.1 ExerciceCréez un fichier avec une liste d’atomes (un nom et 3 coordonnées par ligne). Rajoutez une
fonction LireFichier(self, NomFichier) dans votre classe Molecule, qui lit la liste des atomes. Etensuite listez toutes les distances interatomiques...
Ensuite, ajouter une fonction qui peut écrire dans un fichier la liste des atomes... et vérifiezque vous arrivez à la relire ensuite !
Deuxième partie
Modules scientifiques6 Utilisation de “modules” (standards et librairies extérieures)
Pour importer un module, il faut utiliser la commande “import NomDuModule ”. Il est alorspossible d’obtenir une aide sur le module avec la commande “help(NomDuModule )”. Les fonc-tions s’utilisent sous la forme “NomDuModule .NomDeLaFonction (paramètres )”.
Il est également possible d’importer le contenu du module sous la forme “from NomDuModule
import *” et alors les fonctions peuvent être utilisées directement par “NomDeLaFonction(paramètres)”.
6.1 mathCe module standard comporte toutes les fonctions mathématiques usuelles :>�>�> import math
>�>�> print math.sin(math.pi/4)
0.707106781187
>�>�> print math.log(10.0)
2.30258509299
ou :>�>�> from math import *
>�>�> print sin(pi/4)
0.707106781187
>�>�> print log(10.0)
2.30258509299
Pour utiliser des fonctions mathématiques sur des complexes, il faudra importer le modulecmath en plus du module math. Néanmoins en général il est plus simple d’utiliser directement
24
scipy, qui inclut toutes les fonctions de math et cmath, et permet également de les utiliser sur destableaux.
6.2 Scipy (scientific python, http ://www.scipy.org)Ce module ne fait pas partie par défaut de Python mais est en général présent, ou peut être
obtenu à partir de l’adresse http ://www.scipy.org.Ce module permet en particulier d’effectuer des calculs sur des tableaux :>�>�> from scipy import *
>�>�> a=zeros([2,5],floating) # un tableau de 2 lignes et 5 colonnes
>�>�> print a # rempli de 0.0 (nombres réels)
[[ 0. 0. 0. 0. 0.]
[ 0. 0. 0. 0. 0.]]
>�>�> a[1,3]=4.0 # Modification d'un élément
>�>�> print a
[[ 0. 0. 0. 0. 0.]
[ 0. 0. 0. 4. 0.]]
>�>�> a[0,:]=1.0 # Modification de la première ligne
>�>�> print a
[[ 1. 1. 1. 1. 1.]
[ 0. 0. 0. 4. 0.]]
>�>�> print a[:,3] # Affichage de la quatrième colonne
[ 1. 4.]
>�>�> sin(a)
array([[ 0.84147098, 0.84147098, 0.84147098, 0.84147098, 0.84147098],
[ 0. , 0. , 0. , -0.7568025 , 0. ]])
Attention sur la dernière ligne on utilise une fonction sin(), qui provient du module scipy.Si les deux modules (math et scipy) étaient importés avec “from NomDuModule import *”,il y aurait une ambiguité sur quelle fonction sin() à utiliser... En fait la dernière fonction sin()
importée écraserait la précédente...Dans ces cas là, n’utiliser que “import NomDuModule” et ensuite math.sin() et scipy.sin()
suivant la fonction désirée. On peut même n’importer qu’une fonction d’un module, par exempleavec “from math import sin”.Lire l’aide de scipy pour voir les différentes fonctions disponibles. En particulier, on peut créerdes tableaux avec les fonctions ones, zeros , et en utilisant comme type : complex64, com-plex128, float32, float64, int16, int32, int64, suivant le type de donnée et la précision souhaitée.
6.2.1 Exemples
Commencer par le didacticiel de scipy, consacré aux manipulations algébriques de matrics,qui se trouve à :
25
http://www.scipy.org/SciPy_Tutorial
Essayer “Example 1”, “Example 2” et “Numerical integration”.
Regarder des petits exercices dans le cookbook de scipy : http://www.scipy.org/CookbookEn particulier “linear regression”, “optimization”, “smoothing a signal”Des petits exemples d’utilisation de fonctions scipy peuvent être trouvé à :http://www.scipy.org/Numpy_Example_List
6.2.2 Sous-modules de scipy
Scipy est un ensemble qui comprend de nombreux modules utiles pour des scientifiques :* cluster : information theory functions (currently, vq and kmeans)* weave : compilation of numeric expressions to C++ for fast execution* fftpack : fast Fourier transform module based on fftpack and fftw when available* ga : genetic algorithms* io : reading and writing numeric arrays, MATLAB .mat, and Matrix Market .mtx files* integrate : numeric integration for bounded and unbounded ranges. ODE solvers.* interpolate : interpolation of values from a sample data set.* optimize : constrained and unconstrained optimization methods and root-finding algorithms* signal : signal processing (1-D and 2-D filtering, filter design, LTI systems, etc.)* special : special function types (bessel, gamma, airy, etc.)* stats : statistical functions (stdev, var, mean, etc.)* linalg : linear algebra and BLAS routines based on the ATLAS implementation of LAPACK* sparse : Some sparse matrix support. LU factorization and solving Sparse linear systems.
Là encore, de la documentation est disponible (après import du module) avec la commande“help(NomDuModule)” Par exemple le module FFTPACK :
>�>�> import scipy
>�>�> from scipy import fftpack
>�>�> a=scipy.array(range(20),scipy.floating)
>�>�> print a
[ 0. 1. 2. 3. 4. 5. 6. 7. 8. 9. 10. 11. 12. 13. 14.
15. 16. 17. 18. 19.]
>�>�> print scipy.fftpack.fft(a)
[ 190. +0.j -10.+63.13751515j -10.+30.77683537j
-10.+19.62610506j -10.+13.7638192j -10.+10.j
-10. +7.26542528j -10. +5.09525449j -10. +3.24919696j
-10. +1.5838444j -10. +0.j -10. -1.5838444j
-10. -3.24919696j -10. -5.09525449j -10. -7.26542528j
-10.-10.j -10.-13.7638192j -10.-19.62610506j
26
-10.-30.77683537j -10.-63.13751515j]
6.2.3 Extensions ou applications de scipy
Se référer à : http ://www.scipy.org/Topical_Software
6.3 Tracé de données scientifiques (1D, 2D) avec matplotlib/pylabLe tracé de toutes les courbes “scientifiques” se fait à l’aide de matplotlib, qui est une li-
brairie dont les commandes sont similaires à matlab. Pour l’utiliser, il faut importer le module“pylab” (rcommandé) ou matplotlib. Si on utilise ipython, le plus simple est de démarrer ipythonavec l’option -pylab, i.e. : “ipython -pylab” 1. Cela importe tout le module et permet de tra-vailler en mode “interactif”, ç’est-à-dire que la figure s’affiche au fur et à mesure qu’on tape lesinstructions de tracé (plutôt que de ne voir la figure qu’à la fin).
La référence complète de matplotlib est lisible à l’adresse :http ://matplotlib.sourceforge.net/matplotlib.pylab.htmlRegarder la section Il est en particulier recommandé de regarder les “screenshots”, qui sont
donnés avec le code utilisé pour les générer.
6.3.1 Courbe 1D
Pour tracer une sinusoïde :x=linspace(-5,5,101) # coordonnées de -5 à 5 avec 101 valeurs
y=sin(x)
plot(x,y) # Tracé de la courbe !
On obtient une courbe sur laquelle on peut zoomer, modifier les marges, et sauvegarder dansdifférents formats (jpg, png, eps...)
On peut rajouter un titre, une légende, du texte avec les fonctions title(), legend() ettext(). Voir les documentations de ces fonctions soit sur le site web de matplotlib, soit enutilisant “?” après le nom de la fonction dans ipython.
Pour tracer plusieurs courbes, on peut les mettre les unes à la suite des autres, par exemple :plot(x,y,"r-",x,cos(x),"g.")
“r-” indique que la première courbe est à tracer en rouge avec des traits, et “g.” que ladeuxième est à tracer en vers avec des points. Voir l’aide de plot() pour connaître les autresoptions de ce tracé.
1. Pour les utilisateurs de windows, il faut soit modifier le raccourci permettant de lancer ipython (en ajoutant“-pylab” à sa suite), soit copier ce raccourci dans une console, toujours pour ajouter l’option “ -pylab” à la fin.
27
6.3.2 Courbe 2D
Pour cela on utilise imshow(z) ou pcolor(x,y,z).x=linspace(-5,5,201)
y=linspace(-7,7,201)[:,newaxis] # newaxis indique que ce vecteur est selon
la 2ème dimension
z=sin(x**2+y**2)
imshow(z) # Affiche l'image en 2D
imshow(z,extent=(x.min(),x.max(),y.min(),y.max())) # On précise les coordonnées
des axes
jet() # Pour avoir une plus jolie table de couleurs
L’inconvénient de imshow est que cette fonction suppose que le tableau 2D affiché (z) cor-respond à des coordonnées régulières en x et y, ce qui n’est pas forcément le cas. Pour cela onutilise pcolor, mais x,y,z doivent alors tous être des tableaux 2D ! Par exemple :
x=linspace(-5,5,201)
y=linspace(-7,7,201)[:,newaxis]
x=x+y*0.4 # transforme x en tableau 2D
y=y+x*0
z=sin(x**2+y**2)
#imshow(z,extent=(x.min(),x.max(),y.min(),y.max())) # Représentation non
correcte, inclinée
clf() # Efface la figure avant un nouveau tracé (si on affiche plusieurs
figures à la suite)
pcolor(x,y,z,shading='flat') # effectue le tracé
6.4 Autres modules scientifiquesPyMol et cctbx : pour la cristallographie (en particulier des protéines)PyQuante : Chimie QuantiqueSnack : pour le traitement du signalpyVTK et Mayavi, OpenDX : pour la représentation graphique en 3D
etc... Une majeure partie des librairies de calcul développées en fortran ou en C/C++ sontainsi disponibles en Python (voir plus bas comment créer une interface avec python grâce àBoost.Python ou SWIG)
Une liste (très incomplète) de modules disponibles pour Python est disponible sur le site webconsacré au language (http ://www.python.org/pypi ; http ://www.python.org/moin/NumericAndScientific).De nombreux modules peuvent également se trouver à partir du site Sourceforge (en cherchantdans les projets utilisant python comme langage : http ://sourceforge.net/softwaremap/trove_list.php ?form_cat=178).
Mais le meilleur moyen de savoir si un outil particulier a été développé en Python est encored’utiliser Google !
28
De nombreux laboratoires utilisent et développent des outils à base de Python pour le cal-cul scientifique, à Grenoble (ILL, ESRF, CEA, CNRS) et ailleurs (en particulier le LaboratoireLawrence Livermore LLNL, le CERN).
7 Performance et interface C/C++ <-> Python [Facultatif]
7.1 Performance : C/C++ vs PythonEtant un langage interprété, Python présente des perfomances en terme de calcul assez mé-
diocres si on ne prend pas garde à la méthode utilisée. Par exemple pour une simple opérationd’addition de 2 tableaux de 100 000 éléments, on peut calculer le nombre d’opérations par se-conde :
# -*- coding: iso-8859-15 -*-
import scipy
import time # Module de fonction sur le temps (date, heure)
taille=100000
# 1ère version avec une boucle en Pythonnbiter=10
a=range(taille) # Avec une boucle
b=range(taille)
c=range(taille)
t1=time.time() # time.time() renvoie le nombre de secondes écoulées
for i in xrange(nbiter):
for i in xrange(taille):
c[i]=a[i]+b[i]
t2=time.time()
print "Boucle : %6.3f Mflops"%( (taille*nbiter)/(t2-t1)/1e6)
# 2ème version vectorisée à l’aide d’un tableaunbiter=1000
a=scipy.ones(taille) # Avec des tableaux
b=scipy.ones(taille)
c=scipy.ones(taille)
t1=time.time()
for i in xrange(nbiter):
c=a+b
t2=time.time()
print "Tableau : %6.3f Mflops"%( (taille*nbiter)/(t2-t1)/1e6)
29
La différence de temps d’éxécution est très nette, plus qu’un facteur 50 ! Si on compare avecun programme en c++ (compiler en utilisant “g++ vite.cpp -o vite” et éxécuter le programmevite avec “./vite”) :
# 3ème version en c++#include <stdlib.h>
#include <time.h>
#include <iostream>
using namespace std;
int main()
{
const unsigned long taille=100000;
const unsigned long nbiter=1000;
long *a=new long[taille];
long *b=new long[taille];
long *c=new long[taille];
clock_t time0=clock();
for(unsigned long i=0;i<nbiter;i++)
{
long *pa=a;
long *pb=b;
long *pc=c;
for(unsigned long j=0;j<taille;j++)
*pc++ = *pa++ + *pb++;
}
clock_t time1=clock();
const float seconds=(float)(time1-time0)/(float)CLOCKS_PER_SEC;
cout <�<"C++ : "<�< (float)taille * (float)nbiter/ seconds /1e6<�<endl;
delete[]a;
delete[]b;
delete[]c;
}
La différence reste importante avec Python (facteur 2 par rapport au calcul vectorisé), maissans être trop gênante pour des calculs pas trop longs (<1h). Ce d’autant que la version en c++est deux fois plus longue, et utilise des pointeurs qui sont une source fréquente d’erreurs deprogrammation.
7.1.1 Utilisation de scipy.weave
Pour une petite partie de calcul qui doit être exécutée très rapidement, il est possible d’insérerdu code C++ à l’intérieur d’un programme Python - cette partie du code est alors compilée auto-matiquement, est peut accélérer considérablement certaines opérations. Pour cela il faut importer
30
scipy et le sous-module scipy.weave - pour insérer du code de type C++ il faut alors utiliserla fonction scipy.weave.inline. L’exemple ci-dessus devient alors :
# -*- coding: iso-8859-15 -*-
import scipy
from scipy import weave
import scipy
nbiter=1000
a=scipy.ones(taille)
b=scipy.ones(taille)
c=scipy.ones(taille)
def testweave():
code="""
for(unsigned int ct=0;ct<nbiter;++ct)
{
const double *pa=a.data();
const double *pb=b.data();
double *pc=c.data();
for(unsigned int i=0;i<taille;++i) *pc++ = *pa++ + *pb++;
}
"""
err = weave.inline(code,['a', 'b', 'c', 'taille', 'nbiter'],
type_converters=weave.converters.blitz,
compiler = 'gcc')
testweave() # Le premier appel est long, car le code est alors compilé !
nbiter=1000
t1=time.time()
testweave() # On recommence, en utilisant les code pré-compilé
t2=time.time()
print "SciPy.weave : %6.3f Mflops"%( (taille*nbiter)/(t2-t1)/1e6)
7.2 Interface C/C++ <-> Python avec SWIGLorsque des calculs longs (soit intrinsèquement, soit parce qu’il sont répétés) sont néces-
saires, il vaut mieux sous-traiter les calculs à un langage plus performant (en pratique C++ oufortran), tout en organisant le programme (entrées/sorties, représentation des données, interfaceutilisateur etc...) en Python.
Lorsqu’aucune librairie proposant ce calcul n’est disponible sous Python (cela devient deplus en plus rare ! Un outil essentiel du programmateur scientifique est aujourd’hui Google !), ilpeut être nécessaire de créer cette interface (et éventuellement le programme en C+C++/fortran).Il existe pour cela des programmes spécialisés, les plus utiles aujourd’hui étant Boost.Python(http ://www.boost.org/libs/python/doc/index.html) et SWIG (http ://www.swig.org/ ). Nous al-lons présenter (très) rapidement ce dernier.
31
Séparer le petit programme en C++ ci-dessus en 2 fichiers :— le fichier d’en-tête test1.h qui ne comprend qu’une seule ligne de déclaration “void
FonctionTest(long taille,long nbiter);”— le ficher de code test1.cpp qui contient le même code que la fonction ci-dessus, en rem-
plaçant la fonction main() par une fonction FonctionTest() prenant comme argumentle nombre d’éléments et le nombre d’itérations à effectuer.
Ensuite créer un fichier d’interface “test1.i” qui définira les éléments à partager entre SWIGet Python :
%module test1
%{
#include "test1.h"
%}
extern void FonctionTest(long,long);
Enfin, compiler et créer l’inteface avec SWIG avec :swig -python -module test1.i # crée test1_wrap.c
g++ -c test1_wrap.cxx test1.cpp -I /usr/include/python2.3/
g++ -shared test1_wrap.o test1.o -o _test1.so # crée _test1.so
Ensuite il n’y a plus qu’à tester dans l’interpréteur Python :>�>�> import test1
>�>�> help(test1)
>�>�> test1.FonctionTest(100000,100)
C++ : 4.54545e+07
Bien sûr ce travail d’interface peut être complexe, donc le réserver aux calculs réellements in-tenses. Rien ne sert de passer plus de temps à écrire un programme que vous n’en passerez àl’utiliser !
8 Fenêtres et graphiques avec wxPythonwxPython (http ://wxpython.org) est une librairie graphique très générale, multi-plateforme.
Elle est écrite en c++ (wxWidgets, anciennement appelée wxWindows -http ://wxwidgets.org), et permet de créer des fenêtre avec des graphiques 2D, 3D, des bou-
tons/contrôles, la communication avec d’autres ordinateurs (sockets), les exécutions en parallèle(threads), etc... Elle est donc assez complexe, nous n’en présenterons ici qu’une très petite par-tie !
De manière générale lorsqu’on crée une application avec des calculs et un affichage gra-phique, il faut savoir que plusieurs “fils” (threads) doivent s’éxécuter en parallèle : l’un pour gérerle graphisme (retracer une fenêtre si elle a été effacée par une autre passant devant, par exemple),l’autre pour les calcul (ou pour lire les commandes tapées sur la console). Pour travailler dans cemode multi-fil (multi-thread), il faut lancer ipython avec l’option wthread “ipython -wthread”.
32
8.1 Animation : corde pendanteVoici un petit exemple d’animation - on crée une fenêtre, qui possède une fonction “OnPaint”
dans laquelle est défini tout ce qui doit être dessiné. Un objet wxTimer est utiliser pour demanderrégulièrement à la fenêtre d’être redessinée.
import wx
from wxPython.wx import *
import time
from math import cos
TIMER_ID = wxNewId()
class Fenetre(wxPanel):
def __init__(self, parent):
wxPanel.__init__(self, parent, -1)
wx.EVT_PAINT(self, self.OnPaint)
self.t0=time.time()
wx.EVT_TIMER(self, TIMER_ID, self.OnPaint)
def OnPaint(self, event=None):
dc = wxPaintDC(self)
dc.Clear()
dc.SetPen(wx.Pen("BLACK", 4))
angle=0.2*cos(time.time()-self.t0)
dc.DrawLine(50, 0, 50+100*sin(angle), 100*cos(angle))
app=wxPySimpleApp()
cadre = wxFrame(None, -1, "Mon cadre !")
fenetre=Fenetre(cadre)
cadre.Show(True)
t = wxTimer(fenetre, TIMER_ID)
t.Start(200)
#app.MainLoop() #Pour laisser la main à l'application plutôt qu'à la ligne
de commande
En commentant la dernière ligne app.MainLoop(), on peut continuer à utiliser la ligne decommande pour taper des instructions. Essayez par exemple “fenetre.t0+=1” pour voir lependule faire un bon dans le temps.
Pour réaliser d’autres graphiques qu’un seimple pendule, il faut utiliser d’autres fonctions dewxPaintDC - regarder pour cela la référence de wxDC à :
http ://wxwidgets.org/manuals/2.6/wx_classref.htmlEn particulier DrawCircle, DrawArc, DrawText,...
33
8.2 Animation et calculSi on souhaite en même temps effectuer des calculs et avoir un affichage graphique, cela se
complique car un seul fil du programme peut s’éxécuter à la fois. Par exemple si on sépare lecalcul et l’affichage du pendule :
Ajouter à la fin du programme précédent une boucle de calcul (ou la taper à la console) :for i in xrange(10):
print i
time.sleep(1) # Attend 1 seconde
Le pendule cesse de s’afficher ! Parce que tant que la boucle ci-dessus n’est pas terminée, ellemonopolise l’ordinateur... Dès que la boucle est finie, l’affichage reprend.
Pour permettre au graphique de se tracer, il suffit de temps à autres de premettre au “filgraphique” de travailler lui aussi. Il suffit pour cela d’insérer l’instruction wxYield() au milieude la boucle de calcul :
for i in xrange(10):
time.sleep(1) # Attend 1 seconde
wxYield()
Par contre cette méthode ne marche pas toujours, car lorsque wxYield est appelé rien negaranti que le temps laissé serve au fil d’éxécution graphique... Plutôt que d’utiliser un wxTimerqui demande périodiquement un rafraichissement de l’affichage, il vaut mieux commander cetaffichage de la boucle de calcul avec wxPostEvent() suivi de wxYield() :
import wx
from wxPython.wx import *
import time
from math import cos,sin
class Fenetre(wxPanel):
def __init__(self, parent):
wxPanel.__init__(self, parent, -1)
wx.EVT_PAINT(self, self.OnPaint)
self.t0=time.time()
def OnPaint(self, event=None):
dc = wxPaintDC(self)
dc.Clear()
dc.SetPen(wx.Pen("BLACK", 4))
angle=0.2*cos(time.time()-self.t0)
x,y=50+100*sin(angle),100*cos(angle)
dc.DrawLine(50, 0, x, y)
dc.DrawCircle(x, y,20)
app=wxPySimpleApp()
cadre = wxFrame(None, -1, "Mon cadre !")
34
fenetre=Fenetre(cadre)
cadre.Show(True)
#Boucle de "calcul"
for i in xrange(100):
print i
time.sleep(0.05) #Mettre ici le calcul
wxPostEvent(fenetre,wxPaintEvent()) # Demande un nouvel affichage
wxYield() # Laisse du temps à l'affichage
35