Funktionen und Klassen aus Python-Dateien importieren – Vollständiger Leitfaden

1. Gründe und Vorteile des Aufrufens separater Dateien in Python

Wenn Programme größer werden, wird die Aufteilung des Codes wichtig

Beim Einstieg in das Lernen von Python ist es in Ordnung, alle Logik in einer einzigen Datei zu schreiben. Allerdings wird die Logik mit wachsendem Code komplexer, und die Verwaltung von allem in einer Datei wird schwierig.

Dann wird der strukturierte Ansatz wichtig, Funktionen und Klassen in separaten Dateien zu definieren und sie bei Bedarf aufzurufen. Dies macht den Code lesbarer und verbessert die Wartbarkeit und Wiederverwendbarkeit erheblich.

Erhöhung der Code-Wiederverwendbarkeit

Zum Beispiel gibt es viele Funktionen, die Sie in mehreren Skripten wiederverwenden möchten, wie Funktionen zum Formatieren von Strings oder Datumsangaben. Wenn Sie solche Logik in einer separaten Datei zusammenfassen, können Sie sie in anderen Skripten einfach durch importieren verwenden.

# Definiert in utils.py
def format_date(date):
    return date.strftime('%Y-%m-%d')

# Aufgerufen aus main.py
from utils import format_date

Durch das können Sie Code, den Sie einmal geschrieben haben, so oft wie nötig wiederverwenden und die Produktivität erheblich steigern.

Verbesserte Wartbarkeit und Lesbarkeit

Wenn Sie alle Logik in einer einzigen Datei schreiben, wird es schwierig, die Ursache von Fehlern zu lokalisieren, wenn sie auftreten. Es macht es auch anderen schwerer, den Code zu verstehen.

Wenn Sie Dateien nach Funktionalität verwalten,

• Datenbankverarbeitung ist in dieser Datei
• Validierung der Benutzereingaben ist in dieser Datei

werden die Verantwortlichkeiten klar.

Als Ergebnis,

• Fehlerbehebungen werden schneller
• Konflikte werden sogar in der Team-Entwicklung reduziert
• Code-Reviews werden einfacher

erhalten Sie diese Vorteile.

Essentielle Fähigkeit für umfassende Projekte

Beim Erstellen von Web-Anwendungen mit Python oder beim Verwalten mehrerer Machine-Learning-Modelle in einem Projekt ist die Aufteilung von Dateien und die Organisation der Funktionalität eine grundlegende Praxis. Sogar beim Einsatz von Frameworks (wie Django oder FastAPI) ist das Verständnis von Verzeichnisstrukturen und dem Konzept der Imports eine Voraussetzung.

Daher sollten sogar Python-Anfänger frühzeitig das Wissen darüber erwerben, „wie man Funktionen oder Klassen aus separaten Dateien aufruft“.

2. Wie man grundlegende Python-import-Anweisungen verwendet

Was ist eine import-Anweisung?

In Python verwenden Sie die import-Anweisung, wenn Sie Funktionen oder Klassen aus anderen Dateien (Modulen) verwenden möchten. Damit können Sie Code, der in einer anderen Datei definiert ist, so aufrufen, als ob er in derselben Datei wäre.

In Python ermöglicht dieser Mechanismus das Laden von Funktionen der Standardbibliothek oder die Verwendung Ihrer eigenen Module.

Grundlegender Import zum Laden von Dateien im selben Ordner

Die grundlegendste Verwendung besteht darin, eine andere Datei im selben Verzeichnis zu importieren.

Zum Beispiel betrachten Sie die folgende Struktur.

project/
├── main.py
└── utils.py

Wenn Sie eine in utils.py definierte Funktion aus main.py verwenden möchten, schreiben Sie es wie folgt.

# utils.py
def greet(name):
    return f"Hallo, {name}!"

# main.py
import utils

print(utils.greet("Sagawa"))

Auf diese Weise können Sie durch Angabe des Dateinamens die enthaltenen Funktionen und Variablen verwenden.
Beim Zugriff auf eine Funktion verwenden Sie das Format „module_name.function_name“.

