Python-Module und Imports: import, from-import, pip und Pakete

Eine Datei ist ein Modul

Sobald dein Python-Code über ein einzelnes Skript hinauswächst, wirst du ihn in mehrere Dateien aufteilen wollen. Pythons Modulsystem ist schlicht: jede .py-Datei ist automatisch ein Modul, importierbar per Namen.

Sag, du hast eine Datei util.py:

# util.py
def greet(name):
    return f"Hello, {name}"

PI = 3.14159

Aus einer anderen Datei im selben Verzeichnis — main.py — kannst du sie nutzen:

# main.py
import util

print(util.greet("Ada"))
print(util.PI)

Führ python3 main.py aus, und Python findet util.py, führt es einmal aus und macht alles auf oberster Ebene Definierte (Funktionen, Variablen, Klassen) als Attribute des Moduls util zugänglich.

Die drei Import-Formen

Das ganze Modul importieren. Elemente sind über den Modulnamen erreichbar:

Bestimmte Namen importieren. Sie werden direkt verfügbar:

Mit Alias importieren. Nützlich, wenn der Modulname lang ist oder zwei Module denselben Namen haben:

import numpy as np
import pandas as pd

# Now use np.array(...), pd.DataFrame(...), etc.

Es gibt eine vierte Form, from math import *, die alles in deinen Namensraum zieht. Meide sie außerhalb der REPL-Erkundung — sie macht es unmöglich zu erkennen, woher ein Name kommt, und sie erzeugt stille Namenskollisionen.

Wann Imports laufen

Python führt den Top-Level-Code eines importierten Moduls einmal aus, beim ersten Import in einem Programm. Spätere Imports desselben Moduls liefern die bereits geladene Version. Also:

# setup.py
print("setup module loading...")
VALUE = 42

# main.py
import setup
import setup  # imported twice — but "loading" only prints once
print(setup.VALUE)

Gibt "setup module loading..." nur einmal aus. Das ist wichtig: steckst du Seiteneffekte (etwa eine Datei öffnen oder etwas drucken) auf Modul-Top-Level, passieren sie beim Import, was du meist nicht willst. Pack sie in Funktionen.

Die Standardbibliothek

Python liefert eine große Standardbibliothek an Modulen. Ein paar hast du schon gesehen. Ein paar, zu denen du ständig greifen wirst:

• math — sqrt, sin, log, Konstanten wie pi und e.
• random — Zufallszahlen, Auswahlen, Mischen.
• datetime — Datums- und Zeitangaben.
• json — JSON lesen/schreiben.
• os, os.path — Pfade und Operationen im Dateisystem.
• pathlib — modernes Pfad-Handling, oft angenehmer als os.path.
• re — reguläre Ausdrücke.
• collections — spezialisierte Sammlungstypen (Counter, defaultdict, deque usw.).
• itertools, functools — Iterator- und Funktions-Helfer.
• csv — CSV-Dateien lesen und schreiben.

Die Standardbibliothek ist schon installiert — kein pip install nötig.

Drittanbieter-Pakete und pip

Für alles, was die Standardbibliothek nicht abdeckt, hostet der Python Package Index (PyPI) Hunderttausende Pakete. Installier sie mit pip:

pip install requests
pip install pandas
pip install --upgrade requests
pip uninstall requests

Einmal installiert, importierst du sie wie alles andere:

import requests

response = requests.get("https://api.example.com/data")
print(response.status_code)

Ein paar Tipps, um das im Griff zu behalten:

Nutz virtuelle Umgebungen

Alles global zu installieren führt zu Schmerz. Verschiedene Projekte brauchen verschiedene Versionen; manche Pakete hängen an bestimmten Python-Versionen; globale Installationen verlangen auf manchen Systemen Adminrechte. Eine virtuelle Umgebung ist eine isolierte Python-Installation nur für ein Projekt:

python3 -m venv .venv
source .venv/bin/activate    # macOS/Linux
.venv\Scripts\activate       # Windows

pip install requests

Solange die venv aktiviert ist, installiert pip in den Projektordner, nicht ins System. Mit deactivate verlässt du sie, wenn du fertig bist.

Pin deine Abhängigkeiten

Speicher die Liste installierter Pakete, damit andere (einschließlich deines zukünftigen Ichs) dieselbe Umgebung nachbauen können:

pip freeze > requirements.txt

Später dann:

pip install -r requirements.txt

Werkzeuge wie Poetry, pipenv und uv machen das ergonomischer, aber der schlichte pip + requirements.txt-Ablauf reicht zum Lernen.

Eigene Module schreiben

Sobald du Funktionen hast, die du über Dateien hinweg wiederverwenden willst, pack sie in ein eigenes Modul. Namenskonventionen:

• Dateinamen lower_snake_case.py.
• Modul-Ebene-Funktionen und -Variablen ebenfalls lower_snake_case.
• Klassen nutzen PascalCase.

# shopping.py
PRICES = {"apple": 0.50, "bread": 2.00}

def total(items):
    return sum(PRICES[item] for item in items)

# main.py
from shopping import total, PRICES

print(total(["apple", "bread"]))
print(PRICES)

Importieren sich zwei Dateien im selben Ordner gegenseitig, kannst du aus Versehen einen zirkulären Import erzeugen. Die übliche Lösung: den gemeinsamen Code in eine dritte Datei verschieben, die beide importieren.

Pakete: Ordner voller Module

Sobald du mehr als eine Handvoll Module hast, gruppier sie zu einem Paket — einem Ordner mit einer __init__.py-Datei:

myproject/
├── main.py
└── utils/
    ├── __init__.py
    ├── text.py
    └── numbers.py

Dann:

from utils.text import slugify
from utils import numbers

print(slugify("Hello, World"))
print(numbers.mean([1, 2, 3]))

__init__.py darf leer sein; sein Vorhandensein macht utils zum Paket. Modernes Python unterstützt auch „Namespace Packages“ ohne __init__.py, aber für den Anfang ist die explizite Variante klarer.

Eine kleine Checkliste, wenn Imports streiken

• „ModuleNotFoundError: No module named X“. Entweder ist das Paket nicht installiert, oder du startest Python mit einem anderen Interpreter als dem, gegen den du pip install ausgeführt hast. In einer venv: stell sicher, dass die venv aktiviert ist.
• „ImportError: cannot import name Y from X“. Das Modul existiert, aber der Name, den du wolltest, ist nicht da. Prüf auf Tippfehler und schau in den echten Modulinhalt.
• „Circular import“. Zwei Module importieren einander. Gemeinsamen Code in ein drittes Modul verschieben.

Als Nächstes: Drittanbieter-Pakete installieren

Deine eigenen Module bringen dich weit, aber die meisten echten Projekte ziehen auch Bibliotheken von PyPI — requests, pandas, ein Test-Framework. Die nächste Seite behandelt pip, wie du Pakete sauber installierst und wie du festhältst, wovon dein Projekt abhängt.