Über unsMediaKontaktImpressum
Thomas Theis 30. Juni 2020

Datenbanken mit Python und SQLite

Eine Datenbank dient zur Speicherung größerer Datenmengen, zur übersichtlichen Darstellung von Daten und zur komfortablen Änderung von Daten. In diesem Artikel wird das leicht zu nutzende Datenbankmanagementsystem SQLite vorgestellt. Es ist einfach mit Python zu verbinden, erfordert keine aufwändige Installation eines Datenbankservers und basiert auf Textdateien. Wie viele andere Datenbanksysteme ist es SQL-basiert. Bei SQL (Structured Query Language) handelt es sich um die am meisten verwendete Datenbanksprache.

Aufbau von Datenbanken

Innerhalb einer Datenbank befinden sich verschiedene Datenbanktabellen. In Tabelle 1 sehen Sie ein einfaches Beispiel für eine Datenbanktabelle mit Personaldaten.

Tabelle 1: Datenbanktabelle mit Personaldaten

Name Vorname Personalnummer Gehalt Geburtstag
Maier Hans 6714 3.500,00 15.03.62
Schmitz Peter 81343 3.750,00 12.04.58
Mertens Julia 2297 3.621,50 30.12.59

Die Begriffe in der ersten Zeile bezeichnet man als Datenbankfelder. Es folgen die einzelnen Datensätze der Datenbanktabelle, hier sind es drei. Natürlich legt niemand für drei Datensätze eine Datenbank mit einer Datenbanktabelle an, aber die vorliegende Struktur könnte auch für mehrere Tausend Datensätze verwendet werden. Die Felder haben jeweils einen bestimmten Datentyp. In diesem Fall gibt es die Datentypen Text, Ganze Zahl, Zahl mit Nachkommastellen und Datumsangabe.

Eine Datenbank wird in den folgenden Schritten erzeugt:

  • Anlegen der Datenbank
  • Anlegen von Datenbanktabellen durch Angabe der Struktur
  • Eingeben der Datensätze in die Datenbanktabellen

Sie können die Struktur einer Datenbank auch noch verändern, wenn sie bereits Daten enthält. Allerdings kann es dabei leicht zu Datenverlusten kommen. Daher sollten Sie die Struktur besser vorher gründlich planen. Sie werden mit SQL-Anweisungen arbeiten. Diese dienen zur Erzeugung der Struktur von Datenbanken und Datenbanktabellen und zum Bearbeiten der Datensätze (Erzeugen, Anzeigen, Ändern, Löschen).

SQLite

SQLite wird über das Modul sqlite3 direkt in Python eingebunden. Es bietet standardmäßig die folgenden Datentypen:

  • TEXT – für Zeichenketten
  • INTEGER – für ganze Zahlen
  • REAL – für Zahlen mit Nachkommastellen
  • BLOB – für binary large objects, also große binäre Datenmengen
  • NULL – entspricht None in Python

Für die Kontrolle und die richtige Konvertierung anderer Datentypen von SQLite nach Python, zum Beispiel für die Umwandlung einer SQLite-Zeichenkette in eine Python-Variable für eine Datumsangabe, muss der Entwickler selbst sorgen.

Die oben genannten Datentypen und andere SQL-spezifische Angaben werden in Großbuchstaben notiert. Das ist für SQL nicht notwendig, dient aber zur deutlicheren Darstellung.

Datenbank, Datenbanktabelle und Datensätze

Im folgenden Python-Programm wird zunächst eine SQLite-Datenbank erzeugt und eine Datenbanktabelle mit einem eindeutigen Index angelegt. Anschließend werden drei Datensätze in der Datenbanktabelle angelegt. Dazu werden die Struktur und die Daten aus Tabelle 1 genutzt. Der eindeutige Index dient dazu, Datensätze zu erzeugen, die jeweils ein unverwechselbares Merkmal haben und somit eindeutig identifiziert und voneinander unterschieden werden können. In der vorliegenden Datenbanktabelle ist dazu das Feld personalnummer geeignet.

Listing 1: Datei sqlite_erzeugen.py

import os, sys, sqlite3

# Existenz feststellen
if os.path.exists("firma.db"):
    print("Datei bereits vorhanden")
    sys.exit(0)

# Verbindung zur Datenbank erzeugen
connection = sqlite3.connect("firma.db")

# Datensatz-Cursor erzeugen
cursor = connection.cursor()

