Notes de cours Python scientifique

Premiers pas avec Python pour la science 1 : Le calcul scientifique avec des outils et des flux de travail

La rédaction Developpez.com a le plaisir de vous présenter les notes de cours sur la programmation scientifique en Python. Un cours traduit par l'équipe Python.

Les commentaires et les suggestions d'amélioration sont les bienvenus, alors, après votre lecture, n'hésitez pas. 1 commentaire Donner une note à l'article (5)

Article lu   fois.

Les cinq auteurs et traducteur

Voir la liste des auteurs

Liens sociaux

Viadeo Twitter Facebook Share on Google+   

I. Calcul scientifique avec outils et gestion de flux

I-A. Pourquoi Python ?

I-A-1. Les besoins du scientifique

  • Obtenir des données (simulation, vérification expérimentale).
  • Manipuler et traiter les données.
  • Visualiser les résultats… pour comprendre ce que l'on fait !
  • Communiquer les résultats : produire des graphiques pour les rapports ou les publications, écrire des présentations.

I-A-2. Spécifications

  • Une collection fournie de briques préexistantes, correspondant aux méthodes numériques classiques ou aux actions basiques : nous ne voulons pas reprogrammer le traçage d'une courbe, une transformée de Fourier ou un algorithme d'ajustement. Ne réinventons pas la roue !
  • Facilité d'apprentissage : l'informatique n'est ni notre métier ni notre formation. Nous voulons juste pouvoir tracer une courbe, lisser un signal ou encore réaliser une transformée de Fourier en quelques minutes.
  • Facilité de communication avec les collaborateurs, les étudiants et les clients, pour que le code puisse vivre au sein d'un laboratoire ou d'une entreprise : le code devrait être aussi facile à lire qu'un simple livre. Pour ce faire, le langage utilisé devrait contenir le moins d'éléments de syntaxe ou d'implémentation possibles, de sorte que le lecteur ne s'écarte pas de l'essentiel, du contenu mathématique ou scientifique implémenté dans le code.
  • Un code efficace, qui s'exécute rapidement… mais inutile de préciser qu'un code très rapide devient inutile si l'on passe trop de temps à l'écrire. Donc, nous aurions besoin aussi bien de rapidité de codage que de rapidité d'exécution du code.
  • Un seul environnement/langage pour tout faire, si possible, afin d'éviter l'apprentissage d'un nouveau logiciel à chaque nouveau problème rencontré.

I-A-3. Solutions existantes

Quelles sont les solutions utilisées par les scientifiques ?

Langages compilés : C, C++, Fortran, etc.

  • Avantages :

    • très rapide, compilateurs très optimisés ; pour les calculs massifs, il est difficile de surpasser ces langages ;
    • quelques bibliothèques très optimisées ont été écrites pour ces langages, par exemple : BLAS (opérations sur tableaux et matrices).
  • Inconvénients :

    • mise en œuvre difficile : pas d'interactivité durant la phase de développement, des étapes de compilation obligatoires et contraignantes, une syntaxe souvent fournie (&, ::, }}, ; etc.), une gestion manuelle de la mémoire (particulièrement épineuse en C). Ce sont des langages difficiles à apprendre pour les scientifiques non-informaticiens.

Langages de script : Matlab™

  • Avantages :

    • une collection très riche de bibliothèques avec de nombreux algorithmes pour toute sorte de domaines et une exécution rapide du code, du fait que la plupart de ces bibliothèques sont écrites en langage compilé ;
    • un environnement de développement plaisant : une aide facile à comprendre et bien organisée, un éditeur de texte intégré, etc.
    • le support commercial est disponible.
  • Inconvénients :

    • le langage de base est pauvre et peut rapidement devenir insuffisant pour les utilisateurs avancés ;
    • pas gratuit.