Importieren spezifischer Funktionen mit der from-import-Syntax

Wenn Sie nur spezifische Funktionen verwenden möchten, können Sie sie in der Form from module_name import function_name schreiben.

# main.py
from utils import greet

print(greet("Sagawa"))

Dadurch können Sie greet() statt utils.greet() schreiben. Außerdem können Sie mehrere Funktionen auf einmal importieren, indem Sie sie mit Kommas trennen.

from utils import greet, farewell

Verwendung eines Aliases mit import

Wenn der Modulname lang ist oder Sie ihn vereinfachen möchten, können Sie as verwenden, um einen Alias anzugeben.

import utils as ut

print(ut.greet("Sagawa"))

Dies ermöglicht es, den Code knapp zu halten und Konflikte mit anderen Modulen zu vermeiden.

Achten Sie darauf, wo Sie import-Anweisungen platzieren

In Python wird allgemein empfohlen, import-Anweisungen oben in der Datei zu platzieren. Allerdings können Sie in Ausnahmefällen, in denen eine Bibliothek nur an einem bestimmten Punkt benötigt wird, den Import innerhalb einer Funktion schreiben.

def use_numpy_temporarily():
    import numpy as np
    return np.array([1, 2, 3])

Dennoch ist die beste Praxis für Lesbarkeit und Wartbarkeit, Imports im Allgemeinen oben zu konsolidieren.

3. Aufrufen von Dateien aus Unterverzeichnissen oder anderen Ordnern

Importmethoden variieren je nach Ordnerstruktur in Python

When a Python script is split across multiple folders, there are cases wherea simple import statement cannot load the file.
In such situations,understanding the correct path specification and the underlying mechanism is necessary.
This section explains how to call functions and classes from files located in subdirectories or other folders, with concrete examples.

Importing Files from a Subdirectory

First, assume a directory structure like the following.

project/
├── main.py
└── tools/
    └── formatter.py

If you want to call a function in formatter.py from main.py, you generally write it as follows.

# tools/formatter.py
def shout(text):
    return text.upper() + "!"

# main.py
from tools import formatter

print(formatter.shout("hallo"))

Or, if you only want to use the function:

from tools.formatter import shout

print(shout("hallo"))

In this way, you specify the file in a subdirectory using the“directory_name.file_name”syntax.

Sometimes an __init__.py Is Needed to Treat It as a Package

In older Python versions (≤3.2) or some tools, a __init__.py is requiredto have the subdirectory recognized as a module (package).

tools/
├── __init__.py
└── formatter.py

In this case, simply placing an empty __init__.py file is sufficient. It’s not required in Python 3.3 and later, butincluding it provides peace of mind.

Importing Files from Parent or Sibling Folders

Now consider importing a file that resides in a different folder. Let’s look at the following layout:

project/
├── main.py
└── modules/
    └── helper.py

In this case, Python does not include the modules/ directory in its default search path, so you need to take measures such as the following.

Solution 1: Add the Path Using sys.path

# main.py
import sys
import os
sys.path.append(os.path.join(os.path.dirname(__file__), 'modules'))

import helper

print(helper.some_function())

This way, you canadd an arbitrary folder to Python’s module search path.
It is especiallyeffective when running the script from the project root.

Solution 2: Pay Attention to Where You Run Python

Python imports are affected by thelocation from which you run the script (current directory).
Whether you runcode>main.py from within the project/ directory or from modules/ can affect whether the import succeeds.

# Correct way to run
cd project
python main.py

Also, in editors like VSCode, the behavior of the“Run Python File” button can affect the script’s execution path, so be cautious.

Be Aware of the Difference Between Absolute and Relative Imports

• from modules.helper import func statements areabsolute imports
• from ..modules import helper statements arerelative imports

Relative imports are convenient, but theytend to raise errors depending on the location of the executing file.
In general,using absolute imports is recommended.

4. Unterschiede zwischen relativen und absoluten Imports und wie man wählt

Es gibt zwei Arten von Imports in Python

When calling another file in Python, there are mainly two methods.

• Absoluter Import (absolute import)
• Relativer Import (relative import)

