Phenquestions
Wir können mit Datenbanken in jeder Programmiersprache interagieren oder wir können ein Softwareprogramm verwenden, das es uns ermöglicht, mit der Datenbank über eine GUI zu interagieren. In diesem Artikel besprechen wir Datenbanken und zeigen Ihnen, wie Sie mit der Programmiersprache Python mit ihnen interagieren interact.
Relationale Datenbanken (SQL)
Relationale Datenbanken (SQL) unterscheiden sich in Bezug auf das Schema von nicht-relationalen Datenbanken (NoSQL). Ein Schema ist eine Vorlage, die die Struktur der Daten definiert, die Sie speichern möchten. In relationalen Datenbanken erstellen wir Tabellen zum Speichern von Daten. Das Schema einer Tabelle wird beim Erstellen der Tabelle definiert defined. Wenn wir beispielsweise Daten zu Schülern in einer relationalen Datenbank speichern möchten, erstellen wir eine Schülertabelle und definieren das Schema der Tabelle, das den Namen, die Registrierungsnummer, die Note usw. von jedem Schüler. Nach dem Erstellen des Schemas speichern wir die Daten in den Zeilen der Tabelle. Es ist wichtig zu beachten, dass wir keine Daten speichern können, die nicht im Schema definiert sind. In diesem Beispiel kann die Note, die ein Student bei einer Prüfung erhalten hat, nicht in der Tabelle gespeichert werden, da wir im Schema keine Spalte für diese Daten definiert haben.
Die folgende Liste enthält einige beliebte relationale Datenbanken:
- MariaDB
- MySQL
- SQL Server
- PostgreSQL
- Orakel
Nicht-relationale Datenbanken (NoSQL)
Wie oben besprochen, haben nicht-relationale Datenbanken kein definiertes Schema. Nicht-relationale Datenbanken haben Sammlungen anstelle von Tabellen, und diese Sammlungen enthalten Dokumente, die den Zeilen in einer relationalen Datenbank entsprechen. Wenn wir beispielsweise eine nicht relationale Datenbank zum Speichern von Schülerdaten erstellen möchten, können wir eine Sammlung von Benutzern erstellen und in dieser Sammlung ein Dokument für jeden Schüler speichern store. Diese Dokumente haben kein definiertes Schema, und Sie können für jeden Schüler alles speichern, was Sie möchten.
Ausführen von CRUD-Operationen in MySQL
Jetzt zeigen wir Ihnen, wie Sie mit Python mit MySQL interagieren.
MySQL-Treiber für Python installieren
Um mit MySQL mit Python zu interagieren, müssen wir zuerst den MySQL-Treiber in Python installieren.
[email protected]:~$ sudo pip3 install mysql-connector-pythonoder
[email protected]:~$ sudo pip install mysql-connector-pythonErstellen einer Datenbank
Bevor wir eine Datenbank erstellen, müssen wir uns mit Python mit dem MySQL-Server verbinden. Das mysql.Das Connector-Modul bietet die Methode connect(), um mithilfe von Python eine Verbindung zu MySQL herzustellen.
>>> mysql importieren.Verbinder//Ersetzen Sie durch Ihre eigene IP- und Server-Anmeldeinformationen
>>> sql = mysql.Verbinder.verbinden(
… host='localhost',
… user='root',
… Passwort='12345'
…)
>>> Drucken (sql)
Diese Meldung zeigt, dass wir mit Python erfolgreich eine Verbindung zu einer MySQL-Datenbank hergestellt haben. Jetzt führen wir eine SQL-Abfrage auf dem MySQL-Server mit der Methode execute() aus dem mysql aus.Anschlussmodul.
>>> Cursor = sql.Mauszeiger()>>> Abfrage = 'DATENBANK ERSTELLEN demo_db'
>>> Cursor.ausführen (abfrage)
Der obige Code erstellt eine Datenbank namens demo_db in MySQL.
Erstellen einer Tabelle
Nachdem wir nun eine Datenbank erstellt haben, erstellen wir eine neue Tabelle namens Students. Um eine Tabelle zu erstellen, müssen wir eine Verbindung zur Datenbank herstellen.
>>> sql_db = mysql.Verbinder.verbinden(… host='localhost',
… user='root',
… Passwort='12345',
… database='demo_db'
…)
Nachdem wir eine Verbindung zur Datenbank hergestellt haben, verwenden wir die Methode execute(), um eine SQL-Abfrage auszuführen, um eine Tabelle mit einem Schema zu erstellen.
>>> query = "CREATE TABLE Students(name VARCHAR(64), id INT, grade INT, dob DATE)";>>> Cursor.ausführen (abfrage);
Der obige Befehl erstellt eine Tabelle namens Students in der Datenbank demo_db; wir können nur einen Namen, eine ID, einen Grad und ein Geburtsdatum in die Tabelle einfügen, wie im Schema definiert.
Einfügen von Zeilen in eine Tabelle
Nachdem wir nun eine Tabelle erstellt haben, fügen wir einen Schüler in diese Tabelle ein. Wir erstellen eine Abfrage und verwenden dann die Methode execute(), um die Abfrage auf dem MySQL-Server mit Python auszuführen.
>>> query = 'INSERT INTO students(name, id, grade, dob) VALUES("John", 1, 3, "2020-7-04")'>>> Cursor.ausführen (abfrage)
>>> sql_db.verpflichten()
Diese Abfrage fügt einen Schüler mit den in der Abfrage definierten Daten in die Tabelle ein. Auf die gleiche Weise können wir der Tabelle weitere Schüler hinzufügen.
HINWEIS: Änderungen werden nur auf die Datenbank angewendet, wenn Sie sql_db ausführen.commit() nach dem Anwenden von Änderungen.
Auswählen von Zeilen aus einer Tabelle
Die SELECT-Anweisung in MySQL wird verwendet, um Daten aus einer Tabelle zurückzugeben. Wir verwenden die Methode execute(), um eine Abfrage auszuführen, und verwenden dann die Methode fetchall(), um eine Liste aller Schüler zu erhalten. Dann können wir eine for-Schleife verwenden, um alle Schüler anzuzeigen
>>> query = 'SELECT * FROM Students'>>> Cursor.ausführen (abfrage)
>>> Ergebnis = Cursor.holen ()
>>> für x im Ergebnis:
… drucken(x)
('John', 1, 3, Datum/Uhrzeit.Datum(2020, 7, 4))
Wir können sehen, dass nur Daten für einen einzelnen Schüler zurückgegeben werden, da wir nur einen Schüler in der Tabelle haben. Wir können die WHERE-Anweisung in MySQL mit der SELECT-Anweisung verwenden, um Einschränkungen anzugeben. Wenn wir beispielsweise nur die Schüler der 4. Klasse zurückgeben möchten, können wir die folgende Abfrage verwenden:
>>> query = 'SELECT * FROM Students WHERE grade = 4'>>> Cursor.ausführen (abfrage)
>>> Ergebnis = Cursor.holen ()
>>> für x im Ergebnis:
… drucken(x)
Der obige Code holt nur die Schüler ab Klasse 4.
Aktualisieren einer Zeile
In diesem Abschnitt zeigen wir Ihnen, wie Sie die Schülerdaten in einer MySQL-Tabelle mit Python aktualisieren. Wir werden die UPDATE-Anweisung mit den WHERE- und SET-Anweisungen in MySQL verwenden, um die Daten bestimmter Schüler zu aktualisieren. Die WHERE-Anweisung wird verwendet, um zu bestimmen, welche Zeilen aktualisiert werden, und die SET-Anweisung wird verwendet, um die für die Aktualisierung verwendeten Werte zu definieren.
>>> query = 'UPDATE Students SET name="Mark" WHERE id = 4'>>> Cursor.ausführen (abfrage)
>>> sql_db.verpflichten()
Jetzt werden wir versuchen, die Schülerdaten aus der Tabelle zu lesen, indem wir die SELECT-Anweisung verwenden.
>>> query = 'SELECT * FROM Students WHERE id=4'>>> Cursor.ausführen (abfrage)
>>> für x im Cursor:
… drucken(x)
('Markieren', 4, 4, Datum/Uhrzeit.Datum(2020, 7, 15))
Jetzt können wir sehen, dass der Name des Schülers mit der ID 4 in Mark geändert wurde.
Löschen einer Zeile
Wir können eine Zeile aus der Tabelle löschen, indem wir die DELETE-Anweisung in MySQL mit Python anwenden. Wir verwenden eine DELETE-Anweisung mit einer WHERE-Anweisung, um bestimmte Schüler aus der Tabelle zu löschen.
>>> query = 'DELETE FROM Students WHERE id=2'>>> Cursor.ausführen (abfrage)
>>> sql_db.verpflichten()
Jetzt können wir mit der SELECT-Anweisung alle Schüler aus der Tabelle zurückgeben.
>>> query = 'SELECT * FROM Students'>>> Cursor.ausführen (abfrage)
>>> für x im Cursor:
… drucken(x)
('John', 1, 3, Datum/Uhrzeit.Datum(2020, 7, 4))
('John', 3, 3, Datum/Uhrzeit.Datum(2020, 7, 8))
('Markieren', 4, 4, Datum/Uhrzeit.Datum(2020, 7, 15))
Wir sehen, dass die Tabelle keinen Schüler mit der ID 2 enthält, da wir den Schüler aus der Tabelle entfernt haben.
Einen Tisch fallen lassen
Das mysql.Connector-Modul kann auch zum Ablegen eines Tisches verwendet werden. Wir können eine DROP-Anweisung in MySQL ausführen, indem wir die Methode execute() verwenden.
>>> Cursor = sql_db.Mauszeiger()>>> query = 'DROP TABLE Schüler'
>>> Cursor.ausführen (abfrage)
Der obige Code löscht die Tabelle namens Students, wenn er in Python ausgeführt wird.
Damit ist unsere Diskussion über SQL-Datenbanken abgeschlossen. Wir haben Ihnen gezeigt, wie Sie mit Python verschiedene Abfragen auf die MySQL-Datenbank anwenden. Als Nächstes wenden wir CRUD-Operationen auf eine NoSQL-Datenbank namens MongoDB an
Ausführen von CRUD-Operationen in MongoDB
Um mit MongoDB mit Python zu interagieren, müssen wir zuerst pymongo installieren, einen MongoDB-Treiber für Python.
[email protected]:~$ sudo pip install pymongooder
[email protected]:~$ sudo pip3 installiere pymongoErstellen einer Datenbank
Wir können eine Verbindung zu MongoDB herstellen, indem wir die Methode MongoClient() des Pymongo-Moduls in MongoDB verwenden. Bevor wir irgendwelche Aktionen ausführen, müssen wir uns mit der MongoDB-Datenbank verbinden.
>>> Pymongo importieren>>> client = pymongo.MongoClient('mongodb://localhost:27017/')
Nachdem wir uns mit dem Datacase verbunden haben, können wir die folgende Zeile ausführen, um eine neue Datenbank namens demo_db . zu erstellen.
>>> db = client['demo_db']Wenn die Datenbank bereits existiert, wird dieser Befehl ignoriert.
Erstellen einer Sammlung
Nachdem wir nun eine Datenbank erstellt haben, erstellen wir eine Sammlung namens Students in der Datenbank namens.
>>> Pymongo importieren>>> client = pymongo.MongoClient('mongodb://localhost:27017/')
>>> db = client['demo_db']
>>> col = db['students']
HINWEIS: MongoDB erstellt keine Sammlung, bis Sie Daten darin eingeben. Wenn Sie also versuchen, auf die Sammlung zuzugreifen, nachdem Sie den obigen Code ausgeführt haben, werden Sie feststellen, dass sich nichts in der Datenbank befindet.
Ungefüttertes MySQL, wir müssen kein Schema definieren, wenn wir eine neue Sammlung erstellen, da MongoDB eine nicht relationale Datenbank ist.
Einfügen eines Dokuments
Nachdem wir eine Sammlung erstellt haben, können wir ein Dokument in die Sammlung einfügen. Zuerst müssen wir ein Wörterbuch definieren und dann können wir die Methode insert_one() verwenden, um die im Wörterbuch definierten Daten in die Sammlung einzufügen.
HINWEIS: MongoDB erstellt automatisch eine eindeutige '_id' für jedes Dokument; Daher müssen wir keine ID angeben.
>>> Daten =… "Name": "Johannes",
… "3. Klasse,
… "dob": "2020-04-03"
…
>>> Ergebnis = col.insert_one(Daten)
In das obige Dokument haben wir Name, Klasse und Geburtsdatum eingefügt. Jetzt fügen wir ein Dokument in die Schülersammlung ein, das ein Feld für das Alter enthält.
>>> Daten =… „Name“ : „Markus“,
… "Klasse 4,
… "dob": "2020-04-09",
… "Alter" : 8
…
>>> Ergebnis = col.insert_one(Daten)
Wir können sehen, dass dieser Befehl keinen Fehler auslöst. Da MongoDB eine nicht relationale Datenbank ist, können wir beliebige Informationen in das Dokument einfügen.
Dokumente abrufen
In diesem Abschnitt verwenden wir die Methoden find() und find_one(), um Daten aus der Datenbank abzurufen. Die Methode find() verwendet zwei Argumente: das erste wird verwendet, um Dokumente zu filtern, und das zweite wird verwendet, um die Felder des Dokuments zu definieren, das wir zurückgeben möchten. Wenn wir beispielsweise die ID von "John" erhalten möchten, können wir die folgende Abfrage ausführen:
>>> Ergebnis = col.find("name": "John", "_id": 1)>>> für x im Ergebnis:
… drucken(x)
'_id': ObjectId('5f8f0514cb12c01f7420656e')
Alternativ können wir alle Dokumente aus der Sammlung mit der folgenden Abfrage abrufen:
>>> Ergebnis = col.finden()>>> für x im Ergebnis:
… drucken(x)
'_id': ObjectId('5f8f0514cb12c01f7420656e'), 'name': 'John', 'grade': 3, 'dob': '2020-04-03'
'_id': ObjectId('5f8f061ccb12c01f7420656f'), 'name': 'Mark', 'note': 4, 'dob': '2020-04-09', 'age': 8
Aktualisieren von Dokumenten
Das pymongo-Modul bietet die Methoden update_one() und update_many() zum Aktualisieren der Dokumente in einer Sammlung. Beide Methoden verwenden zwei Argumente: das erste definiert, welches Dokument geändert werden soll, und das zweite definiert die neuen Werte. Jetzt ändern wir die Note des Schülers 'Mark'.
>>> query = "name": "Mark">>> Wert = "$set": "grade": 5
>>> Farbe.update_one(Abfrage, Wert)
>>> für x in Farbe.finden():
… drucken(x)
'_id': ObjectId('5f8f0514cb12c01f7420656e'), 'name': 'John', 'grade': 3, 'dob': '2020-04-03'
'_id': ObjectId('5f8f061ccb12c01f7420656f'), 'name': 'Mark', 'note': 5, 'dob': '2020-04-09', 'age': 8
Löschen eines Dokuments
Das Pymongo-Modul in Python hat zwei Methoden, nämlich.e., delete_one() und delete_many(), zum Löschen von Dokumenten. Beide Methoden verwenden ein Argument, das das zu löschende Dokument auswählt. Mit dem folgenden Code löschen wir einen Schüler namens 'John'.
>>> query = "name": "John">>> Farbe.delete_one(Abfrage)
>>> für x in Farbe.finden():
… drucken(x)
'_id': ObjectId('5f8f061ccb12c01f7420656f'), 'name': 'Mark', 'id': 2, 'grade': 5, 'dob': '2020-04-09', 'alter': 8
Eine Sammlung aufgeben
Wir können eine Sammlung in MongoDB löschen, indem wir die Methode drop() des Pymongo-Moduls in Python verwenden. Zuerst müssen wir uns mit der Datenbank verbinden; Dann wählen wir die Datenbank aus, die die Sammlung enthält, die wir entfernen möchten. Nachdem wir die Sammlung aus der Datenbank ausgewählt haben, können wir die Sammlung mit der Methode drop() entfernen. Der folgende Code lässt die Schüler fallen.
>>> Pymongo importieren>>> client = pymongo.MongoClient('mongodb://localhost:27017/')
>>> db = client['demo_db']
>>> col = db['students']
>>> Farbe.fallen()
Fazit
Datenbankkenntnisse sind unerlässlich, wenn Sie eine Webanwendung erstellen möchten. Fast jede Programmiersprache hat Frameworks und Bibliotheken für die Backend-Webentwicklung. Python kann in der Backend-Webentwicklung verwendet werden, sodass wir mit Datenbanken mit Python interagieren können, während wir mit Python-Backend-Frameworks arbeiten working. In diesem Artikel haben wir Ihnen gezeigt, wie Sie mit MongoDB- und MySQL-Datenbanken interagieren, indem Sie einfache in Python geschriebene CRUD-Operationen verwenden.
