Quelle est l'exécution du curseur en python?
Nous pouvons créer l'objet curseur via le mysql.
Créer un objet de curseur:
#python cursor_object.py# Importer la bibliothèque
importer mysql.connecteur
# Création de connexion
Conn = mysql.connecteur.connecter(
host = "localhost",
user = "sammy",
mot de passe = "mot de passe"
)
# print la connexion
Imprimer (Conn)
# Importer le curseur à partir de la connexion (CONN)
myCursor = Conn.le curseur()
# printent le mycursor
imprimer (myCursor)
Sortir: python cursor_object.py
Cmysqlcursor: (rien d'exécuté encore)
Ligne 4: Nous importons la classe de connecteur à partir de mysql.
Ligne 7 à 11: Nous accédons à la méthode Connect via la classe Connector, que nous importons déjà dans notre programme. Maintenant, nous passons nos paramètres de connexion à la méthode de connexion. Le nom d'utilisateur et le mot de passe seront différents en fonction de votre processus d'installation.
Ligne 16: Nous avons importé la méthode du curseur de l'objet de connexion établie (CONN) et créé l'objet du curseur (MyCursor).
Ligne 18: Maintenant, nous imprimons simplement ce myCursor que nous avons créé sur la ligne 16, et la sortie montre que CMYSQLCURSOR: (Rien d'exécuté encore).
Curseur de la méthode.exécuter ():
La méthode EXECUTE () nous aide à exécuter la requête et à retourner des enregistrements en fonction de la requête. La syntaxe de la fonction EXECUTE () est:
exécuter (requête, args = aucun)Paramètres :
- mettre en doute: Cela devrait être un type de chaîne.
- Arguments: Par défaut, les arguments sont Aucun Parce que parfois nous ne pouvons passer qu'une question comme un SÉLECTIONNER interroger qui récupère les enregistrements et ne nécessite aucune valeur. C'est donc la raison du args = aucun par défaut. Mais si nous voulons transmettre les valeurs dans le cas du INSÉRER requête, alors le type des arguments doit être un tuple, une liste ou un dict uniquement.
Retour:
- Il renverra le nombre du nombre de lignes affectées pendant la requête.
Type de retour:
- Le type de retour sera un entier (int).
Maintenant, nous allons montrer quelques exemples.
Exemple 1: Utilisez la méthode EXECUTE () uniquement pour la requête
#python Simple_execute_function.py# Importer la bibliothèque
importer mysql.connecteur
# Création de connexion
Conn = mysql.connecteur.connecter(
host = "localhost",
user = "sammy",
mot de passe = "mot de passe",
database = "dbest"
)
# Importer le curseur à partir de la connexion (CONN)
myCursor = Conn.le curseur()
mycursor.exécuter ("sélectionner * dans le film")
# itérer sur le résultat
pour la rangée à MyCursor:
Imprimer (ligne)
# Nous fermons le curseur et Conn tous les deux
mycursor.fermer()
Connecticut.fermer()
Sortir: Python Simple_execute_function.py
(1, «Bruce Tout-Puissant», 2003)(2, «Kung Fu Panda», 2014)
(3, «Kung Fu Panda», 2014)
(4, «Frozen», 2014)
(5, «Frozen2», 2020)
(6, «Iron Man», 2013)
Ligne 11: Nous avons ajouté un nom de paramètre de plus à la base de données. Maintenant, notre code Python essaiera de se connecter avec cette base de données MySQL (DBTEST) uniquement.
Ligne 15: Nous avons créé un objet de curseur (MyCursor).
Ligne 17: Nous exécutons une simple requête sélectionnée via la fonction d'exécution.
Ligne 20 à 21: Nous avons itéré sur les résultats récupérés par l'objet du curseur et avons remarqué que tous les enregistrements sont retournés en tuples.
Exemple_2: Utiliser la méthode EXECUTE () pour l'insertion d'enregistrement unique
#python insert_record_execute.py# Importer la bibliothèque
importer mysql.connecteur
# Création de connexion à la base de données
Conn = mysql.connecteur.connecter(
host = "localhost",
user = "sammy",
mot de passe = "mot de passe",
database = "dbest"
)
myCursor = Conn.le curseur()
# Exécutez la requête avec leur valeur d'enregistrement
query = 'Insérer dans le film (id, nom, année) Valeurs (% s,% s,% s)'
Val = (7, "Merlin", 2001)
mycursor.Exécuter (Query, Val)
# Nous engageons (enregistrer) les enregistrements à la table
Connecticut.commettre()
Imprimer (MyCursor.Rowcount, "Record (s) inséré.")
Sortir: python insert_record_execute.py
mySQL> Utiliser DBTest;Lecture des informations sur la table pour l'achèvement des noms de table et de colonne
Vous pouvez désactiver cette fonctionnalité pour obtenir une startup plus rapide avec -a
La base de données modifiée
mysql> sélectionner * dans le film;
+----+----------------+------+
| ID | Nom | Année |
+----+----------------+------+
| 1 | Bruce Tout-Puissant | 2003 |
| 2 | Kung Fu Panda | 2014 |
| 3 | Kung Fu Panda | 2014 |
| 4 | Frozen | 2014 |
| 5 | Frozen2 | 2020 |
| 6 | Iron Man | 2013 |
| 7 | Merlin | 2001 |
+----+----------------+------+
7 rangées en jeu (0.00 sec)
mysql>
Ligne 11: Nous avons ajouté un nom de paramètre de plus à la base de données. Maintenant, notre code Python essaiera de se connecter avec cette base de données MySQL (DBTEST) uniquement.
Ligne 17: Nous créons notre requête pour les données d'insertion.
Ligne 18: Nous créons la valeur pour que cette requête insére dans la table.
Ligne 21: Nous utilisons la fonction EXECUTE () et leur transmettons la requête et Val comme paramètre.
Et la sortie ci-dessus montre que l'enregistrement a été inséré avec succès dans la table.
| Méthode | Détails de la méthode |
|---|---|
| fetchone () | Cela renverra la ligne unique du résultat, et s'il n'y a pas d'enregistrement à retourner, alors il reviendra comme aucun. |
| Fetchmany ([taille]) | Cela renverra le nombre de lignes en tant que taille spécifiée à partir des ensembles de résultats, et s'il n'y a pas d'enregistrement à retourner, il retournera []. La taille par défaut est 1. |
| fetchall () | Renvoie les lignes toutes ou restantes de l'ensemble de résultats. |
Expliquons les méthodes ci-dessus en utilisant un exemple.
#python cursor_method.py# Importer la bibliothèque
importer mysql.connecteur
# Création de connexion
Conn = mysql.connecteur.connecter(
host = "localhost",
user = "sammy",
mot de passe = "mot de passe",
database = "dbest"
)
# Importer le curseur à partir de la connexion (CONN)
myCursor = Conn.le curseur()
mycursor.exécuter ("sélectionner * dans le film")
Imprimer (MyCursor.fetchone ()) # Récupérez la première ligne
Imprimer (MyCursor.fetchmany (4)) # Répondez les 2 lignes suivantes
Imprimer (MyCursor.fetchall ()) # récupérer toutes les lignes restantes
Imprimer (MyCursor.fetchmany ()) # Le jeu de résultats est maintenant vide
# Nous fermons le curseur et Conn tous les deux
mycursor.fermer()
Connecticut.fermer()
Sortir: python cursor_method.py
(1, «Bruce Tout-Puissant», 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)]]
Ligne 19: La méthode fetchone () récupère le premier enregistrement des ensembles de résultats.
Ligne 20: La méthode Fetchmany (4) récupère les quatre enregistrements des ensembles de résultats.
Ligne 21: La méthode fetchall () récupère tous les enregistrements restants à partir des ensembles de résultats.
Ligne 22: Le fetchmany () a la taille par défaut 1, il essaie donc à nouveau de récupérer un enregistrement à partir des ensembles de résultats. Mais comme la méthode Fetchmany (4) accéde déjà aux 4 enregistrements et à la méthode fetchone () accédez au 1er enregistrement, il essaie donc de récupérer le 6ème tuple des ensembles d'enregistrements.
Curseur de la méthode.Execumany ():
La méthode Execumany () nous aide à insérer ou à remplacer plusieurs enregistrements à la fois. La syntaxe de la fonction ExecutiveMany () est:
Execumany (requête, args)Paramètres :
- mettre en doute: Cela devrait être un type de chaîne.
- Arguments: Par défaut, les arguments sont pas, C'est pourquoi nous ne sommes pas en mesure d'exécuter le SÉLECTIONNER interroger. Nous pouvons transmettre les valeurs l'un ou l'autre type de tuple ou liste seul.
Retour:
- Il renverra le nombre du nombre de lignes affectées pendant la requête le cas échéant.
Type de retour:
- Le type de retour sera un entier (int ou aucun).
Maintenant, nous allons montrer un exemple de la méthode ci-dessus.
#Python Execumany.py# Importer la bibliothèque
importer mysql.connecteur
# Création de connexion à la base de données
Conn = mysql.connecteur.connecter(
host = "localhost",
user = "sammy",
mot de passe = "mot de passe",
database = "dbest"
)
myCursor = Conn.le curseur()
# Exécutez la requête avec leur valeur d'enregistrement
query = 'Insérer dans le film (id, nom, année) Valeurs (% s,% s,% s)'
Val = [(2, "Kung Fu Panda", 2014),
(4, "Frozen", 2014),
(5, "Frozen2", 2020),
(6, "Iron Man", 2013)
]]
mycursor.Execumany (Query, Val)
# Nous engageons (enregistrer) les enregistrements à la table
Connecticut.commettre()
Imprimer (MyCursor.Rowcount, "Record (s) inséré.")
Ligne 17: Nous créons notre requête pour les données d'insertion.
Ligne 18: Nous créons une liste de valeurs que nous voulons insérer dans la table.
Ligne 25: Nous utilisons la méthode Execumany () pour entrer les enregistrements multiples.
Sortir: Python Execumany.py
mysql> sélectionner * dans le film;+----+----------------+------+
| ID | Nom | Année |
+----+----------------+------+
| 1 | Bruce Tout-Puissant | 2003 |
| 2 | Kung Fu Panda | 2014 |
| 3 | Kung Fu Panda | 2014 |
| 4 | Frozen | 2014 |
| 5 | Frozen2 | 2020 |
| 6 | Iron Man | 2013 |
+----+----------------+------+
6 lignes en jeu (0.00 sec)
Exécuter de nombreuses requêtes à l'aide d'une fonction EXECUTE () unique:
Nous pouvons également exécuter plusieurs requêtes en utilisant la fonction unique EXECUTE (). La fonction EXECUTE () accepte un paramètre supplémentaire, multi. Le multi = faux par défaut. Si nous gardons Multi = vrai, Ensuite, nous pouvons exécuter une requête multi-SQL à l'aide du séparateur semi-collé (;).
# python exécute_multi.py# Importer la bibliothèque
importer mysql.connecteur
# Création de connexion
Conn = mysql.connecteur.connecter(
host = "localhost",
user = "sammy",
mot de passe = "mot de passe",
database = "dbest"
)
# Importer le curseur à partir de la connexion (CONN)
myCursor = Conn.le curseur()
# Requête avec style de paramètre de format
query_1 = "select * dans le film"
query_2 = 'Insérer dans le film (id, nom, année) Valeurs (% s,% s,% s)'
requêtes = [query_1, query_2]
Val = (8, "Series", 2001)
multiresults = mycursor.exécuter(";".join (requêtes), val, multi = true)
compter = 1
pour en résulter desultes:
# Le résultat est comme un curseur, donc nous pouvons accéder à tous
# Attributs du curseur
print ("query_ 0 - 1:".format (compter, résultat.déclaration))
Si résultat.avec_rows:
pour la ligne dans le résultat:
Imprimer (ligne)
Count = Count + 1
autre:
imprimer ("pas de résultat")
imprimer()
mycursor.fermer()
Connecticut.fermer()
Sortir: python exécute_multi.py
Query_1 - Sélectionner * dans le film:(1, «Bruce Tout-Puissant», 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 - Insérer dans le film (id, nom, année) Valeurs (8, «série», 2001):
Pas de résultat
Ligne 23: Nous avons créé une liste de deux requêtes.
Ligne 28: Nous passons la liste des requêtes, Val et séparateur (;) à la méthode EXECUTE (). Nous modifions également la valeur de multi de faux à vrai.
Dans la sortie ci-dessus, nous pouvons voir nos résultats de la multi-Quey.
Conclusion:
Dans cet article, nous avons étudié la méthode Execute (). Nous avons également vu différents types de méthodes EXECUTE () comme la méthode exécutive (). Nous avons également étudié comment interroger le curseur. EXECUTE () Méthode et différents paramètres de cette méthode. Enfin, nous avons également vu comment nous pouvons faire plusieurs requins en utilisant la méthode EXECUTE ().
Le code de cet article est disponible sur le lien GitHub:
https: // github.com / shekharpandey89 / curseur-exécutif-python
- « Quel matériel dois-je mettre à niveau d'abord sur mon ordinateur pour le faire fonctionner plus rapidement?
- Fonction strStr en c »