Importation Python à partir dun répertoire parent : un guide rapide

Vous êtes-vous déjà retrouvé plongé dans les fichiers Python, luttant pour importer un module à partir d'un répertoire parent ? Si oui, vous êtes en bonne compagnie. Le système d'importation de Python peut parfois ressembler à un labyrinthe sinueux, mais ne vous inquiétez pas, nous sommes là pour vous aider à naviguer !

Pour importer depuis un répertoire parent en Python, vous pouvez utiliser le module sys . En insérant le répertoire requis dans la liste sys.path, vous fournissez à l'interpréteur l'emplacement du module souhaité. Après avoir modifié le sys.path, vous pouvez importer le module cible à l'aide de l'instruction d'importation standard.

Dans cet article, nous allons explorer comment vous pouvez importer à partir de répertoires parents en Python. De plus, nous examinerons des cas d'utilisation spécifiques d'importation qui vous aideront à mieux comprendre la structure sous-jacente des répertoires.

Allons-y !

Table des matières

• Comment importer en Python
  • Qu'est-ce que le système d'importation Python ?
  • Démonstration de l'importation à partir du répertoire parent
    • 1. Création des répertoires et fichiers nécessaires
    • 2. Ajout de fichiers Python
    • 3. Modification des fichiers Python
    • 4. Exécution du code
  • Comment gérer ImportError et ModuleNotFoundError en Python
• Structure du répertoire Python
  • Structure du paquet
  • Que sont les fichiers init.py ?
• Chemin de recherche Python
  • 1. Qu'est-ce que la liste sys.path en Python ?
  • 2. Que sont les variables d'environnement PythonPath ?
• Importations du répertoire parent
  • 1. Importations relatives
  • 2. Ajustement de sys.path
• Comment travailler avec des modules et des packages
  • 1. Que sont les espaces de noms ?
  • 2. Que sont les variables et les définitions ?
  • 3. Que sont les déclarations d'importation ?
• Dernières pensées

Comment importer en Python

Nous allons passer directement au sujet d'aujourd'hui : importer en Python. Ces simples lignes de code au début de vos scripts Python qui commencent souvent par import ou from ? Ce sont vos tickets pour exploiter la puissance des bibliothèques et modules étendus de Python.

Dans cette section, nous allons passer en revue le code d'importation à partir du répertoire parent en Python. Nous examinerons également les erreurs potentielles pouvant survenir lors de l'importation de modules à partir du répertoire parent.

Qu'est-ce que le système d'importation Python ?

Le système d'importation Python permet une réutilisation et une organisation efficaces du code. Il vous facilite la gestion de projets complexes.

Pour importer un module ou un package en Python, vous pouvez utiliser l' instruction import . Les modules sont distribués sous forme de packages, qui sont des répertoires avec une collection de fichiers Python.

Pour importer un module depuis le répertoire parent, vous pouvez utiliser le module sys.path pour ajouter le répertoire parent au chemin de Python. Après avoir ajouté le répertoire parent, vous pouvez importer le module à l'aide de l' instruction import .

Démonstration de l'importation à partir du répertoire parent

Pour vous donner une démonstration claire de l'importation à partir du répertoire parent, passons en revue une série d'étapes pour vous aider à comprendre l'ensemble du processus.

1. Création des répertoires et fichiers nécessaires

Tout d'abord, ouvrez votre explorateur de fichiers et accédez au lecteur local souhaité. J'utilise mon lecteur E local, par conséquent, je vais créer un nouveau répertoire nommé my_project .

Dans my_project , créez un autre répertoire nommé module_dir .

Donc, vous devriez maintenant avoir :

E:
|-- /my_project
    |-- /module_dir

2. Ajout de fichiers Python

Ensuite, créez un nouveau fichier .py nommé main.py dans le répertoire my_project .

Après cela, créez un autre fichier Python nommé my_module.py dans module_dir .

Votre structure devrait maintenant ressembler à ceci :

E:
|-- /my_project
    |-- main.py
    |-- /module_dir
        |-- my_module.py

Si vous utilisez Visual Studio Code , votre structure de répertoires doit ressembler à ceci :

3. Modification des fichiers Python

Ouvrez votre my_module.py et ajoutez le code suivant :

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

Ensuite, enregistrez et fermez le fichier.

Maintenant, ouvrez main.py et ajoutez le code suivant :

import sys
import os