Autres langages de script : Scilab, Octave, Igor, R, IDL, etc.

  • Avantages :

    • licences ouvertes, gratuites ou moins chères que Matlab™ ;
    • certaines fonctionnalités peuvent être très sophistiquées (statistiques en langage R, graphiques avec IGOR Pro™, etc.).
  • Inconvénients :

    • moins d'algorithmes disponibles par rapport à Matlab™ et le langage n'est généralement pas plus riche (que Matlab™) ;
    • certains logiciels sont spécifiquement dédiés à un seul domaine, par exemple : Gnuplot ou xmgrace pour tracer des courbes ; ces programmes sont très puissants, mais ils sont aussi complètement restreints à un seul type d'usage, par exemple, uniquement le tracé de courbes.

Qu'en est-il de Python ?

  • Avantages :

    • de très nombreuses bibliothèques à vocation scientifique (un peu moins que Matlab™, toutefois) ;
    • un langage particulièrement bien pensé, qui permet d'écrire un code très lisible et très structuré : on « code comme on pense » ;
    • beaucoup de bibliothèques annexes au calcul scientifique (gestion de serveur web, accès aux ports séries, etc.) ;
    • logiciels gratuits et open source, largement diffusés et adossés à une communauté active.
  • Inconvénients :

    • un environnement de développement moins plaisant que – par exemple – Matlab™ (plus orienté geek ou développeur) ;
    • ne dispose pas d'autant d'algorithmes que certains autres logiciels spécialisés pourraient fournir.

I-B. Briques scientifiques Python

Contrairement à Matlab™, Scilab™ ou R, le langage Python ne vient pas avec des modules de calcul scientifique préintégrés en standard. Voici quelques briques logicielles qui peuvent être combinées dans ce langage pour obtenir un environnement de calcul scientifique :

  • Python, un langage de programmation moderne et générique :

    • le langage lui-même : types de données (string, int), contrôle du flux programmatique (boucles, conditions), ensembles de données (listes, dictionnaires), motifs, etc.
    • les modules de la librairie standard,
    • un grand nombre d'applications ou de modules spécialisés écrits en Python : protocole web, framework web, etc. ainsi que le calcul scientifique,
    • des outils de développement pratiques (tests automatiques, génération automatique de documentation) ;
  • IPython, une console Python améliorée : http://ipython.org/ ;

    Image non disponible
  • Numpy : fournit des objets tableaux numériques très puissants, ainsi que des algorithmes pour les manipuler : http://www.numpy.org/ ;
Image non disponible

I-C. Gestion de flux interactive : IPython et éditeur de texte

Process interactif pour tester et pour comprendre les algorithmes : dans cette rubrique, nous décrirons un flux de travaux interactif basé sur la console IPython, qui est très pratique pour explorer et pour comprendre les algorithmes.

Python est un langage à usage général. De ce fait, il n'existe pas d'environnement de travail privilégié ni même une façon unique de l'utiliser. Bien que cela rende la tâche plus difficile pour les débutants, cela permet toutefois d'écrire des programmes Python pour toute sorte de domaines, tels que par exemple les serveurs web ou encore les équipements à base d'électronique embarquée.

Document de référence pour cette rubrique :

Manuel utilisateur IPython : http://ipython.org/documentation.html.

I-C-1. Interactivité en ligne de commande

Dans une console shell, lancez la commande ipython, puis tapez :

In
Sélectionnez
print('Hello world')
Out
Sélectionnez
Hello world

Pour obtenir de l'aide, utilisez l'opérateur '?' après le nom d'un objet :

In
Sélectionnez
print?
Out
Sélectionnez
Type:               builtin_function_or_method
Base Class:         <type 'builtin_function_or_method'>
String Form:        <built-in function print>
Namespace:          Python builtin
Docstring:
    print(value, ..., sep=' ', end='\n', file=sys.stdout)

    Prints the values to a stream, or to sys.stdout by default.
    Optional keyword arguments:
    file: a file-like object (stream); defaults to the current sys.stdout.
    sep:  string inserted between values, default a space.
    end:  string appended after the last value, default a newline.

I-C-2. Mise au point d'un algorithme avec un éditeur de texte

