Python Datenbank verbinden: sqlite3 & SQLAlchemy einfach erklärt

Dein Python-Programm soll sich Daten merken - auch nach dem Neustart? Dann kommst du um eine Datenbank nicht herum. Die gute Nachricht: Für die Verbindung von Python mit einer Datenbank bringt die Standardbibliothek mit sqlite3 bereits alles mit, was du brauchst. Kein Server, keine Installation, kein separates Datenbank-Programm. Und wenn deine Projekte größer werden, wartet SQLAlchemy als nächster Schritt.

In diesem Beitrag baust du eine kleine Teilnehmer-Verwaltung: Tabelle anlegen, Daten einfügen, abfragen - erst mit sqlite3 direkt, dann dasselbe mit SQLAlchemy. Am Ende hast du ein lauffähiges Programm, das du für eigene Projekte anpassen kannst. Das Thema schlägt übrigens regelmäßig in Prüfungen und Vorstellungsgesprächen auf - Grundlagen im Datenbankzugriff werden überall erwartet.

Voraussetzungen: Was brauchst du?

Für sqlite3 brauchst du nur eine Python-Installation ab Version 3.7 - das Modul ist direkt eingebaut. SQLAlchemy installierst du per pip, dem Paketmanager von Python. Falls du mit virtuellen Umgebungen noch nicht vertraut bist, wirf einen Blick in unseren Beitrag zu Python pip und virtualenv.

• Python 3.7 oder neuer (python.org)

• Grundlagen: Variablen, Funktionen, einfache Schleifen

• Grobes Verständnis von SQL (Structured Query Language, die Sprache zum Ansprechen von Datenbanken) - für dieses Tutorial reicht INSERT und SELECT

• Für SQLAlchemy: `pip install sqlalchemy`

Was ist sqlite3 - und wie verbindest du Python mit einer Datenbank?

sqlite3 ist Pythons eingebautes Modul für den Zugriff auf SQLite - eine dateibasierte Datenbank. Stell dir SQLite wie eine Tabellenkalkulation vor, die SQL versteht: Die komplette Datenbank ist eine einzige Datei auf deiner Festplatte. Ein separater Datenbankserver wie bei MySQL oder PostgreSQL ist nicht nötig.

Kernantwort: SQLite speichert die gesamte Datenbank in einer einzigen Datei - ohne Server, ohne Installation. Das sqlite3-Modul greift direkt aus Python darauf zu.

Die offizielle Referenz findest du in der Python-Dokumentation zu sqlite3.

Schritt 1: Verbindung aufbauen und Tabelle erstellen

Als Erstes öffnest du eine Verbindung und legst eine Tabelle an. Die Datenbankdatei erzeugt SQLite automatisch, falls sie noch nicht existiert.

import sqlite3

# Verbindung zur Datei kurse.db aufbauen (wird bei Bedarf erstellt)
connection = sqlite3.connect("kurse.db")

# Ein Cursor fuehrt SQL-Befehle aus
cursor = connection.cursor()

# Tabelle anlegen, IF NOT EXISTS verhindert Fehler bei Wiederholung
cursor.execute("""
  CREATE TABLE IF NOT EXISTS teilnehmer (
    id INTEGER PRIMARY KEY AUTOINCREMENT,
    name TEXT NOT NULL,
    kurs TEXT NOT NULL
  )
""")

# Aenderungen dauerhaft speichern
connection.commit()
connection.close()

Der Cursor ist dein Werkzeug, um SQL-Anweisungen abzuschicken und Ergebnisse entgegenzunehmen - vergleichbar mit einem Zeiger, der Zeile für Zeile durch die Ergebnismenge wandert. `commit()` sorgt dafür, dass deine Änderungen wirklich in der Datei landen. Ohne `commit()` ist alles nach dem Schließen verloren.

Schritt 2: Daten einfügen und abfragen

Beim Einfügen von Daten nutzt du immer Platzhalter (das `?`). Warum? Weil zusammengeklebte Strings die berüchtigte SQL Injection ermöglichen - Angreifer könnten so eigenen SQL-Code einschleusen.

# RICHTIG: Platzhalter verwenden
cursor.execute(
    "INSERT INTO teilnehmer (name, kurs) VALUES (?, ?)",
    ("Anna", "Python-Grundlagen"),
)
connection.commit()