Diese beiden haben denselben Zweck, aberdie Syntax und die geeigneten Anwendungsfälle unterscheiden sich, daher ist es wichtig, je nach Situation korrekt zu wählen.

Was ist ein absoluter Import?

Ein absoluter Import spezifiziert ein Modul unter Verwendung eines Pfads vom Root-Verzeichnis des Projekts. Es ist der gängigste und empfohlene Stil in vielen Projekten.

from tools.formatter import shout

Wie oben gezeigt, spezifizieren Sie es in der Form ‚Verzeichnisname.Dateiname.Funktionsname‘.Vorteile

• Leicht lesbar und klar
• Läuft stabil in verschiedenen Ausführungsumgebungen
• Macht es anderen Entwicklern leichter, die Struktur zu verstehen

Nachteile

• Kann lang werden (umständlich in tiefen Hierarchien)

Was ist ein relativer Import?

Ein relativer Import spezifiziert ein Modul relativ zum Standort der aktuellen Datei. Er wird hauptsächlich für interne Modulaufrufe innerhalb eines Pakets verwendet.

from . import formatter          # gleiches Verzeichnis
from ..tools import formatter   # eine Ebene höher

. (Punkt) bezieht sich auf das aktuelle Verzeichnis, .. (zwei Punkte) zeigt eine Ebene höher an.Vorteile

• Klare Beziehungen innerhalb des Pakets
• Ermöglicht flexible Navigation innerhalb desselben Pakets

Nachteile

• Fehleranfällig je nach Skriptstandort
• Nicht geeignet für Skripte, die direkt von außen ausgeführt werden
• Kann in komplexen Strukturen schwer lesbar werden

Welchen sollte man verwenden? Wie wählt man in der Praxis?

Generell empfiehlt auch die offizielle Python-Dokumentation Folgendes:

• Wenn die Bibliothek oder das Projekt von außen aufgerufen werden soll: absoluter Import
• Für einfache Modulinteraktion innerhalb eines Pakets: relativer Import

Auch,für Anfänger und kleine bis mittelgroße Projekte reduziert die Verwendung absoluter Imports als Standard Probleme.

Reales Fehlbeispiel: Relativer Import funktioniert nicht?

# example.py (standalone ausführen)
from .module import func  # ValueError: attempted relative import beyond top-level package

Wie oben gezeigt,können relative Imports Fehler auslösen, wenn das Skript als eigenständige Datei ausgeführt wird.
Das passiert, weil Python die Datei nicht als Teil eines Pakets erkennt.

In diesem Fall können Sie es vermeiden, indem Sie es wie unten gezeigt als Modul ausführen.

python -m package.module

Zusammenfassung: Standardmäßig absolute Imports verwenden, relative Imports bei Bedarf

• Standardmäßig absolute Imports(einfach, klar und robust für externe Nutzung)
• Relative Imports nur verwenden, wenn es viele Referenzen innerhalb desselben Pakets gibt

Relative Imports sind bequem, abersie können instabil werden, je nach der Ausführung des Skripts und der Entwicklungsumgebung.

5. Paketierung für das Modulmanagement

Organisation mehrerer Dateien: Die Paketierung ist wirksam

Beim Entwickeln großer Programme in Python ist es äußerst wichtig, Dateien richtig aufzuteilen und zu organisieren.
Der BegriffPaketierungist in dieser Situation nützlich.Ein Paket ist eine Sammlung von Modulen (Python-Dateien), die in einem Verzeichnis gruppiert sind.Das Gruppieren mehrerer Funktionalitäten verbessert die Lesbarkeit, Wartbarkeit und Wiederverwendbarkeit erheblich.

init.py: Welche Rolle spielt es?

Verzeichnisse, die ein Paket bilden, müssen in der Regel eine Datei mit dem Namen __init__.py enthalten.

project/
└── tools/
    ├── __init__.py
    └── formatter.py

Diese __init__.py dient als Marker, der Python mitteilt, das Verzeichnis als einPaketzu erkennen.
Ihr Inhalt kann leer sein, aber Sie können auch Modulinitialisierungscode schreiben oder Funktionen explizit angeben, die offengelegt werden sollen, wie unten gezeigt.

