Come possiamo eseguire mysql query in python
Prima di iniziare, dobbiamo installare il connettore MySQL nel nostro ambiente di sistema locale.
Ci sono due metodi da installare:
Method_1:
Possiamo scaricare direttamente e installare il connettore MySQL dal loro sito Web ufficiale in base alla nostra compatibilità e versione del sistema operativo.
Method_2:
Il modo più semplice è utilizzare il metodo PIP.
PIP Installa MySQL-Connector-PythonSe stiamo usando una versione particolare, dobbiamo assegnare il nome della versione come indicato di seguito:
PIP Installa mysql-connector-python ==Creazione di connessione:
Ora, nel primo passo dopo l'installazione riuscita di MySQL al nostro sistema locale, proviamo a creare una connessione. Se la connessione ha esito positivo, allora possiamo passare al passaggio successivo.
#python EASTABLISH_Connection.Py#import la biblioteca
Importa mysql.connettore
# Creazione di connessioni
Conn = mysql.connettore.Collegare(
host = "localhost",
user = "Sammy",
password = "password"
)
# Stampa il Conn
Stampa (Conn)
Produzione:
Riga 4:
Importiamo la classe del connettore da MySQL.
Riga da 7 a 11:
Accediamo al metodo Connect tramite la classe Connector, che già importa nel nostro programma. Ora stiamo passando i nostri parametri di connessione al metodo Connect. Il nome utente e la password saranno diversi in base al processo di installazione.
Riga 13:
Alla fine, stampiamo semplicemente la connessione e mostra nella connessione di output eseguita a MySQL e restituisce un oggetto con il suo indirizzo di memoria.
Crea un database:
Ora creiamo un database con l'aiuto di Python.
#python create_a_database.Py#import la biblioteca
Importa mysql.connettore
# Creazione di connessioni
Conn = mysql.connettore.Collegare(
host = "localhost",
user = "Sammy",
password = "password"
)
#print la connessione
Stampa (Conn)
# Importa il cursore dalla connessione (Conn)
Mycursor = Conn.cursore()
#print the mycursor
Stampa (Myursor)
monoulere.Esecute ("Crea database dBtest")
Produzione:
Cmysqlcursor: (niente ancora eseguito)
Riga 16:
Importiamo il metodo del cursore dall'oggetto Connection (Conn).
Riga 18:
Ora, stampiamo solo questo mycursor che abbiamo creato sulla riga 16 e l'output mostra che cmysqlcursor: (niente ancora eseguito).
Riga 20:
Stiamo eseguendo una query per creare un database, ma non restituisce nulla. Quindi se stampiamo (mycursor.eseguire ("Crea database dBtest")), non ne otterremo come tipo di ritorno.
Se controlliamo il nostro database MySQL, possiamo vedere che il nostro nuovo database (DBTest) è stato creato correttamente.
➜ ~ mysql -u sammy -pInserire la password:
Benvenuti al monitor MySQL. I comandi terminano con; o \ g.
Il tuo ID connessione MySQL è 17
Versione del server: 8.0.26-0ubuntu0.20.04.2 (Ubuntu)
Copyright (C) 2000, 2021, Oracle e/o i suoi affiliati.
Oracle è un marchio registrato di Oracle Corporation e/o il suo
affiliati. Altri nomi possono essere marchi dei rispettivi
proprietari.
Tipo 'aiuto;' o '\ h' per aiuto. Digitare '\ c' per cancellare l'istruzione di input corrente.
MySQL> Show Database;
+--------------------+
| Database |
+--------------------+
| dbtest |
| Information_Schema |
| mysql |
| Performance_schema |
| sys |
+--------------------+
5 righe in set (0.00 sec)
mysql>
Connessione al database:
Ora stiamo cercando di connetterci con il nostro database appena creato (DBtest) con Python. Il codice per questo è riportato di seguito:
#python conn_to_database.Py#import la biblioteca
Importa mysql.connettore
# Creazione di connessione al database
Conn = mysql.connettore.Collegare(
host = "localhost",
user = "Sammy",
password = "password",
Database = "DBtest"
)
# Stampa il Conn
Stampa (Conn)
Riga 11:
Abbiamo aggiunto un altro nome di parametro al database. Ora, il nostro codice Python proverà a connettersi solo con questo database MySQL (DBTest).
Crea una tabella:
- Crea una nuova tabella (film) nel database appena creato (DBTest).
- Le tre colonne che useremo sono ID, nome e anno. L'ID e l'anno saranno il tipo int (intero) e il nome sarà il tipo Varchar. Definiremo anche una colonna (ID) come una chiave primaria.
- Il nome della colonna memorizzerà il numero massimo di caratteri 30, mentre definiamo Varchar (30).
#import la biblioteca
Importa mysql.connettore
# Creazione di connessione al database
Conn = mysql.connettore.Collegare(
host = "localhost",
user = "Sammy",
password = "password",
Database = "DBtest"
)
# Creiamo un oggetto MyCursor usando il Conn.cursore()
Mycursor = Conn.cursore()
monoulere.eseguire ("drop table se esiste film")
# Scriviamo una query per creare una tabella
query = "Crea un film tabella (Id int Primary Key, Nome Varchar (30), anno int)"
# Eseguiamo la query qui
monoulere.eseguire (query)
# Dopo aver eseguito il processo, chiudiamo la connessione
Conn.vicino()
Riga 14:
Creiamo un oggetto del cursore.
Riga 15:
Stiamo anche eseguendo una query qui con il metodo Esecut che se il nome della tabella (film) esiste già nel database MySQL, eliminerà quella tabella. Altrimenti, otterremo l'errore che esiste già.
Riga 18 a 21:
Creiamo una query per creare una tabella ed eseguiamo quella query in riga numero 21 con la funzione Esegui.
Riga 24:
Finalmente, chiudiamo la nostra connessione.
Di seguito è riportato l'output MySQL, dove confermiamo che la nostra tabella viene creata correttamente all'interno del database MySQL.
MySQL> Show Database;+--------------------+
| Database |
+--------------------+
| dbtest |
| Information_Schema |
| mysql |
| Performance_schema |
| sys |
+--------------------+
5 righe in set (0.00 sec)
mysql> usa dbtest;
Informazioni sulla tabella di lettura per il completamento dei nomi della tabella e delle colonne
Puoi disattivare questa funzione per ottenere una startup più rapida con -A
Database modificato
Mysql> Show Tables;
+------------------+
| Tables_in_dbtest |
+------------------+
| Film |
+------------------+
1 riga in set (0.00 sec)
mysql> seleziona * dal film;
Set vuoto (0.00 sec)
mysql> seleziona * dal film;
Errore 1146 (42S02): Tabella 'DBtest.Il film 'non esiste
Mysql> Desc Movie;
+-------+-------------+------+-----+---------+-------+
| Campo | Tipo | Null | Chiave | Predefinito | Extra |
+-------+-------------+------+-----+---------+-------+
| id | int | No | Pri | Null | |
| nome | Varchar (30) | Sì | | Null | |
| anno | int | Sì | | Null | |
+-------+-------------+------+-----+---------+-------+
3 righe in set (0.00 sec)
mysql>
Aggiungi un record alla tabella:
Ora, inseriremo un record nel tavolo. Il codice Python per quello è indicato di seguito.
#python record_insertion.Py#import la biblioteca
Importa mysql.connettore
# Creazione di connessione al database
Conn = mysql.connettore.Collegare(
host = "localhost",
user = "Sammy",
password = "password",
Database = "DBtest"
)
Mycursor = Conn.cursore()
# Esegui la query con il loro valore record
query = 'insert in film (id, nome, anno) \
Valori (1, "Bruce Onniighty", 2003) '
monoulere.eseguire (query)
# impegniamo (salva) i record sulla tabella
Conn.commettere()
Riga 17:
Creiamo una query per inserire un record nel film del tavolo.
Riga 19:
Eseguiamo quella domanda.
Riga 22:
Alla fine impegniamo il record.
Produzione:
L'output seguente mostra che abbiamo registrato correttamente inserito nel film del tavolo.
mysql> seleziona * dal film;+----+----------------+------+
| id | nome | anno |
+----+----------------+------+
| 1 | Bruce Onnipotente | 2003 |
+----+----------------+------+
1 riga in set (0.00 sec)
mysql>
Inserimento record multipli:
Possiamo anche aggiungere più record contemporaneamente nella tabella. Quindi, in questo programma, vedremo quel metodo. Per immettere i record multipli, dobbiamo utilizzare il metodo ExecuteMany () anziché il metodo Execute ().
#python insert_record_multiple.Py#import la biblioteca
Importa mysql.connettore
# Creazione di connessione al database
Conn = mysql.connettore.Collegare(
host = "localhost",
user = "Sammy",
password = "password",
Database = "DBtest"
)
Mycursor = Conn.cursore()
# Esegui la query con il loro valore record
query = 'inserisci nel film (id, nome, anno) valori ( %s, %s, %s)
Val = [(2, "Kung Fu Panda", 2014),
(4, "Frozen", 2014),
(5, "Frozen2", 2020),
(6, "Iron Man", 2013)
"
monoulere.ExecuteMany (query, Val)
# impegniamo (salva) i record sulla tabella
Conn.commettere()
Stampa (mycursor.Rowcount, "Record (i) inserito.")
Riga 17:
Creiamo la nostra query per i dati di inserimento.
Riga 18:
Creiamo un elenco di valori che vogliamo inserire nella tabella.
Riga 25:
Utilizziamo il metodo ExecuteMany () per inserire i record multipli.
Produzione:
mysql> seleziona * dal film;+----+----------------+------+
| id | nome | anno |
+----+----------------+------+
| 1 | Bruce Onnipotente | 2003 |
| 2 | Kung Fu Panda | 2014 |
| 3 | Kung Fu Panda | 2014 |
| 4 | Frozen | 2014 |
| 5 | Frozen2 | 2020 |
| 6 | Iron Man | 2013 |
+----+----------------+------+
6 righe in set (0.00 sec)
Seleziona Record dalla tabella:
In questo programma, aggiungeremo un'altra query Seleziona per recuperare i record dalla tabella.
#python Select_Query.Py#import la biblioteca
Importa mysql.connettore
# Creazione di connessione al database
Conn = mysql.connettore.Collegare(
host = "localhost",
user = "Sammy",
password = "password",
Database = "DBtest"
)
Mycursor = Conn.cursore()
# eseguire la query e recuperare tutti i record
query = 'seleziona * dal film'
monoulere.eseguire (query)
Risultato = Mycursor.fetchall ()
# Stampiamo il nostro risultato
Stampa (risultato)
# Ora, facciamo iterazione su ogni record e stampa
per record in risultato:
stampa (record)
Riga da 17 a 19:
Creiamo una query selezionata ed eseguiamo quella query. Il metodo Fetchall () viene utilizzato per recuperare tutti i record da quella particolare tabella.
Riga 22:
Stampiamo il risultato e scopriamo che tutti i record sono tuple e all'interno di un elenco. L'output seguente mostra l'elenco.
Riga da 25 a 26:
Iteiamo l'elenco e stampiamo ogni record di tupla.
Produzione:
[(1, "Bruce Almiighty", 2003), (2, "Kung Fu Panda", 2014), (3, "Kung Fu Panda", 2014), (4, "Frozen", 2014), (5, " Frozen2 ', 2020), (6,' Iron Man ', 2013)](1, "Bruce Onnipoty", 2003)
(2, "Kung Fu Panda", 2014)
(3, "Kung Fu Panda", 2014)
(4, 'Frozen', 2014)
(5, 'Frozen2', 2020)
(6, "Iron Man", 2013)
Conclusione:
In questo articolo, abbiamo visto come creare una connessione con MySQL usando Python. Abbiamo anche studiato i diversi metodi di inserimento dei dati, come inserzioni di record di dati singoli o multipli nella tabella. Abbiamo anche visto come possiamo eseguire la query tramite Python. Dobbiamo creare una query e quindi passare quella query al metodo Execute () per l'esecuzione e archiviare che si traduce in una variabile.
Il codice per questo articolo è disponibile sul collegamento GitHub:
https: // github.com/shekharpandey89/mysql-query-connection