# Datenbanktabelle erzeugen
sql = "CREATE TABLE personen(" \
      "name TEXT, " \
      "vorname TEXT, " \
      "personalnummer INTEGER PRIMARY KEY, " \
      "gehalt REAL, " \
      "geburtstag TEXT)"
cursor.execute(sql)

# Datensatz erzeugen
sql = "INSERT INTO personen VALUES('Maier', " \
      "'Hans', 6714, 3500, '15.03.1962')"
cursor.execute(sql)
connection.commit()

# Datensatz erzeugen
sql = "INSERT INTO personen VALUES('Schmitz', " \
      "'Peter', 81343, 3750, '12.04.1958')"
cursor.execute(sql)
connection.commit()

# Datensatz erzeugen
sql = "INSERT INTO personen VALUES('Mertens', " \
      "'Julia', 2297, 3621.5, '30.12.1959')"
cursor.execute(sql)
connection.commit()

# Verbindung beenden
connection.close()

Zunächst wird geprüft, ob die Datenbankdatei firma.db existiert. Ist das der Fall, wurde das Programm bereits einmal aufgerufen, die Datenbanktabelle personen existiert und ist mit Daten gefüllt. Ein zweiter Aufruf würde zu einem Fehler führen. Falls Sie in diesem Fall feststellen möchten, ob das Programm sqlite_erzeugen.py erfolgreich arbeitet, müssen Sie die Datenbankdatei firma.db zunächst löschen.

Anschließend wird mithilfe der Funktion connect() aus dem Modul sqlite3 eine Verbindung zur Datenbank hergestellt. Da die Datenbankdatei noch nicht existiert, wird sie nun erzeugt. Der Rückgabewert der Funktion connect() ist ein Objekt der Klasse sqlite3.connection. Über diese Verbindung kann auf die Datenbank zugegriffen werden.

Der Rückgabewert der Methode cursor() ist ein Objekt der Klasse sqlite3.cursor. Über dieses cursor-Objekt können SQL-Abfragen an die Datenbank gesendet und die Ergebnisse empfangen werden. Es wird eine Zeichenkette zusammengesetzt, die einen SQL-Befehl enthält. SQL-Befehle werden mithilfe der Methode execute() des cursor-Objekts an die Datenbank gesendet.

Die SQL-Anweisung CREATE TABLE erzeugt eine Datenbanktabelle in einer Datenbank. Hinter dem Namen der Datenbanktabelle (hier: personen) werden in Klammern die Namen der einzelnen Felder der Datenbanktabelle mit ihrem jeweiligen Datentyp angegeben. Die Felder name, vorname und geburtstag sind vom Typ TEXT. Das Feld gehalt ist vom Typ REAL, das Feld personalnummer vom Typ INTEGER. Auf dem Feld personalnummer wird mithilfe des Ausdrucks PRIMARY KEY ein Primärschlüssel definiert. Dabei handelt es sich um einen eindeutigen Index, der dafür sorgt, dass es keine zwei Datensätze geben kann, die dieselbe Personalnummer besitzen.

Mithilfe der SQL-Anweisung INSERT INTO werden Datensätze eingefügt. Es handelt sich um eine Aktionsabfrage, die zu einer Änderung in der Datenbanktabelle führt. Innerhalb der SQL-Anweisung INSERT INTO werden nach dem Namen der Datenbanktabelle und dem Schlüsselwort VALUES die einzelnen Werte des Datensatzes für die Felder der Datenbanktabelle in Klammern angegeben. Dabei ist es wichtig, Zeichenketten in einfache Anführungsstriche zu setzen. Außerdem muss die Reihenfolge der Felder derjenigen bei der Erzeugung der Datenbanktabelle entsprechen.

Auf eine Aktionsabfrage sollte immer ein Aufruf der Methode commit() des connection-Objekts folgen, damit die Änderungen unmittelbar ausgeführt werden. Zuletzt wird die Verbindung zur Datenbank mithilfe der Methode close() wieder geschlossen.

Daten anzeigen

Alle Datensätze der Datenbanktabelle sollen mit allen Inhalten angezeigt werden.

Das Programm lautet wie folgt:

Listing 2: Datei sqlite_anzeigen.py

import sqlite3

# Verbindung, Cursor
connection = sqlite3.connect("firma.db")
cursor = connection.cursor()

# SQL-Abfrage
sql = "SELECT * FROM personen"

# Kontrollausgabe der SQL-Abfrage
# print(sql)