Ouvrez un éditeur de texte, puis créez un fichier my_file.py. Avec EPD™ (Enthought Python Distribution™), vous pouvez utiliser l'éditeur Scite, accessible via le menu Démarrer de Windows™. Avec la distribution Python(x,y), vous pouvez utiliser l'éditeur de texte Spyder. Sous Ubuntu™, si vous n'avez pas d'ores et déjà votre éditeur de texte préféré, nous vous conseillerons d'installer Stani's Python editor. Une fois le fichier créé, ajoutez-y les lignes suivantes :

 
Sélectionnez
s = 'Hello world'
print(s)

À présent, vous pouvez lancer ce script dans IPython et explorer les différentes variables :

In
Sélectionnez
%run my_file.py
Out
Sélectionnez
Hello world
In
Sélectionnez
s
Out
Sélectionnez
'Hello world'
In
Sélectionnez
%whos
Out
Sélectionnez
Variable   Type    Data/Info
----------------------------
s          str     Hello world

Du script aux fonctions

Bien qu'il soit tentant de ne travailler qu'avec des scripts, c'est-à-dire avec un fichier rempli d'instructions qui se suivent ligne après ligne, prévoyez toutefois de passer progressivement du script vers un ensemble de fonctions :

  • un script n'est pas réutilisable, alors que les fonctions, si ;
  • raisonner en termes de fonctions permet d'analyser un problème en le subdivisant en petits problèmes unitaires plus simples à résoudre.

I-C-3. Trucs et astuces IPython

Le manuel utilisateur IPython contient force information sur l'utilisation de la console IPython, mais pour vous permettre de commencer, nous voudrions rapidement vous présenter trois ou quatre fonctionnalités particulièrement utiles : l'historique des commandes, les fonctions magiques, les alias et le complètement automatique par tabulation.

Bien que « complètement automatique » soit la locution exacte pour désigner cette fonctionnalité, on emploie plus couramment l'expression « complétion automatique », voire parfois « autocomplétion ».

Comme la console shell UNIX™, la console IPython gère aussi l'historique des commandes insérées au clavier. Utilisez les touches fléchées <Haut> et <Bas> du clavier pour naviguer dans cet historique. Par exemple :

In
Sélectionnez
x = 10

Pressez la touche fléchée <Haut> du clavier et vous obtenez de nouveau dans la console :

In
Sélectionnez
x = 10

La console IPython gère aussi ce que l'on appelle des fonctions magiques, en préfixant une commande par le caractère '%'. Par exemple, les fonctions 'run' et 'whos' sont des fonctions dites magiques. Notez que le réglage 'automagic' – activé par défaut – vous permet de négliger le signe '%'. Il vous suffit donc de taper le nom de la fonction magique (sans préfixe) et cela fonctionnera.

Quelques autres fonctions magiques fort utiles :

  • %cd pour changer le répertoire de travail actuel ;

    In
    Sélectionnez
    cd /tmp
  • %timeit permet de chronométrer le temps d'exécution de petits bouts de code grâce au module Python standard timeit ;

    In
    Sélectionnez
    timeit x = 10
    Out
    Sélectionnez
    10000000 loops, best of 3: 39 ns per loop
  • %cpaste permet de coller du code provenant, par exemple, d'un site web et contenant des préfixes reconnaissables tels que l'invite de commande Python ('>>>') ou l'invite de commande IPython ('in [nnn]:') ;

    In
    Sélectionnez
    cpaste
    Out
    Sélectionnez
    Pasting code; enter '--' alone on the line to stop or use Ctrl-D.
    In
    Sélectionnez
    :In [3]: timeit x = 10
    :--
    Out
    Sélectionnez
    10000000 loops, best of 3: 85.9 ns per loop
    In
    Sélectionnez
    cpaste
    Out
    Sélectionnez
    Pasting code; enter '--' alone on the line to stop or use Ctrl-D.
    In
    Sélectionnez
    :>>> timeit x = 10
    :--
    Out
    Sélectionnez
    10000000 loops, best of 3: 86 ns per loop
  • %debug permet d'entrer en mode débogage post-mortem ; pour faire simple, si le code que vous exécutez lève une exception (erreur), l'utilisation de %debug lancera le débogueur à l'endroit où l'erreur a eu lieu ;
