Python Module importieren: Praktischer Guide mit Beispielen

Was sind Python Module?

Ein Modul ist eine einzelne Python-Datei, die Variablen, Funktionen und Klassen enthalten kann. Wenn Sie die Datei guru99.py nennen, wird das Modul als guru99 angesprochen. Module erlauben es Ihnen, ein großes Programm in logische Stücke zu splitten, Ihren Code organisiert und wiederverwendbar zu halten.

Warum Module importieren?

Um Code zu nutzen, der in einer anderen Datei definiert ist, müssen Sie ihn importieren. Importieren gibt Ihnen Zugriff auf die Funktionen, Klassen und Variablen des Moduls, ähnlich wie das import Keyword in Sprachen wie JavaScript, Java oder Ruby.

Modul erstellen und importieren

Gehen wir ein einfaches Beispiel durch.

Ordner-Layout:

modtest/
  test.py
  display.py

1. test.py erstellen:

def display_message():
    return 'Welcome to Guru99 Tutorials!'

2. display.py erstellen und test importieren:

import test
print(test.display_message())

display.py ausführen gibt aus:

Welcome to Guru99 Tutorials!

Klasse aus Modul importieren

Angenommen Car.py definiert eine Car-Klasse:

class Car:
    brand_name = 'BMW'
    model = 'Z4'
    manu_year = '2020'

    def __init__(self, brand_name, model, manu_year):
        self.brand_name = brand_name
        self.model = model
        self.manu_year = manu_year

    def car_details(self):
        print('Car brand is', self.brand_name)
        print('Car model is', self.model)
        print('Car manufacture year is', self.manu_year)

    def get_car_brand(self):
        print('Car brand is', self.brand_name)

    def get_car_model(self):
        print('Car model is', self.model)

In display.py nutzen:

import Car
car_det = Car.Car('BMW', 'Z5', 2020)
print(car_det.brand_name)
car_det.car_details()
car_det.get_car_brand()
car_det.get_car_model()

Output:

BMW
Car brand is BMW
Car model is Z5
Car manufacture year is 2020
Car brand is BMW
Car model is Z5

from für spezifische Imports nutzen

Wenn Sie nur wenige Funktionen oder Variablen brauchen, importieren Sie sie direkt:

from test import display_message
print(display_message())

Versuchen Sie einen nicht importierten Namen zu nutzen, wirft Python einen NameError:

from test import display_message
print(display_message1())

Alles aus Modul importieren

Modul komplett mit import test importieren und Names mit Modul präfixieren, oder alle Names in aktuellen Namespace mit from test import * importieren. Letzteres ist praktisch, kann aber den Namespace verschmutzen.

dir() verstehen

Die eingebaute dir()-Funktion listet alle Attribute eines Objekts, inklusive der in einem Modul definierten:

import Car
print(dir(Car))

Für Standardbibliotheken:

import json
print(dir(json))

Mit Packages arbeiten

Ein Package ist ein Verzeichnis, das eine __init__.py Datei und ein oder mehrere Module enthält. Beispiel:

Verzeichnis-Layout:

mypackage/
  __init__.py
  module1.py
  module2.py
  module3.py

In module1.py:

def mod1_func1():
    print('Welcome to Module1 function1')
def mod1_func2():
    print('Welcome to Module1 function2')
# …

Mit Alias importieren:

import mypackage.module1 as mod1
mod1.mod1_func1()
mod1.mod1_func2()

Python Module Search Path

Beim Auflösen eines Imports prüft Python:

1. Aktuelles Working Directory.
2. Eingebaute Module.
3. Verzeichnisse in sys.path.

Inspizieren mit:

import sys
print(sys.path)

Aliases für Module nutzen

Einem Modul einen kürzeren Namen geben für bessere Lesbarkeit:

import test as t
print(t.display_message())
print(t.my_name)

Absolute vs. Relative Imports

In Multi-Modul-Projekten können Sie Module entweder über ihren vollen Pfad (absolut) oder relativ zur aktuellen Datei referenzieren.

Absolute Import Beispiel

from package1.module1 import myfunc1
# oder
import package1.module1
package1.module1.myfunc1()

Relative Import Beispiel

from .module1 import myfunc1
# oder
from .subpkg.module3 import myfunc3

Absolute Imports sind klarer und weniger fehleranfällig beim Verschieben von Projekten, können aber verbose werden. Relative Imports halten Code knapp, sind aber in großen Projekten schwerer zu verfolgen.

Kernaussagen

• Module erlauben Aufsplitten von Python Code in separate Dateien.
• import oder from … import … nutzen, um Modul-Inhalte zuzugreifen.
• Aliases (as) machen lange Modulnamen handlicher.
• Packages organisieren Module in Verzeichnisse, mit __init__.py als Marker.
• sys.path verstehen, um Import-Fehler zu troubleshooten.
• Absolute Imports für Klarheit wählen, Relative Imports für Kürze.