# Get the parent directory
parent_dir = os.path.dirname(os.path.realpath(__file__))

# Add the parent directory to sys.path
sys.path.append(parent_dir)

# Import the module from the parent directory
from module_dir import my_module

# Use a function from my_module
my_module.my_function()

Dans ce script, nous déterminons d'abord l'emplacement du répertoire à un niveau supérieur à partir du script que nous exécutons (c'est le répertoire parent). Ensuite, nous disons à Python de regarder également dans ce dossier parent lorsqu'il doit importer des modules.

Après cela, nous importons un module nommé my_module qui se trouve dans un répertoire appelé module_dir situé dans ce répertoire parent. Enfin, nous appelons une fonction nommée my_function depuis my_module .

Après avoir ajouté le code ci-dessus, enregistrez et fermez le fichier.

4. Exécution du code

Pour exécuter ce code, ouvrez le terminal de l'éditeur de code de votre choix et exécutez le fichier main.py. Si vous utilisez Visual Studio Code, la sortie doit ressembler à ceci :

Le main.py importera la fonction de my_module.py , comme indiqué dans l'image ci-dessus.

Cet exemple montre en détail comment le système de fichiers et l'importation depuis le répertoire parent fonctionnent en Python.

Comment gérer ImportError et ModuleNotFoundError en Python

Python lèvera une exception ImportError lorsque le module que vous essayez d'importer n'est pas trouvé pendant le processus d'importation.

ImportError est une sous-classe de l' exception ModuleNotFoundError . Il est déclenché lorsque le module importé n'existe pas ou ne peut pas être chargé.

Voici des exemples de scénarios dans lesquels ceux-ci peuvent se produire :

• Le module ou le package ne se trouve pas dans sys.path .

• Le nom du module ou du package est mal orthographié ou n'existe pas.

• Il y a un problème avec le code du module, l'empêchant d'être correctement importé.

Lorsque vous rencontrez ces erreurs, vous pouvez utiliser les solutions suivantes :

• Revérifier l'orthographe et l'existence du module ou du package.

• Ajout du répertoire nécessaire à sys.path en utilisant append() ou insert() .

• Résoudre tous les problèmes dans le code du module qui peuvent entraver son importation.

Pour en savoir plus sur la gestion des erreurs dans Python, regardez la vidéo suivante :

Après avoir compris le fonctionnement de l'importation dans Python, il est également important que vous vous familiarisiez avec la structure de répertoires de Python.

La structure des répertoires et l'importation vont de pair, car l'importation nécessite une compréhension de la structure des répertoires, nous allons donc en parler dans la section suivante.

Structure du répertoire Python

Comprendre la structure des répertoires Python ne se limite pas à savoir où placer vos scripts ou où trouver la bibliothèque que vous venez d'installer.

C'est comme avoir un bureau propre et bien organisé : vous saurez exactement où tout se trouve et votre productivité montera en flèche, alors passons en revue les bases dans cette section.

Structure du paquet

La structure de répertoires d'un projet Python est essentielle pour une organisation correcte. Si vous structurez correctement votre package, cela vous aidera à minimiser les risques de conflits de noms. De plus, cela vous permettra également de naviguer facilement dans votre système de fichiers.

Voici une structure de répertoire de projet Python typique :

project/
?
??? package1/
?   ??? __init__.py
?   ??? module1.py
?   ??? module2.py
?
??? package2/
?   ??? __init__.py
?   ??? module3.py
?   ??? module4.py
?
??? main.py

Dans l'exemple ci-dessus, project est le répertoire racine contenant deux sous-packages, package1 et package2 . Chaque package a ses fichiers .py et un fichier init.py unique .

Que sont les fichiers init.py ?

Les fichiers init.py sont importants pour définir le comportement du package lors de son importation. Ces fichiers sont exécutés lorsque leur package parent est importé.

Les fichiers init.py peuvent être vides ou contenir du code d'initialisation. Ils indiquent également à Python que le dossier doit être traité comme un package.

Pour importer un module depuis un répertoire parent, vous pouvez utiliser la méthode sys.path . Vous devrez ajouter le chemin du répertoire parent à sys.path .

Pour le démontrer, construisons sur notre exemple précédent. Nous avions la structure de répertoire suivante :

E:
|-- /my_project
    |-- main.py
    |-- /module_dir
        |-- my_module.py

Maintenant, ajoutons le fichier init.py au répertoire my_module . Vous pouvez laisser ce fichier vide pour l'instant. Sa présence indique à Python que ce répertoire doit être traité comme un package.

Votre structure de répertoires devrait maintenant ressembler à ceci :

Après avoir ajouté le fichier init.py , vous devez apporter des modifications à votre fichier main.py pour lui demander de traiter le dossier module_dir comme un package. Votre fichier main.py devrait maintenant avoir le code suivant :

import sys
import os

# Get the parent directory
parent_dir = os.path.dirname(os.path.realpath(__file__))

# Add the parent directory to sys.path
sys.path.append(parent_dir)

# Import my_module from the package module_dir
import module_dir

# Call my_function from my_module
my_module.my_function()

Dans cet exemple, main.py importe le package module_dir , puis appelle la fonction my_function() à partir de my_module dans ce package.

Notez le changement dans l'appel à la my_function ; comme nous traitons maintenant module_dir comme un package, nous devons inclure le nom du package lors de l'appel de fonctions à partir de modules dans le package.

The output will be similar to the previous one. The only change we made was to treat module_dir as a package with the inclusion of init.py file.

Python Search Path

Ever wondered how Python knows where to find the modules you’re trying to import? Or maybe you’ve encountered an annoying ‘ModuleNotFoundError’ and couldn’t figure out why?

In this section, we’re going to tackle these mysteries head-on and delve into the concept of the Python search path.

The Python search path, also known as sys.path, is Python’s little roadmap to finding all the modules you need. Like a diligent scout, Python uses this path to scour your computer for modules whenever you use the import statement.

Understanding how it works can save you from headaches and help you troubleshoot when things go awry, so let’s go over some basics!

1. What is the sys.path List in Python?

The sys.path list is a crucial component when importing modules in a directory. It’s a list of strings that represents the module search path.

Each string in the list is a directory location where Python looks for modules (*.py files) or packages (folders containing init.py files).

The following example shows you how to view your current sys.path list:

import sys

for path in sys.path:
    print(path)

After running the above code, you’ll see an output like the following:

You can also add new directories to the sys.path list so that Python finds your custom modules.

For instance:

import sys
sys.path.append('/path/to/new/module/directory')

2. What are PythonPath Environment Variables?

Another way you can manage the module search path is by using the PYTHONPATH environment variable.

PYTHON PATH is a string containing a list of directories that is appended to the default sys.path list. This means you can add directories to PYTHONPATH. This allows Python to search for modules in those directories when importing.

Setting the PYTHONPATH environment variable depends on your operating system:

• Unix-based systems (Linux, macOS): You can use the export command in your terminal or add the following line to your shell configuration file (.bashrc, .zshrc or similar):

  export PYTHONPATH="/path/to/module/directory1:/path/to/module/directory2"

• Windows OS: Go to System Properties > Environment Variables, and under User variables, click New to create a new variable with the name: “PYTHONPATH” and the value as a list of directory paths separated by a semi-colon (;).

  C:pathtomoduledirectory1;C:pathtomoduledirectory2
  

Once the path variable is set, you can run your Python script. It will search for imported modules in those directories as well as the default ones in sys.path.

When organizing your code into files and folders, you’ll frequently come across relative imports and adjusting sys.path.

In the next section, we’ll explore both and see how they fit into the framework for Python imports.

Parent Directory Imports

You can organize code into different folders and files to improve both readability and maintainability. However, importing modules from parent directories can be a bit tricky.

In this section, we’ll discuss two approaches to achieve this:

1. Relative Imports

2. Adjusting sys.path

1. Relative Imports

Relative imports allow you to import modules based on their relative position in the directory hierarchy.

You can use the dot (.) notation to refer to the current directory or double dot (..) notation to refer to the parent directory.

Suppose you have a directory structure like the following:

parent_directory/
?
??? module_a.py
?
??? sibling_directory/
    ??? module_b.py

Inside module_b.py, you can use relative imports to access module_a.py:

from .. import module_a

The double dot refers to the parent directory. It is important to note that relative imports only work if the parent directory is a package (has an init.py file).

2. Adjusting sys.path

You can also import modules from a parent directory by modifying the sys.path.

Avant l' instruction d'importation , vous pouvez ajouter le chemin du répertoire parent au sys.path . Tout d'abord, vous devez importer le module sys . Ensuite, vous utilisez le module os pour obtenir le chemin du répertoire parent.

Supposons que vous ayez une structure de répertoires comme celle-ci :

project_root/
?
??? parent_directory/
?   ??? module_a.py
?
??? current_directory/
    ??? module_b.py

Dans module_b.py , vous pouvez ajouter le chemin du répertoire parent à sys.path comme ceci :

import os
import sys

parent_dir = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
sys.path.append(parent_dir)

import module_a

Désormais, Python recherchera module_a.py dans le répertoire parent lors de son importation dans module_b.py .

Vous pouvez utiliser l'approche d'importation relative ou l' approche sys.path pour importer des modules à partir d'un répertoire parent.

Comment travailler avec des modules et des packages

En Python, les modules et les packages sont un moyen d'organiser et de réutiliser le code. Vous pouvez les utiliser pour diviser des projets complexes en parties gérables.

Cette section explique comment travailler avec des modules et des packages en Python . Nous inclurons également des concepts clés tels que :

1. Espaces de noms

2. Variables et définitions

3. Importer des relevés

1. Que sont les espaces de noms ?

Les espaces de noms en Python sont un moyen de s'assurer que les noms des variables, des fonctions et des classes n'entrent pas en conflit entre différents modules.

Il existe différents niveaux d'espaces de noms en Python, tels que :

• Espace de noms global : fait référence à l'espace de noms de l'ensemble du module.

• Espace de noms local : fait référence à l'espace de noms au sein d'une fonction ou d'une classe.

Vous pouvez obtenir un nom dans un espace de noms particulier avec la notation namespace[name] .

2. Que sont les variables et les définitions ?

Dans un script Python, vous pouvez définir des variables, des fonctions et des classes. Ces définitions sont stockées dans l'espace de noms du script.

En important le script en tant que package, vous pouvez accéder à ses définitions et les réutiliser dans d'autres parties de votre projet.

Voici un exemple de définition d'une variable et d'une fonction dans le même espace de noms :

# my_variable.py
my_variable = 5

def my_function(x):
    return x + my_variable

Ce module a une variable my_variable et une fonction my_function .

Pour exécuter ce code, vous pouvez créer un nouveau fichier nommé my_variable.py et y mettre le code comme indiqué ci-dessous :

Maintenant, vous pouvez importer ce fichier et l'utiliser dans un autre script comme indiqué ci-dessous :

Après avoir exécuté le fichier main.py , vous obtiendrez une sortie semblable à celle-ci :

3. Que sont les déclarations d'importation ?

Vous pouvez importer des fichiers, des modules ou des packages en Python avec l' instruction d'importation

Voici quelques méthodes d'importation courantes :

• import module_name : Cette méthode importe un module, rendant toutes ses définitions accessibles avec la notation module_name.definition_name .

import mymodule

result = mymodule.my_function(3)

• from module_name import some_definition : Cette méthode importe une définition spécifique d'un module, vous permettant de l'utiliser directement sans le préfixe du module.

from mymodule import my_function

result = my_function(3)

• from module_name import * : Cette méthode importe toutes les définitions d'un module, mais elle n'est pas recommandée car elle peut entraîner des conflits de nommage.

Dernières pensées

Comprendre comment importer à partir d'un répertoire parent en Python est important pour maintenir une base de code organisée.

Cette connaissance vous permet de concevoir vos projets de manière plus modulaire. Cela augmente également la réutilisabilité de votre code. En structurant votre code en modules et packages distincts, vous pouvez éviter de répéter le code et faciliter sa maintenance et sa mise à jour.

La compétence pour utiliser les instructions import et from est particulièrement utile lorsque vous travaillez sur des projets plus importants où les fonctionnalités sont réparties dans différents répertoires.

En sachant ajuster correctement le chemin de Python pour importer des modules, vous pouvez accéder aux fonctionnalités définies dans un répertoire tout en travaillant dans un autre.

N'oubliez pas que la clé de la maîtrise de Python - ou de tout langage de programmation - réside dans une pratique constante et une curiosité insatiable. Alors, continuez à explorer, continuez à expérimenter et continuez à vous mettre au défi.

Avec ce guide rapide, vous devriez être bien équipé pour gérer toutes les énigmes d'importation que Python vous lance. Mais ne vous arrêtez pas là. Il y a tout un univers de techniques et d'astuces Python à découvrir !