Modules - `import`¶

Module¶

Un module est basiquement un fichier nom_module.py ordinaire. Les variables, fonctions, classes qui y sont définies peuvent être importées afin d’être réutilisées.

Python est accompagné de nombreux modules; ils forment sa librairie standard. On y trouve par exemple les modules random, math, tkinter et beaucoup d’autres.

Importer un module et l’utiliser - import <nom_module>:

>>> import random # random -> aléatoire
>>> random.randint(1,6) # «dé electronique»
2
>>> def de(): # trop long à écrire ?
...     return random.randint(1,6)
...
>>> de()
3
>>> de()
1
>>> random.choice('abcdefghijklmnop') # caractère aléatoire de la chaîne
'h'

Utiliser un alias - import <nom_module> as <alias>:

>>> import random as alea
>>> l = [1, 2, 3, 4]
>>> alea.shuffle(l)
>>> l
[1, 4, 2, 3]

Importer une ou plusieurs fonctions d’un module - from module import f1, f2, ...:

>>> from math import sqrt as racine, exp, log as ln, e
>>> r = racine(5)
>>> r
2.23606797749979
>>> round(r,2)
2.24
>>> [(x, round(racine(x), 2) ) for x in [0,1,2,3,4,5]]
[(0, 0.0), (1, 1.0), (2, 1.41), (3, 1.73), (4, 2.0), (5, 2.24)]
>>> from random import uniform
>>> x = uniform(0, 100)
>>> ln(exp(x)) == x
True
>>> exp(ln(x)) == x
True
>>> e
2.718281828459045
>>> ln(e)
1.0

Importer tout ce qu’un module définit - from <nom_module> import *:

>>> from tkinter import *
>>> fenetre = Tk() # une fenêtre devrait apparaître
>>> bouton = Button(fenetre, text="cliquez moi !", command=fenetre.destroy)
>>> # le bouton n'apparaît pas ??? normal, il faut encore le positionner
>>> bouton.pack()

Avertissement

Procéder de la sorte est généralement déconseillé car de nombreux «noms» sont alors introduis dans l’interpréteur Python ce qui peut être source de conflits (en cas de multiples imports par exemple). Vous pouvez toutefois utiliser cette facilité pour écrire de petits programmes de découvertes de tel ou tel module:

>>> # La fonction dir(truc) sert à connaître les noms définis dans le contexte de «truc»
>>> dir() # si «truc» est omis, c'est le contexte courant
['__builtins__', '__doc__', '__name__', '__package__']
>>> a = 5
>>> dir() # le nom «a» existe à présent
['__builtins__', '__doc__', '__name__', '__package__', 'a']
>>> import tkinter
>>> dir() # seul le nom «tkinter» (ou plutôt l'espace de nom) est importé
['__builtins__', '__doc__', '__name__', '__package__', 'a', 'tkinter']
>>> from tkinter import *
>>> dir() # et maintenant ? argh !
['ACTIVE', 'ALL', 'ANCHOR', 'ARC', 'At', 'AtEnd', 'AtInsert', 'AtSelFirst', 'AtSelLast', 'BASELINE', 'BEVEL', 'BOTH', 'BOTTOM', 'BROWSE', 'BUTT', 'BaseWidget', 'BitmapImage', 'BooleanVar', 'Button', 'CASCADE', 'CENTER', 'CHAR', 'CHECKBUTTON', 'CHORD', 'COMMAND', 'CURRENT' ...

Mon module: exemple¶

Créer un fichier d’extension .py. Dans cet exemple, il s’appelle monModule.py:

# définitions de monModule.py
CONST = 3.14
def truc():
    print("Salut cowboy.")

Démarrer l’interpréteur depuis le dossier qui contient le fichier monModule.py:
```
>>> from monModule import *
>>> CONST
3.14
>>> truc()
Salut cowboy.
```
Note

Votre module sera chargé pourvu que Python puisse le trouver ! Pour savoir où Python cherche les modules:
```
>>> import sys
>>> sys.path # affiche la liste des dossiers de recherche des modules
```

Tester son module - if __name__ == '__main__'::

# ajouter les lignes suivantes à votre module puis exécuter le normalement

if __name__ == '__main__':
     # __name__ vaut '__main__'
     # seulement si Python est
     # directement appelé sur ce fichier
     # code pour tester le module:
     print(CONST)
     truc()

Notion de Paquet (avancé)¶

Un paquet - package - sert à regrouper logiquement plusieurs modules. En pratique, c’est un dossier caractérisé par la présence d’un fichier __init__.py (qui peut être vide). Outre ce fichier «spécial», on y trouve les modules et éventuellement d’autres paquets...

Un paquet est donc un dossier de la forme:

paquet/
        __init__.py
        module1.py
        module2.py
        sousPaquet/
                __init__.py
                autreModule.py
                ...
        ...

Importer un paquet (revient en fait à «charger» son __init__.py) - import <paquet>:

import paquet
# si son __init__.py définit la fonction «truc»
paquet.truc() # ok
truc() # pas ok !
from paquet import truc
truc() # là ok

Importer un module contenu dans un paquet - import <paquet>.<module> ou aussi from <paquet> import <module>:

import paquet.module1
# si module1.py définit la fonction «bidulle»
paquet.module1.bidulle() # ok.

# vous pouvez utiliser un alias
import paquet.module1 as pm1
pm1.bidulle() # ok

# ou encore
from paquet import module1
module1.bidulle() # ok

# Enfin, pour importer «autreModule»
import paquet.sousPaquet.autreModule

Importer un (ou plusieurs) «objets» définis dans un module d’un paquet - from <paquet>.<module> import obj1, obj2, ....
Sens particulier de from <paquet> import *.

On pourrait penser que ça charge tous les (sous)modules de <paquet> mais ce n’est en général pas le cas; La convention est la suivante:

si le fichier __init__.py définit une liste nommée __all__, elle est utilisée comme la liste des noms de modules qui devraient être chargés si from <paquet> import * est utilisé.

Modules - import¶

Module¶

Mon module: exemple¶

Notion de Paquet (avancé)¶

Modules - `import`¶