CRUD -Operationen zu SQL- und NoSQL -Datenbanken mit Python
Wir können mit Datenbanken mit jeder Programmiersprache interagieren, oder wir können ein Softwareprogramm verwenden, mit dem wir mit einer GUI mit der Datenbank interagieren können. In diesem Artikel werden wir Datenbanken diskutieren und Ihnen zeigen, wie Sie mit der Python -Programmiersprache mit ihnen interagieren können.
Relationale Datenbanken (SQL)
Relationale Datenbanken (SQL) unterscheiden sich von nicht-relationalen Datenbanken (NOSQL) in Bezug auf das Schema. Ein Schema ist eine Vorlage, die die Struktur der Daten definiert, die Sie speichern werden. In relationalen Datenbanken erstellen wir Tabellen zum Speichern von Daten. Das Schema einer Tabelle wird definiert, wenn die Tabelle erstellt wird. Wenn wir beispielsweise Daten zu Schülern in einer relationalen Datenbank speichern möchten, erstellen wir eine Tabelle der Schüler und definieren das Schema der Tabelle, das den Namen, die Registrierungsnummer, die Note usw. enthalten kann. von jedem Schüler. Nach dem Erstellen des Schemas werden wir die Daten in den Zeilen der Tabelle speichern. Es ist wichtig zu beachten, dass wir keine Daten speichern können, die im Schema nicht definiert sind. In diesem Beispiel kann der in einer Prüfung erhaltene Schüler der Klasse A nicht in der Tabelle gespeichert werden, da wir keine Spalte für diese Daten im Schema definiert haben.
Die folgende Liste enthält einige beliebte relationale Datenbanken:
- Mariadb
- Mysql
- SQL Server
- PostgreSQL
- Orakel
Nicht-relationale Datenbanken (NoSQL)
Wie oben erläutert, 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 erstellen möchten, um Studentendaten zu speichern, können wir eine Sammlung von Benutzern erstellen. In dieser Sammlung werden wir ein Dokument für jeden Schüler speichern. Diese Dokumente haben kein definiertes Schema, und Sie können alles, was Sie für jeden Schüler wollen, aufbewahren.
CRUD -Operationen in MySQL durchführen
Jetzt zeigen wir Ihnen, wie Sie mit Python mit MySQL interagieren können.
Installieren Sie den MySQL -Treiber für Python
Um mit MySQL mit Python zu interagieren, müssen wir zunächst den MySQL -Treiber in Python installieren.
Ubuntu@Ubuntu: ~ $ sudo pip3 install mySQL-connector-python
oder
Ubuntu@ubuntu: ~ $ sudo pip installieren Sie MySQL-Connector-Python
Erstellen einer Datenbank
Vor dem Erstellen einer Datenbank müssen wir mit Python mit MySQL Server eine Verbindung herstellen. Der MySQL.Das Connector -Modul bietet die Connect () -Methode an, um eine Verbindung mit MySQL mit Python herzustellen.
>>> MySQL importieren.Verbinder// Ersetzen Sie durch Ihre eigenen IP- und Server -Anmeldeinformationen
>>> SQL = Mysql.Verbinder.verbinden(
… Host = 'localhost',
… User = 'root' ',
… Passwort = '12345'
…)
>>> drucken (SQL)
Diese Nachricht zeigt, dass wir mit Python erfolgreich eine Verbindung mit einer MySQL -Datenbank erstellt haben. Jetzt werden wir eine SQL -Abfrage auf dem MySQL -Server mithilfe der Methode Execute () aus der MySQL ausführen.Steckermodul.
>>> cursor = sql.Mauszeiger()>>> query = 'Datenbank erstellen Demo_DB'
>>> Cursor.ausführen (Abfrage)
Der obige Code erstellt eine Datenbank namens Demo_DB in MySQL.
Erstellen einer Tabelle
Nachdem wir eine Datenbank erstellt haben, werden wir eine neue Tabelle mit dem Namen Studenten erstellen. Um eine Tabelle zu erstellen, müssen wir eine Verbindung zur Datenbank herstellen.
>>> SQL_DB = Mysql.Verbinder.verbinden(… Host = 'localhost',
… User = 'root' ',
… Passwort = '12345',
… Datenbank = 'Demo_DB'
…)
Nach der Verbindung zur Datenbank werden wir mit der Methode execute () eine SQL -Abfrage ausführen, um eine Tabelle mit einem Schema zu erstellen.
>>> query = "table table student (name varchar (64), id int, grade int, dob date)";>>> Cursor.ausführen (Abfrage);
Der obige Befehl erstellt eine Tabelle mit dem Namen Studenten in der Demo_DB -Datenbank. Wir können nur einen Namen, ID, Note und Geburtsdatum in der Tabelle einfügen, wie im Schema definiert.
Zeilen in einen Tisch einfügen
Nachdem wir eine Tabelle erstellt haben, werden wir einen Schüler in diese Tabelle einfügen. Wir erstellen eine Abfrage und verwenden dann die Methode execute (), um die Abfrage auf MySQL Server mit Python auszuführen.
>>> query = 'in Schüler (Name, ID, Note, Dob) Werte („John“, 1, 3, „2020-7-04“)' einfügen>>> Cursor.ausführen (Abfrage)
>>> SQL_DB.begehen()
Diese Abfrage fügt einen Schüler mit den in der Abfrage definierten Daten in die Tabelle hinzu. Auf die gleiche Weise können wir zusätzliche Schüler zum Tisch hinzufügen.
Hinweis: Änderungen werden nur dann auf die Datenbank angewendet, wenn Sie SQL_DB ausführen.Commit () nach Antrag von Änderungen.
Zeilen aus einer Tabelle auswählen
Die Auswahlanweisung in MySQL wird verwendet, um Daten aus einer Tabelle zurückzugeben. Wir werden die Methode execute () verwenden, um eine Abfrage auszuführen, und dann werden wir die Fetchall () -Methode verwenden, um eine Liste aller Schüler zu erhalten. Dann können wir eine für Schleife verwenden, um alle Schüler anzuzeigen
>>> query = 'select * aus den Schülern'>>> Cursor.ausführen (Abfrage)
>>> result = cursor.fetchall ()
>>> für x im Ergebnis:
… Druck (x)
('John', 1, 3, datetime.Datum (2020, 7, 4))
Wir können sehen, dass nur Daten für eine einzelne Studentendaten zurückgegeben werden, da wir nur einen Schüler in der Tabelle haben. Wir können die Anweisung in MySQL mit der Auswahlanweisung verwenden, um Einschränkungen anzugeben. Wenn wir beispielsweise die Schüler nur in der 4 -Klasse zurückgeben möchten, können wir die folgende Abfrage verwenden:
>>> query = 'select * von Schülern wobei Klasse = 4'>>> Cursor.ausführen (Abfrage)
>>> result = cursor.fetchall ()
>>> für x im Ergebnis:
… Druck (x)
Der obige Code holt nur die Schüler aus der 4. Klasse ab.
Aktualisieren einer Zeile
In diesem Abschnitt zeigen wir Ihnen, wie Sie die Studentendaten in einer MySQL -Tabelle mit Python aktualisieren können. Wir werden die Update -Anweisung mit dem WHERE verwenden und Anweisungen in MySQL festlegen, um die Daten bestimmter Schüler zu aktualisieren. Die WO -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 = 'Aktualisieren Sie die Schüler setzen name = "mark" wobei id = 4'>>> Cursor.ausführen (Abfrage)
>>> SQL_DB.begehen()
Jetzt werden wir versuchen, die Studentendaten aus der Tabelle mit der Auswahlanweisung zu lesen.
>>> query = 'select * von Schülern wobei ID = 4'>>> Cursor.ausführen (Abfrage)
>>> für x in Cursor:
… Druck (x)
('Mark', 4, 4, datetime.Datum (2020, 7, 15))
Jetzt können wir sehen, dass der Name des Schülers mit ID 4 in Mark geändert wurde.
Eine Reihe löschen
Wir können eine Zeile aus der Tabelle löschen, indem wir die Löschanweisung in MySQL mit Python anwenden. Wir werden eine Löschanweisung mit einer WO -Anweisung verwenden, um bestimmte Schüler aus der Tabelle zu löschen.
>>> query = 'von Schülern löschen, wobei ID = 2'>>> Cursor.ausführen (Abfrage)
>>> SQL_DB.begehen()
Jetzt können wir alle Schüler aus der Tabelle mit der Auswahlanweisung zurückgeben.
>>> query = 'select * aus den Schülern'>>> Cursor.ausführen (Abfrage)
>>> für x in Cursor:
… Druck (x)
('John', 1, 3, datetime.Datum (2020, 7, 4))
('John', 3, 3, datetime.Datum (2020, 7, 8))
('Mark', 4, 4, datetime.Datum (2020, 7, 15))
Wir können sehen, dass die Tabelle keinen Schüler mit einer ID von 2 enthält, da wir den Schüler vom Tisch entfernt haben.
Einen Tisch fallen lassen
Der MySQL.Das Steckermodul kann auch verwendet werden, um eine Tabelle fallen zu lassen. Wir können eine Drop -Anweisung in MySQL mit der Methode Execute () ausführen.
>>> cursor = sql_db.Mauszeiger()>>> query = 'Droptabelle Schüler'
>>> Cursor.ausführen (Abfrage)
Der oben genannte Code löscht die mit dem Namen Studierende mit dem Namen von Students in Python ausgeführte.
Das schließt unsere Diskussion über SQL -Datenbanken ab. Wir haben Ihnen gezeigt, wie Sie mit Python verschiedene Abfragen auf die MySQL -Datenbank anwenden können. Als nächst
Durchführung von CRUD -Operationen in MongoDB
Um mit Python mit MongoDB zu interagieren, müssen wir zuerst Pymongo installieren, einem MongoDB -Treiber für Python.
Ubuntu@Ubuntu: ~ $ sudo pip install pymongo
oder
Ubuntu@Ubuntu: ~ $ sudo pip3 install Pymongo
Erstellen einer Datenbank
Wir können mit der Mongoclient () -Methode des Pymongo -Moduls in MongoDB eine Verbindung zu MongoDB herstellen. Bevor wir Aktionen ausführen, müssen wir eine Verbindung zur MongoDB -Datenbank herstellen.
>>> Pymongo importieren>>> client = pymongo.Mongoclient ('mongoDB: // localhost: 27017/')
Nachdem wir eine Verbindung zum DataCase herstellen können, können wir die folgende Zeile ausführen, um eine neue Datenbank mit dem Namen Demo_DB zu erstellen.
>>> db = client ['Demo_db']Wenn die Datenbank bereits vorhanden ist, wird dieser Befehl ignoriert.
Erstellen einer Sammlung
Nachdem wir eine Datenbank erstellt haben, werden wir eine Sammlung namens Schüler in der genannten Datenbank erstellen.
>>> Pymongo importieren>>> client = pymongo.Mongoclient ('mongoDB: // localhost: 27017/')
>>> db = client ['Demo_db']
>>> col = db ['Studenten']
Hinweis: MongoDB erstellt keine Sammlung, wenn Sie Daten darin eingeben. Wenn Sie dann versuchen, auf die Sammlung zuzugreifen, nachdem Sie den obigen Code ausgeführt haben, werden Sie feststellen, dass in der Datenbank nichts vorhanden ist.
Unledes MySQL, wir müssen kein Schema definieren, wenn wir eine neue Sammlung erstellen, da MongoDB eine nicht-relationale Datenbank ist.
Einfügen eines Dokuments
Nach dem Erstellen einer Sammlung 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 ein eindeutiges '_id' für jedes Dokument; Daher müssen wir keine ID angeben.
>>> Data =… "Name": "John",
… "3. Klasse,
… "Dob": "2020-04-03"
…
>>> result = col.Inise_one (Daten)
Im obigen Dokument haben wir Namen, Note und DOB eingefügt. Jetzt werden wir ein Dokument in die Studentensammlung einfügen, das ein Feld für das Alter hat.
>>> Data =… "Name": "Mark",
… "Klasse 4,
… "Dob": "2020-04-09",
… "Alter": 8
…
>>> result = col.Inise_one (Daten)
Wir können sehen, dass dieser Befehl keinen Fehler wirft. Da MongoDB eine nicht-relationale Datenbank ist, können wir alle gewünschten Informationen im Dokument hinzufügen.
Dokumente erhalten
In diesem Abschnitt werden wir die Methoden Find () und Find_one () verwenden, um Daten aus der Datenbank zu erhalten. Die Find () -Methode nimmt zwei Argumente an: Mit dem ersten wird zum Filtern von Dokumenten verwendet, und die zweite wird verwendet, um die Felder des Dokuments zu definieren, die wir zurückgeben möchten. Wenn wir beispielsweise die ID von 'John' bekommen wollen, können wir die folgende Abfrage ausführen:
>>> result = col.find ("name": "John", "_id": 1)>>> für x im Ergebnis:
… Druck (x)
'_id': ObjectID ('5F8F0514CB12C01F7420656E')
Alternativ können wir alle Dokumente aus der Sammlung mit der folgenden Abfrage erhalten:
>>> result = col.finden()>>> für x im Ergebnis:
… Druck (x)
'_id': ObjectID ('5F8F0514CB12C01F7420656E'), 'Name': 'John', 'Klasse': 3, 'Dob': '2020-04-03'
'_id': ObjectID ('5f8f061ccb12c01f7420656f'), 'Name': 'Mark', 'Grade': 4, 'Dob': '2020-04-09', 'Alter': 8
Aktualisieren von Dokumenten
Das Pymongo -Modul bietet die Methoden update_one () und update_many () zur Aktualisierung der Dokumente in einer Sammlung an. Beide Methoden nehmen zwei Argumente an: das erste definiert, welches Dokument sich ändern soll, und die zweite definiert die neuen Werte. Jetzt werden wir die Note des Schülers "Mark" ändern.
>>> query = "name": "mark">>> value = "$ set": "grade": 5
>>> col.update_one (Abfrage, Wert)
>>> für x in col.finden():
… Druck (x)
'_id': ObjectID ('5F8F0514CB12C01F7420656E'), 'Name': 'John', 'Klasse': 3, 'Dob': '2020-04-03'
'_id': ObjectID ('5f8f061ccb12c01f7420656f'), 'Name': 'Mark', 'Note': 5, 'Dob': '2020-04-09', 'Alter': 8
Löschen eines Dokuments
Das Pymongo -Modul in Python hat zwei Methoden, ich.e., Delete_one () und Delete_Many () zum Löschen von Dokumenten. Beide Methoden nehmen ein Argument an, das das zum Löschen des Dokuments auswählt. Mit dem folgenden Code löschen wir einen Schüler namens "John".
>>> query = "name": "John">>> col.Delete_one (Abfrage)
>>> für x in col.finden():
… Druck (x)
oder
Eine Sammlung fallen lassen
Wir können eine Sammlung in MongoDB fallen lassen, indem wir die Drop () -Methode des Pymongo -Moduls in Python verwenden. Zunächst müssen wir eine Verbindung zur Datenbank herstellen. Anschließend wählen wir die Datenbank aus, in der die Sammlung entfernen wird, die wir entfernen möchten. Nach Auswahl der Sammlung aus der Datenbank können wir die Sammlung mithilfe der Drop () -Methode entfernen. Der folgende Code lässt die Schüler fallen lassen.
>>> Pymongo importieren>>> client = pymongo.Mongoclient ('mongoDB: // localhost: 27017/')
>>> db = client ['Demo_db']
>>> col = db ['Studenten']
>>> col.tropfen()
Abschluss
Das Wissen über Datenbanken ist unerlässlich, wenn Sie eine Webanwendung durchführen möchten. Fast jede Programmiersprache verfügt über Frameworks und Bibliotheken für die Backend -Webentwicklung. Python kann in der Backend -Webentwicklung verwendet werden. Daher können wir mit Python mit Datenbanken interagieren, während wir mit Python Backend Frameworks arbeiten. In diesem Artikel haben wir Ihnen gezeigt, wie Sie mit MongoDB- und MySQL -Datenbanken interagieren, indem Sie einfache CRUD -Operationen verwenden, die in Python geschrieben wurden.