Modules en Python

Dans cet article, vous apprendrez à créer et à importer des modules personnalisés en Python. Vous découvrirez également les différentes techniques d'importation et d'utilisation des modules personnalisés et intégrés en Python.

Qu'est-ce qu'un module en Python ?

Un module est un fichier contenant des instructions et des définitions Python.

Les fichiers contenant du code Python, tels que example.py, sont appelés modules et leur nom de module est example.

Nous utilisons des modules pour décomposer de grands programmes en fichiers de petite taille gérables. De plus, les modules fournissent la réutilisabilité du code.

Nous pouvons définir les fonctions les plus utilisées dans le module et les importer, plutôt que de les copier dans d'autres programmes.

Créons un module. Tapez ce qui suit et enregistrez-le sous le nom example.py.

# Exemple de module Python
def add(a, b):
　　　"""Ce programme ajoute deux nombres"
　　　　　　　et retourne le résultat de la somme ""
　　　result = a　+　b
　　　return result

Ici, nous définissons une fonction add() dans un module nommé example.Fonction. Cette fonction prend deux nombres en entrée et retourne leur somme.

Comment importer des modules en Python ?

Nous pouvons importer les définitions internes des modules dans un autre module ou dans un interpréteur interactif Python.

Nous utilisons la keyword import pour cela. Pour importer le module que nous avons défini précédemment, tapez ce qui suit à la invite Python.

>>> import example

Cela n'insère pas directement le nom de la fonction définie dans le symbole example actuel. Il n'insère que le nom du module ici.

En utilisant le nom du module, nous pouvons accéder aux fonctions avec l'opérateur point. Par exemple :

>>> example.add(4,5.5)
9.5

Python dispose d'un grand nombre de modules standard disponibles.

Vous pouvez consulterModules standard PythonListe complète et leurs usages. Ces fichiers se trouvent dans le répertoire Lib de l'emplacement d'installation de Python.

Les modules standard peuvent être importés de la même manière que les modules définis par l'utilisateur.

Il existe plusieurs méthodes pour importer des modules. Ils sont répertoriés ci-dessous.

Déclaration d'importation Python

Nous pouvons utiliser la déclaration d'importation pour importer des modules et accéder à leurs définitions internes en utilisant l'opérateur point, comme précédemment mentionné. Voici un exemple.

# Exemple de déclaration d'importation
# Importation du module math standard
import math
print("valeur de π", math.pi)

Lors de l'exécution de ce programme, la sortie est la suivante :

valeur de π　3.141592653589793

Renommage des imports

Nous pouvons importer des modules de la manière suivante.

# Importation de modules par renommage
import math as m
print("valeur de π", m.pi)

Nous avons renommé le module math en m. Dans certains cas, cela peut économiser notre temps d'écriture.

Veuillez noter que le nom math n'est pas reconnu dans notre portée. Par conséquent, math.pi est incorrect, tandis que m.pi est une utilisation correcte.

Expression from ... import de Python

Nous pouvons importer des noms spécifiques du module sans importer l'ensemble du module. Voici un exemple.

# Importation de pi du module mathématique uniquement
from math import pi
print("La valeur de π", pi)

Nous n'importons que l'attribut pi du module.

Dans ce cas, nous n'utilisons pas l'opérateur point. Nous pouvons importer plusieurs attributs comme suit.

>>> from math import pi, e
>>> pi
3.141592653589793
>>> e
2.718281828459045

Importation de tous les noms

Nous pouvons utiliser les constructions suivantes pour importer tous les noms (définitions) du module.

# Importation de tous les noms du module standard math
from math import　*
print("La valeur de pi", pi)

Nous avons importé toutes les définitions du module mathématique. Cela rend tous les noms, sauf ceux commençant par un trait de soulignement, visibles dans notre portée.

Importation de noms avec un astérisque (*Tous les caractères de l'ensemble de symboles ne constituent pas une bonne habitude de programmation. Cela peut entraîner des redéfinitions de noms d'identifiants. Cela peut également affecter la lisibilité de notre code.

Chemin de recherche des modules Python

Lors de l'importation d'un module, Python vérifie plusieurs emplacements. L'interpréteur cherche d'abord un module intégré, puis (si ce n'est pas le cas) dans la liste des répertoires définis dans sys.path. La recherche se déroule dans cet ordre.

• Répertoire courant.

• PYTHONPATH (variable d'environnement contenant une liste de répertoires).

• Répertoires par défaut liés à l'installation.

>>> import sys
>>> sys.path
['',
'C:\\Python33\\Lib\\idlelib',
'C:\\Windows\\system32\\python33.zip',
'C:\\Python33\\DLLs',
'C:\\Python33\\lib',
'C:\\Python33',
'C:\\Python33\\lib\\site-packages'

Nous pouvons ajouter ou modifier cette liste pour ajouter nos propres chemins.

Recharger le module

L'interpréteur Python n'importe qu'une seule fois le module pendant la session. Cela rend les choses plus efficaces. Voici un exemple pour illustrer son principe de fonctionnement.

Supposons qu'il y ait le code suivant dans un module nommé my_module.

# Ce module affiche
# Plusieurs imports et redéfinitions
print("Ce code a été exécuté")

Maintenant, nous avons vu l'effet de l'importation multiple.

>>> import my_module
This code is executed
>>> import my_module
>>> import my_module

Nous pouvons voir que notre code n'a été exécuté qu'une seule fois. Cela signifie que notre module n'a été importé qu'une seule fois.

Now, if our module changes during the execution of the program, we will have to reload it. One method is to restart the interpreter. But this does not help much.

Python provides a concise method. We can use the reload() function within the module and the imp function to reload the module. How is this done.

>>> import imp
>>> import my_module
This code is executed
>>> import my_module
>>> imp.reload(my_module)
This code is executed
<module 'my_module' from '.\my_module.py'>

dir() built-in function

We can use the dir() function to find the names defined within the module.

For example, we defined an add() function in the starting module example.

>>> dir(example)
['__builtins__',
'__cached__',
'__doc__',
'__file__',
'__initializing__',
'__loader__',
'__name__',
'__package__',
'add'

Here, we can see a sorted list of names (including add). All other names starting with an underscore are default Python attributes associated with the module (we did not define them ourselves).

For example, the __name__ attribute contains the name of the module.

>>> import example
>>> example.__name__
'example'

You can use the dir() function without any parameters to find all the names defined in the current namespace.

>>> a =　1
>>> b = "hello"
>>> import math
>>> dir()
['__builtins__', '__doc__', '__name__', 'a', 'b', 'math', 'pyscripter']