IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)

Programmation Python pour les scientifiques

Utilisation de modules sous Python - Cours avec exercices corrigés


précédentsommairesuivant

I. Utilisation d'un module

I-A. Importer un module

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
importer une fonction ou constante
Sélectionnez
>>> from math import sqrt
>>> sqrt(2)
1.4142135623730951
>>> from math import cos, pi
>>> cos(pi/4)
0.7071067811865476
importer toute la bibliothèque
Sélectionnez
>>> from math import *
>>> sin(pi/4)
0.7071067811865476
  • sans l'instruction from
 
Sélectionnez
>>> 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 :

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

I-B. Exemple : le module random

Voici quelques fonctions fournies par le module random :

randrange(a,b,k)

Choisit un entier int aléatoirement dans range(a,b,k)

randint(a,b)

Choisit un entier int aléatoirement dans [a, b]

choice(List)

Choisit un entier int aléatoirement dans la liste List

random()

Choisit un float aléatoirement dans [0, 1[

uniform(a,b)

Choisit un float aléatoirement dans [a, b[

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

Exemple : que fait le programme suivant ?

 
Sélectionnez
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é).

 
Sélectionnez
>>> 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%']

I-C. Application : méthode de Monte-Carlo

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 :

kitxmlcodelatexdvp\int^b_a f(t)\textrm{d}t\approx\left(\dfrac{b-a}{n}\right)\sum^{n}_{i=1} f(x_i)finkitxmlcodelatexdvp

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 Image non disponible pour dévoiler la solution.

 
Cacher/Afficher le codeSélectionnez

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

 
Sélectionnez
>>> 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 :

 
Sélectionnez
>>> def f(x) :
        return x**2
>>> f(3)
9
avec lambda
Sélectionnez
>>> 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 » :

 
Sélectionnez
>>> 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).

 
Sélectionnez
>>> 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

précédentsommairesuivant

Les sources présentées sur cette page sont libres de droits et vous pouvez les utiliser à votre convenance. Par contre, la page de présentation constitue une œuvre intellectuelle protégée par les droits d'auteur. Copyright © 2015 Jean-Philippe PREAUX. Aucune reproduction, même partielle, ne peut être faite de ce site ni de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.