# Absenden der SQL-Abfrage
# Empfang des Ergebnisses
cursor.execute(sql)

# Ausgabe des Ergebnisses
for dsatz in cursor:
    print(dsatz[0], dsatz[1], dsatz[2],
          dsatz[3], dsatz[4])

# Verbindung beenden
connection.close()

Das Programm erzeugt diese Ausgabe:

Mertens Julia 2297 3621.5 30.12.1959
Maier Hans 6714 3500.0 15.03.1962
Schmitz Peter 81343 3750.0 12.04.1958

Nach Erzeugung der Datenbankverbindung und des Datensatz-Cursors wird eine SQL-Abfrage mithilfe der Methode execute() gesendet.

Mit der SQL-Anweisung SELECT werden Auswahlabfragen formuliert. Sie dienen zum Sichten, aber nicht zum Ändern der Datenbankinhalte. Die Anweisung SELECT * FROM personen liefert alle Datensätze mit allen Feldern der Datenbanktabelle. Der Stern (*) steht für "alle Felder".

Die SQL-Anweisung wird zunächst in einer Zeichenkette gespeichert. Das ermöglicht eine Kontrollausgabe zur Fehlersuche bei komplexeren SQL-Befehlen. Nach Ausführung der Methode execute() steht das Ergebnis der Abfrage im cursor-Objekt zur Verfügung. Dabei handelt es sich um die Datensätze, die zur Abfrage passen. Die Abfolge dieser Datensätze kann mithilfe einer Schleife durchlaufen werden. Jeder Datensatz entspricht einem Tupel, das aus den Werten für die einzelnen Felder in der gleichen Reihenfolge wie bei der Erzeugung der Datenbanktabelle besteht.

Da es sich bei SELECT nicht um eine Aktionsabfrage handelt (die eine Änderung in der Datenbank vornimmt), sondern nur um eine Auswahlabfrage (die Informationen ermittelt), muss hier die Methode commit() nicht aufgerufen werden.

Zuletzt wird die Verbindung zur Datenbank wieder beendet.

Daten auswählen, SQL-Operatoren

Mithilfe von SELECT und WHERE können Sie einen oder mehrere Datensätze herausfiltern. Im nachfolgenden Programm sehen Sie einige Beispiele:

Listing 3: Datei sqlite_auswaehlen.py

import sqlite3

# Verbindung, Cursor
connection = sqlite3.connect("firma.db")
cursor = connection.cursor()

# SQL-Abfragen
# Einzelne Felder
sql = "SELECT name, vorname FROM personen"
cursor.execute(sql)
for dsatz in cursor:
    print(dsatz[0], dsatz[1])
print()

# Auswahl mit WHERE-Klausel und Vergleichsoperator
sql = "SELECT * FROM personen " \
      "WHERE gehalt > 3600"
cursor.execute(sql)
for dsatz in cursor:
    print(dsatz[0], dsatz[3])
print()

# Auswahl mit Zeichenkette
sql = "SELECT * FROM personen " \
      "WHERE name = 'Schmitz'"
cursor.execute(sql)
for dsatz in cursor:
    print(dsatz[0], dsatz[1])
print()

# Auswahl mit logischen Operatoren
sql = "SELECT * FROM personen " \
      "WHERE gehalt >= 3600 AND gehalt <= 3650"
cursor.execute(sql)
for dsatz in cursor:
    print(dsatz[0], dsatz[3])

# Verbindung beenden
connection.close()

Erzeugt wird die Ausgabe:

Mertens Julia
Maier Hans
Schmitz Peter

Mertens 3621.5
Schmitz 3750.0

Schmitz Peter

Mertens 3621.5

Es werden vier voneinander unabhängige SQL-Abfragen ausgeführt. Wenn Sie nur die Werte bestimmter Felder sehen möchten, notieren Sie die Namen dieser Felder zwischen SELECT und FROM. Die Anweisung SELECT name, vorname FROM personen liefert nur die Inhalte der beiden genannten Felder aller Datensätze der Datenbanktabelle.

Mithilfe von WHERE können Sie die Auswahl der Datensätze einschränken, indem Sie eine Bedingung mit Vergleichsoperatoren erstellen (ähnlich wie bei den Anweisungen if oder while in Python).

