Comment nous pouvons exécuter Mysql Query dans Python
Avant de commencer, nous devons installer le connecteur MySQL dans notre environnement système local.
Il existe deux méthodes à installer:
Method_1:
Nous pouvons télécharger directement et installer le connecteur MySQL à partir de leur site Web officiel en fonction de notre compatibilité et de notre version du système d'exploitation.
Method_2:
Le moyen facile est d'utiliser la méthode PIP.
pip installer mysql-connector-pythonSi nous utilisons une version particulière, nous devons attribuer le nom de la version comme indiqué ci-dessous:
pip install mysql-connector-python ==Création de connexion:
Maintenant, dans la première étape après l'installation réussie du MySQL vers notre système local, nous essayons de créer une connexion. Si la connexion est réussie, nous pouvons passer à l'étape suivante.
#Python Eastablish_Connection.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"
)
# Imprimez le Conn
Imprimer (Conn)
Sortir:
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 13:
Enfin, nous imprimons simplement la connexion, et il se montre dans la connexion de sortie effectuée au MySQL, et il renvoie un objet avec son adresse mémoire.
Créer une base de données:
Maintenant, nous créons une base de données à l'aide de Python.
#python create_a_database.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)
mycursor.exécuter ("Créer une base de données DBTest")
Sortir:
Cmysqlcursor: (rien d'exécuté encore)
Ligne 16:
Nous importons la méthode du curseur à partir de l'objet de connexion établie (CONN).
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).
Ligne 20:
Nous exécutons une requête pour créer une base de données, mais elle ne renvoie rien. Donc, si nous imprimons (MyCursor.exécuter («Créer une base de données DBTest»)), nous n'en obtiendrons aucun comme type de retour.
Si nous vérifions notre base de données MySQL, nous pouvons voir que notre nouvelle base de données (DBTest) est créée avec succès.
➜ ~ mysql -u sammy -pEntrer le mot de passe:
Bienvenue dans le moniteur MySQL. Les commandes se terminent avec; ou \ g.
Votre ID de connexion MySQL est 17
Version du serveur: 8.0.26-0ubuntu0.20.04.2 (Ubuntu)
Copyright (C) 2000, 2021, Oracle et / ou ses affiliés.
Oracle est une marque déposée d'Oracle Corporation et / ou
affiliés. D'autres noms peuvent être les marques de leur
les propriétaires.
Type 'help;' ou '\ h' pour obtenir de l'aide. Tapez '\ c' pour effacer l'instruction de saisie actuelle.
MySQL> Afficher les bases de données;
+--------------------+
| Base de données |
+--------------------+
| DBTest |
| information_schema |
| mysql |
| Performance_schema |
| sys |
+--------------------+
5 lignes en jeu (0.00 sec)
mysql>
Connexion à la base de données:
Maintenant, nous essayons de nous connecter avec notre base de données nouvellement créée (DBTEST) avec Python. Le code pour cela est donné ci-dessous:
#python conn_to_database.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"
)
# Imprimez le Conn
Imprimer (Conn)
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.
Créer une table:
- Créons une nouvelle table (film) dans la base de données nouvellement créée (DBTest).
- Les trois colonnes que nous allons utiliser sont l'ID, le nom et l'année. L'ID et l'année seront de type int (entier), et le nom sera de type varchar. Nous définirons également une colonne (ID) comme clé primaire.
- Le nom de la colonne stockera le nombre maximum de caractères 30, car nous définissons Varchar (30).
# 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"
)
# Nous créons un objet MyCursor en utilisant le Conn.le curseur()
myCursor = Conn.le curseur()
mycursor.exécuter ("Drop Table If existe un film")
# Nous écrivons une requête pour créer une table
Query = "Create Table Movie (id int Key, Name Varchar (30), Year int)"
# Nous exécutons la requête ici
mycursor.exécuter l'ordre)
# Après avoir terminé le processus, nous fermons la connexion
Connecticut.fermer()
Ligne 14:
Nous créons un objet du curseur.
Ligne 15:
Nous exécutons également une requête ici avec la méthode d'exécution selon laquelle si le nom de la table (film) existe déjà dans la base de données MySQL, il supprimera ce tableau. Sinon, nous obtiendrons l'erreur qui existe déjà.
Ligne 18 à 21:
Nous créons une requête pour créer une table et exécuter cette requête dans le numéro 21 de la ligne avec la fonction d'exécution.
Ligne 24:
Enfin, nous fermons notre connexion.
Vous trouverez ci-dessous la sortie MySQL, où nous confirmons que notre tableau est créé avec succès à l'intérieur de la base de données MySQL.
MySQL> Afficher les bases de données;+--------------------+
| Base de données |
+--------------------+
| DBTest |
| information_schema |
| mysql |
| Performance_schema |
| sys |
+--------------------+
5 lignes en jeu (0.00 sec)
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> show tables;
+------------------+
| Tables_in_dbtest |
+------------------+
| Film |
+------------------+
1 ligne en jeu (0.00 sec)
mysql> sélectionner * dans le film;
Ensemble vide (0.00 sec)
mysql> sélectionner * dans le film;
Erreur 1146 (42S02): Tableau 'DBTest.film 'n'existe pas
MySQL> Film DESC;
+-------+-------------+------+-----+---------+-------+
| Champ | Type | NULL | Clé | Par défaut | Extra |
+-------+-------------+------+-----+---------+-------+
| ID | int | Non | Pri | NULL | |
| Nom | varchar (30) | Oui | | NULL | |
| Année | int | Oui | | NULL | |
+-------+-------------+------+-----+---------+-------+
3 lignes en jeu (0.00 sec)
mysql>
Ajoutez un enregistrement au tableau:
Maintenant, nous allons insérer un enregistrement dans la table. Le code Python pour cela est donné ci-dessous.
#Python Record_insertion.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 = 'INSERT IN ID (ID, nom, année) \
Valeurs (1, "Bruce Tout-Puissant", 2003) '
mycursor.exécuter l'ordre)
# Nous engageons (enregistrer) les enregistrements à la table
Connecticut.commettre()
Ligne 17:
Nous créons une requête pour insérer un enregistrement dans le film de table.
Ligne 19:
Nous exécutons cette requête.
Ligne 22:
Nous engageons enfin le dossier.
Sortir:
La sortie ci-dessous montre que nous avons réussi à enregistrer inséré dans le film de table.
mysql> sélectionner * dans le film;+----+----------------+------+
| ID | Nom | Année |
+----+----------------+------+
| 1 | Bruce Tout-Puissant | 2003 |
+----+----------------+------+
1 ligne en jeu (0.00 sec)
mysql>
Insertion d'enregistrements multiples:
Nous pouvons également ajouter plusieurs enregistrements à la fois dans le tableau. Donc, dans ce programme, nous allons voir cette méthode. Pour saisir les enregistrements multiples, nous devons utiliser la méthode exécutaire () au lieu de la méthode Execute ().
#python insert_record_multiple.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:
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)
Sélectionnez l'enregistrement dans le tableau:
Dans ce programme, nous ajouterons une autre requête SELECT pour récupérer les enregistrements du tableau.
#python select_query.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 et récupérez tous les enregistrements
query = 'select * from film'
mycursor.exécuter l'ordre)
Résultat = MyCursor.fetchall ()
# Nous imprimons notre résultat
Imprimer (résultat)
# Maintenant, nous faisons itération sur chaque enregistrement et imprimez
pour le résultat enregistré:
Imprimer (enregistrer)
Ligne 17 à 19:
Nous créons une requête sélectionnée et exécutons cette requête. La méthode fetchall () est utilisée pour récupérer tous les enregistrements de ce tableau particulier.
Ligne 22:
Nous imprimons le résultat et constatons que tous les enregistrements sont des tuple et à l'intérieur d'une liste. La sortie ci-dessous affiche la liste.
Ligne 25 à 26:
Nous itérons la liste et imprimons chaque enregistrement de tuple.
Sortir:
[(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 Tout-Puissant», 2003)
(2, «Kung Fu Panda», 2014)
(3, «Kung Fu Panda», 2014)
(4, «Frozen», 2014)
(5, «Frozen2», 2020)
(6, «Iron Man», 2013)
Conclusion:
Dans cet article, nous avons vu comment créer une connexion avec MySQL à l'aide de Python. Nous avons également étudié les différentes méthodes d'insertion de données, comme les insertions d'enregistrements de données uniques ou multiples dans le tableau. Nous avons également vu comment nous pouvons exécuter la requête via Python. Nous devons créer une requête, puis transmettre cette requête à la méthode EXECUTE () pour l'exécution et le stockage qui résulte à une variable.
Le code de cet article est disponible sur le lien GitHub:
https: // github.com / shekharpandey89 / mysql-query-connection