Modules Python : Organiser votre code pour la clarté et la réutilisabilité

Un module permet d'organiser logiquement votre code Python. Regrouper du code connexe dans un module le rend plus facile à comprendre et à utiliser. Un module est un objet Python doté d'attributs nommés arbitrairement que vous pouvez lier et référencer.

En termes simples, un module est un fichier constitué de code Python. Un module peut définir des fonctions, des classes et des variables. Il peut également inclure du code exécutable.

Exemple

Le code Python d'un module nommé aname réside normalement dans un fichier nommé aname.py. Voici un exemple de module simple, support.py :

def print_func(par):
    print("Hello : ", par)
    return

L'instruction import

Vous pouvez utiliser n'importe quel fichier source Python comme module en exécutant une instruction import dans un autre fichier source Python. La syntaxe de import est la suivante :

import module1[, module2[,... moduleN]]

Lorsque l'interpréteur rencontre une instruction import, il importe le module s'il est présent dans le chemin de recherche. Un chemin de recherche est une liste de répertoires que l'interpréteur parcourt avant d'importer un module. Par exemple, pour importer le module support.py, placez la commande suivante au début du script :

#!/usr/bin/python
# Importer le module support
import support

# Vous pouvez maintenant appeler la fonction définie dans ce module
support.print_func("Zara")

L'exécution du code ci-dessus produit le résultat suivant :

Hello : Zara

Un module n'est chargé qu'une seule fois, quel que soit le nombre de fois où il est importé. Cela empêche l'exécution répétée du code du module si plusieurs imports se produisent.

L'instruction from...import

L'instruction from de Python permet d'importer des attributs spécifiques d'un module dans l'espace de noms courant. Sa syntaxe est :

from modname import name1[, name2[, ... nameN]]

Par exemple, pour importer la fonction fibonacci depuis le module fib :

from fib import fibonacci

Cette instruction n'importe pas l'intégralité du module fib dans l'espace de noms courant ; elle introduit seulement l'élément fibonacci du module fib dans la table des symboles globale du module importateur.

L'instruction from...import *

Il est également possible d'importer tous les noms d'un module dans l'espace de noms courant à l'aide de l'instruction suivante :

from modname import *

Cela fournit un moyen facile d'importer tous les éléments d'un module dans l'espace de noms courant ; toutefois, cette instruction doit être utilisée avec parcimonie.

Localisation des modules

Lorsque vous importez un module, l'interpréteur Python le recherche dans l'ordre suivant :

• Le répertoire courant.

• Si le module n'est pas trouvé, Python recherche ensuite chaque répertoire dans la variable d'environnement PYTHONPATH.

• En dernier recours, Python vérifie le chemin par défaut. Sous UNIX, ce chemin par défaut est normalement /usr/local/lib/python/.

Le chemin de recherche des modules est stocké dans le module système sys sous la variable sys.path. Cette variable contient le répertoire courant, PYTHONPATH et le chemin par défaut dépendant de l'installation.

La variable PYTHONPATH

PYTHONPATH est une variable d'environnement constituée d'une liste de répertoires. Sa syntaxe est identique à celle de la variable shell PATH.

Voici un PYTHONPATH typique sur un système Windows :

set PYTHONPATH = c:\python20\lib;

Et voici un PYTHONPATH typique sur un système UNIX :

set PYTHONPATH = /usr/local/lib/python

Espaces de noms et portée

Les variables sont des noms (identificateurs) qui correspondent à des objets. Un espace de noms est un dictionnaire associant des noms de variables (clés) à leurs objets correspondants (valeurs).

Une instruction Python peut accéder aux variables dans un espace de noms local et dans l'espace de noms global. Si une variable locale et une variable globale portent le même nom, la variable locale masque la variable globale.

Chaque fonction possède son propre espace de noms local. Les méthodes de classe suivent la même règle de portée que les fonctions ordinaires.

Python déduit si les variables sont locales ou globales. Il considère que toute variable à laquelle une valeur est assignée dans une fonction est locale.

Par conséquent, pour assigner une valeur à une variable globale à l'intérieur d'une fonction, vous devez d'abord utiliser l'instruction global.

