PostgreSQL in Python verwenden

Daten sind das Herzstück fast jeder digitalen Anwendung, die du dir vorstellen kannst. Von mobilen Apps und Computerspielen bis hin zu Banking-Tools und autonomen Fahrzeugen - alles basiert auf Daten. Wo werden all diese Daten gespeichert? Die Antwort sind Datenbanken. 

Eine Datenbank ist eine organisierte Sammlung von strukturierten Daten, die in der Regel elektronisch in einem Computersystem gespeichert werden. Trotz der jüngsten Entwicklung neuer Datenbanktypen (die für das wachsende Volumen und die Variabilität von Daten entwickelt wurden), wird immer noch ein beträchtlicher Teil der Daten weltweit in sogenannten relationalen Datenbanken gespeichert. Relationale Datenbanken speichern Daten als Sammlungen von vordefinierten Tabellen mit Zeilen und Spalten, die durch eine oder mehrere Beziehungen miteinander verbunden sind. 

Die Fähigkeit, Daten aus diesen Datenbanken zu verarbeiten und zu extrahieren, ist eine wichtige Fähigkeit in der Datenbranche und wird immer stärker nachgefragt. Die Standardmethode zur Erstellung und Verwaltung von Datenbanken ist SQL (Structured Query Language). SQL ist der Grundstein für einige der beliebtesten relationalen Datenbanken auf dem Markt, wie PostgreSQL, Microsoft SQL Server, MySQL und SQLite.

In diesem Tutorial konzentrieren wir uns auf PostgreSQL-basierte Datenbanken und wie du sie mit Python erstellen, mit ihnen verbinden und verwalten kannst. Das Tandem aus SQL und Python ist eine der wichtigsten Fähigkeiten, die du auf deiner Reise durch die Datenwissenschaft beherrschen solltest. Um Python mit PostgreSQL zu verbinden, werden wir das Paket psycopg2 verwenden, den beliebtesten PostgreSQL-Datenbankadapter für Python. Bist du bereit für die Herausforderung? Lass uns loslegen!

PostgreSQL verstehen

PostgreSQL ist eine schlanke, kostenlose und quelloffene relationale Datenbank. Aufgrund seiner bewährten Architektur, Zuverlässigkeit, Datenintegrität und nahtlosen Integration mit anderen beliebten Programmiersprachen wie Python und R ist PostgreSQL in der Branche äußerst beliebt und wird von Unternehmen aller Größen und Regionen genutzt. 

PostgreSQL nutzt und erweitert die SQL-Sprache in Kombination mit vielen Funktionen, die die kompliziertesten Datenworkloads sicher speichern und skalieren. 

Um PostgreSQL nutzen zu können, musst du es zunächst auf deinem Computer installieren. Auf der offiziellen PostgreSQL-Website findest du viele gebrauchsfertige Pakete und Installationsprogramme für PostgreSQL sowie ein Quellcode-Archiv für verschiedene Plattformen und Anwendungsfälle.

Für dieses Tutorial verwenden wir Postgres App, eine einfache, native macOS-App, die alle Funktionen enthält, die für den Einstieg in PostgreSQL erforderlich sind. Aber bedenke, dass alle anderen verfügbaren Pakete genauso gültig sind und die PostgreSQL-Syntax zum Ausführen von Abfragen in allen Paketen gleich ist.

Wenn du mehr über PostgreSQL wissen willst, schau dir unseren Beginner's Guide to PostgreSQL und die zahlreichen SQL-Kurse an.

psycopg2 verstehen

Um eine Verbindung zu einer Datenbank herzustellen, die bereits in deinem System oder im Internet angelegt ist, musst du Python anweisen, wie es sie erkennen soll. Mit anderen Worten: Du musst Python mitteilen, dass die Datenbank, die dich interessiert, eine PostgreSQL-Datenbank ist. 

In Python hast du mehrere Optionen, aus denen du wählen kannst. In diesem Fall werden wir psycopg2 verwenden, den wahrscheinlich beliebtesten PostgreSQL-Datenbankadapter für Python. Psycopg2 benötigt ein paar Voraussetzungen, um auf deinem Computer richtig zu funktionieren. Sobald du sie installiert hast (lies die Dokumentation für weitere Informationen), kannst du psycopg2 wie jedes andere Python-Paket installieren:

