Comment vérifier si un module est importé depuis un chemin spécifique en Python

Introduction

Dans ce laboratoire (lab), vous apprendrez à vérifier si un module Python est importé depuis un chemin spécifique. Le laboratoire se concentre sur la compréhension des chemins des modules et sur la façon dont Python recherche les modules à l'aide de sys.path.

Vous commencerez par explorer sys.path pour voir la liste des répertoires que Python utilise pour trouver les modules. Ensuite, vous créerez un simple module et un script principal pour l'importer, en apprenant à accéder à l'attribut __file__ d'un module pour déterminer son emplacement et le comparer avec un chemin attendu. Cela vous permettra de vérifier la source des modules importés dans vos projets Python.

Comprendre les chemins des modules

Dans cette étape, vous apprendrez comment Python gère les chemins des modules et comment déterminer l'emplacement d'un fichier de module. Comprendre les chemins des modules est crucial pour gérer et organiser vos projets Python.

Python utilise une liste de répertoires pour rechercher les modules lorsque vous les importez. Cette liste est stockée dans la variable sys.path. Explorons comment afficher et comprendre ce chemin.

Ouvrez l'éditeur VS Code dans l'environnement LabEx.
Créez un nouveau fichier nommé module_path.py dans le répertoire ~/project.
```
import sys

print(sys.path)
```
Ce script importe le module sys puis affiche la valeur de sys.path, qui est une liste de chemins de répertoires.
Exécutez le script en utilisant la commande suivante dans le terminal :
```
python module_path.py
```
Vous verrez une liste de chemins de répertoires affichée dans le terminal. C'est l'ordre dans lequel Python recherche les modules. La sortie ressemblera à ceci :
```
['/home/labex/project', '/usr/lib/python310.zip', '/usr/lib/python3.10', '/usr/lib/python3.10/lib-dynload', '/usr/local/lib/python3.10/dist-packages', '/usr/lib/python3/dist-packages']
```
Le premier chemin de la liste, /home/labex/project, est le répertoire de travail actuel. Cela signifie que Python cherchera d'abord les modules dans le répertoire où vous exécutez le script.

Les autres chemins sont des répertoires système où les bibliothèques Python sont installées.
Maintenant, créons un simple module et voyons comment Python le trouve. Créez un nouveau fichier nommé my_module.py dans le répertoire ~/project.
```
def my_function():
    return "Hello from my_module!"
```
Ce module définit une seule fonction appelée my_function.
Créez un autre fichier nommé main.py dans le répertoire ~/project.
```
import my_module

result = my_module.my_function()
print(result)
```
Ce script importe le module my_module et appelle la fonction my_function.
Exécutez le script main.py :
```
python main.py
```
Vous devriez voir la sortie suivante :
```
Hello from my_module!
```
Cela montre que Python a pu trouver et importer le module my_module car il est situé dans le même répertoire que le script main.py, qui est dans sys.path.

Accéder à l'attribut file

Dans cette étape, vous apprendrez à accéder à l'attribut __file__ en Python. L'attribut __file__ fournit le chemin du fichier à partir duquel un module est chargé. Cela est utile pour déterminer l'emplacement de votre code et pour travailler avec des chemins relatifs.

Ouvrez l'éditeur VS Code dans l'environnement LabEx.
Modifiez le fichier my_module.py dans le répertoire ~/project pour inclure le code suivant :
```
def my_function():
    return "Hello from my_module!"

print(f"The location of my_module is: {__file__}")
```
Ce script affiche maintenant la valeur de l'attribut __file__.
Exécutez à nouveau le script main.py :
```
python main.py
```
Vous devriez voir une sortie similaire à ceci :
```
The location of my_module is: /home/labex/project/my_module.py
Hello from my_module!
```
La première ligne montre le chemin absolu du fichier my_module.py. C'est la valeur de l'attribut __file__.

