Wie wir MySQL -Abfrage in Python ausführen können
Vor dem Start müssen wir den MySQL -Anschluss in unserer lokalen Systemumgebung installieren.
Es gibt zwei Methoden zu installieren:
Methode 1:
Wir können den MySQL -Connector direkt von ihrer offiziellen Website gemäß unserer Betriebssystemkompatibilität und -version direkt herunterladen und installieren.
Method_2:
Der einfache Weg ist die Verwendung der PIP -Methode.
PIP Installieren Sie MySQL-Connector-PythonWenn wir eine bestimmte Version verwenden, müssen wir den Versionsnamen wie unten angegeben zuweisen:
PIP Installation MySQL-Connector-Python ==Verbindungsschöpfung:
Jetzt, im ersten Schritt nach der erfolgreichen Installation der MySQL in unserem lokalen System, versuchen wir, eine Verbindung zu erstellen. Wenn die Verbindung erfolgreich ist, können wir zum nächsten Schritt übergehen.
#Python Eastablish_Connection.py#Importieren Sie die Bibliothek
MySQL importieren.Verbinder
# Verbindung erstellen
conn = mysql.Verbinder.verbinden(
Host = "Localhost",
User = "Sammy",
Passwort = "Passwort"
)
# Drucken Sie den Conn aus
Druck (conn)
Ausgang:
Zeile 4:
Wir importieren die Connector -Klasse aus MySQL.
Zeile 7 bis 11:
Wir haben über die Connector -Klasse auf die Connect -Methode zugreifen, die wir bereits in unser Programm importieren. Jetzt übergeben wir unsere Verbindungsparameter an die Connect -Methode. Der Benutzername und das Kennwort sind je nach Installationsprozess unterschiedlich.
Zeile 13:
Endlich drucken wir nur die Verbindung, und sie zeigt in der Ausgangsverbindung mit der MySQL angezeigt, und es gibt ein Objekt mit seiner Speicheradresse zurück.
Erstellen Sie eine Datenbank:
Jetzt erstellen wir eine Datenbank mit Hilfe von Python.
#Python create_a_database.py#Importieren Sie die Bibliothek
MySQL importieren.Verbinder
# Verbindung erstellen
conn = mysql.Verbinder.verbinden(
Host = "Localhost",
User = "Sammy",
Passwort = "Passwort"
)
#print der Verbindung
Druck (conn)
# Importieren Sie den Cursor aus der Verbindung (Conn)
MyCursor = conn.Mauszeiger()
#print der MyCursor
Druck (MyCursor)
Mycursor.ausführen ("Datenbank erstellen DBTEST"))
Ausgang:
CMYSQLCURSOR: (Noch nichts ausgeführt)
Zeile 16:
Wir importieren die Cursormethode aus dem Objekt für etablierte Verbindung (Conn).
Zeile 18:
Jetzt drucken wir diesen MyCursor, den wir in Zeile 16 erstellt haben, nur aus, und die Ausgabe zeigt, dass CMYSQLCURSOR: (Noch nichts ausgeführt).
Zeile 20:
Wir führen eine Abfrage aus, um eine Datenbank zu erstellen, aber sie gibt nichts zurück. Also, wenn wir drucken (MyCursor.Führen Sie aus („Datenbank erstellen dbtest“)), wir erhalten keine als Rückgabetyp.
Wenn wir unsere MySQL -Datenbank überprüfen, können wir sehen, dass unsere neue Datenbank (DBTEST) erfolgreich erstellt wird.
➜ ~ mysql -u sammy -pPasswort eingeben:
Willkommen im MySQL Monitor. Befehle enden mit; oder \ g.
Ihre MySQL -Verbindungs -ID ist 17
Serverversion: 8.0.26-0ubuntu0.20.04.2 (Ubuntu)
Copyright (C) 2000, 2021, Oracle und/oder seine verbundenen Unternehmen.
Oracle ist ein eingetragenes Markenzeichen der Oracle Corporation und/oder dessen
Mitgliedsorganisationen. Andere Namen können Marken von ihrem jeweiligen
Besitzer.
Geben Sie "Hilfe" ein; " oder '\ h' für Hilfe. Geben Sie '\ c' ein, um die aktuelle Eingabeanweisung zu löschen.
MySQL> Datenbanken anzeigen;
+--------------------+
| Datenbank |
+--------------------+
| DBTEST |
| Information_schema |
| Mysql |
| Performance_schema |
| sys |
+--------------------+
5 Zeilen im Set (0.00 Sek.)
MySQL>
Verbindung zur Datenbank:
Jetzt versuchen wir, uns mit unserer neu erstellten Datenbank (DBTEST) mit Python zu verbinden. Der Code dafür ist unten angegeben:
#Python conn_to_database.py#Importieren Sie die Bibliothek
MySQL importieren.Verbinder
# Die Verbindung zur Datenbank erstellen
conn = mysql.Verbinder.verbinden(
Host = "Localhost",
User = "Sammy",
Passwort = "Passwort",
Database = "DBTEST"
)
# Drucken Sie den Conn aus
Druck (conn)
Zeile 11:
Wir haben der Datenbank noch einen Parameternamen hinzugefügt. Jetzt versucht unser Python -Code nur, nur eine Verbindung mit dieser MySQL -Datenbank (DBTEST) zu erreichen.
Erstellen Sie eine Tabelle:
- Erstellen wir eine neue Tabelle (Film) in der neu erstellten Datenbank (DBTEST).
- Die drei Spalten, die wir verwenden werden, sind ID, Name und Jahr. Die ID und das Jahr sind intier (Ganzzahl), und der Name wird VARCHAR -Typ sein. Wir werden auch eine Spalte (ID) als Primärschlüssel definieren.
- Der Spaltenname speichert die maximale Anzahl von Zeichen 30, wie wir VARCHAR (30) definieren,.
#Importieren Sie die Bibliothek
MySQL importieren.Verbinder
# Die Verbindung zur Datenbank erstellen
conn = mysql.Verbinder.verbinden(
Host = "Localhost",
User = "Sammy",
Passwort = "Passwort",
Database = "DBTEST"
)
# Wir erstellen ein MyCursor -Objekt mit dem Conn.Mauszeiger()
MyCursor = conn.Mauszeiger()
Mycursor.ausführen ("Droptabelle, wenn existiert Film")
# Wir schreiben eine Abfrage, um eine Tabelle zu erstellen
query = "Tabellenfilm erstellen (ID int Primärschlüssel, Name Varchar (30), Jahr int)"
# Wir führen die Abfrage hier aus
Mycursor.ausführen (Abfrage)
# Nach dem Vorgang schließen wir die Verbindung
Conn.schließen()
Zeile 14:
Wir erstellen ein Objekt des Cursors.
Zeile 15:
Wir führen hier auch eine Abfrage mit der Ausführungsmethode aus, dass der Tabellenname (Film), der bereits in der MySQL -Datenbank vorliegt, diese Tabelle löscht. Andernfalls erhalten wir den bereits existierenden Fehler.
Zeile 18 bis 21:
Wir erstellen eine Abfrage, um eine Tabelle zu erstellen und diese Abfrage in Zeile 21 mit der Ausführungsfunktion auszuführen.
Zeile 24:
Endlich schließen wir unsere Verbindung.
Unten ist die MySQL -Ausgabe, in der wir bestätigen, dass unsere Tabelle erfolgreich in der MySQL -Datenbank erstellt wurde.
MySQL> Datenbanken anzeigen;+--------------------+
| Datenbank |
+--------------------+
| DBTEST |
| Information_schema |
| Mysql |
| Performance_schema |
| sys |
+--------------------+
5 Zeilen im Set (0.00 Sek.)
MySQL> Verwenden Sie DBTEST;
Informationen zum Lesen von Tabellen zum Abschluss der Tabellen- und Spaltennamen
Sie können diese Funktion ausschalten, um ein schnelleres Start mit -A zu erhalten
Datenbank geändert
MySQL> Tische anzeigen;
+------------------+
| Tables_in_dbtest |
+------------------+
| Film |
+------------------+
1 Zeile in Set (0.00 Sek.)
MySQL> SELECT * aus dem Film;
Leeres Set (0.00 Sek.)
MySQL> SELECT * aus dem Film;
Fehler 1146 (42S02): Tabelle 'DBTEST.Film 'existiert nicht
MySQL> Desc Movie;
+-------+-------------+------+-----+---------+-------+
| Feld | Typ | NULL | Schlüssel | Standard | Extra |
+-------+-------------+------+-----+---------+-------+
| id | int | Nein | Pri | NULL | |
| Name | varchar (30) | Ja | | NULL | |
| Jahr | int | Ja | | NULL | |
+-------+-------------+------+-----+---------+-------+
3 Zeilen im Set (0.00 Sek.)
MySQL>
Fügen Sie der Tabelle einen Datensatz hinzu:
Jetzt werden wir einen Datensatz in die Tabelle einfügen. Der Python -Code dafür ist unten angegeben.
#Python record_insertion.py#Importieren Sie die Bibliothek
MySQL importieren.Verbinder
# Die Verbindung zur Datenbank erstellen
conn = mysql.Verbinder.verbinden(
Host = "Localhost",
User = "Sammy",
Passwort = "Passwort",
Database = "DBTEST"
)
MyCursor = conn.Mauszeiger()
# Führen Sie die Abfrage mit ihrem Datensatzwert aus
query = 'in film (id, name, Jahr) \ einfügen \
Werte (1, "Bruce Allmighty", 2003) '
Mycursor.ausführen (Abfrage)
# Wir verpflichten (speichern) die Datensätze auf der Tabelle
Conn.begehen()
Zeile 17:
Wir erstellen eine Abfrage, um einen Datensatz in den Tischfilm einzufügen.
Zeile 19:
Wir führen diese Abfrage aus.
Zeile 22:
Wir begehen endlich die Aufzeichnung.
Ausgang:
Die folgende Ausgabe zeigt, dass wir erfolgreich in den Tischfilm eingefügt wurden.
MySQL> SELECT * aus dem Film;+----+----------------+------+
| id | Name | Jahr |
+----+----------------+------+
| 1 | Bruce Allmighy | 2003 |
+----+----------------+------+
1 Zeile in Set (0.00 Sek.)
MySQL>
Multiple Record Insertion:
Wir können auch mehrere Datensätze gleichzeitig in die Tabelle hinzufügen. In diesem Programm werden wir diese Methode sehen. Um die mehrfachen Datensätze einzugeben, müssen wir die Methode Executemany () anstelle der ausführenden () -Methode verwenden.
#Python Insert_Record_Multiple.py#Importieren Sie die Bibliothek
MySQL importieren.Verbinder
# Die Verbindung zur Datenbank erstellen
conn = mysql.Verbinder.verbinden(
Host = "Localhost",
User = "Sammy",
Passwort = "Passwort",
Database = "DBTEST"
)
MyCursor = conn.Mauszeiger()
# Führen Sie die Abfrage mit ihrem Datensatzwert aus
Query = 'In Film (ID, Name, Jahr) Werte ( %s, %s, %s) einfügen
Val = [(2, "Kung Fu Panda", 2014),
(4, "Frozen", 2014),
(5, "Frozen2", 2020),
(6, "Iron Man", 2013)
]
Mycursor.Executemany (Abfrage, Val)
# Wir verpflichten (speichern) die Datensätze auf der Tabelle
Conn.begehen()
Druck (MyCursor.RowCount, "Aufzeichnungen) eingefügt."))
Zeile 17:
Wir erstellen unsere Abfrage für die Einfügungsdaten.
Zeile 18:
Wir erstellen eine Liste von Werten, die wir in die Tabelle einfügen möchten.
Zeile 25:
Wir verwenden die Methode Executemany (), um die Mehrere Datensätze einzugeben.
Ausgang:
MySQL> SELECT * aus dem Film;+----+----------------+------+
| id | Name | Jahr |
+----+----------------+------+
| 1 | Bruce Allmighy | 2003 |
| 2 | Kung Fu Panda | 2014 |
| 3 | Kung Fu Panda | 2014 |
| 4 | Gefroren | 2014 |
| 5 | Frozen2 | 2020 |
| 6 | Iron Man | 2013 |
+----+----------------+------+
6 Zeilen im Set (0.00 Sek.)
Wählen Sie den Datensatz aus der Tabelle aus:
In diesem Programm werden wir eine weitere Abfrage hinzufügen, um die Datensätze aus der Tabelle abzurufen.
#Python select_query.py#Importieren Sie die Bibliothek
MySQL importieren.Verbinder
# Die Verbindung zur Datenbank erstellen
conn = mysql.Verbinder.verbinden(
Host = "Localhost",
User = "Sammy",
Passwort = "Passwort",
Database = "DBTEST"
)
MyCursor = conn.Mauszeiger()
# Führen Sie die Abfrage aus und holen Sie alle Datensätze
query = 'select * aus dem Film'
Mycursor.ausführen (Abfrage)
Ergebnis = MyCursor.fetchall ()
# Wir drucken unser Ergebnis
Druck (Ergebnis)
# Jetzt führen wir in jedem Datensatz Iteration durch und drucken
Für Aufzeichnung im Ergebnis:
Druck (Datensatz)
Zeile 17 bis 19:
Wir erstellen eine ausgewählte Abfrage und führen diese Abfrage aus. Die Fetchall () -Methode wird verwendet, um alle Datensätze aus dieser bestimmten Tabelle abzurufen.
Zeile 22:
Wir drucken das Ergebnis und stellen fest, dass alle Datensätze Tupel und in einer Liste sind. Die folgende Ausgabe zeigt die Liste an.
Zeile 25 bis 26:
Wir iterieren die Liste und drucken jeden Tuple -Datensatz.
Ausgang:
[(1, 'Bruce Almighty', 2003), (2, 'Kung Fu Panda', 2014), (3, 'Kung Fu Panda', 2014), (4, Frozen ', 2014), (5,' Frozen2 ', 2020), (6,' Iron Man ', 2013)](1, 'Bruce Allmighty', 2003)
(2, 'Kung Fu Panda', 2014)
(3, 'Kung Fu Panda', 2014)
(4, 'Frozen', 2014)
(5, 'Frozen2', 2020)
(6, 'Iron Man', 2013)
Abschluss:
In diesem Artikel haben wir gesehen, wie man eine Verbindung mit MySQL mit Python erstellt. Wir haben auch die verschiedenen Methoden der Dateninsertion untersucht, wie einzelnen oder mehrere Datensätze in der Tabelle. Wir haben auch gesehen, wie wir die Abfrage durch Python ausführen können. Wir müssen eine Abfrage erstellen und diese Abfrage dann an die Ausführungsmethode für die Ausführung übergeben und diese Ergebnisse an eine Variable speichern.
Der Code für diesen Artikel ist unter dem GitHub -Link verfügbar:
https: // github.com/shekharpandey89/mysql-query-Verbindung