def affiche_message(parametre):
    print("Bonjour :", parametre)
    return

L'instruction import

Après avoir défini un module, vous pouvez l'utiliser avec l'instruction import. La syntaxe est la suivante :

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

Pour utiliser le module math, par exemple, vous pouvez l'importer au début de votre fichier avec import math. Lors de l'appel des fonctions du module math, vous devez utiliser la syntaxe suivante :

NomDuModule.NomDeLaFonction

Lorsque l'interpréteur rencontre une instruction import, il recherche le module dans le chemin de recherche actuel. Le chemin de recherche est une liste de répertoires que l'interpréteur recherche en premier. Pour importer le module support.py, vous devez placer la commande en haut de votre script :

import support

support.affiche_message("Exemple")

Un module n'est importé qu'une seule fois, quel que soit le nombre d'exécutions de l'instruction import. Cela empêche l'exécution répétée du module importé.

L'instruction from...import

L'instruction from de Python vous permet d'importer une partie spécifique d'un module dans l'espace de noms actuel. La syntaxe est la suivante :

from nom_module import nom1[, ... nomN]

Par exemple, pour importer la fonction fibonacci du module fib, utilisez l'instruction suivante :

from fib import fibonacci

Cette instruction n'importe pas tout le module fib dans l'espace de noms actuel ; elle importe uniquement la fonction fibonacci dans la table des symboles globaux du module exécutant cette instruction.

L'instruction from...import *

Il est également possible d'importer tout le contenu d'un module dans l'espace de noms actuel en utilisant l'instruction suivante :

from nom_module import *

Cette méthode fournit un moyen simple d'importer tous les éléments d'un module, mais elle ne devrait pas être utilisée excessivement. Par exemple, pour importer tout le module math, utilisez l'instruction suivante :

from math import *

Le chemin de recherche

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

1. Le répertoire actuel
2. Si ce n'est pas dans le répertoire actuel, Python recherche chaque répertoire dans la variable d'environnement PYTHONPATH
3. Si rien n'est trouvé, Python consulte le chemin par défaut. Sous Unix, le chemin par défaut est généralement /usr/local/lib/python/

Le chemin de recherche des modules est stocké dans la variable sys.path du module système, qui contient le répertoire actuel, PYTHONPATH et les répertoires d'installation par défaut déterminés par le processus d'installation.

La variable PYTHONPATH

En tant que variable d'environnement, PYTHONPATH est composée de nombreux répertoires listés, avec une syntaxe similaire à la variable PATH du shell. Sous Windows, un PYTHONPATH typique ressemble à ceci :

set PYTHONPATH=c:\\python27\\lib

Sous Unix, un PYTHONPATH typique ressemble à ceci :

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 qui contient les noms de variables (clés) et leurs objets correspondants (valeurs).

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

Chaque fonction a son propre espace de noms. Les règles de portée des méthodes de classe sont les mêmes que celles des fonctions ordinaires.

Python devine intelligemment si une variable est locale ou globale. Il suppose que toute variable assignée dans une fonction est locale. Par conséquent, pour assigner une valeur à une variable globale dans une fonction, vous devez utiliser l'instruction global.

L'expression global NomDeVariable indique à Python que NomDeVariable est une variable globale, afin que Python ne recherche pas cette variable dans l'espace de noms local.

Par exemple, si nous définissons une variable Argent dans l'espace de noms global, puis que nous essayons d'assigner une valeur à cette variable dans une fonction, Python supposera que c'est une varible locale. Cependant, si nous n'avons pas déclaré de variable locale Argent avant de l'utiliser, une erreur UnboundLocalError se produira. Pour résoudre ce problème, nous devons utiliser l'instruction global.

La fonction dir()

La fonction dir() retourne une liste de chaînes de caractères triées, contenant les noms définis dans un module. La liste comprend tous les modules, variables et fonctions définis dans un module. La variable spéciale __name__ pointe vers le nom du module.

Les fonctions globals() et locals()

Selon l'endroit où elles sont appelées, les fonctions globals() et locals() peuvent être utilisées pour retourner les noms des espaces de noms global et local. Si locals() est appelée à l'intérieur d'une fonction, elle retourne tous les noms accessibles dans cette fonction. Si globals() est appelée à l'intérieur d'une fonction, elle retourne tous les noms globaux accessibles dans cette fonction. Les deux fonctions retournent un dictionnaire, donc les noms peuvent être extraits avec la fonction keys().

La fonction reload()

Lorsqu'un module est importé dans un autre script, le code de niveau supérieur du 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 foncsion réimporte un module précédemment importé. La syntaxe est la suivante :

reload(nom_module)

Ici, nom_module doit être le nom du module directement, pas sous forme de chaîne de caractères. Par exemple, pour recharger le module hello, utilisez :

reload(hello)

Les packages en Python

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

En bref, un package est un dossier, mais ce dossier doit contenir un fichier __init__.py, dont le contenu peut être vide. Le fichier __init__.py est utilisé pour identifier que le dossier actuel est un package.

Considérons une structure de fichiers avec un package nommé package_exemple contenant les fichiers module1.py, module2.py et __init__.py. Le fichier test.py est un script qui appelle le package. La structure de répertoires est la suivante :

test.py
package_exemple
|-- __init__.py
|-- module1.py
|-- module2.py

Le code source pour chaque fichier est le suivant :

# module1.py
def fonction1():
    print("Je suis dans module1")

# module2.py
def fonction2():
    print("Je suis dans module2")

# __init__.py
if __name__ == '__main__':
    print('Exécuté comme programme principal')
else:
    print('package_exemple initialisé')

# test.py
from package_exemple.module1 import fonction1
from package_exemple.module2 import fonction2

fonction1()
fonction2()

Une fois le code correctement structuré et la syntaxe valide, l'exécution affiche les résultats des fonctions module1 et module2.

Il est important de noter que la structure des fichiers doit être correcte et que test.py ne doit pas être placé à l'intérieur du package, sinon les résultats des fonctions module1 et module2 ne s'afficheront pas.