Python-Import aus einem übergeordneten Verzeichnis: Eine Kurzanleitung

Waren Sie schon einmal knietief in Python-Dateien versunken und hatten Schwierigkeiten, ein Modul aus einem übergeordneten Verzeichnis zu importieren? Dann sind Sie in guter Gesellschaft. Das Importsystem von Python kann manchmal wie ein verwinkeltes Labyrinth wirken, aber keine Sorge, wir sind hier, um Ihnen bei der Navigation zu helfen!

Zum Importieren aus einem übergeordneten Verzeichnis in Python können Sie das sys- Modul verwenden. Durch Einfügen des erforderlichen Verzeichnisses in die sys.path-Liste geben Sie dem Interpreter den Speicherort des gewünschten Moduls an. Nachdem Sie den sys.path geändert haben, können Sie das Zielmodul mit der Standard-Importanweisung importieren.

In diesem Artikel untersuchen wir, wie Sie in Python aus übergeordneten Verzeichnissen importieren können. Darüber hinaus betrachten wir spezifische Anwendungsfälle des Imports, die Ihnen helfen, die zugrunde liegende Struktur der Verzeichnisse besser zu verstehen.

Lasst uns loslegen!

Inhaltsverzeichnis

• So importieren Sie in Python
  • Was ist das Python-Importsystem?
  • Demonstration des Imports aus dem übergeordneten Verzeichnis
    • 1. Erstellen der erforderlichen Verzeichnisse und Dateien
    • 2. Python-Dateien hinzufügen
    • 3. Bearbeiten der Python-Dateien
    • 4. Ausführen des Codes
  • Umgang mit ImportError und ModuleNotFoundError in Python
• Python-Verzeichnisstruktur
  • Paketstruktur
  • Was sind init.py-Dateien?
• Python-Suchpfad
  • 1. Was ist die sys.path-Liste in Python?
  • 2. Was sind PythonPath-Umgebungsvariablen?
• Importe von übergeordneten Verzeichnissen
  • 1. Relative Importe
  • 2. sys.path anpassen
• So arbeiten Sie mit Modulen und Paketen
  • 1. Was sind Namespaces?
  • 2. Was sind Variablen und Definitionen?
  • 3. Was sind Importanweisungen?
• Abschließende Gedanken

So importieren Sie in Python

Wir springen direkt zum heutigen Thema: Importieren in Python. Diese einfachen Codezeilen am Anfang Ihrer Python-Skripte, die oft mit import oder from beginnen ? Dies ist Ihre Eintrittskarte, um die Leistungsfähigkeit der umfangreichen Bibliotheken und Module von Python zu nutzen.

In diesem Abschnitt gehen wir den Code für den Import aus dem übergeordneten Verzeichnis in Python durch. Wir werden uns auch mit möglichen Fehlern befassen, die beim Importieren von Modulen aus dem übergeordneten Verzeichnis auftreten können.

Was ist das Python-Importsystem?

Das Python-Importsystem ermöglicht eine effiziente Wiederverwendung und Organisation von Code. Es erleichtert Ihnen die Pflege komplexer Projekte.

Um ein Modul oder Paket in Python zu importieren, können Sie die Importanweisung verwenden . Module werden als Pakete verteilt, bei denen es sich um Verzeichnisse mit einer Sammlung von Python-Dateien handelt.

Um ein Modul aus dem übergeordneten Verzeichnis zu importieren, können Sie das Modul sys.path verwenden , um das übergeordnete Verzeichnis zum Python-Pfad hinzuzufügen. Nachdem Sie das übergeordnete Verzeichnis hinzugefügt haben, können Sie das Modul mit der Importanweisung importieren .

Demonstration des Imports aus dem übergeordneten Verzeichnis

Um Ihnen den Import aus dem übergeordneten Verzeichnis anschaulich zu veranschaulichen, gehen wir eine Reihe von Schritten durch, damit Sie den gesamten Vorgang verstehen.

1. Erstellen der erforderlichen Verzeichnisse und Dateien

Öffnen Sie zunächst Ihren Datei-Explorer und navigieren Sie zu Ihrem gewünschten lokalen Laufwerk. Ich verwende mein lokales Laufwerk E und erstelle daher ein neues Verzeichnis mit dem Namen my_project .

Erstellen Sie in my_project ein weiteres Verzeichnis mit dem Namen module_dir .

Sie sollten also jetzt Folgendes haben:

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

2. Python-Dateien hinzufügen

Erstellen Sie als Nächstes eine neue .py- Datei mit dem Namen main.py im Verzeichnis my_project .

Erstellen Sie anschließend eine weitere Python-Datei mit dem Namen my_module.py in module_dir .

Ihre Struktur sollte nun so aussehen:

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