Die Anweisung SELECT * FROM personen WHERE gehalt > 3600 liefert die Inhalte aller Felder für die Datensätze, bei denen der Wert des Felds gehalt oberhalb der genannten Grenze liegt. Bei Zeichenketten kann ebenfalls ein Vergleich stattfinden. Dabei ist allerdings auf die einfachen Anführungsstriche zu achten. Die SQL-Anweisung SELECT * FROM personen WHERE name = 'Schmitz' liefert nur die Datensätze, bei denen der Name gleich "Schmitz" ist.

Logische Operatoren ermöglichen, wie in Python, die Verknüpfung mehrerer Bedingungen. Die Anweisung SELECT * FROM personen WHERE gehalt >= 3600 AND gehalt <= 3650 liefert nur die Datensätze, bei denen der Wert des Felds gehalt innerhalb der genannten Grenzen liegt.

In SQL gibt es die folgenden Vergleichsoperatoren für Zahlen: = (gleich), <> (ungleich), > (größer als), >= (größer als oder gleich), < (kleiner als) und <= (kleiner als oder gleich).

Es folgen die logischen Operatoren:

  • NOT: Entspricht dem logischen NICHT. Der Wahrheitswert einer Bedingung wird umgekehrt.
  • AND: Entspricht dem logischen UND. Beide Bedingungen müssen zutreffen.
  • OR: Entspricht dem logischen ODER. Nur eine der Bedingungen muss zutreffen.

Operator "LIKE"

Der Operator LIKE dient zum Vergleich von Zeichenketten. Das kann zur Auswahl von Datensätzen eingesetzt werden. Dabei können auch Platzhalter verwendet werden. Sie können also Abfragen bilden wie:

  • Suche alle Datensätze, die mit … beginnen.
  • Suche alle Datensätze, die mit … enden.
  • Suche alle Datensätze, die … enthalten.

Einige Beispiele sehen Sie in nachfolgendem Programm:

Listing 4: Datei sqlite_like.py

import sqlite3

# Verbindung, Cursor
connection = sqlite3.connect("firma.db")
cursor = connection.cursor()

# SQL-Abfragen

# Beliebig viele beliebige Zeichen
sql = "SELECT * FROM personen WHERE name LIKE 'm%'"
cursor.execute(sql)
for dsatz in cursor:
    print(dsatz[0], dsatz[1])
print()

# Beinhaltet ...
sql = "SELECT * FROM personen WHERE name LIKE '%i%'"
cursor.execute(sql)
for dsatz in cursor:
    print(dsatz[0], dsatz[1])
print()

# Einzelne beliebige Zeichen
sql = "SELECT * FROM personen WHERE name LIKE 'M__er'"
cursor.execute(sql)
for dsatz in cursor:
    print(dsatz[0], dsatz[1])

# Verbindung beenden
connection.close()

Es wird diese Ausgabe erzeugt:

Mertens Julia
Maier Hans

Maier Hans
Schmitz Peter

Maier Hans

Es werden drei voneinander unabhängige SQL-Abfragen ausgeführt.

Der Platzhalter % (Prozentzeichen) steht für eine unbestimmte Anzahl beliebiger Zeichen. Die Anweisung SELECT * FROM personen WHERE name LIKE 'm%' liefert nur die Datensätze, bei denen der Name mit dem Buchstaben "m" beginnt (unabhängig von Groß- und Kleinschreibung).

Steht das Prozentzeichen vor und nach einem bestimmten Zeichen, werden alle Datensätze gesucht, in denen dieses Zeichen vorkommt. Die Anweisung SELECT * FROM personen WHERE name LIKE '%i%' liefert nur die Datensätze, in denen der Buchstabe "i" (oder "I") vorkommt.

Der Platzhalter _ (Unterstrich) steht für ein einzelnes beliebiges Zeichen. Die Anweisung SELECT * FROM personen WHERE name LIKE 'M__er' liefert nur die Datensätze, bei denen der Name mit "M" beginnt und nach zwei weiteren Zeichen mit "er" endet. Dies trifft z. B. auf "Maier", "Mayer" und "Meyer" zu.

Sortierung der Ausgabe

Mithilfe von ORDER BY werden die Datensätze in sortierter Form geliefert. Es kann nach einem oder mehreren Feldern, aufsteigend oder absteigend sortiert werden. Ein Beispiel:

Listing 5: Datei sqlite_sortieren.py

import sqlite3

# Verbindung, Cursor
connection = sqlite3.connect("firma.db")
cursor = connection.cursor()

# Sortierung absteigend
sql = "SELECT * FROM personen ORDER BY gehalt DESC"
cursor.execute(sql)
for dsatz in cursor:
    print(dsatz[0], dsatz[1], dsatz[3])