pip install psycopg2

Wenn du psycopg2 jedoch direkt verwenden möchtest, kannst du auch psycopg2-binary installieren, eine eigenständige Version des Pakets, die keinen Compiler oder externe Bibliotheken benötigt. Dies ist die bevorzugte Installation für neue Nutzer.

pip install psycopg2-binary

Wenn du Python in einer Conda-Umgebung verwendest, solltest du psycopg2 über die Anaconda-Installation:

conda install -c anaconda psycopg2

Nachdem du nun alles vorbereitet hast, kannst du mit psycopg2 deine erste Verbindung zu deiner PostgreSQL-Sitzung herstellen!

Verbindung zwischen Python und PostgreSQL

Um mit Python mit einer PostgreSQL-Datenbank interagieren zu können, müssen wir eine Verbindung herstellen. Dies geschieht mit der Funktion psycopg2 connect(), die eine neue Datenbanksitzung erstellt und eine neue Verbindungsinstanz zurückgibt.

In diesem Lernprogramm verbinden wir uns mit einer Datenbank namens "datacamp_courses", die lokal gehostet wird. 

conn = psycopg2.connect(database = "datacamp_courses", 
                        user = "datacamp", 
                        host= 'localhost',
                        password = "postgresql_tutorial",
                        port = 5432)

Die grundlegenden erforderlichen Verbindungsparameter sind:

• Datenbank. Der Name der Datenbank.
• user. Benutzername, der für die Authentifizierung erforderlich ist.
• password. Passwort, das für die Authentifizierung verwendet wird.
• host. Adresse des Datenbankservers (in unserem Fall wird die Datenbank lokal gehostet, aber es könnte auch eine IP-Adresse sein).
• port. Nummer des Verbindungsports (standardmäßig 5432, wenn nicht angegeben).

Erstellen einer Tabelle in PostgreSQL

Es ist an der Zeit, deine erste Tabelle in der Datenbank "datacamp_courses" zu erstellen. Wir möchten eine Tabelle mit Informationen über einige der Kurse im DataCamp-Kurskatalog erstellen. Die Tabelle hat das folgende Schema: 

Die Spezifikation gibt uns ziemlich viele Informationen über die Spalten der Tabelle. Der Primärschlüssel der Tabelle sollte course_id sein (nur dieser ist fett gedruckt) und der Datentyp sollte eine ganze Zahl sein. Ein Primärschlüssel ist eine Einschränkung, die erzwingt, dass die Spaltenwerte nicht null und eindeutig sind. Damit kannst du eine bestimmte oder eine Gruppe von Instanzen in der Tabelle eindeutig identifizieren. 

Die übrigen Spalten enthalten Informationen über den Kursnamen, den Namen der Lehrkraft und das Thema des Kurses.

Bevor du die Tabelle erstellst, ist es wichtig zu erklären, wie die Verbindungsinstanz funktioniert, die du gerade erstellt hast. Im Wesentlichen kapselt die Verbindung eine Datenbanksitzung und ermöglicht es dir, SQL-Befehle und Abfragen wie SELECT, INSERT, CREATE, UPDATE, OR DELETE mit der Methode cursor() auszuführen und Änderungen mit der Methode commit() dauerhaft zu machen .

Sobald du die Cursor-Instanz erstellt hast, kannst du Befehle an die Datenbank senden, indem du die execute() Methode Befehle an die Datenbank senden und Daten aus einer Tabelle abrufen. fetchone(), fetchmany()oder fetchall().

Schließlich ist es wichtig, den Cursor und die Verbindung zur Datenbank zu schließen, wenn du deine Operationen beendet hast. Andernfalls werden sie weiterhin serverseitige Ressourcen halten. Dazu kannst du dieMethode close() verwenden.

Unten findest du den Code, um die Tabelle datacamp_courses zu erstellen:

# Open a cursor to perform database operations
cur = conn.cursor()
# Execute a command: create datacamp_courses table
cur.execute("""CREATE TABLE datacamp_courses(
            course_id SERIAL PRIMARY KEY,
            course_name VARCHAR (50) UNIQUE NOT NULL,
            course_instructor VARCHAR (100) NOT NULL,
            topic VARCHAR (20) NOT NULL);
            """)
# Make the changes to the database persistent
conn.commit()
# Close cursor and communication with the database
cur.close()
conn.close()

Dies ist ein sehr einfaches Beispiel dafür, wie man Tabellen in PostgreSQL erstellt, aber die Dinge können noch viel komplexer werden. Wenn du mehr darüber erfahren möchtest, wie du eine PostgreSQL-Datenbank erstellst und die Struktur, die Datentypen und die Normalisierung von Datenbanken kennenlernen möchtest, schau dir unseren PostgreSQL-Datenbank erstellen Kurs.

Ausführen von einfachen PostgreSQL-Abfragen in Python

Die Tabelle datacamp_courses ist fertig; jetzt ist es an der Zeit, mit SQL einige grundlegende Abfragen durchzuführen!

INSERT 

Du hast vielleicht bemerkt, dass die Tabelle bisher keine Werte enthält. Um Datensätze in der Tabelle datacamp_courses zu erstellen, brauchen wir den Befehl INSERT.

cur = conn.cursor()

cur.execute("INSERT INTO datacamp_courses(course_name, course_instructor, topic) VALUES('Introduction to SQL','Izzy Weber','Julia')");

cur.execute("INSERT INTO datacamp_courses(course_name, course_instructor, topic) VALUES('Analyzing Survey Data in Python','EbunOluwa Andrew','Python')");

cur.execute("INSERT INTO datacamp_courses(course_name, course_instructor, topic) VALUES('Introduction to ChatGPT','James Chapman','Theory')");

cur.execute("INSERT INTO datacamp_courses(course_name, course_instructor, topic) VALUES('Introduction to Statistics in R','Maggie Matsui','R')");

cur.execute("INSERT INTO datacamp_courses(course_name, course_instructor, topic) VALUES('Hypothesis Testing in Python','James Chapman','Python')");

conn.commit()
cur.close()
conn.close()

Die resultierende Tabelle sieht wie folgt aus:

SELECT 

Das Lesen von Daten in SQL-Datenbanken ist wahrscheinlich etwas, das du auf deiner Reise durch die Datenwissenschaft häufig tun wirst. Dies wird im Allgemeinen als SELECT Abfrage bezeichnet. Sehen wir uns erst einmal an, wie sich die Tabelle datacamp_courses verhält.

Wir rufen die klassische SELECT * FROM database_name-Anweisung auf, um alle in der Tabelle verfügbaren Daten zu lesen. Dann werden wir die Methode fetchall() verwenden, um alle verfügbaren Zeilen zu holen. Beachte, dass PostgreSQL automatisch einen numerischen Index für die Spalte course_id erstellt.

cur = conn.cursor()
cur.execute('SELECT * FROM datacamp_courses;')
rows = cur.fetchall()
conn.commit()
conn.close()
for row in rows:
    print(row)

(1, 'Introduction to SQL', 'Izzy Weber', 'Julia')
(2, 'Analyzing Survey Data in Python', 'EbunOluwa Andrew', 'Python')
(3, 'Introduction to ChatGPT', 'James Chapman', 'Theory')
(4, 'Introduction to Statistics in R', 'Maggie Matsui', 'R')
(5, 'Hypothesis Testing in Python', 'James Chapman', 'Python')

UPDATE 

Daten sind oft mit Fehlern behaftet. Im vorherigen Abschnitt hast du vielleicht bemerkt, dass das Thema des Kurses "Einführung in SQL" Julia ist. Nachdem wir die Informationen über den Kurs überprüft hatten, entdeckten wir den Fehler. Wir müssen es ändern und stattdessen "SQL" schreiben. Das kannst du mit der Anweisung UPDATE wie folgt tun:

cur = conn.cursor()
cur.execute("UPDATE datacamp_courses SET topic = 'SQL' WHERE course_name = 'Introduction to SQL';")
conn.commit()
conn.close()

DELETE 