Wenn Sie Visual Studio Code verwenden , sollte Ihre Verzeichnisstruktur wie folgt aussehen:

3. Bearbeiten der Python-Dateien

Öffnen Sie Ihre my_module.py und fügen Sie den folgenden Code hinzu:

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

Fahren Sie dann fort und speichern und schließen Sie die Datei.

Öffnen Sie nun main.py und fügen Sie den folgenden Code hinzu:

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()

In diesem Skript ermitteln wir zunächst den Speicherort des Verzeichnisses eine Ebene über dem Skript, das wir ausführen (das ist das übergeordnete Verzeichnis). Dann weisen wir Python an, auch in diesem übergeordneten Ordner nachzuschauen, wenn Module importiert werden müssen.

Anschließend importieren wir ein Modul namens „ my_module“ , das sich in einem Verzeichnis namens „ module_dir“ in diesem übergeordneten Verzeichnis befindet. Schließlich rufen wir eine Funktion namens my_function aus my_module auf .

Speichern und schließen Sie die Datei, nachdem Sie den obigen Code hinzugefügt haben.

4. Ausführen des Codes

Um diesen Code auszuführen, öffnen Sie das Terminal Ihres gewünschten Code-Editors und führen Sie die Datei main.py aus. Wenn Sie Visual Studio Code verwenden, sollte die Ausgabe wie folgt aussehen:

main.py importiert die Funktion aus my_module.py , wie im Bild oben gezeigt.

Dieses Beispiel zeigt im Detail, wie das Dateisystem und der Import aus dem übergeordneten Verzeichnis in Python funktionieren.

Umgang mit ImportError und ModuleNotFoundError in Python

Python löst eine ImportError- Ausnahme aus, wenn das Modul, das Sie importieren möchten, während des Importvorgangs nicht gefunden wird.

ImportError ist eine Unterklasse der ModuleNotFoundError- Ausnahme. Es wird ausgelöst, wenn das importierte Modul nicht existiert oder nicht geladen werden kann.

The following are examples of scenarios when these may occur:

• The module or package is not in the sys.path.

• The module or package name is misspelled or does not exist.

• There is a problem with the module’s code, preventing it from being properly imported.

When encountering these errors, you could use the following solutions:

• Double-checking the spelling and existence of the module or package.

• Adding the necessary directory to sys.path using append() or insert().

• Fixing any issues in the module’s code that may be hindering its import.

To learn more about handling errors in Python, check the following video out:

After understanding how importing works in Python, it’s also important that you gain some familiarity with Python’s directory structure.

Directory structure and importing go hand-in-hand with each other as importing requires an understanding of the directory structure, so let’s go over that in the next section.

Python Directory Structure

Understanding the Python directory structure is more than just knowing where to put your scripts or where to find that library you just installed.

It’s like having a clean, well-organized desk: you’ll know exactly where everything is, and your productivity will skyrocket, so let’s go over the basics in this section.

Package Structure

The directory structure of a Python project is essential for correct organization. If you structure your package properly, it’ll help you minimize the chance of naming conflicts. Furthermore, it’ll also enable you to easily navigate through your filesystem.

The following is a typical Python project directory structure:

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

In the example above, project is the root directory containing two sub-packages, package1 and package2. Each package has its .py files and a unique init.py file.

What Are init.py Files?

init.py files are important for defining the package’s behavior when it’s imported. These files are executed when their parent package is imported.

The init.py files can be empty or contain initialization code. They also indicate to Python that the folder should be treated as a package.

To import a module from a parent directory, you can use the sys.path method. You’ll need to append the parent directory path to sys.path.

To demonstrate this, let’s build up on our previous example. We had the following directory structure:

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

Now, let’s add the init.py file to my_module directory. You can leave this file empty for now. Its presence indicates to Python that this directory should be treated as a package.

Your directory structure should now look like the following:

After adding the init.py file, you must make changes to your main.py file to instruct it to treat the module_dir folder as a package. Your main.py file should now have the following code:

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()

In this example, main.py imports the module_dir package, and then calls the function my_function() from my_module within that package.

Note the change in the call to the my_function; because we are now treating module_dir as a package, we have to include the package name when calling functions from modules within the 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.

Vor der Importanweisung können Sie den Pfad des übergeordneten Verzeichnisses an sys.path anhängen . Zuerst müssen Sie das sys- Modul importieren. Anschließend verwenden Sie das OS- Modul, um den Pfad des übergeordneten Verzeichnisses abzurufen.

Angenommen, Sie haben eine Verzeichnisstruktur wie die folgende:

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

In module_b.py können Sie den übergeordneten Verzeichnispfad wie folgt an sys.path anhängen:

import os
import sys

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

import module_a