print()

# Sortierung nach mehreren Feldern
sql = "SELECT * FROM personen ORDER BY name, vorname"
cursor.execute(sql)
for dsatz in cursor:
    print(dsatz[0], dsatz[1])

connection.close()

Die Ausgabe lautet:

Maier Wolfgang 3810.0
Schmitz Peter 3750.0
Mertens Julia 3621.5
Maier Hans 3500.0

Maier Hans
Maier Wolfgang
Mertens Julia
Schmitz Peter

Es werden zwei voneinander unabhängige SQL-Abfragen ausgeführt. Zur deutlicheren Darstellung wurde vor Ausführung dieses Programms noch ein weiterer Datensatz hinzugefügt.

Die Anweisung SELECT * FROM personen ORDER BY gehalt DESC liefert alle Datensätze, absteigend nach Gehalt sortiert. Der Zusatz DESC steht für descending (deutsch: absteigend). Für eine aufsteigende Sortierung könnten Sie den Zusatz ASC (ascending, deutsch: aufsteigend) verwenden. Allerdings ist das die Standardsortierung, daher kann ASC weggelassen werden.

Die Anweisung SELECT * FROM personen ORDER BY name, vorname liefert alle Datensätze, aufsteigend nach dem Feld name sortiert. Bei gleichem Namen wird nach dem Feld vorname sortiert.

Auswahl nach Eingabe

Der Benutzer kann Datensätze auch selbst auswählen. Mit dem folgenden Programm werden nur die Datensätze angezeigt, die dem eingegebenen Namen entsprechen oder die den eingegebenen Namensteil enthalten.

Listing 6: Datei sqlite_eingabe.py

import sqlite3

# Verbindung, Cursor
connection = sqlite3.connect("firma.db")
cursor = connection.cursor()

# Eingabe Name
eingabe = input("Bitte den gesuchten Namen eingeben: ")
sql = "SELECT * FROM personen WHERE name LIKE ?"
cursor.execute(sql, (eingabe,))
for dsatz in cursor:
    print(dsatz[0], dsatz[1])
print()

# Eingabe Teil des Namens
eingabe = input("Bitte den gesuchten Namensteil eingeben: ")
sql = "SELECT * FROM personen WHERE name LIKE ?"
eingabe = '%' + eingabe + '%'
cursor.execute(sql, (eingabe,))
for dsatz in cursor:
    print(dsatz[0], dsatz[1])
print()

connection.close()

Die Ausgabe (mit Eingabe des Benutzers) sieht wie folgt aus:

Bitte den gesuchten Namen eingeben: Maier

Maier Hans

Bitte den gesuchten Namensteil eingeben: r

Mertens Julia
Maier Hans
Maier Wolfgang

Die erste Eingabe des Benutzers lautet "Maier". Es wird ein SQL-Befehl gesendet, der diese Eingabe nutzt. Zur Abwehr einer möglichen Einschleusung von schädlichem SQL-Code (SQL-Injection) durch den Benutzer des Programms wird die Parameter-Substitution der Datenbankschnittstelle von Python verwendet: Für jedes Fragezeichen im SQL-Code wird ein Element des Tupels verwendet, das als zweiter, optionaler Parameter der Methode execute() angegeben wird. Hier gibt es nur ein Fragezeichen, daher enthält das Tupel nur ein Element, und zwar die Eingabe. Es werden alle Datensätze mit dem Namen "Maier" geliefert.

Die zweite Eingabe des Benutzers ist das Zeichen "r". Diese Eingabe wird zwischen die Prozentzeichen gesetzt, die als Platzhalter dienen. Es werden alle Datensätze geliefert, deren Name ein "r" enthält.

Datensätze ändern

Die Anweisung UPDATE dient zur Änderung von Inhalten in einem oder mehreren Datensätzen. Sie ähnelt in ihrem Aufbau der Anweisung SELECT. Wählen Sie Ihre Auswahlkriterien sorgfältig, damit Sie nicht versehentlich die falschen Änderungen vornehmen.

sql = "UPDATE personen SET gehalt = 3800"

Diese Anweisung würde bei sämtlichen Datensätzen der Datenbanktabelle personen den Wert für das Feld gehalt auf den Wert 3800 setzen – diese Aktion ist sicherlich nicht beabsichtigt. Nehmen Sie daher eine Einschränkung vor, am besten über das Feld mit dem eindeutigen Index (hier das Feld personalnummer).