# FALSCH: niemals Strings per f-string zusammenbauen!
# cursor.execute(f"INSERT INTO teilnehmer (name, kurs) VALUES ('{name}', '{kurs}')")

# Abfragen
cursor.execute("SELECT id, name, kurs FROM teilnehmer")
ergebnisse = cursor.fetchall()  # Liste mit Tupeln

for zeile in ergebnisse:
    print(f"[{zeile[0]}] {zeile[1]} - {zeile[2]}")

Merke: Platzhalter (`?`) statt String-Verkettung - das ist der wichtigste Sicherheitsgrundsatz beim Datenbankzugriff.

Jede Zeile bekommst du als Tupel zurück, also als unveränderliche Werteliste. Der Zugriff erfolgt über den Index, wie im Beispiel gezeigt.

Was ist SQLAlchemy?

SQLAlchemy ist ein ORM (Object-Relational Mapper) - eine Bibliothek, die Datenbanktabellen auf Python-Klassen abbildet. Statt SQL-Strings zu schreiben, arbeitest du direkt mit Objekten. Stell dir das wie einen Übersetzer vor: Du redest Python, er redet SQL.

Kernidee: Deine Python-Klasse wird zur Tabelle, jedes Objekt zu einer Zeile. SQLAlchemy erzeugt das SQL automatisch im Hintergrund.

Details und Tutorials findest du in der offiziellen SQLAlchemy-Dokumentation.

from sqlalchemy import create_engine, String, select
from sqlalchemy.orm import DeclarativeBase, Mapped, mapped_column, Session


# Basisklasse fuer alle Tabellen-Definitionen
class Base(DeclarativeBase):
    pass


# Eine Python-Klasse entspricht einer Tabelle
class Teilnehmer(Base):
    __tablename__ = "teilnehmer"
    id: Mapped[int] = mapped_column(primary_key=True)
    name: Mapped[str] = mapped_column(String(50))
    kurs: Mapped[str] = mapped_column(String(50))


# Engine = Verbindung zur Datenbank
engine = create_engine("sqlite:///kurse.db")

# Alle definierten Tabellen anlegen
Base.metadata.create_all(engine)

# Objekt erzeugen und speichern
with Session(engine) as session:
    person = Teilnehmer(name="Ben", kurs="Datenbanken")
    session.add(person)
    session.commit()

    # Abfragen: Du erhaelst echte Objekte statt Tupel
    for t in session.scalars(select(Teilnehmer)):
        print(f"[{t.id}] {t.name} - {t.kurs}")

Der große Vorteil: Du wechselst die Datenbank, indem du nur den Verbindungsstring änderst - etwa `postgresql://user:pass@server/db` statt `sqlite:///kurse.db`. Dein Code bleibt gleich. Die `with`-Syntax kennst du vielleicht schon aus unserem Artikel zu Python Context Managern - hier sorgt sie dafür, dass die Session sauber geschlossen wird.

sqlite3 oder SQLAlchemy: Was nutzt du wann?

Die kurze Antwort: sqlite3 für den Einstieg, SQLAlchemy für wachsende Projekte. Die Details im Vergleich:

Faustregel für den Berufseinstieg: Lerne zuerst sqlite3 und SQL richtig - auch mit SQLAlchemy solltest du verstehen, was unter der Haube passiert. SQLAlchemy holst du dir, wenn Projekte wachsen.

Vollständiges Beispiel: Teilnehmer-Verwaltung

Alle Schritte zusammen ergeben ein lauffähiges Programm. Kopiere es in eine Datei `verwaltung.py` und führe es aus:

import sqlite3


def main():
    connection = sqlite3.connect("kurse.db")
    cursor = connection.cursor()

    # Tabelle anlegen, falls noch nicht vorhanden
    cursor.execute("""
    CREATE TABLE IF NOT EXISTS teilnehmer (
      id INTEGER PRIMARY KEY AUTOINCREMENT,
      name TEXT NOT NULL,
      kurs TEXT NOT NULL
    )
  """)

    # Zwei Teilnehmer einfuegen
    daten = [("Anna", "Python-Grundlagen"), ("Ben", "Datenbanken")]
    cursor.executemany(
        "INSERT INTO teilnehmer (name, kurs) VALUES (?, ?)", daten
    )
    connection.commit()

    # Alle Teilnehmer ausgeben
    cursor.execute("SELECT id, name, kurs FROM teilnehmer")
    for zeile in cursor.fetchall():
        print(f"[{zeile[0]}] {zeile[1]} besucht {zeile[2]}")

    connection.close()