Zum Schluss möchtest du vielleicht einen der Datensätze in deiner Tabelle löschen. Lass uns zum Beispiel den Kurs Einführung in die Statistik in R löschen:

cur = conn.cursor()
cur.execute("""DELETE from datacamp_courses WHERE course_name = 'Introduction to Statistics in R'""");
conn.commit()
cur.close()

Erweiterte PostgreSQL-Abfragen in Python

Im vorherigen Abschnitt haben wir die grundlegendsten SQL-Abfragen untersucht. Aber es gibt viel zu lernen. Sehen wir uns einige fortgeschrittene Abfragen an.

ORDER BY

Angenommen, du möchtest deine Datenbank nach dem Namen der Lehrkraft sortieren. Du kannst die Anweisung ORDER BY verwenden:

cur = conn.cursor()

cur.execute('SELECT * FROM datacamp_courses ORDER BY course_instructor')
rows = cur.fetchall()
for row in rows:
    print(row)

(2, 'Analyzing Survey Data in Python', 'EbunOluwa Andrew', 'Python')
(1, 'Introduction to SQL', 'Izzy Weber', 'SQL')
(3, 'Introduction to ChatGPT', 'James Chapman', 'Theory')
(4, 'Hypothesis Testing in Python', 'James Chapman', 'Python')

GRUPPE BY

Du möchtest vielleicht einige Aggregatfunktionen innerhalb verschiedener Datengruppen durchführen. Du könntest zum Beispiel daran interessiert sein, die Anzahl der Kurse der verschiedenen Kursleiter/innen zu berechnen. Du kannst diese Art von Operation mit der Funktion GROUP BY durchführen.

cur = conn.cursor()
cur.execute('SELECT course_instructor, COUNT(*) FROM datacamp_courses GROUP BY course_instructor')
rows = cur.fetchall()
for row in rows:
    print(row)

('James Chapman', 2)
('Izzy Weber', 1)
('EbunOluwa Andrew', 1)

JOIN

Bis zu diesem Punkt haben wir nur mit der Tabelle datacamp_course gearbeitet. Das volle Potenzial von relationalen Datenbanken wie PostgreSQL kannst du aber erst dann nutzen, wenn du mit mehreren Tabellen gleichzeitig arbeitest. 

Das magische Werkzeug, um mehrere Tabellen zu kombinieren, ist die JOIN-Operation. Stell dir vor, wir haben eine zweite Tabelle in unserer Datenbank mit dem Namen programming_languages, die grundlegende Informationen über die Top-Programmiersprachen für Data Science enthält, darunter den Namen, die Position im TIOBE-Index und die Anzahl der Kurse über die Programmiersprache in Datacamp. Die Tabelle sieht wie folgt aus:

Stell dir vor, du möchtest die beiden Tabellen zusammenführen, um die Informationen zu den Kursen zusammen mit der Position der Sprache im TIOBE-Index zu erhalten. Wir werden eine INNER JOIN verwenden, um nur die Informationen der Programmiersprachen zu erhalten, die in der Tabelle datacamp_course erscheinen. 

cur = conn.cursor()
cur.execute("""SELECT course_name, course_instructor, topic, tiobe_ranking
FROM datacamp_courses
INNER JOIN programming_languages
ON datacamp_courses.topic = programming_languages.language_name""")
rows = cur.fetchall()
for row in rows:
    print(row)

('Introduction to SQL', 'Izzy Weber', 'SQL', 8)
('Analyzing Survey Data in Python', 'EbunOluwa Andrew', 'Python', 1)
('Hypothesis Testing in Python', 'James Chapman', 'Python', 1)

Das ist nur ein Beispiel, aber das Potenzial von SQL JOINS ist endlos, so dass es ein Muss ist, dieses Thema zu kennen. Unser Kurs, Tutorium, und Spickzettel zu JOINS werden dir den Einstieg erleichtern.

Erste Schritte mit SQLAlchemy

Psycopg2 ist ein großartiges Tool zur Verbindung mit PostgreSQL-Datenbanken. Aber was ist, wenn du mit Datenbanken arbeiten musst, die in verschiedenen SQL-Datenbanken gehostet werden, wie z.B. Oracle und MySQL? In diesen Fällen kann es besser sein, ein Tool zu verwenden, das sich mit verschiedenen Arten von SQL-Datenbanken verbinden kann. Hierfür ist SQLAlchemy ein hervorragender Kandidat. 