sql = "UPDATE personen SET gehalt = 3780 " \
      "WHERE personalnummer = 81343"

Das obige Beispiel sieht, mit einer Ausgabe vor der Änderung und einer Ausgabe nach der Änderung, wie folgt aus:

Listing 7: Datei sqlite_aendern.py

import sqlite3

def ausgabe():
    # SQL-Abfrage, senden, Ausgabe
    sql = "SELECT * FROM personen"
    cursor.execute(sql)
    for dsatz in cursor:
        print(dsatz[0], dsatz[1], dsatz[2], dsatz[3])
    print()

# Verbindung, Cursor
connection = sqlite3.connect("firma.db")
cursor = connection.cursor()

# Vorher
ausgabe()

# Datensatz aktualisieren
sql = "UPDATE personen SET gehalt = 3780 " \
      "WHERE personalnummer = 81343"
cursor.execute(sql)
connection.commit()

# Nachher
ausgabe()

connection.close()

Folgende Ausgabe wird erzeugt:

Mertens Julia 2297 3621.5
Maier Hans 6714 3500.0
Maier Wolfgang 8339 3810.0
Schmitz Peter 81343 3750.0

Mertens Julia 2297 3621.5
Maier Hans 6714 3500.0
Maier Wolfgang 8339 3810.0
Schmitz Peter 81343 3780.0

Wie Sie sehen, wird nur ein Datensatz verändert. Nachfolgend ein Beispiel für die Änderung mehrerer Feldinhalte eines Datensatzes:

sql = "UPDATE personen SET gehalt = 3780, " \
      "vorname = 'Hans-Peter' " \
      "WHERE personalnummer = 81343"

Es darf keine Änderung durchgeführt werden, die dazu führt, dass zwei oder mehr Datensätze den gleichen Inhalt in dem Feld haben, auf dem der eindeutige Index (PRIMARY KEY) liegt, hier das Feld personalnummer. So würde die Anweisung …

sql = "UPDATE personen SET personalnummer = 6714 " \
      "WHERE personalnummer = 81343"

… zur folgenden Fehlermeldung führen:

sqlite3.IntegrityError: PRIMARY KEY must be unique

Die Einträge im Feld mit dem PRIMARY KEY sind einzigartig.

Datensätze löschen

Mit der SQL-Anweisung DELETE löschen Sie Datensätze. Wählen Sie Ihre Auswahlkriterien besonders sorgfältig, damit Sie nicht versehentlich die falschen Datensätze oder alle Datensätze löschen. Ein Beispiel:

Listing 8: Datei sqlite_loeschen.py

import sqlite3

def ausgabe():
    # SQL-Abfrage, senden, Ausgabe
    sql = "SELECT * FROM personen"
    cursor.execute(sql)
    for dsatz in cursor:
        print(dsatz[0], dsatz[1], dsatz[2], dsatz[3])
    print()

# Verbindung, Cursor
connection = sqlite3.connect("firma.db")
cursor = connection.cursor()

# Vorher
ausgabe()

# Datensatz entfernen
sql = "DELETE FROM personen " \
      "WHERE personalnummer = 8339"
cursor.execute(sql)
connection.commit()

# Nachher
ausgabe()

connection.close()

Die Ausgabe lautet:

Mertens Julia 2297 3621.5
Maier Hans 6714 3500.0
Maier Wolfgang 8339 3810.0
Schmitz Peter 81343 3780.0

Mertens Julia 2297 3621.5
Maier Hans 6714 3500.0
Schmitz Peter 81343 3780.0

Der Datensatz mit der Personalnummer 8339 wird gelöscht. Das zeigt der Vergleich der Ausgaben vor dem Löschen und nach dem Löschen.

Der Artikel ist ein Auszug aus dem Buch "Einstieg in Python"

Einstieg in Python. Programmieren lernen für Anfänger. Inklusive Objektorientierung, Datenbanken, Raspberry Pi...

Sie möchten Python lernen? Mit diesem Buch schaffen Sie es! Folgen Sie Thomas Theis bei der Entwicklung eines kleinen Spiels und lernen Sie ganz nebenbei das Basiswissen.

Autor

Thomas Theis

Thomas Theis ist Diplom-Ingenieur für Technische Informatik und Software-Entwickler. Er hat langjährige Erfahrung als IT-Dozent, unter anderem an der Fachhochschule Aachen.
>> Weiterlesen

Kommentare (0)

Neuen Kommentar schreiben