Remarque : L'attribut __file__ peut afficher un chemin relatif ou ne pas être disponible dans certains cas, par exemple lorsque le module fait partie d'une archive zip ou lorsqu'il est exécuté directement dans l'interpréteur interactif.
Créons un autre module dans un sous - répertoire pour explorer davantage __file__. Créez un nouveau répertoire nommé utils à l'intérieur du répertoire ~/project :
```
mkdir ~/project/utils
```

Créez un nouveau fichier nommé helper.py à l'intérieur du répertoire ~/project/utils :

def helper_function():
    return "Hello from helper!"

print(f"The location of helper is: {__file__}")

Modifiez le fichier main.py pour importer et utiliser le module helper.py :

import my_module
from utils import helper

result_my_module = my_module.my_function()
print(result_my_module)

result_helper = helper.helper_function()
print(result_helper)

Exécutez le script main.py :
```
python main.py
```
Vous devriez voir une sortie similaire à ceci :
```
The location of my_module is: /home/labex/project/my_module.py
Hello from my_module!
The location of helper is: /home/labex/project/utils/helper.py
Hello from helper!
```
Cela démontre comment __file__ fournit le chemin de chaque module, quelle que soit son emplacement dans la structure du projet.

Comparer avec le chemin attendu

Dans cette étape, vous apprendrez à comparer l'attribut __file__ avec un chemin attendu pour vous assurer que votre script s'exécute depuis l'emplacement correct. Cela est utile pour valider votre environnement et éviter les erreurs causées par des chemins de fichiers incorrects.

Ouvrez l'éditeur VS Code dans l'environnement LabEx.

Modifiez le fichier my_module.py dans le répertoire ~/project pour inclure une comparaison avec un chemin attendu :

import os

def my_function():
    return "Hello from my_module!"

expected_path = os.path.abspath(__file__)
current_path = os.path.abspath("/home/labex/project/my_module.py")

if expected_path == current_path:
    print("The script is running from the expected location.")
else:
    print(f"The script is running from an unexpected location: {__file__}")
    print(f"Expected location: {current_path}")

print(f"The location of my_module is: {__file__}")

Ce script compare maintenant le chemin absolu de __file__ avec le chemin absolu attendu /home/labex/project/my_module.py.

Nous utilisons os.path.abspath() pour nous assurer que les deux chemins sont absolus, ce qui rend la comparaison plus fiable.

Exécutez à nouveau le script main.py :
```
python main.py
```
Vous devriez voir une sortie similaire à ceci :
```
The script is running from the expected location.
The location of my_module is: /home/labex/project/my_module.py
Hello from my_module!
The location of helper is: /home/labex/project/utils/helper.py
Hello from helper!
```
Si le script s'exécute depuis l'emplacement attendu, il affichera "The script is running from the expected location." Sinon, il affichera l'emplacement actuel et l'emplacement attendu.
Pour tester le scénario "emplacement inattendu", vous pouvez déplacer temporairement le fichier my_module.py dans un autre répertoire et exécuter main.py à nouveau. Cependant, dans le cadre de ce laboratoire, nous supposerons que le fichier est à l'emplacement correct.

Important : Dans un scénario réel, vous utiliserez cette technique pour valider que votre script s'exécute dans le bon environnement et pour gérer les cas où le script s'exécute depuis un emplacement inattendu.

Résumé

Dans ce laboratoire, vous avez appris comment Python gère les chemins des modules et comment déterminer l'emplacement d'un fichier de module. Vous avez exploré la variable sys.path, qui contient une liste de répertoires que Python recherche lors de l'importation de modules. Vous avez créé un script pour afficher sys.path et observé l'ordre dans lequel Python recherche les modules, en commençant par le répertoire de travail actuel.

De plus, vous avez créé un simple module nommé my_module.py et l'avez importé dans main.py. Cela a démontré comment Python localise et importe des modules dans les chemins de recherche définis.