Jetzt sucht Python im übergeordneten Verzeichnis nach module_a.py , wenn es in module_b.py importiert wird .

Sie können entweder den relativen Importansatz oder den sys.path- Ansatz verwenden, um Module aus einem übergeordneten Verzeichnis zu importieren.

So arbeiten Sie mit Modulen und Paketen

In Python sind Module und Pakete eine Möglichkeit, Code zu organisieren und wiederzuverwenden. Mit ihnen können Sie komplexe Projekte in überschaubare Teile aufteilen.

In diesem Abschnitt wird erläutert, wie Sie mit Modulen und Paketen in Python arbeiten . Wir werden auch Schlüsselkonzepte einbeziehen wie:

1. Namensräume

2. Variablen und Definitionen

3. Anweisungen importieren

1. Was sind Namespaces?

Namespaces in Python sind eine Möglichkeit, sicherzustellen, dass die Namen von Variablen, Funktionen und Klassen zwischen verschiedenen Modulen nicht in Konflikt geraten.

In Python gibt es verschiedene Ebenen von Namespaces, wie zum Beispiel:

• Globaler Namespace: Bezieht sich auf den Namespace des gesamten Moduls.

• Lokaler Namespace: Bezieht sich auf den Namespace innerhalb einer Funktion oder Klasse.

Sie können einen Namen in einem bestimmten Namespace mit der Notation namespace[name] erhalten .

2. Was sind Variablen und Definitionen?

In einem Python-Skript können Sie Variablen, Funktionen und Klassen definieren. Diese Definitionen werden im Namensraum des Skripts gespeichert.

Durch den Import des Skripts als Paket können Sie auf seine Definitionen zugreifen und diese in anderen Teilen Ihres Projekts wiederverwenden.

Das Folgende ist ein Beispiel dafür, wie eine Variable und eine Funktion im selben Namespace definiert werden:

# my_variable.py
my_variable = 5

def my_function(x):
    return x + my_variable

Dieses Modul verfügt über eine Variable my_variable und eine Funktion my_function .

Um diesen Code auszuführen, können Sie eine neue Datei mit dem Namen my_variable.py erstellen und den Code wie unten gezeigt dort einfügen:

Jetzt können Sie diese Datei importieren und wie unten gezeigt in einem anderen Skript verwenden:

Nach dem Ausführen der Datei „main.py“ erhalten Sie eine Ausgabe ähnlich der folgenden:

3. Was sind Importanweisungen?

Mit der Import- Anweisung können Sie Dateien, Module oder Pakete in Python importieren

Einige gängige Importmethoden sind:

• import module_name : Diese Methode importiert ein Modul und macht alle seine Definitionen mit der Notation module_name.definition_name zugänglich .

import mymodule

result = mymodule.my_function(3)

• from module_name import some_definition : Diese Methode importiert eine bestimmte Definition aus einem Modul, sodass Sie sie direkt ohne das Modulpräfix verwenden können.

from mymodule import my_function

result = my_function(3)

• from module_name import * : Diese Methode importiert alle Definitionen aus einem Modul, wird jedoch nicht empfohlen, da sie zu Namenskonflikten führen kann.

Abschließende Gedanken

Um eine organisierte Codebasis aufrechtzuerhalten, ist es wichtig zu verstehen, wie man in Python aus einem übergeordneten Verzeichnis importiert.

Dieses Wissen ermöglicht es Ihnen, Ihre Projekte modularer zu gestalten. Es erhöht auch die Wiederverwendbarkeit Ihres Codes. Durch die Strukturierung Ihres Codes in separate Module und Pakete können Sie die Wiederholung von Code vermeiden und die Wartung und Aktualisierung vereinfachen.

Die Fähigkeit, Import- und From -Anweisungen zu verwenden, ist besonders wertvoll, wenn Sie an größeren Projekten arbeiten, bei denen die Funktionalitäten auf verschiedene Verzeichnisse aufgeteilt sind.

Wenn Sie wissen, wie Sie den Python-Pfad zum Importieren von Modulen richtig anpassen, können Sie auf die in einem Verzeichnis definierten Funktionen zugreifen, während Sie in einem anderen arbeiten.

Denken Sie daran, dass der Schlüssel zur Beherrschung von Python – oder jeder anderen Programmiersprache – in konsequenter Übung und unstillbarer Neugier liegt. Erforschen Sie also weiter, experimentieren Sie weiter und fordern Sie sich weiterhin selbst heraus.

Mit dieser Kurzanleitung sollten Sie gut gerüstet sein, um alle Import-Rätsel zu meistern, die Python Ihnen aufwirft. Aber hören Sie hier nicht auf. Es gibt ein ganzes Universum an Python-Techniken und -Tricks, die darauf warten, entdeckt zu werden!