Programmation Python pour les scientifiques

Si le programme que vous rédigez est un peu long, vous voudriez peut-être le scinder en plusieurs fichiers pour maintenir le code plus facilement. Certains de ces fichiers contiendront alors des définitions de classes, constantes et fonctions spécialisées dans un certain domaine, et qui pourront être importées à la demande dans plusieurs programmes sans avoir besoin de recopier tout le code à chaque fois.

Ces fichiers qui peuvent constituer des bibliothèques logicielles sont appelés modules en Python. Un module peut alors être importé dans un autre module ou dans le module principal (main).

Tout programmeur Python peut réaliser un module et nous en avons même utilisés plusieurs provenant de la bibliothèque standard de Python :

• math : ensemble de fonctions mathématiques ;
• fractions : fonctions arithmétiques des nombres rationnels ;
• random : génération de nombres pseudoaléatoires ;
• time : fonctions de gestion du temps ;
• et bien d'autres encore, voir PyPI - the Python Package Index.

Pour importer un module :

• à l'aide de l'instruction from

>>> from math import sqrt
>>> sqrt(2)
1.4142135623730951
>>> from math import cos, pi
>>> cos(pi/4)
0.7071067811865476

>>> from math import *
>>> sin(pi/4)
0.7071067811865476

• sans l'instruction from

>>> import math
>>> math.sqrt(2)
1.4142135623730951
>>> math.cos(math.pi/4)
0.7071067811865476

Fonctions et constantes doivent être précédées d'un préfixe : le nom du module suivi d'un point '.'.
La méthode import nom_du_module est généralement conseillée, car elle évite des conflits de noms potentiels (on sait toujours de quel module vient telle ou telle fonction).
On peut définir un alias à l'aide de l'instruction as quand un nom de module est un peu long :

>>> import numpy as np
>>> x = np.array([1, 2, 3])
>>> print x
[1 2 3]

Voici quelques fonctions fournies par le module random :

Ici « aléatoirement » signifie selon une loi uniforme (quasiment).

Exemple : que fait le programme suivant ?

import random as rand
def de6(n):
    tirs = [0, 0, 0, 0, 0, 0]
    for i in range(n):
        t = rand.randint(1,6)
        tirs[t-1] += 1
    for j in range(6):
        tirs[j] = tirs[j]*100.0/n
        tirs[j] = {:.2f}.format(tirs[j]) + '%' # 2 nombres après la virgule
    return tirs

À l'aide de la méthode format pour le type str, l'expression {:.2f}.format(x), pour un float x, retourne une chaîne de caractères représentant l'écriture décimale du nombre x avec 2 chiffres après la virgule. Voir Format Specification Mini-Language.

Réponse : le programme simule n lancers d'un dé à six faces, et compte le nombre de fois où chaque face apparaît pour finalement retourner le pourcentage d'apparition de chaque face.

Maintenant, vérifions le théorème des grands nombres : pour un grand nombre de tirs, les fréquences d'apparition de chaque face devraient tendre vers leur probabilité de tir, ici donc être égales (la loi est uniforme : le dé est non pipé).

>>> de6(10)
['30.00%', '0.00%', '20.00%', '20.00%', '10.00%', '20.00%']
>>> de6(100)
['10.00%', '22.00%', '19.00%', '20.00%', '15.00%', '14.00%']
>>> de6(1000)
['16.00%', '15.40%', '16.10%', '16.90%', '18.50%', '17.10%']
>>> de6(10000)
['16.45%', '16.66%', '16.50%', '16.84%', '17.37%', '16.18%']
>>> de6(100000)
['16.57%', '16.67%', '16.80%', '16.62%', '16.66%', '16.68%']
>>> de6(1000000)
['16.65%', '16.69%', '16.66%', '16.64%', '16.63%', '16.74%']
>>> de6(10000000)
['16.66%', '16.66%', '16.65%', '16.66%', '16.69%', '16.68%']

Les méthodes de simulation de Monte-Carlo permettent le calcul approché de valeurs numériques par des procédés aléatoires. Elles sont particulièrement employées pour le calcul approché d'intégrales en dimension supérieure à 1 (pour le calcul d'aire, de volume).

Le calcul approché d'intégrales de fonctions réelles d'une variable repose sur le résultat suivant :

Pour n suffisamment grand, et pour kitxmlcodeinlinelatexdvpi\mapsto x_ifinkitxmlcodeinlinelatexdvp , une variable aléatoire suivant une loi uniforme sur l'intervalle [a, b] (c'est-à-dire n points tirés au hasard dans [a, b] selon une loi uniforme), alors avec une probabilité proche de 1 :

Exercice : écrire une fonction montecarlo(f, a, b, n) qui retourne une valeur approchée de l'intégrale de f sur [a, b] selon la méthode de Monte-Carlo et avec n points.

Cliquez sur l'icône pour dévoiler la solution.

import random as rand
def montecarlo(f, a, b, n): # Calcul approché de l'intégrale de f sur [a, b]
    s = 0
    for i in range(n):
        x = rand.uniform(a, b)
        s += f(x)
    s *= (b-a)/float(n)
    return s

Par exemple avec kitxmlcodeinlinelatexdvpf\,:\,x\mapsto x^2finkitxmlcodeinlinelatexdvp sur [0, 1] le résultat devrait être proche de kitxmlcodeinlinelatexdvp\dfrac{1}{3}finkitxmlcodeinlinelatexdvp :

>>> f = lambda x:x**2
>>> montecarlo(f, 0, 1, 100)
0.32889436948779177
>>> montecarlo(f, 0, 1, 1000)
0.3400354481596589
>>> montecarlo(f, 0, 1, 1000)
0.31687077247647943
>>> montecarlo(f, 0, 1, 10000)
0.3347958934090399
>>> montecarlo(f, 0, 1, 100000)
0.3328616254606106

En Python, une fonction lambda est une fonction anonyme (à laquelle on n'a pas donné de nom), et qu'on peut appliquer « à la volée » dans une expression. Ainsi, les constructions suivantes sont équivalentes :

>>> def f(x) :
        return x**2
>>> f(3)
9

>>> f = lambda x : x**2
>>> f(3)
9
>>> (lambda x : x**2)(3)
9

Nous aurions pu alors utiliser une construction plus compacte, en déclarant la fonction « à la volée » :

>>> montecarlo(lambda x : x**2, 0, 1, 100000)
0.3328616254606106

Exercice : en déduire un calcul approché de kitxmlcodeinlinelatexdvp\pifinkitxmlcodeinlinelatexdvp par la méthode de Monte-Carlo.

Avec kitxmlcodeinlinelatexdvpf\,:\,x\mapsto \sqrt{1-x^2}finkitxmlcodeinlinelatexdvp, l'intégrale sur [0, 1] vaut kitxmlcodeinlinelatexdvp\dfrac{\pi}{4}finkitxmlcodeinlinelatexdvp (aire d'un quart du disque unitaire).

>>> f = lambda x : 4*(1-x**2)**0.5
>>> montecarlo(f, 0, 1, 100000)
3.1427991454635724
>>> montecarlo(f, 0, 1, 10000000)
3.1413319841070737
>>> pi
3.141592653589793