# tools/__init__.py
from .formatter import shout

Dies ermöglicht es Aufrufern, wie folgt prägnant zu importieren.

from tools import shout

Beispielhafte Verzeichnisstruktur

Lassen Sie uns ein Beispiel für die Struktur eines gepackten Projekts betrachten.

my_project/
├── main.py
└── tools/
    ├── __init__.py
    ├── formatter.py
    └── validator.py

In diesem Fall können alle Module unter tools von main.py aus zugegriffen werden.

# main.py
from tools import formatter, validator

print(formatter.shout("Hallo"))
print(validator.is_valid("12345"))

Zusammenfassung der Vorteile der Paketierung

Kann init.py in Python 3.3+ weggelassen werden?

Seit Python 3.3 können Verzeichnisse als Pakete behandelt werdenauch ohne eine __init__.py(Implizites Namespace-Paket).
In der Praxis wird jedoch empfohlen, __init__.py einzuschließen aus folgenden Gründen.

• Einige Tools oder Bibliotheken unterstützen es möglicherweise nicht
• Sie möchten möglicherweise eine explizite Initialisierung innerhalb des Pakets durchführen
• Verbessert die Lesbarkeit und Klarheit (einfacher für Menschen zu verstehen)

Daher bleibt die Verwendung von __init__.py die branchenstandard Best Practice.

6. Häufige Importfehler und wie man sie behebt

Gründe für Importfehler stammen oft aus einem Mangel an Verständnis für Pfade und Struktur

Beim Versuch, eine andere Datei in Python aufzurufen, erleben viele Anfänger die Frustration von Fehlern wie „Modul nicht gefunden“ oder „Name nicht definiert“.

Hier stellen wir speziell häufige Importfehler und wie man sie behebt vor.

ModuleNotFoundError: Modul nicht gefunden

Beispiel für Fehler:

ModuleNotFoundError: No module named 'utils'

Ursache und Lösung:Dieser Fehler tritt auf, wenn das angegebene Modul nicht im Suchpfad von Python vorhanden ist. Häufige Ursachen umfassen:

• Die zu importierende Datei existiert nicht im gleichen Verzeichnis oder am geeigneten Ort
• Der Speicherort der ausgeführten Datei ist nicht mit der Paketstruktur synchron
• Der Pfad des Moduls ist nicht in sys.path enthalten

Lösung:

1. Überprüfen Sie den Pfad, in dem das Modul existiert
2. Vereinheitlichen Sie das Ausführungsverzeichnis auf die Wurzel
3. Fügen Sie den Pfad bei Bedarf mit sys.path.append() hinzu

import sys
import os
sys.path.append(os.path.join(os.path.dirname(__file__), 'modules'))

ImportError: Modul existiert, aber sein Inhalt kann nicht geladen werden

Beispiel für Fehler:

ImportError: cannot import name 'greet' from 'utils'

Ursache und Lösung:Dieser Fehler tritt auf, wenn das Modul selbst gefunden wird, aber die angegebene Funktion, Klasse, Variable usw. nicht lokalisiert werden kann.Hauptursachen:

• Tippfehler im Dateinamen
• Die Funktion oder Klasse mit diesem Namen existiert tatsächlich nicht
• Weil __init__.py nicht from .module import greet enthält, ist es nicht extern sichtbar

Lösung:

• Überprüfen Sie, ob der angegebene Name tatsächlich im Modul existiert
• Achten Sie auf Groß-/Kleinschreibung (Python unterscheidet sie)
• Deklarieren Sie die öffentliche Schnittstelle explizit in __init__.py

Relative Importfehler: ValueError und ImportError

Beispiel für Fehler:

ValueError: attempted relative import beyond top-level package

Ursache:Dieser Fehler tritt auf, wenn eine Datei, die relative Imports verwendet, direkt ausgeführt wird. Wenn Python eine solche Datei eigenständig ausführt, erkennt sie sie nicht als Teil eines Pakets.Lösung:

• Beim Verwenden relativer Imports müssen Sie die Datei als Modul ausführen.

# NG: direkt ausführen
python script.py

# OK: als Modul ausführen
python -m package.script

Beste Praktiken zum Vermeiden von Importfehlern

7. Praktisches Code-Beispiel: Aufrufen und Verwenden von Funktionen aus einer anderen Datei

Lassen Sie uns hands-on arbeiten, um zu verstehen

Bis jetzt sollten Sie die grundlegenden Kenntnisse erworben haben, die zum Importieren einer anderen Datei in Python benötigt werden.
Allerdings sind„Verstehen“ und „Anwenden können“ zwei verschiedene Dinge.

Dieser Abschnitt ermöglicht es Ihnen, hands-on zu lernen, während Sie arbeiten,

• Dateien aufteilen
• Wie man Import-Anweisungen verwendet
• Wie man Funktionen aufruft

Schritt 1: Erstellen Sie die Datei, die die aufzurufende Funktion definiert

Zuerst erstellen Sie die Python-Datei, die aufgerufen werden soll.

project/
├── main.py
└── utils.py

Definieren Sie eine einfache Funktion in utils.py.

# utils.py

def greet(name):
    return f"Hallo, {name}!"

Diese Datei definiert eine Funktion namens greet().
Sie nimmt einen Namen als Argument und gibt eine Begrüßungsnachricht zurück.

Schritt 2: Importieren aus der aufrufenden Datei

Als Nächstes erstellen Sie main.py, die die Hauptverarbeitung enthält.

# main.py

import utils

message = utils.greet("Sagawa")
print(message)

Auf diese Weise importieren Sie das utils-Modul und rufen seine greet()-Funktion auf.
Hier verwenden wir das Format Modulname + Funktionsname.

Schritt 3: Ausführen und Ergebnis überprüfen

Als Nächstes führen Sie main.py aus einem Terminal oder der Eingabeaufforderung aus.

python main.py

Ausgabe:

Hallo, Sagawa!

Die Funktion aus der anderen Datei wurde erfolgreich aufgerufen, und die gewünschte Nachricht wurde angezeigt.

Eine andere Import-Methode ausprobieren (from-import)

Indem Sie wie folgt umschreiben, können Sie die Funktion knapper aufrufen.

# main.py (Verbesserte Version)

from utils import greet

print(greet("Sagawa"))

Mit dieser Methode können Sie greet() direkt schreiben statt utils.greet().
Wenn Sie mehrere Funktionen verwenden möchten, listen Sie sie durch Kommas getrennt auf.

Ein Tipp zur Code-Organisation

• Gängige Hilfsfunktionen wie utils.py können in Verzeichnisse wie „modules“ oder „helpers“ gruppiert werden, um die Verwaltung zu erleichtern.
• Auf professionellem Niveau trägt die Organisation der Verzeichnisstruktur zuverbesserter Lesbarkeit und Wartbarkeit bei.

8. FAQ: Häufig gestellte Fragen zum Importieren von Python aus separaten Dateien

Q1. Was ist der Unterschied zwischen import und from ... import ...?

A.Beide sind Wege, eine andere Datei zu laden, aber sie unterscheiden sich darin, wie man sie aufruft.

• import module: Lädt das gesamte Modul und Sie verwenden es wie module.function().
• from module import function: Lädt nur eine spezifische Funktion oder Klasse und ermöglicht den direkten Aufruf als function().

Wenn Sie mehrere Funktionen verwenden oder explizit zeigen möchten, welche Funktionen verwendet werden, ist from ... import ... bequem.

Q2. Warum funktioniert relativer Import nicht korrekt?

A.Relative Imports können einen Fehler verursachen, wenn ein Modul allein ausgeführt wird. Python erkennt die Datei nicht als Teil eines Pakets.
Sie können dies vermeiden, indem Sie es als Modul ausführen, wie unten gezeigt.

python -m package.module

Auch für Anfänger empfehlen wir die Verwendung absoluter Imports. Sie sind stabiler und weniger anfällig für Probleme.

