Qual è il cursore eseguito in Python?
Possiamo creare l'oggetto cursore tramite il mysql.
Crea un oggetto cursore:
#python cursore_object.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)
Produzione: Python Cursor_Object.Py
Cmysqlcursor: (niente ancora eseguito)
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 16: Abbiamo importato il metodo del cursore dall'oggetto Connection (Conn) stabilito e creato l'oggetto cursore (Mycursor).
Riga 18: Ora, stampiamo solo questo mycursor che abbiamo creato sulla riga 16 e l'output mostra che cmysqlcursor: (niente ancora eseguito).
Metodo cursore.eseguire ():
Il metodo Execute () ci aiuta a eseguire i record di query e restituire in base alla query. La sintassi della funzione Esecute () è:
eseguire (query, args = nessuno)Parametri:
- Domanda: Questo dovrebbe essere un tipo di stringa.
- Argomenti: Per impostazione predefinita, gli argomenti sono Nessuno Perché a volte possiamo passare solo una domanda come un SELEZIONARE query che recupera i record e non richiede alcun valori. Quindi questo è il motivo del args = nessuno Per impostazione predefinita. Ma se vogliamo passare i valori nel caso del INSERIRE query, quindi il tipo di argomenti deve essere una tupla, un elenco o un dict.
Ritorna:
- Restituirà il conteggio del numero di righe interessate durante la query.
Tipo di ritorno:
- Il tipo di ritorno sarà un numero intero (int).
Ora mostreremo alcuni esempi.
Esempio 1: Usa il metodo Execute () solo per la query
#python simple_execute_function.Py#import la biblioteca
Importa mysql.connettore
# Creazione di connessioni
Conn = mysql.connettore.Collegare(
host = "localhost",
user = "Sammy",
password = "password",
Database = "DBtest"
)
# Importa il cursore dalla connessione (Conn)
Mycursor = Conn.cursore()
monoulere.Esecute ("Seleziona * dal film")
# iterare per il risultato
Per la riga in Myursor:
Stampa (riga)
# Chiudiamo il cursore e Conn entrambi
monoulere.vicino()
Conn.vicino()
Produzione: Python Simple_Execute_Function.Py
(1, "Bruce Onnipoty", 2003)(2, "Kung Fu Panda", 2014)
(3, "Kung Fu Panda", 2014)
(4, 'Frozen', 2014)
(5, 'Frozen2', 2020)
(6, "Iron Man", 2013)
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).
Riga 15: Abbiamo creato un oggetto cursore (mycursor).
Riga 17: Eseguiamo una semplice query Seleziona tramite la funzione Esegui.
Riga da 20 a 21: Abbiamo iterato sui risultati recuperati dall'oggetto cursore e abbiamo notato che tutti i record vengono restituiti in Tules.
Esempio_2: Utilizzare il metodo Execute () per il record singolo di inserzione
#python insert_record_execute.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 = (7, "Merlin", 2001)
monoulere.eseguire (query, val)
# impegniamo (salva) i record sulla tabella
Conn.commettere()
Stampa (mycursor.Rowcount, "Record (i) inserito.")
Produzione: Python Insert_Record_Execute.Py
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> 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 |
| 7 | Merlino | 2001 |
+----+----------------+------+
7 righe in set (0.00 sec)
mysql>
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).
Riga 17: Creiamo la nostra query per i dati di inserimento.
Riga 18: Creiamo il valore per quella query da inserire nella tabella.
Riga 21: Usiamo la funzione Execute () e passiamo a loro una query e Val come parametro.
E l'output sopra mostra che il record è stato inserito correttamente nella tabella.
| Metodo | Dettagli del metodo |
|---|---|
| fetchone () | Questo restituirà la riga singola dal risultato e se non c'è record per tornare, allora tornerà come nessuno. |
| fetchmany ([dimensione]) | Ciò restituirà il numero di righe come dimensioni specificate dai set di risultati e, se non vi è alcun record da restituire, restituirà []. La dimensione predefinita è 1. |
| fetchall () | Restituisce le righe tutte o rimanenti dal set di risultati. |
Spieghiamo i metodi di cui sopra usando un esempio.
#python cursore_method.Py#import la biblioteca
Importa mysql.connettore
# Creazione di connessioni
Conn = mysql.connettore.Collegare(
host = "localhost",
user = "Sammy",
password = "password",
Database = "DBtest"
)
# Importa il cursore dalla connessione (Conn)
Mycursor = Conn.cursore()
monoulere.Esecute ("Seleziona * dal film")
Stampa (mycursor.fetchone ()) # prendi la prima riga
Stampa (mycursor.FetchMany (4)) # Fetch le successive 2 file
Stampa (mycursor.fetchall ()) # prendi tutte le righe rimanenti
Stampa (mycursor.fetchmany ()) # Il set di risultati è ora vuoto
# Chiudiamo il cursore e Conn entrambi
monoulere.vicino()
Conn.vicino()
Produzione: Python Cursor_method.Py
(1, "Bruce Onnipoty", 2003)[(2, 'Kung Fu Panda', 2014), (3, 'Kung Fu Panda', 2014), (4, 'Frozen', 2014), (5, 'Frozen2', 2020)]
[(6, 'Iron Man', 2013), (7, 'Merlin', 2001)]
[(6, 'Iron Man', 2013)]
Riga 19: Il metodo fetchone () recupera il primo record dai set di risultati.
Riga 20: Il metodo Fetchmany (4) recupera i quattro record dai set di risultati.
Riga 21: Il metodo Fetchall () recupera tutti i record restanti dai set di risultati.
Riga 22: Il fetchmany () ha la taglia predefinita 1, quindi cerca di nuovo di recuperare un record dai set di risultati. Ma poiché il metodo FetchMany (4) accedi già al metodo 4 Records e Fetchone () accedi al primo record, quindi cerca di recuperare la sesta tupla dai set di record.
Metodo cursore.ExecuteMany ():
Il metodo ExecuteMany () ci aiuta a inserire o sostituire più record contemporaneamente. La sintassi della funzione ExecuteMany () è:
ExecuteMany (query, args)Parametri:
- Domanda: Questo dovrebbe essere un tipo di stringa.
- Argomenti: Per impostazione predefinita, gli argomenti sono non nessuno, Ecco perché non siamo in grado di eseguire il SELEZIONARE domanda in questo. Possiamo passare i valori entrambi i tipi di tupla o elenco soltanto.
Ritorna:
- Restituirà il conteggio del numero di righe interessate durante la query, se presente.
Tipo di ritorno:
- Il tipo di ritorno sarà un numero intero (int o nessuno).
Ora mostreremo un esempio del metodo sopra.
#python ExecuteMemany.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: Python Executemany.Py
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)
Eseguire molte query utilizzando una funzione single Esecute ():
Possiamo anche eseguire più query utilizzando la funzione singolo esecuto (). La funzione Execute () accetta un parametro extra, multi. IL multi = false Per impostazione predefinita. Se manteniamo multi = vero, Quindi possiamo eseguire una query multi-SQL utilizzando il separatore Semicolo (;).
# Python Execute_Multi.Py#import la biblioteca
Importa mysql.connettore
# Creazione di connessioni
Conn = mysql.connettore.Collegare(
host = "localhost",
user = "Sammy",
password = "password",
Database = "DBtest"
)
# Importa il cursore dalla connessione (Conn)
Mycursor = Conn.cursore()
# query con stile parametro formato
query_1 = "seleziona * dal film"
query_2 = 'inserisci nel film (id, nome, anno) valori ( %s, %s, %s)
query = [query_1, query_2]
Val = (8, "Series", 2001)
multiresults = mycursor.eseguire(";".join (query), val, multi = true)
conteggio = 1
Per il risultato in multiresults:
# Il risultato è proprio come un cursore, quindi possiamo accedere a tutti
# Attributi del cursore
print ("query_ 0 - 1:".formato (conteggio, risultato.dichiarazione))
se risultato.with_rows:
per riga in risultato:
Stampa (riga)
COUNT = COUNT + 1
altro:
Stampa ("nessun risultato")
stampa()
monoulere.vicino()
Conn.vicino()
Produzione: Python Execute_Multi.Py
query_1 - Seleziona * dal film:(1, "Bruce Onnipoty", 2003)
(2, "Kung Fu Panda", 2014)
(3, "Kung Fu Panda", 2014)
(4, 'Frozen', 2014)
(5, 'Frozen2', 2020)
(6, "Iron Man", 2013)
(7, "Merlin", 2001)
query_2 - INSERT IN FILM (ID, nome, anno) Valori (8, 'Series', 2001):
Nessun risultato
Riga 23: Abbiamo creato un elenco di due domande.
Riga 28: Passiamo l'elenco delle query, Val e separatore (;) al metodo Execute (). Cambiamo anche il valore di multi dal falso a vero.
Nell'output sopra, possiamo vedere i nostri risultati del multi-query.
Conclusione:
In questo articolo, abbiamo studiato il metodo Execute (). Abbiamo anche visto diversi tipi di metodi Esecute () come il metodo ExecuteMany (). Abbiamo anche studiato come interrogare attraverso il cursore. Metodo Execute () e diversi parametri di quel metodo. Alla fine, abbiamo anche visto come possiamo fare multi-query usando il metodo Execute ().
Il codice per questo articolo è disponibile sul collegamento GitHub:
https: // github.com/shekharpandey89/cursore-excute-python
- « Quale hardware dovrei aggiornare prima sul mio computer per farlo funzionare più velocemente?
- Funzione strStr in c »