In
Sélectionnez
x === 10
Out
Sélectionnez
  File "<ipython-input-6-12fd421b5f28>", line 1
    x === 10
        ^
SyntaxError: invalid syntax
In
Sélectionnez
debug
> /home/esc/anaconda/lib/python2.7/site-packages/IPython/core/compilerop.py(87)ast_parse()
Out
Sélectionnez
     86         and are passed to the built-in compile function."""
---> 87         return compile(source, filename, symbol, self.flags | PyCF_ONLY_AST, 1)
     88
In
Sélectionnez
ipdb>locals()
Out
Sélectionnez
{'source': u'x === 10\n', 'symbol': 'exec', 'self':
<IPython.core.compilerop.CachingCompiler instance at 0x2ad8ef0>,
'filename': '<ipython-input-6-12fd421b5f28>'}

Aide IPython :

  • l'antisèche IPython intégrée est accessible via la fonction magique %quickref ;
  • la liste complète de toutes les fonctions magiques s'obtient en tapant %magic.

De plus, la console IPython est fournie avec de multiples alias qui imitent les commandes UNIX habituelles telles que ls pour lister les fichiers d'un répertoire, cp pour copier des fichiers, rm pour supprimer des fichiers, etc. Une liste d'alias est disponible en tapant :

In
Sélectionnez
alias
Out
Sélectionnez
Total number of aliases: 16
[('cat', 'cat'),
('clear', 'clear'),
('cp', 'cp -i'),
('ldir', 'ls -F -o --color %l | grep /$'),
('less', 'less'),
('lf', 'ls -F -o --color %l | grep ^-'),
('lk', 'ls -F -o --color %l | grep ^l'),
('ll', 'ls -F -o --color'),
('ls', 'ls -F --color'),
('lx', 'ls -F -o --color %l | grep ^-..x'),
('man', 'man'),
('mkdir', 'mkdir'),
('more', 'more'),
('mv', 'mv -i'),
('rm', 'rm -i'),
('rmdir', 'rmdir')]

Pour finir, nous voudrions mentionner la fonctionnalité de complètement automatique par tabulation, dont nous citerons l'explication fournie par le manuel IPython :

  • le complètement automatique par tabulation – en particulier pour les attributs de classe – est une méthode pratique pour explorer la structure des objets que vous utilisez. Tapez simplement nom_objet.<Tabulation> pour afficher les attributs de l'objet. En dehors des objets et mots-clés Python, le complètement automatique par tabulation fonctionne aussi sur les noms de fichiers et de dossiers.

Bien que « complètement automatique » soit la locution exacte pour désigner cette fonctionnalité, on emploie plus couramment l'expression « complétion automatique », voire parfois « autocomplétion ».

In
Sélectionnez
x = 10
x.<Tabulation>
Out
Sélectionnez
x.bit_length   x.conjugate    x.denominator  x.imag         x.numerator
x.real
In
Sélectionnez
x.real.<Tabulation>
Out
Sélectionnez
x.real.bit_length   x.real.denominator  x.real.numerator
x.real.conjugate    x.real.imag         x.real.real

II. Remerciements

Sincères remerciements à Jacques THÉRY (jacques_jean) pour sa relecture orthographique minutieuse.

1 commentaire Donner une note à l'article (5)

Vous avez aimé ce tutoriel ? Alors partagez-le en cliquant sur les boutons suivants : Viadeo Twitter Facebook Share on Google+   

  

Licence Creative Commons
Le contenu de cet article est rédigé par Developpez.com et est mis à disposition selon les termes de la Licence Creative Commons Attribution 3.0 non transposé.
Les logos Developpez.com, en-tête, pied de page, css, et look & feel de l'article sont Copyright © 2013 Developpez.com.