L'instruction global VarName indique à Python que VarName est une variable globale. Python cesse alors de rechercher la variable dans l'espace de noms local.

Par exemple, nous définissons une variable Money dans l'espace de noms global. À l'intérieur de la fonction AddMoney, nous assignons une valeur à Money ; Python considère donc Money comme une variable locale. Cependant, nous avons accédé à la valeur de la variable locale Money avant de la définir, ce qui provoque une erreur UnboundLocalError. Le décommentage de l'instruction global résout le problème.

#!/usr/bin/python
Money = 2000

def AddMoney():
    # Décommentez la ligne suivante pour corriger le code :
    # global Money
    Money = Money + 1
    print(Money)

AddMoney()
print(Money)

La fonction dir()

La fonction intégrée dir() renvoie une liste triée de chaînes contenant les noms définis par un module.

La liste contient les noms de tous les modules, variables et fonctions définis dans un module. Voici un exemple simple :

#!/usr/bin/python
# Importer le module intégré math
import math

content = dir(math)
print(content)

L'exécution du code ci-dessus produit le résultat suivant :

['__doc__', '__file__', '__name__', 'acos', 'asin', 'atan', 'atan2', 'ceil', 'cos', 'cosh', 'degrees', 'e', 'exp', 'fabs', 'floor', 'fmod', 'frexp', 'hypot', 'ldexp', 'log', 'log10', 'modf', 'pi', 'pow', 'radians', 'sin', 'sinh', 'sqrt', 'tan', 'tanh']

Ici, la variable de chaîne spéciale __name__ est le nom du module, et __file__ est le nom du fichier à partir duquel le module a été chargé.

Les fonctions globals() et locals()

Les fonctions globals() et locals() permettent de renvoyer les noms présents dans les espaces de noms global et local, selon l'endroit d'où elles sont appelées.

• Si locals() est appelée depuis une fonction, elle renvoie tous les noms accessibles localement depuis cette fonction.

• Si globals() est appelée depuis une fonction, elle renvoie tous les noms accessibles globalement depuis cette fonction.

Le type de retour de ces deux fonctions est un dictionnaire. Les noms peuvent donc être extraits à l'aide de la méthode keys().

La fonction reload()

Lorsqu'un module est importé dans un script, le code de la partie de niveau supérieur d'un module n'est exécuté qu'une seule fois.

Si vous souhaitez réexécuter le code de niveau supérieur d'un module, vous pouvez utiliser la fonction reload(). Cette fonction réimporte un module déjà importé. Sa syntaxe est :

reload(module_name)

Ici, module_name est le nom du module à recharger (et non la chaîne contenant le nom du module). Par exemple, pour recharger le module hello :

reload(hello)

Les packages en Python

Un package est une structure de répertoires hiérarchique qui définit un environnement d'application Python unique, composé de modules, de sous-packages, de sous-sous-packages, etc.

Considérons un fichier Pots.py disponible dans le répertoire Phone. Ce fichier contient la ligne de code source suivante :

#!/usr/bin/python
def Pots():
    print("I'm Pots Phone")

De même, nous avons deux autres fichiers avec différentes fonctions portant le même nom :

• Phone/Isdn.py contenant la fonction Isdn()

• Phone/G3.py contenant la fonction G3()

Maintenant, créez un fichier __init__.py dans le répertoire Phone :

• Phone/__init__.py

Pour rendre toutes vos fonctions disponibles lors de l'importation de Phone, vous devez placer des instructions d'importation explicites dans __init__.py comme suit :

from Pots import Pots
from Isdn import Isdn
from G3 import G3

Après avoir ajouté ces lignes à __init__.py, toutes ces classes sont disponibles lors de l'importation du package Phone :

#!/usr/bin/python
# Importer maintenant votre package Phone
import Phone

Phone.Pots()
Phone.Isdn()
Phone.G3()

L'exécution du code ci-dessus produit le résultat suivant :

I'm Pots Phone
I'm 3G Phone
I'm ISDN Phone

Dans l'exemple ci-dessus, nous avons pris l'exemple d'une seule fonction par fichier, mais vous pouvez conserver plusieurs fonctions dans vos fichiers. Vous pouvez également définir différentes classes Python dans ces fichiers et créer vos packages à partir de ces classes.