if __name__ == "__main__":
    main()

`executemany()` fügt mehrere Datensätze in einem Rutsch ein - effizienter als eine Schleife mit einzelnen `execute()`-Aufrufen.

Welche typischen Fehler treten auf - und wie löst du sie?

Problem 1: `sqlite3.OperationalError: no such table`

Der Klassiker: Die Tabelle wurde in einer anderen Datenbankdatei angelegt. SQLite legt fehlende Dateien stillschweigend an - deine `connect()`-Zeile zeigt also vielleicht auf einen anderen Ordner. Prüfe den Pfad und führe das CREATE-Statement in derselben Datei aus wie die Abfrage.

Problem 2: Eingegebene Daten sind verschwunden

Du hast `commit()` vergessen. SQLite hält deine Änderungen zunächst nur im Speicher. Erst `connection.commit()` schreibt sie dauerhaft in die Datei. Bei SQLAlchemy heißt das Pendant `session.commit()`.

Problem 3: `sqlite3.OperationalError: database is locked`

Eine andere Verbindung hält die Datenbank noch offen, während du schreiben willst. Lösung: Verbindungen nach der Benutzung explizit mit `close()` schließen. Achtung, ein häufiges Missverständnis: `with sqlite3.connect(...) as connection:` schließt die Verbindung nicht automatisch - das `with` commit't nur die Transaktion. Wer sauber arbeiten will, kombiniert beides, etwa mit `contextlib.closing()`.

Häufige Fragen

Brauche ich für SQLite einen eigenen Server?

Nein. SQLite ist komplett dateibasiert und läuft ohne Installation. Genau deshalb ist es ideal für Lernprojekte, Desktop-Tools und Apps - laut sqlite.org steckt SQLite in Milliarden Geräten, vom Browser bis zum Smartphone.

Kann ich mit Python auch auf MySQL oder PostgreSQL zugreifen?

Ja. Für MySQL nutzt du zum Beispiel `mysql-connector-python`, für PostgreSQL `psycopg2`. Der Code-Aufbau mit connect, cursor und commit bleibt gleich. Mit SQLAlchemy änderst du nur den Verbindungsstring.

Ist SQLAlchemy ein Ersatz für SQL-Kenntnisse?

Nein. SQLAlchemy nimmt dir das Schreiben von SQL ab, ersetzt aber kein Verständnis. Für Performance-Analysen, Joins und Fehlerdiagnose brauchst du SQL-Wissen - in Prüfungen und Vorstellungsgesprächen sowieso.

Warum darf ich keine f-Strings für SQL-Abfragen verwenden?

Weil Nutzer-Eingaben dann direkt als SQL-Code interpretiert werden können. Ein `name` wie `'; DROP TABLE teilnehmer; --` könnte deine Tabelle löschen. Platzhalter maskieren Eingaben automatisch.

Fazit

Für den Datenbankzugriff mit Python sind sqlite3 und SQLAlchemy ein eingespieltes Team: sqlite3 für den schnellen Start ohne Installation, SQLAlchemy, sobald Projekte wachsen oder ein Wechsel auf MySQL bzw. PostgreSQL ansteht. Die drei wichtigsten Takeaways: Platzhalter statt String-Verkettung, `commit()` nicht vergessen, Verbindungen sauber schließen. Wenn du diese Grundlagen beherrschst, kannst du jedes CRUD-Programm bauen - Create, Read, Update, Delete.

Hakst du bei Datenbanken, SQLAlchemy oder einer anderen Python-Thematik fest - etwa im Rahmen deiner Abschlussprüfung oder einer Hausaufgabe im Studium? Dann hol dir Unterstützung bei study-it.education. Unsere Nachhilfe-Lehrer arbeiten genau auf dein Niveau und deine Prüfungsanforderungen hin, ob du Azubi, Student oder Berufseinsteiger bist. Schau vorbei und vereinbare deine erste Stunde.