In [1]:
from __future__ import print_function

Modules

Python offre un moyen de mettre des définitions dans un fichier et de les utiliser dans un script ou dans un session interactive de l’interpréteur. Un tel fichier s’appelle un module ; les définitions d’un module peuvent être importées dans un autre module ou dans le module principal (la collection de variables à laquelle vous avez accès dans un script exécuté depuis le plus haut niveau et dans le mode calculatrice).

Un module est un fichier contenant des définitions et des instructions Python. Le nom de fichier est le nom du module auquel est ajouté le suffixe '.py'. Dans un module, le nom du module (comme chaîne de caractères) est disponible comme valeur de la variable globale __name__. Par exemple, employez votre éditeur de texte préféré pour créer un fichier appelé 'fibo.py' dans le répertoire courant avec le contenu suivant :


In [3]:
# Module nombres de Fibonacci
def fib(n):    # écrit la série de Fibonacci jusqu’à n
    a, b = 0, 1
    while b < n:
        print (b, end=' ')
        a, b = b, a+b
        
def fib2(n): # retourne la série de Fibonacci jusqu’à n
    result = []
    a, b = 0, 1
    while b < n:
        result.append(b)
        a, b = b, a+b
    return result

On se déplace dans le répertoire courant, à adapter à votre environnement.


In [3]:
cd src/notebook/coursIntroPython/


[Errno 2] No such file or directory: 'src/notebook/coursIntroPython/'
/Users/sylchev/src/notebook/coursIntroPython

Maintenant lancez l’interpréteur Python et importez ce module avec la commande suivante :


In [2]:
import fibo

En utilisant le nom de module vous pouvez accéder aux fonctions :


In [5]:
fibo.fib(1000)


1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 

In [6]:
fibo.fib2(100)


Out[6]:
[1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]

Pour connaître les noms qu'un module défini on peut utiliser la fonction dir(), qui renvoie la liste triée des chaînes de caractères.


In [7]:
dir(fibo)


Out[7]:
['__builtins__',
 '__doc__',
 '__file__',
 '__name__',
 '__package__',
 'fib',
 'fib2',
 'print_function']

Modules de la bibliothèques standard

Beaucoup de fonctionalités de Python sont disponibles dans des bibliothèques appelées modules. Pour améliorer la lisibilité et la portabilité du code, ces modules ne sont pas pré-chargés lorsque vous lancez Python : il faut les importer explicitement. Par exemple, il y a un module de math qui contient de nombreuses fonctions relatives au mathématiques. Si vous souhaitez utiliser la fonction cosinus, cos, vous pouvez importer le module math puis indiquer que vous appelez la fonction cos en utilisant la notation préfixée. Il en va de même pour les autres éléments de math comme par exemple la constante $\pi$


In [1]:
import math
math.cos(2 * math.pi)


Out[1]:
1.0

Quand on a fait un import, il faut donc préfixer tous les objets du module (par exemple math.cos), ceci permet de lever certaines ambiguïtés lors de la lecture du code.

Cependant, surtout lorsqu'on écrit du code à usage unique, cette notation est lourde. Il est possible d'importer tout le contenu d'un module dans l'espace de noms (namespace) courant.

L'espace de noms est constitué par l'ensemble des variables et des fonctions atteignables depuis un endroit du code. Pour connaître le contenu de l'espace de noms courant dans iPython, on peut faire appel à la commande %whos


In [3]:
%whos


Variable         Type                   Data/Info
-------------------------------------------------
math             module                 <module 'math' from '/Use<...>2.7/lib-dynload/math.so'>
print_function   __future__._Feature    _Feature((2, 6, 0, 'alpha<...>0, 0, 'alpha', 0), 65536)

Revenons aux modules, pour importer tout le contenu d'un module dans l'espace de noms courant, on peut utiliser:


In [4]:
from math import *
cos(2 * pi)


Out[4]:
1.0

Si on importe ainsi beaucoup de modules, ce qui est assez courant, l'espace de nom va vite être très rempli. Si deux fonctions ou variables portent le même nom, alors c'est la fonction du dernier module importé qui sera conservée. Voyons par exemple à quoi ressemble l'espace de noms courant maintenant que nous avons importé tout le module math:


In [13]:
%whos


Variable    Type                          Data/Info
---------------------------------------------------
acos        builtin_function_or_method    <built-in function acos>
acosh       builtin_function_or_method    <built-in function acosh>
asin        builtin_function_or_method    <built-in function asin>
asinh       builtin_function_or_method    <built-in function asinh>
atan        builtin_function_or_method    <built-in function atan>
atan2       builtin_function_or_method    <built-in function atan2>
atanh       builtin_function_or_method    <built-in function atanh>
ceil        builtin_function_or_method    <built-in function ceil>
copysign    builtin_function_or_method    <built-in function copysign>
cos         builtin_function_or_method    <built-in function cos>
cosh        builtin_function_or_method    <built-in function cosh>
degrees     builtin_function_or_method    <built-in function degrees>
e           float                         2.71828182846
erf         builtin_function_or_method    <built-in function erf>
erfc        builtin_function_or_method    <built-in function erfc>
exp         builtin_function_or_method    <built-in function exp>
expm1       builtin_function_or_method    <built-in function expm1>
fabs        builtin_function_or_method    <built-in function fabs>
factorial   builtin_function_or_method    <built-in function factorial>
fibo        module                        <module 'fibo' from 'fibo.pyc'>
floor       builtin_function_or_method    <built-in function floor>
fmod        builtin_function_or_method    <built-in function fmod>
frexp       builtin_function_or_method    <built-in function frexp>
fsum        builtin_function_or_method    <built-in function fsum>
gamma       builtin_function_or_method    <built-in function gamma>
hypot       builtin_function_or_method    <built-in function hypot>
isinf       builtin_function_or_method    <built-in function isinf>
isnan       builtin_function_or_method    <built-in function isnan>
ldexp       builtin_function_or_method    <built-in function ldexp>
lgamma      builtin_function_or_method    <built-in function lgamma>
log         builtin_function_or_method    <built-in function log>
log10       builtin_function_or_method    <built-in function log10>
log1p       builtin_function_or_method    <built-in function log1p>
modf        builtin_function_or_method    <built-in function modf>
pi          float                         3.14159265359
pow         builtin_function_or_method    <built-in function pow>
radians     builtin_function_or_method    <built-in function radians>
sin         builtin_function_or_method    <built-in function sin>
sinh        builtin_function_or_method    <built-in function sinh>
sqrt        builtin_function_or_method    <built-in function sqrt>
tan         builtin_function_or_method    <built-in function tan>
tanh        builtin_function_or_method    <built-in function tanh>
trunc       builtin_function_or_method    <built-in function trunc>

La bonne pratique concilie le meilleur des deux approches. Elle permet d'importer dans l'espace de noms uniquement les fonctions utiles.


In [5]:
from math import cos, pi
cos(2 * pi)


Out[5]:
1.0

Ce notebook est une adaptation de la traduction française, dirigée par Olivier Berger et mise à jour par Henri Garreta, du tutoriel Python édité par Guido van Rossum et Fred L. Drake.