MySQL in Python Tutorial: Einstieg

Eine neue Datenbank in MySQL mit Python erstellen

Ab hier brauchst du SQL-Kenntnisse; der Kurs Introduction to SQL von DataCamp ist ein guter Einstieg, um schnell auf Stand zu kommen. 

So erstellst du typischerweise eine Datenbank in MySQL: 

CREATE DATABASE book_ratings;

Um dieselbe Abfrage in Python auszuführen, musst du eine Instanz des cursor()-Objekts erstellen. 

Über das cursor()-Objekt kannst du SQL-Befehle als String an die Methode execute() übergeben, die den Code ausführt. 

Lass uns eine Datenbank namens „book_ratings“ erstellen…

create_db = "CREATE DATABASE book_ratings"
with database.cursor() as cursor:
    cursor.execute(create_db)

Hinweis: Wenn du diesen Code mehrfach ausführst, erhältst du eine Fehlermeldung, dass die Datenbank bereits existiert.

So prüfst du, welche Datenbanken auf einem Server existieren:

show_existing_db = "SHOW DATABASES"

with database.cursor() as cursor: 
    cursor.execute(show_existing_db)
    for db in cursor:
        print(db)

"""
('book_ratings',)
('information_schema',)
('mysql',)
('performance_schema',)
('sakila',)
('sys',)
('world',)
"""

Der obige Code gibt die Namen aller Datenbanken aus, die aktuell auf unserem MySQL-Server vorhanden sind. Es sind mehrere, da der MySQL-Server automatisch Datenbanken erzeugt, um Zugriff auf verschiedene Metadaten und Servereinstellungen zu bieten.

Verbindung zu einer bestehenden Datenbank

Nehmen wir an, du hast bereits eine Datenbank erstellt, dich aber noch nicht mit dem Server verbunden; wie würdest du dich direkt mit der Datenbank verbinden? 

Ganz einfach. 

Übergebe den Namen der Datenbank als Argument an die Methode connect():

try:
    with connector.connect(
        host = "localhost",
        user = "root",
        password = PASSWORD,
        database = "book_ratings"
    ) as database:
       
        print(database})

except connector.Error as e:
    print(e)

"""
<mysql.connector.connection_cext.CMySQLConnection object at 0x0000016DD8C24970>
"""

Tabellen erstellen

Informationen in einer Datenbank werden in Tabellen gespeichert. Eine Tabelle ist ein Format zur Speicherung zusammenhängender Daten in Spalten und Zeilen. 

In einer Datenbank kann es mehrere Tabellen geben, auch wenn sie nicht miteinander verknüpft sind. Du kannst aber auch eine relationale Datenbank mit nur einer Tabelle haben, wie wir in diesem Abschnitt zeigen – vertiefe dein Wissen zu relationalen Datenbanken im Kurs Introduction to Relational Databases in SQL. 

Das Erstellen einer Tabelle folgt demselben Muster, das du bereits gesehen hast: 

• Schreibe einen SQL-Befehl als String. 
• Übergebe ihn an die Methode execute() des Cursor-Objekts. 

Die SQL-Anweisung in diesem Fall ist CREATE TABLE.

Erstellen wir eine Tabelle für Bücher:

create_books_table = """
CREATE TABLE books(
    id INT NOT NULL AUTO_INCREMENT PRIMARY KEY,
    title VARCHAR(100),
    author VARCHAR(100),
    genre VARCHAR(100),
    release_year YEAR(4)
)
"""
# Create cursor object
with existing_database.cursor() as cursor:
    cursor.execute(create_books_table)
    existing_database.commit()

In der letzten Codezeile siehst du die Methode commit() auf unserem Objekt existing_database. Das ist nötig, weil der MySQL-Python-Connector standardmäßig Transaktionen nicht automatisch bestätigt.

Immer wenn du Daten in einer Tabelle änderst, musst du commit() aufrufen – mehr dazu in den MySQL-Docs. 

Weitere wichtige Punkte im Code: 

• NOT NULL: Eine Einschränkung, die verhindert, dass eine Spalte NULL-Werte akzeptiert. 
• PRIMARY KEY: Ein eindeutiger Wert zur Identifizierung bestimmter Zeilen in einer Tabelle. 
• AUTO_INCREMENT: Generiert automatisch eine eindeutige Zahl für neue Datensätze, die in die Tabelle eingefügt werden. 

Wir können prüfen, ob unser Schema korrekt erstellt wurde, indem wir die Anweisung DESCRIBE verwenden und anschließend alle Elemente mit der Methode fetchall() unseres Cursor-Objekts ausgeben…

describe_books = "DESCRIBE books"
with existing_database.cursor() as cursor:
    cursor.execute(describe_books)
    books_schema = cursor.fetchall()
    for column in books_schema:
        print(column)

"""
('id', b'int', 'NO', 'PRI', None, 'auto_increment')
('title', b'varchar(100)', 'YES', '', None, '')
('author', b'varchar(100)', 'YES', '', None, '')
('genre', b'varchar(100)', 'YES', '', None, '')
('release_year', b'year', 'YES', '', None, '')
"""

Daten einfügen

In den vorherigen Abschnitten haben wir in unserer Datenbank book_ratings eine Tabelle namens books angelegt. Momentan ist sie leer. Im nächsten Abschnitt siehst du zwei Möglichkeiten, wie du eine Tabelle befüllen kannst. 

Einen einzelnen Datensatz einfügen

Mitunter musst du einen einzelnen Datensatz in eine Tabelle einfügen. In der Praxis ist das selten, aber so funktioniert es:

# INSERT SINGLE RECORD
insert_single_record = "INSERT INTO books (id, title, author, genre, release_year)\
    VALUES (%s, %s, %s, %s, %s)"
single_record = (
    "1", "Choose Yourself! Be Happy, Make Millions, Live the Dream", "James Altucher", "self-help", "2013"
    )

# Create cursor object
with existing_database.cursor() as cursor:
    cursor.execute(insert_single_record, single_record)
    existing_database.commit()

Mehrere Datensätze einfügen

Häufiger fügst du Daten mit der Methode executemany(operation_to_perform, seq_of_params) des Cursor-Objekts ein; damit kannst du mehrere Datensätze auf einmal schreiben. 

Die Struktur der Operation bleibt gleich; nur die Parametersequenz ändert sich. 

So sieht das im Code aus: 

multiple_records = [
    (
        "2",
        "Skip the Line: The 10,000 Experiments Rule and Other Surprising Advice for Reaching Your Goals",
        "James Altucher",
        "self-help",
        "2021"        
    ),
    (
        "3",
        "The Power of No: Because One Little Word Can Bring Health, Abundance, and Happiness",
        "James Altucher",
        "self-help",
        "2014"
    ),
    ]

with existing_database.cursor() as cursor:
    cursor.executemany(insert_multiple_records, multiple_records)
    existing_database.commit()

Daten abfragen 

Die Anweisung SELECT dient dazu, Zeilen aus einer oder mehreren Tabellen einer Datenbank abzurufen. Wir können SELECT auf zwei Arten nutzen: 

1. Bestimmte Spalten aus einer Tabelle auswählen.

select_specific_cols = "SELECT author, release_year FROM books"
with existing_database.cursor() as cursor:
    cursor.execute(select_specific_cols)

1. Alle Spalten mit einem Sternchen „*“ zurückgeben.

# Create cursor object
select_all_cols = "SELECT * FROM books"
with existing_database.cursor() as cursor:
    cursor.execute(select_all_cols)

Daten sortieren und filtern 

Daten zu sortieren und zu filtern hilft dir, genau die Ergebnisse zurückzugeben, die dich interessieren, indem du Bedingungen vorgibst, die die Datensätze erfüllen müssen. 

Einige Beispiele: 

WHERE

Die Anweisung WHERE filtert Daten anhand einer definierten Bedingung. 

Angenommen, wir möchten Autor und Buchtitel für alle Bücher ausgeben, die bis einschließlich 2010 erschienen sind: 

condition = "SELECT author, title FROM books WHERE release_year <= 2010"
with existing_database.cursor() as cursor:
    cursor.execute(condition)

ORDER BY

Mit ORDER BY lassen sich Ergebnisse aufsteigend (ASC) oder absteigend (DESC) sortieren. Standard ist aufsteigend, sofern nichts anderes angegeben ist. 

So sortieren wir nach Veröffentlichungsjahr in absteigender Reihenfolge:

order_by_year = "SELECT * FROM books ORDER BY release_year DESC"
with existing_database.cursor() as cursor:
    cursor.execute(order_by_year)

LIMIT

Mit der Anweisung LIMIT legst du fest, wie viele Datensätze im Resultset zurückgegeben werden.

# Create cursor object
define_limit = "SELECT * FROM books LIMIT 3"
with existing_database.cursor() as cursor:
    cursor.execute(define_limit)

Der obige Code begrenzt die Anzahl der zurückgegebenen Datensätze auf drei. 

Daten aktualisieren und löschen

Es gibt Zeiten, in denen sich Daten ändern, nicht mehr nützlich sind oder Fehler enthalten. In diesem Abschnitt lernst du, wie du solche Fälle mit Updates und Löschungen handhabst. 

UPDATE

Die Abfrage UPDATE ermöglicht dir, bestehende Werte in einer Tabelle zu ändern, ohne deren Struktur zu beeinflussen. 

Beispielsweise musst du einen Datensatz anpassen, wenn jemand seinen Namen ändert; so sieht das im Code aus:

update_query = """
UPDATE
    books
SET
    author = "Big J"
WHERE
    author = "James Altucher"
"""
with existing_database.cursor() as cursor:
    cursor.execute(update_query)
    existing_database.commit()

DELETE

Mit der Abfrage DELETE löschst du Datensätze aus einer Tabelle:

drop_record = "DELETE FROM books WHERE release_year <= 2000"
with existing_database.cursor() as cursor:
    cursor.execute(drop_record)
    existing_database.commit()

In diesem Code löschen wir alle Datensätze mit einem Veröffentlichungsjahr kleiner oder gleich 2000. 

DROP TABLE

Mit DROP TABLE entfernst du eine Tabelle dauerhaft aus einer Datenbank. Mit IF EXISTS kannst du optional Fälle abfangen, in denen unklar ist, ob die gewünschte Tabelle existiert. 

Lass uns die Tabelle in unserer book_ratings-Datenbank löschen: 

drop_table = "DROP TABLE IF EXISTS books"
with existing_database.cursor() as cursor:
    cursor.execute(drop_table)
    existing_database.commit()

Fazit

In diesem Tutorial hast du gelernt, wie du in Python eine Verbindung zu einem MySQL-Server herstellst, eine neue Datenbank anlegst, dich mit einer bestehenden Datenbank verbindest, eine Tabelle erstellst und verschiedene Abfragen auf eine MySQL-Tabelle aus Python heraus ausführst.  

Sieh dir diese Ressourcen an, um weiterzulernen:

• Introduction to Databases in Python 
• SQL Server, PostgreSQL, MySQL … Wo liegen die Unterschiede? Wo fange ich an?
• SQL-Kurse für Einsteiger
• PostgreSQL vs. MySQL