Q3. Ich bin unsicher, wie ich Dateien in Python strukturiere

A.Generell wird die folgende Struktur empfohlen, die Verzeichnisse und Module nach Funktionalität trennt.

project/
├── main.py
├── utils/
│   ├── __init__.py
│   ├── formatter.py
│   └── validator.py
└── config/
    └── settings.py

• Teilen Sie Dateien auf, wenn sie mehrere Funktionen enthalten.
• Gruppieren Sie gemeinsamen Code in Verzeichnisse wie „utils“ oder „common“.
• Paketieren Sie auf Verzeichnisebene, um Erweiterungen zu erleichtern.

Q4. Ist __init__.py immer erforderlich?

A.Seit Python 3.3 können Pakete ohne ein __init__.pycode> funktionieren (Implizite Namespace-Pakete).
Dennoch wird empfohlen, es einzuschließen aus den folgenden Gründen.

• Es macht explizit, dass das Verzeichnis ein Paket ist.
• Einige ältere Tools und bestimmte Editoren erfordern es.
• Es kann für Initialisierungscode verwendet werden und um öffentliche Funktionen bereitzustellen.

Da es von Entwicklungsteams und kommerziellen Projekten weit verbreitet ist, ist es generell sicherer, es immer einzuschließen.

Q5. Kann ich Dateinamen mit Japanisch oder Sonderzeichen beim Importieren verwenden?

A.Generell sollten Modulnamen (Dateinamen) nur alphanumerische Zeichen und Unterstriche (_) verwenden.
Zum Beispiel sind die folgenden Dateinamen nicht erlaubt:

• ❌ function.py
• ❌ utils-mod.py

In Python wird der Dateiname zum Modulnamen, daher verursachen Sonderzeichen und Bindestriche Fehler.
Korrekte Namensbeispiele:

• ✅ utils.py
• ✅ data_handler.py

9. Zusammenfassung: Das Verständnis von Imports macht Python flexibler

Überblick über das Gelernte in diesem Artikel

Bislang hat dieser Artikel die folgenden Themen Schritt für Schritt erklärt:

• Warum eine separate Datei importieren?→ Um Code zu organisieren und wiederverwendbar zu machen
• Grundlegende Verwendung von Import-Anweisungen→ Wahl zwischen import / from ... import ...
• Wie man Module aus Unterverzeichnissen oder anderen Ordnern importiert→ Verständnis der Pfadbehandlung und der Notwendigkeit für __init__.py
• Unterschied zwischen absoluten und relativen Imports→ Absolute Imports werden für Anfänger empfohlen
• Häufige Import-Fehler und wie man sie behebt→ Die meisten Fehler entstehen durch Ausführungspfade und Konfigurationsfehler
• Überprüfung mit praktischem Code und ergänzender FAQ→ Umfasst Theorie, Praxis und häufige Fragen

Das Beherrschen von Imports eröffnet die Welt von Python

Das Verständnis, wie Imports funktionieren, und ihre korrekte Verwendung bieten die folgenden Vorteile:

• Sie können eine klare Struktur sogar für große Projekte entwerfen
• Gemeinsame Funktionalitäten zusammenfassen, um Wartung und Updates zu erleichtern
• Einfacher zu verstehen, welchen Code andere geschrieben haben
• Natürliche Arbeit mit Bibliotheken und Frameworks (Django, Flask, FastAPI usw.)

Mit anderen Worten kann das Verständnis von Imports alsein Tor für Anfänger beschrieben werden, um über die Grundlagen hinauszugehen.

Schlussfolgerung

Die einfache Syntax und Flexibilität von Python sind ansprechend, erfordern aber starke Designfähigkeiten.
Durch das korrekte Verständnis, wie man separate Dateien importiert, und das Beherrschen von Modulen und Paketenwird Ihr Code dramatisch weiterentwickelt.

Ich hoffe, dieser Artikel hilft bei Ihrem Python-Lernen und Ihrer beruflichen Weiterentwicklung.
Zögern Sie nicht, hands-on zu experimentieren und Ihre eigene Modulorganisation auszuprobieren.