Mit einfachen Worten: SQLAlchemy ermöglicht es Nutzern, Datenbanken mit Python zu verbinden, SQL-Abfragen mit objektbasierter Programmierung auszuführen und den Arbeitsablauf zu optimieren. 

Die Syntax unterscheidet sich zwar von der in psycopg2, aber du kannst so ziemlich das Gleiche tun. Im Folgenden findest du ein Beispiel, wie du eine Engine erstellst, die sich mit unseren datacamp_courses-Datensätzen verbindet und alle in der Tabelle datacap_course verfügbaren Daten liest.

import sqlalchemy as db


engine = db.create_engine("postgresql://datacamp@localhost:5432/datacamp_courses")
conn = engine.connect() 
output = conn.execute("SELECT * FROM datacamp_courses")
print(output.fetchall())
conn.close()

[(3, 'Introduction to ChatGPT', 'James Chapman', 'Theory'),
 (5, 'Hypothesis Testing in Python', 'James Chapman', 'Python'),
 (2, 'Analyzing Survey Data in Python', 'EbunOluwa Andrew', 'Python'),
 (1, 'Introduction to SQL', 'Izzy Weber', 'SQL')]

SQLAlchemy ist ein weiteres großartiges Tool, das du lernen solltest. Um einen Einblick in die Funktionsweise des Tools zu bekommen, wirf einen Blick auf unser SQLALchemy Tutorial.  

PostgreSQL im DataCamp DataLab verwenden

Beim DataCamp arbeiten wir hart daran, Data Science einfacher und für jeden zugänglich zu machen. Das war der Grund für die Entwicklung von DataCamp DataLab, einem cloudbasierten Notebook, das speziell für Data Science entwickelt wurde. Du kannst dir das DataCamp DataLab als eine Mischung aus Jupyter Notebook und Google Docs vorstellen, die es den Nutzern ermöglicht, Code zu schreiben, Daten einzeln oder gemeinsam zu analysieren und Dateneinsichten zu teilen.

Die Verbindung von DataLab mit PostgreSQL-Datenbanken und anderen SQL-Datenbanken ist extrem einfach. Mit DataLab kannst du dich auf sichere Weise mit Datenquellen verbinden, während du deine Datenanalyse nahtlos mit Python oder R fortsetzen kannst. Du musst nur eine Integration erstellen, indem du einen unkomplizierten, codefreien Prozess durchführst, bei dem du deine Verbindungsdaten eingeben musst. 

Die folgende Abbildung zeigt, wie du eine PostgreSQL-Integration erstellst. 

Wenn du die Integration ausprobieren möchtest, aber keine PostgreSQL-Datenbank hast, mit der du dich verbinden kannst, kannst du einfach eine unserer verfügbaren PostgreSQL-Beispieldatenbanken verwenden!

Neugierig auf das DataCamp DataLab? In diesem Artikel erfährst du mehr über dieses Notebook der nächsten Generation für Data Science.

Fazit

Gute Arbeit! In diesem Tutorial hast du dich mit PostgreSQL vertraut gemacht und gelernt, wie du mit dem Paket psycopg2 Datenbanken verwalten kannst, ohne Python zu verlassen. Aber das ist erst der Anfang der Reise. SQL ist eine der am weitesten verbreiteten Programmiersprachen in der Datenwissenschaft. Außerdem ist es ziemlich einfach zu lernen, du hast also keine Ausrede.  

Zum Glück ist Datacamp für dich da. Hier sind einige Ressourcen, die dir helfen können, PostgreSQL und SQL im Allgemeinen fließend zu beherrschen:

• Einführung in PostgreSQL für Anfänger Tutorial
• PostgreSQL-Datenbanken erstellen Kurs
• Verbesserung der Abfrageleistung in PostgreSQL Kurs
• Datenbanken verwalten in SQL Kurs
• Funktionen zur Datenmanipulation in PostgreSQL Kurs