Module
Les modules sont des fichiers qui regroupent des ensembles de fonctions.
Beaucoup de ceux-ci font partie intégrante de Python (modules internes), mais il est nécessaire de les
appeler au préalable pour avoir accès à leurs fonctions.
Import de modules
import module : charge un module appelé module.py
import module as alias : permet d'utiliser un alias plus explicite ou plus court
from module import fonction : charge une fonction précise du module
from module import fonction as alias : charge une fonction précise du module et utilise un alias
from module import * : charge toutes les fonctions d'un module
Appel de fonctions importées
En fonction de la façon dont vous importez vos fonctions, l'appel est différent :
import module : les fonctions du module devront êtres appelées par module.fonction()
import module as alias : les fonctions du module devront êtres appelées par alias.fonction()
1
Dans les autres cas, on n'a pas besoin d'utiliser le préfixe du module et l'on peut directement utiliser le
nom de la fonction ou de l'alias.
Informations sur les modules et fonctions
dir() : liste les modules chargés
dir(module) : liste les fonctions et constantes d'un module chargé
module.fonction.__doc__ : documente la fonction d'un module chargé
print(module.__file__) : renvoie la localisation du module sur votre système
help(module) : renvoie des informations sur les fonctions d'un module
help(module.fonction): renvoie des informations sur une fonction particulière
Sous-module
Certains modules (comme le module os ) contiennent des sous-modules (par exemple os.path ).
Il faut en tenir compte lors de l'appel d'une fonction de ce sous-module :
>>> import os
>>> os.path.split("/home/toto/index.htm")
('/home/toto','index.htm')
Il est aussi possible d'utiliser des alias pour charger des sous-modules :
2
>>> import os.path as P
>>> P.split("/home/toto/index.htm")
('/home/toto','index.htm')
Il est encore possible de charger toutes les fonctions d'un sous-module, qui ne devront plus être préfixées :
>>> from os.path import *
>>> split("/home/toto/index.htm")
('/home/toto','index.htm')
importe les fonctions du module et les sous-modules, mais il sera nécessaire de préfixer les
from os import *
fonctions du sous-module :
>>> from os import *
>>> path.split("/home/toto/index.htm")
('/home/toto','index.htm')
Modules Internes
Voici une courte présentation de différents modules internes pouvant être chargés...
Module Système : sys
3
Ce module contient les fonctions nécessaires pour interagir avec Python et récupérer des informations sur le
système.
Fonctions et variables
platform : affiche la descrition du système d'exploitation
version : affiche la version de python et du compilateur C
hexversion : affiche la version exprimée en hexadécimal
copyright : affiche le copyright
path : renvoie une liste des chemins d'accès de python (/usr/lib/python2.5...)
exit() : pour quitter le programme (ou le shell)
argv est la liste des paramètres passés dans la ligne de commande (argv[0] contient le chemin/nom du
script):
for x in sys.argv:
print(x)
Pour déterminer le chemin du répertoire où se situe un script lancé par un double clic :
import os,sys
4
chemin=os.path.dirname(sys.argv[0])
Module mathématique : math
Ce module contient les fonctions mathématiques permettant d'effectuer les calculs scientifiques de base.
Fonctions et variables
pi retourne une approximation de la constante pi : 3.141592653589793
degrees() et radians() transforment en degrés ou en radians
cos(), sin(), tan() rapports trigonométriques usuels
acos(), asin(), atan()rapports trigonométriques inverses
cosh(), sinh(), tanh() rapports trigonométriques hyperboliques
atan2(y,x) permet des réponses dans les quatre quadrants selon les signes respectifs de y et x
e retourne une approximation de la constante e : 2.718281828459045
exp() exponentielle à base e
log() logarithme naturel (base e)
log10() logarithme en base 10
pow(x,y) renvoie x à la puissance y (c'est-à-dire x**y)
5
sqrt() renvoie la racine carrée
hypot(x,y) renvoie l'hypoténuse pour un triangle rectangle de côtés x et y
fabs() renvoie la valeur absolue (notation décimale)
fmod(x,y) renvoie le reste (notation décimale) de x modulo y
modf() renvoie un tuple (partie décimale, partie entière) d'un "réel"
ldexp(x,y) renvoie x*y**2, soit x fois y exposant 2
frexp(z) renvoie la matisse et l'exposant de z avec z=x*y**2
>>> frexp(9)
(0.5625, 4)
ceil() arrondissement par excès d'un nombre "réel"
floor() arrondissement par défaut d'un nombre "réel"
Le module cmath reprend la plupart des fonctions du module math pour les nombres complexes a+bj :
pi, e, log, log10, exp, sqrt
cos(), sin(), tan(), acos(), asin(), atan()
cosh(), sinh(), tanh(), acosh(), asinh(), atanh()
6
Module de génération aléatoire : random
Dans son module random, Python propose toute une série de fonctions permettant de générer des nombres
aléatoires qui suivent différentes distributions mathématiques.
Fonctions et variables
choice(liste) choisit un élément d'une liste : random.choice([1,'a',125,'ouiche'])
sample(liste,n) renvoie une liste de n éléments choisis d'une liste
shuffle(list) mélange les éléments d'une liste
randint(borne1,borne2) renvoie un entier au hasard entre deux bornes (incluses) -> préférer le suivant !
randrange(borne1,borne2,pas) renvoie un entier entre la première borne (incluse) et la deuxième (exclue). Le pas
est optionnel.
seed(n) (ré-)initialise le générateur de nombres pseudo-aléatoires
random() renvoie un "réel" compris dans l'intervalle [0,1[
uniform(r1,r2) renvoie un "réel" compris dans l'intervalle [r1,r2[
7
Les fonctions suivantes génèrent des nombres pseudo-aléatoires selon des distributions particulières :
betavariate, cunifvariate, expovariate, gammavariate, gauss, lognormvariate, normalvariate, paretovariate,
vonmisesvariate et weibullvariate.
Exemple :
print random.gauss(moyenne,ecart-type) fournit un nombre "réel" selon les probabilités d'une distribution normale.
