trouver un expert Python
Toutes les applications logicielles interagissent avec Les données, le plus souvent via un système de gestion de base de données (SGBD). Certains langages de programmation sont livrés avec des modules que vous pouvez utiliser pour interagir avec un SGBD, tandis que d'autres nécessitent l'utilisation de packages tiers. Dans ce didacticiel, vous allez explorer les différents Bibliothèques SQL Python que vous pouvez utiliser. Vous allez développer une application simple pour interagir avec les bases de données SQLite, MySQL et PostgreSQL.
Dans ce didacticiel, vous allez apprendre à:
- Relier vers différents systèmes de gestion de base de données avec des bibliothèques SQL Python
- Interagir avec les bases de données SQLite, MySQL et PostgreSQL
- Effectuer requêtes de base de données courantes à l'aide d'une application Python
- Développer des applications sur différentes bases de données à l'aide d'un script Python
Pour tirer le meilleur parti de ce didacticiel, vous devez avoir une connaissance de base de Python, SQL et travailler avec des systèmes de gestion de base de données. Vous devez également pouvoir télécharger et importer des packages en Python et savoir comment installer et exécuter différents serveurs de base de données localement ou à distance.
Comprendre le schéma de la base de données
Dans ce didacticiel, vous allez développer une très petite base de données pour une application de médias sociaux. La base de données comprendra quatre tableaux:
utilisateursdes postescommentairesaime
Un diagramme de haut niveau du schéma de base de données est illustré ci-dessous:
Tous les deux utilisateurs et des postes aura une relation un-à-plusieurs, car un utilisateur peut aimer plusieurs publications. De même, un utilisateur peut publier de nombreux commentaires et un message peut également contenir plusieurs commentaires. Donc, les deux utilisateurs et des postes aura également des relations un à plusieurs avec le commentaires table. Cela vaut également pour aime table, donc les deux utilisateurs et des postes aura une relation un-à-plusieurs avec le aime table.
Utilisation de bibliothèques Python SQL pour se connecter à une base de données
Avant d'interagir avec une base de données via une bibliothèque SQL Python, vous devez relier à cette base de données. Dans cette section, vous verrez comment se connecter aux bases de données SQLite, MySQL et PostgreSQL à partir d'une application Python.
Il est recommandé de créer trois fichiers Python différents, vous en avez donc un pour chacune des trois bases de données. Vous exécuterez le script pour chaque base de données dans son fichier correspondant.
SQLite
SQLite est probablement la base de données la plus simple à laquelle se connecter avec une application Python, car vous n'avez pas besoin d'installer de modules Python SQL externes pour le faire. Par défaut, votre installation Python contient une bibliothèque SQL Python nommée sqlite3 que vous pouvez utiliser pour interagir avec une base de données SQLite.
De plus, les bases de données SQLite sont sans serveur et autonome, car ils lisent et écrivent des données dans un fichier. Cela signifie que, contrairement à MySQL et PostgreSQL, vous n'avez même pas besoin d'installer et d'exécuter un serveur SQLite pour effectuer des opérations de base de données!
Voici comment vous utilisez sqlite3 se connecter à une base de données SQLite en Python:
1 importation sqlite3
2 de sqlite3 importation Erreur
3
4 def create_connection(chemin):
5 lien = Aucun
6 essayer:
sept lien = sqlite3.relier(chemin)
8 impression("Connexion à SQLite DB réussie")
9 sauf Erreur comme e:
dix impression(F"L'erreur e eu lieu")
11
12 revenir lien
Voici comment ce code fonctionne:
- Lignes 1 et 2 importation
sqlite3et le moduleErreurclasse. - Ligne 4 définit une fonction
.create_connection ()qui accepte le chemin d'accès à la base de données SQLite. - Ligne 7 les usages
.relier()dusqlite3module et prend le chemin de la base de données SQLite comme paramètre. Si la base de données existe à l'emplacement spécifié, une connexion à la base de données est établie. Sinon, une nouvelle base de données est créée à l'emplacement spécifié et une connexion est établie. - Ligne 8 imprime l'état de la connexion réussie à la base de données.
- Ligne 9 intercepte toute exception qui pourrait être levée si
.relier()ne parvient pas à établir une connexion. - Ligne 10 affiche le message d'erreur dans la console.
sqlite3.connect (chemin) renvoie un lien objet, qui est à son tour retourné par create_connection (). Cette lien peut être utilisé pour exécuter des requêtes sur une base de données SQLite. Le script suivant crée une connexion à la base de données SQLite:
lien = create_connection("E:\sm_app.sqlite ")
Une fois que vous aurez exécuté le script ci-dessus, vous verrez qu'un fichier de base de données sm_app.sqlite est créé dans le répertoire racine. Notez que vous pouvez modifier l'emplacement en fonction de votre configuration.
MySQL
Contrairement à SQLite, il n'y a pas de module SQL Python par défaut que vous pouvez utiliser pour vous connecter à une base de données MySQL. À la place, vous devrez installer un Pilote SQL Python pour MySQL afin d'interagir avec une base de données MySQL à partir d'une application Python. Un tel pilote est mysql-connector-python. Vous pouvez télécharger ce module SQL Python avec pépin:
$ pip installer mysql-connector-python
Notez que MySQL est un sur serveur système de gestion de base de données. Un serveur MySQL peut avoir plusieurs bases de données. Contrairement à SQLite, où créer une connexion équivaut à créer une base de données, une base de données MySQL a un processus en deux étapes pour la création de base de données:
- Établissez une connexion à un serveur MySQL.
- Exécuter une requête distincte pour créer la base de données.
Définissez une fonction qui se connecte au serveur de base de données MySQL et renvoie l'objet de connexion:
1 importation mysql.connector
2 de mysql.connector importation Erreur
3
4 def create_connection(nom_hôte, Nom d'utilisateur, mot de passe de l'utilisateur):
5 lien = Aucun
6 essayer:
sept lien = mysql.connecteur.relier(
8 hôte=nom_hôte,
9 utilisateur=Nom d'utilisateur,
dix passwd=mot de passe de l'utilisateur
11 )
12 impression("Connexion à la base de données MySQL réussie")
13 sauf Erreur comme e:
14 impression(F"L'erreur e eu lieu")
15
16 revenir lien
17
18 lien = create_connection("localhost", "racine", "")
Dans le script ci-dessus, vous définissez une fonction create_connection () qui accepte trois paramètres:
- nom_hôte
- Nom d'utilisateur
- mot de passe de l'utilisateur
le mysql.connector Le module Python SQL contient une méthode .relier() que vous utilisez à la ligne 7 pour vous connecter à un serveur de base de données MySQL. Une fois la connexion établie, le lien l'objet est renvoyé à la fonction appelante. Enfin, à la ligne 18, vous appelez create_connection () avec le nom d'hôte, le nom d'utilisateur et le mot de passe.
Jusqu'à présent, vous avez uniquement établi la connexion. La base de données n'est pas encore créée. Pour ce faire, vous allez définir une autre fonction create_database () qui accepte deux paramètres:
lienest lelienobjet au serveur de base de données avec lequel vous souhaitez interagir.requeteest la requête qui crée la base de données.
Voici à quoi ressemble cette fonction:
def create_database(lien, requete):
le curseur = lien.le curseur()
essayer:
le curseur.exécuter(requete)
impression("Base de données créée avec succès")
sauf Erreur comme e:
impression(F"L'erreur e eu lieu")
Pour exécuter des requêtes, vous utilisez le le curseur objet. le requete à exécuter est transmis à cursor.execute () au format chaîne.
Créez une base de données nommée sm_app pour votre application de médias sociaux dans le serveur de base de données MySQL:
create_database_query = "CRÉER LA BASE DE DONNÉES sm_app"
create_database(lien, create_database_query)
Vous venez de créer une base de données sm_app sur le serveur de base de données. Cependant, le lien objet retourné par le create_connection () est connecté au serveur de base de données MySQL. Vous devez vous connecter au sm_app base de données. Pour ce faire, vous pouvez modifier create_connection () comme suit:
1 def create_connection(nom_hôte, Nom d'utilisateur, mot de passe de l'utilisateur, db_name):
2 lien = Aucun
3 essayer:
4 lien = mysql.connecteur.relier(
5 hôte=nom_hôte,
6 utilisateur=Nom d'utilisateur,
sept passwd=mot de passe de l'utilisateur,
8 base de données=db_name
9 )
dix impression("Connexion à la base de données MySQL réussie")
11 sauf Erreur comme e:
12 impression(F"L'erreur e eu lieu")
13
14 revenir lien
Vous pouvez voir à la ligne 8 que create_connection () accepte maintenant un paramètre supplémentaire appelé db_name. Ce paramètre spécifie le nom de la base de données à laquelle vous souhaitez vous connecter. Vous pouvez saisir le nom de la base de données à laquelle vous souhaitez vous connecter lorsque vous appelez cette fonction:
lien = create_connection("localhost", "racine", "", "sm_app")
Le script ci-dessus appelle avec succès create_connection () et se connecte au sm_app base de données.
PostgreSQL
Comme MySQL, il n'y a pas de bibliothèque SQL Python par défaut que vous pouvez utiliser pour interagir avec une base de données PostgreSQL. Au lieu de cela, vous devez installer un pilote Python SQL tiers pour interagir avec PostgreSQL. Un tel pilote Python SQL pour PostgreSQL est psycopg2. Exécutez la commande suivante sur votre terminal pour installer le psycopg2 Module SQL Python:
Comme avec les bases de données SQLite et MySQL, vous définissez create_connection () pour établir une connexion avec votre base de données PostgreSQL:
importation psycopg2
de psycopg2 importation OperationalError
def create_connection(db_name, db_user, db_password, db_host, db_port):
lien = Aucun
essayer:
lien = psycopg2.relier(
base de données=db_name,
utilisateur=db_user,
mot de passe=db_password,
hôte=db_host,
Port=db_port
)
impression("Connexion à la base de données PostgreSQL réussie")
sauf OperationalError comme e:
impression(F"L'erreur e eu lieu")
revenir lien
Tu utilises psycopg2.connect () pour vous connecter à un serveur PostgreSQL depuis votre application Python.
Vous pouvez ensuite utiliser create_connection () pour créer une connexion à une base de données PostgreSQL. Tout d'abord, vous établirez une connexion avec la base de données par défaut postgres en utilisant la chaîne suivante:
lien = create_connection("postgres",
"postgres",
"abc123",
"127.0.0.1",
"5432")
Ensuite, vous devez créer la base de données sm_app à l'intérieur de la valeur par défaut postgres base de données. Vous pouvez définir une fonction pour exécuter n'importe quelle requête SQL dans PostgreSQL. Ci-dessous, vous définissez create_database () pour créer une nouvelle base de données dans le serveur de base de données PostgreSQL:
def create_database(lien, requete):
lien.validation automatique = Vrai
le curseur = lien.le curseur()
essayer:
le curseur.exécuter(requete)
impression("Requête exécutée avec succès")
sauf OperationalError comme e:
impression(F"L'erreur e eu lieu")
create_database_query = "CRÉER LA BASE DE DONNÉES sm_app"
create_database(lien, create_database_query)
Une fois que vous avez exécuté le script ci-dessus, vous verrez le sm_app dans votre serveur de base de données PostgreSQL.
Avant d'exécuter des requêtes sur le sm_app base de données, vous devez vous y connecter:
lien = create_connection("sm_app",
"postgres",
"abc123",
"127.0.0.1",
"5432")
Une fois que vous avez exécuté le script ci-dessus, une connexion sera établie avec le sm_app base de données située dans le postgres serveur de base de données. Ici, 127.0.0.1 fait référence à l'adresse IP de l'hôte du serveur de base de données, et 5432 fait référence au numéro de port du serveur de base de données.
Création de tableaux
Dans la section précédente, vous avez vu comment se connecter aux serveurs de bases de données SQLite, MySQL et PostgreSQL à l'aide de différentes bibliothèques SQL Python. Vous avez créé le sm_app base de données sur les trois serveurs de base de données. Dans cette section, vous verrez comment créer des tableaux à l'intérieur de ces trois bases de données.
Comme indiqué précédemment, vous allez créer quatre tableaux:
utilisateursdes postescommentairesaime
Vous allez commencer avec SQLite.
SQLite
Pour exécuter des requêtes dans SQLite, utilisez cursor.execute (). Dans cette section, vous allez définir une fonction exécuter l'ordre() qui utilise cette méthode. Votre fonction acceptera le lien un objet et une chaîne de requête, que vous passerez à cursor.execute ().
.exécuter() peut exécuter n'importe quelle requête qui lui est passée sous forme de chaîne. Vous utiliserez cette méthode pour créer des tableaux dans cette section. Dans les sections à venir, vous utiliserez cette même méthode pour exécuter la mise à jour et supprimer également les requêtes.
Remarque: Ce script doit être exécuté dans le même fichier que celui où vous avez créé la connexion pour votre base de données SQLite.
Voici votre définition de fonction:
def exécuter l'ordre(lien, requete):
le curseur = lien.le curseur()
essayer:
le curseur.exécuter(requete)
lien.commettre()
impression("Requête exécutée avec succès")
sauf Erreur comme e:
impression("L'erreur '" + str(e) + "' eu lieu")
Ce code essaie d'exécuter la donnée requete et imprime un message d'erreur si nécessaire.
Ensuite, écrivez votre requete:
create_users_table = "" "CRÉER UN TABLEAU SI IL N'EXISTE PAS les utilisateurs (
ID INTEGER PRIMARY KEY AUTOINCREMENT,
nom TEXT NOT NULL,
âge INTEGER,
TEXTE de genre,
nationalité TEXTE
); "" "
Cela dit de créer une table utilisateurs avec les cinq colonnes suivantes:
idNomâgele sexenationalité
Enfin, vous appellerez exécuter l'ordre() pour créer la table. Vous passerez le lien objet que vous avez créé dans la section précédente, avec le create_users_table chaîne contenant la requête de création de table:
exécuter l'ordre(lien, create_users_table)
La requête suivante est utilisée pour créer le des postes table:
create_posts_table = "" "CRÉER UN TABLEAU SI IL N'EXISTE PAS (
ID INTEGER PRIMARY KEY AUTOINCREMENT,
titre TEXT NOT NULL,
description TEXT NOT NULL,
user_id INTEGER NOT NULL,
CLÉ ÉTRANGÈRE (id_utilisateur)
REFERENCES utilisateurs (id)
); "" "
Puisqu'il existe une relation un à plusieurs entre utilisateurs et des postes, vous pouvez voir une clé étrangère identifiant d'utilisateur dans le des postes table qui fait référence à la id dans la colonne utilisateurs table. Exécutez le script suivant pour créer le des postes table:
exécuter l'ordre(lien, create_posts_table)
Enfin, vous pouvez créer le commentaires et aime tables avec le script suivant:
create_comments_table = "" "CRÉER UN TABLEAU SI IL N'EXISTE PAS les commentaires (
ID INTEGER PRIMARY KEY AUTOINCREMENT,
texte TEXT NOT NULL,
user_id INTEGER NOT NULL,
post_id INTEGER NOT NULL,
CLÉ ÉTRANGÈRE (id_utilisateur)
REFERENCES utilisateurs (id)
CLÉ ÉTRANGÈRE (post_id)
RÉFÉRENCES messages (id)
); "" "
create_likes_table = "" "CRÉER UN TABLEAU SI IL N'EXISTE PAS aime (
ID INTEGER PRIMARY KEY AUTOINCREMENT,
user_id INTEGER NOT NULL,
post_id entier NON NUL,
CLÉ ÉTRANGÈRE (id_utilisateur)
REFERENCES utilisateurs (id)
CLÉ ÉTRANGÈRE (post_id)
RÉFÉRENCES messages (id)
); "" "
exécuter l'ordre(lien, create_comments_table)
exécuter l'ordre(lien, create_likes_table)
Tu peux voir ça création de tableaux dans SQLite est très similaire à l'utilisation de SQL brut. Tout ce que vous avez à faire est de stocker la requête dans une variable de chaîne, puis de transmettre cette variable à cursor.execute ().
MySQL
Vous utiliserez le mysql-connector-python Module SQL Python pour créer des tables dans MySQL. Tout comme avec SQLite, vous devez transmettre votre requête à cursor.execute (), qui est retourné en appelant .le curseur() sur le lien objet. Vous pouvez créer une autre fonction exécuter l'ordre() qui accepte le lien et requete chaîne:
1 def exécuter l'ordre(lien, requete):
2 le curseur = lien.le curseur()
3 essayer:
4 le curseur.exécuter(requete)
5 lien.commettre()
6 impression("Requête exécutée avec succès")
sept sauf Erreur comme e:
8 impression("L'erreur '" + str(e) + "' eu lieu")
À la ligne 4, vous passez le requete à cursor.execute ().
Vous pouvez maintenant créer votre utilisateurs table utilisant cette fonction:
create_users_table = "" "CRÉER UN TABLEAU SI IL N'EXISTE PAS
(
id INT AUTO_INCREMENT,
nom TEXT NOT NULL,
âge INT,
TEXTE de genre,
nationalité TEXTE,
CLÉ PRIMAIRE (id)) MOTEUR = InnoDB "" "
exécuter l'ordre(lien, create_users_table)
La requête pour implémenter la relation de clé étrangère est légèrement différente dans MySQL par rapport à SQLite. De plus, MySQL utilise le INCRÉMENTATION AUTOMATIQUE mot-clé (par rapport au SQLite INCRÉMENTATION AUTOMATIQUE mot-clé) pour créer des colonnes où les valeurs sont incrémenté automatiquement lorsque de nouveaux enregistrements sont insérés.
Le script suivant crée le des postes table, qui contient une clé étrangère identifiant d'utilisateur qui fait référence à la id colonne du utilisateurs table:
create_posts_table = "" "CRÉER UN TABLEAU SI IL N'EXISTE PAS
(
id INT AUTO_INCREMENT,
titre TEXT NOT NULL,
description TEXT NOT NULL,
user_id INTEGER NOT NULL,
FOREIGN KEY fk_user_id (user_id) REFERENCES utilisateurs (id),
CLÉ PRIMAIRE (id)) MOTEUR = InnoDB "" "
exécuter l'ordre(lien, create_posts_table)
De même, pour créer le commentaires et aime tables, vous pouvez passer les CRÉER requêtes à exécuter l'ordre().
PostgreSQL
Comme avec les bases de données SQLite et MySQL, le lien objet retourné par psycopg2.connect () contient un le curseur objet. Vous pouvez utiliser cursor.execute () pour exécuter des requêtes SQL Python sur votre base de données PostgreSQL.
Définir une fonction exécuter l'ordre():
def exécuter l'ordre(lien, requete):
lien.validation automatique = Vrai
le curseur = lien.le curseur()
essayer:
le curseur.exécuter(requete)
impression("Requête exécutée avec succès")
sauf OperationalError comme e:
impression("L'erreur '" + str(e) + "' eu lieu")
Vous pouvez utiliser cette fonction pour créer des tables, insérer des enregistrements, modifier des enregistrements et supprimer des enregistrements dans votre base de données PostgreSQL.
Maintenant, créez le utilisateurs table à l'intérieur du sm_app base de données:
create_users_table = "" "CRÉER UN TABLEAU SI IL N'EXISTE PAS
(
id SERIAL PRIMARY KEY,
nom TEXT NOT NULL,
âge INTEGER,
TEXTE de genre,
nationalité TEXTE
) "" "
exécuter l'ordre(lien, create_users_table)
Vous pouvez voir que la requête pour créer le utilisateurs table dans PostgreSQL est légèrement différente de SQLite et MySQL. Ici, le mot-clé EN SÉRIE est utilisé pour créer des colonnes qui s'incrémentent automatiquement. Rappelons que MySQL utilise le mot-clé INCRÉMENTATION AUTOMATIQUE.
En outre, le référencement de clé étrangère est également spécifié différemment, comme indiqué dans le script suivant qui crée le des postes table:
create_posts_table = "" "CRÉER UN TABLEAU SI IL N'EXISTE PAS
(
id SERIAL PRIMARY KEY,
titre TEXT NOT NULL,
description TEXT NOT NULL,
user_id INTEGER REFERENCES utilisateurs (id)
) "" "
exécuter l'ordre(lien, create_posts_table)
Pour créer le commentaires table, vous devrez écrire un CRÉER requête pour le commentaires table et le passer à exécuter l'ordre(). Le processus de création du aime la table est la même. Il suffit de modifier le CRÉER requête pour créer le aime table au lieu de la commentaires table.
Insertion d'enregistrements
Dans la section précédente, vous avez vu comment créer des tables dans vos bases de données SQLite, MySQL et PostgreSQL en utilisant différents modules Python SQL. Dans cette section, vous verrez comment insérer des enregistrements dans vos tables.
SQLite
Pour insérer des enregistrements dans votre base de données SQLite, vous pouvez utiliser le même exécuter l'ordre() fonction que vous avez utilisée pour créer des tables. Vous devez d'abord stocker votre INSÉRER DANS requête dans une chaîne. Ensuite, vous pouvez passer le lien objet et requete chaîne à exécuter l'ordre(). Insérons cinq enregistrements dans le utilisateurs table:
create_users = "" "INSÉRER DANS les utilisateurs (nom, âge, sexe, nationalité)
VALEURS («James», 25 ans, «homme», «USA»),
(«Leila», 32 ans, «femme», «France»),
('Brigitte', 35 ans, 'femme', 'Angleterre'),
(«Mike», 40 ans, «homme», «Danemark»),
('Elizabeth', 21 ans, 'femme', 'Canada'); "" "
exécuter l'ordre(lien, create_users)
Depuis que vous avez défini id pour incrémenter automatiquement, vous n'avez pas besoin de spécifier la valeur de la id colonne pour ceux-ci utilisateurs. le utilisateurs table remplira automatiquement ces cinq enregistrements avec id valeurs de 1 à 5.
Insérez maintenant six enregistrements dans le des postes table:
create_posts = "" "INSERT INTO posts (title, description, user_id)
VALEURS («Heureux», «Je me sens très heureux aujourd'hui», 1),
(«Temps chaud», «Le temps est très chaud aujourd'hui», 2),
('Aide', 'J'ai besoin d'aide pour mon travail', 2),
('Great News', 'Je me marie', 1),
('Jeu intéressant', 'C'était un jeu fantastique de tennis', 5),
("Fête", "Quelqu'un est-il prêt pour une soirée tardive aujourd'hui?", 3); "" "
exécuter l'ordre(lien, create_posts)
Il est important de mentionner que le identifiant d'utilisateur colonne du des postes la table est un clé étrangère qui fait référence à la id colonne du utilisateurs table. Cela signifie que le identifiant d'utilisateur La colonne doit contenir une valeur qui existe déjà dans le id colonne du utilisateurs table. S'il n'existe pas, vous verrez une erreur.
De même, le script suivant insère des enregistrements dans le commentaires et aime les tables:
create_comments = "" "INSÉRER DANS les commentaires (texte, user_id, post_id)
VALEURS («Comptez-moi», 1, 6),
('Quelle sorte d'aide?', 5, 3),
('Félicitations mon pote', 2, 4),
(«Je soutenais Nadal cependant», 4, 5),
('Aide à ta thèse?', 2, 3),
('Beaucoup de félicitations', 5, 4); "" "
create_likes = "" "INSERT INTO likes (user_id, post_id)
VALEURS (1, 6),
(2, 3),
(1, 5),
(5, 4),
(2, 4),
(4, 2),
(3, 6); "" "
exécuter l'ordre(lien, create_comments)
exécuter l'ordre(lien, create_likes)
Dans les deux cas, vous stockez votre INSÉRER DANS interroger en tant que chaîne et l'exécuter avec exécuter l'ordre().
MySQL
Il existe deux façons d'insérer des enregistrements dans des bases de données MySQL à partir d'une application Python. La première approche est similaire à SQLite. Vous pouvez stocker le INSÉRER DANS requête dans une chaîne, puis utilisez cursor.execute () pour insérer des enregistrements.
Plus tôt, vous avez défini une fonction wrapper exécuter l'ordre() que vous avez utilisé pour insérer des enregistrements. Vous pouvez maintenant utiliser cette même fonction pour insérer des enregistrements dans votre table MySQL. Le script suivant insère des enregistrements dans le utilisateurs table utilisant exécuter l'ordre():
create_users = "" "INSÉRER DANS` utilisateurs` (`nom`,` âge`, `sexe`,` nationalité`)
VALEURS («James», 25 ans, «homme», «USA»),
(«Leila», 32 ans, «femme», «France»),
('Brigitte', 35 ans, 'femme', 'Angleterre'),
(«Mike», 40 ans, «homme», «Danemark»),
('Elizabeth', 21 ans, 'femme', 'Canada'); "" "
exécuter l'ordre(lien, create_users)
La deuxième approche utilise cursor.executemany (), qui accepte deux paramètres:
- La requête chaîne contenant des espaces réservés pour les enregistrements à insérer
- La liste des enregistrements que vous souhaitez insérer
Regardez l'exemple suivant, qui insère deux enregistrements dans le aime table:
sql = "INSERT INTO likes (user_id, post_id) VALUES ( % s, % s ) "
val = [([([([(4, 5),
(3, 4)]
le curseur = lien.le curseur()
le curseur.exécutoire(sql, val)
lien.commettre()
C'est à vous de choisir l'approche que vous choisissez pour insérer des enregistrements dans votre table MySQL. Si vous êtes un expert en SQL, vous pouvez utiliser .exécuter(). Si vous n'êtes pas très familier avec SQL, il peut être plus simple d'utiliser .executemany (). Avec l'une des deux approches, vous pouvez insérer avec succès des enregistrements dans le des postes, commentaires, et aime les tables.
PostgreSQL
Dans la section précédente, vous avez vu deux approches pour insérer des enregistrements dans des tables de base de données SQLite. Le premier utilise une requête de chaîne SQL et le second utilise .executemany (). psycopg2 suit cette deuxième approche, bien que .exécuter() est utilisé pour exécuter une requête basée sur un espace réservé.
Vous passez la requête SQL avec les espaces réservés et la liste des enregistrements à .exécuter(). Chaque enregistrement de la liste sera un tuple, où les valeurs de tuple correspondent aux valeurs de colonne dans la table de base de données. Voici comment vous pouvez insérer des enregistrements utilisateur dans le utilisateurs table dans une base de données PostgreSQL:
utilisateurs = [([([([('James', 25, 'Masculin', 'ETATS-UNIS'),
(«Leila», 32, 'femelle', 'France'),
(«Brigitte», 35, 'femelle', 'Angleterre'),
('Mike', 40, 'Masculin', 'Danemark'),
(«Elizabeth», 21, 'femelle', 'Canada')]
user_records = ','.joindre([[[["% s"] * len(utilisateurs))
insert_query = "INSÉRER DANS les utilisateurs (nom, âge, sexe, nationalité)
VALEURS ".format (user_records)
lien.validation automatique = Vrai
le curseur = lien.le curseur()
le curseur.exécuter(insert_query, utilisateurs)
Le script ci-dessus crée une liste utilisateurs qui contient cinq enregistrements utilisateur sous forme de tuples. Ensuite, vous créez une chaîne d'espace réservé avec cinq éléments d'espace réservé (% s) qui correspondent aux cinq enregistrements utilisateur. La chaîne d'espace réservé est concaténée avec la requête qui insère des enregistrements dans le utilisateurs table. Enfin, la chaîne de requête et les enregistrements utilisateur sont passés à .exécuter(). Le script ci-dessus insère avec succès cinq enregistrements dans le utilisateurs table.
Jetez un œil à un autre exemple d'insertion d'enregistrements dans une table PostgreSQL. Le script suivant insère des enregistrements dans le des postes table:
des postes = [[[[ ('Content', «Je me sens très heureux aujourd'hui», 1),
('Temps chaud', «Le temps est très chaud aujourd'hui», 2),
('Aidez-moi', «J'ai besoin d'aide pour mon travail», 2),
('Bonne nouvelle', 'Je me marrie', 1),
(«Jeu intéressant», «C'était un jeu de tennis fantastique», 5),
('Fête', «Quelqu'un est-il prêt pour une soirée tardive aujourd'hui?, 3)]
post_records = ','.joindre([[[["% s"] * len(des postes))
insert_query = "INSERT INTO posts (title, description, user_id)
VALEURS ".format (post_records)
lien.validation automatique = Vrai
le curseur = lien.le curseur()
le curseur.exécuter(insert_query, des postes)
Vous pouvez insérer des enregistrements dans le commentaires et aime tables avec la même approche.
Sélection d'enregistrements
Dans cette section, vous allez voir comment sélectionner des enregistrements à partir de tables de base de données à l'aide des différents modules Python SQL. En particulier, vous verrez comment effectuer SÉLECTIONNER requêtes sur vos bases de données SQLite, MySQL et PostgreSQL.
SQLite
Pour sélectionner des enregistrements à l'aide de SQLite, vous pouvez à nouveau utiliser cursor.execute (). Cependant, après avoir fait cela, vous devrez appeler .fetchall (). Cette méthode renvoie une liste de tuples où chaque tuple est mappé à la ligne correspondante dans les enregistrements récupérés.
Pour simplifier le processus, vous pouvez créer une fonction execute_read_query ():
def execute_read_query(lien, requete):
le curseur = lien.le curseur()
résultat = Aucun
essayer:
le curseur.exécuter(requete)
résultat = le curseur.fetchall()
revenir résultat
sauf Erreur comme e:
impression("L'erreur '" + str(e) + "' eu lieu")
Cette fonction accepte le lien objet et SÉLECTIONNER interroger et renvoie l'enregistrement sélectionné.
SÉLECTIONNER
Sélectionnons maintenant tous les enregistrements du utilisateurs table:
select_users = "SELECT * des utilisateurs"
utilisateurs = execute_read_query(lien, select_users)
pour utilisateur dans utilisateurs:
impression(utilisateur)
Dans le script ci-dessus, le SÉLECTIONNER requête sélectionne tous les utilisateurs du utilisateurs table. Ceci est transmis au execute_read_query (), qui renvoie tous les enregistrements de la utilisateurs table. Les enregistrements sont ensuite parcourus et imprimés sur la console.
Remarque: Il n'est pas recommandé d'utiliser SELECT * sur de grandes tables car cela peut entraîner un grand nombre d'opérations d'E / S qui augmentent le trafic réseau.
La sortie de la requête ci-dessus ressemble à ceci:
(1, 'James', 25, 'male', 'USA')
(2, «Leila», 32 ans, «femme», «France»)
(3, 'Brigitte', 35 ans, 'femme', 'Angleterre')
(4, «Mike», 40 ans, «homme», «Danemark»)
(5, «Elizabeth», 21 ans, «femme», «Canada»)
De la même manière, vous pouvez récupérer tous les enregistrements du des postes table avec le script ci-dessous:
select_users_posts = "" "SELECT users.id, users.name, posts.description
FROM posts
INNER JOIN utilisateurs ON users.id = posts.user_id "" "
users_posts = execute_read_query(lien, select_users_posts)
pour users_post dans users_posts:
impression(users_post)
La sortie ressemble à ceci:
(1, 'James', 'Je me sens très heureux aujourd'hui')
(2, «Leila», «Il fait très chaud aujourd'hui»)
(2, 'Leila', 'J'ai besoin d'aide pour mon travail')
(1, 'James', 'Je me marie')
(5, 'Elizabeth', 'C'était un jeu fantastique de tennis')
(3, 'Brigitte', 'Quelqu'un est-il prêt pour une soirée tardive aujourd'hui?')
Le résultat montre tous les enregistrements de la des postes table.
JOINDRE
Vous pouvez également exécuter des requêtes complexes impliquant JOINDRE opérations pour récupérer les données de deux tables liées. Par exemple, le script suivant renvoie les identifiants et noms d'utilisateur, ainsi que la description des publications que ces utilisateurs ont publiées:
select_users_posts = "" "SELECT users.id, users.name, posts.description
FROM posts
INNER JOIN utilisateurs ON users.id = posts.user_id "" "
users_posts = execute_read_query(lien, select_users_posts)
pour users_post dans users_posts:
impression(users_post)
Voici la sortie:
(1, 'James', 'Je me sens très heureux aujourd'hui')
(2, «Leila», «Il fait très chaud aujourd'hui»)
(2, 'Leila', 'J'ai besoin d'aide pour mon travail')
(1, 'James', 'Je me marie')
(5, 'Elizabeth', 'C'était un jeu fantastique de tennis')
(3, 'Brigitte', 'Quelqu'un est-il prêt pour une soirée tardive aujourd'hui?')
Vous pouvez également sélectionner des données à partir de trois tableaux associés en implémentant plusieurs JOINDRE les opérateurs. Le script suivant renvoie tous les messages, ainsi que les commentaires sur les messages et les noms des utilisateurs qui ont publié les commentaires:
select_posts_comments_users = "" "SELECT posts.description as post,
texte comme commentaire, nom
FROM posts
Commentaires INNER JOIN
SUR
posts.id = comments.post_id
Utilisateurs INNER JOIN
SUR
users.id = comments.user_id "" "
posts_comments_users = execute_read_query(lien,
select_posts_comments_users)
pour posts_comments_user dans posts_comments_users:
impression(posts_comments_user)
La sortie ressemble à ceci:
('Quelqu'un pour une soirée tardive aujourd'hui?', 'Comptez sur moi', 'James')
('J'ai besoin d'aide pour mon travail', 'Quelle sorte d'aide?', 'Elizabeth')
('Je me marie', 'Félicitations mon pote', 'Leila')
('C'était un jeu de tennis fantastique', 'J'étais pourtant enraciné pour Nadal', 'Mike')
('J'ai besoin d'aide pour mon travail', 'Aide pour ta thèse?', 'Leila')
('Je me marie', 'Beaucoup de félicitations', 'Elizabeth')
Vous pouvez voir dans la sortie que les noms de colonne ne sont pas renvoyés par .fetchall (). Pour renvoyer des noms de colonne, vous pouvez utiliser le .la description attribut de le curseur objet. Par exemple, la liste suivante renvoie tous les noms de colonnes pour la requête ci-dessus:
le curseur = lien.le curseur()
le curseur.exécuter(select_posts_comments_users)
le curseur.fetchall()
noms_colonnes = [[[[la description[[[[0] pour la description dans le curseur.la description]
impression(noms_colonnes)
La sortie ressemble à ceci:
['post', 'comment', 'name']
Vous pouvez voir les noms des colonnes pour la requête donnée.
OÙ
Vous allez maintenant exécuter un SÉLECTIONNER requête qui renvoie la publication, ainsi que le nombre total de mentions J'aime que la publication a reçues:
select_post_likes = "" "SELECT description comme Post, COUNT (likes.id) comme Likes
FROM likes, posts
OERE posts.id = likes.post_id
GROUP BY likes.post_id "" "
post_likes = execute_read_query(lien, select_post_likes)
pour post_like dans post_likes:
impression(post_like)
La sortie est la suivante:
(«Le temps est très chaud aujourd'hui», 1)
(«J'ai besoin d'aide pour mon travail», 1)
('Je me marie', 2)
(«C'était un jeu de tennis fantastique», 1)
('Quelqu'un est-il prêt pour une soirée tardive aujourd'hui?', 2)
En utilisant un OÙ , vous pouvez renvoyer des résultats plus spécifiques.
MySQL
The process of selecting records in MySQL is absolutely identical to selecting records in SQLite. Vous pouvez utiliser cursor.execute() followed by .fetchall(). The following script creates a wrapper function execute_read_query() that you can use to select records:
def execute_read_query(connection, requete):
cursor = connection.cursor()
résultat = Aucun
try:
cursor.execute(requete)
résultat = cursor.fetchall()
return résultat
except Erreur comme e:
impression("The error '" + str(e) + "' occurred")
Now select all the records from the users table:
select_users = "SELECT * from users"
users = execute_read_query(connection, select_users)
pour user dans users:
impression(user)
The output will be similar to what you saw with SQLite.
PostgreSQL
The process of selecting records from a PostgreSQL table with the psycopg2 Python SQL module is similar to what you did with SQLite and MySQL. Again, you’ll use cursor.execute() followed by .fetchall() to select records from your PostgreSQL table. The following script selects all the records from the users table and prints them to the console:
def execute_read_query(connection, requete):
cursor = connection.cursor()
résultat = Aucun
try:
cursor.execute(requete)
résultat = cursor.fetchall()
return résultat
except OperationalError comme e:
impression("The error '" + str(e) + "' occurred")
select_users = "SELECT * from users"
users = execute_read_query(connection, select_users)
pour user dans users:
impression(user)
Again, the output will be similar to what you’ve seen before.
Updating Table Records
In the last section, you saw how to select records from SQLite, MySQL, and PostgreSQL databases. In this section, you’ll cover the process for updating records using the Python SQL libraries for SQLite, PostgresSQL, and MySQL.
SQLite
Updating records in SQLite is pretty straightforward. You can again make use of execute_query(). As an example, you can update the description of the post with an id de 2. Premier, SELECT the description of this post:
select_post_description = """SELECT description from posts
WHERE id = 2"""
post_description = execute_read_query(connection, select_post_description)
pour description dans post_description:
impression(description)
You should see the following output:
('The weather is very hot today',)
The following script updates the description:
update_post_description = """UPDATE posts
set description = "The weather has become pleasant now"
WHERE id = 2"""
execute_query(connection, update_post_description)
Now, if you execute the SELECT query again, you should see the following result:
('The weather has become pleasant now',)
The output has been updated.
MySQL
The process of updating records in MySQL with mysql-connector-python is also a carbon copy of the sqlite3 Python SQL module. You need to pass the string query to cursor.execute(). For example, the following script updates the description of the post with an id de 2:
update_post_description = """UPDATE posts
set description = "The weather has become pleasant now"
WHERE id = 2"""
execute_query(connection, update_post_description)
Again, you’ve used your wrapper function execute_query() to update the post description.
PostgreSQL
The update query for PostgreSQL is similar to what you’ve seen with SQLite and MySQL. You can use the above scripts to update records in your PostgreSQL table.
Deleting Table Records
In this section, you’ll see how to delete table records using the Python SQL modules for SQLite, MySQL, and PostgreSQL databases. The process of deleting records is uniform for all three databases since the DELETE query for the three databases is the same.
SQLite
You can again use execute_query() to delete records from YOUR SQLite database. All you have to do is pass the connection object and the string query for the record you want to delete to execute_query(). Alors, execute_query() will create a cursor object using the connection and pass the string query to cursor.execute(), which will delete the records.
As an example, try to delete the comment with an id de 5:
delete_comment = """DELETE FROM comments
WHERE id = 5"""
execute_query(connection, delete_comment)
Now, if you select all the records from the commentaires table, you’ll see that the fifth comment has been deleted.
MySQL
The process for deletion in MySQL is also similar to SQLite, as shown in the following example:
delete_comment = """DELETE FROM comments
WHERE id = 2"""
execute_query(connection, delete_comment)
Here, you delete the second comment from the sm_app database’s commentaires table in your MySQL database server.
PostgreSQL
The delete query for PostgreSQL is also similar to SQLite and MySQL. You can write a delete query string by using the DELETE keyword and then passING the query and the connection object to execute_query(). This will delete the specified records from your PostgreSQL database.
Conclusion
In this tutorial, you’ve learned how to use three common Python SQL libraries. sqlite3, mysql-connector-python, et psycopg2 allow you to connect a Python application to SQLite, MySQL, and PostgreSQL databases, respectively.
Now you can:
- Interact with SQLite, MySQL, or PostgreSQL databases
- Utilisation three different Python SQL modules
- Execute SQL queries on various databases from within a Python application
However, this is just the tip of the iceberg! There are also Python SQL libraries for object-relational mapping, such as SQLAlchemy and Django ORM, that automate the task of database interaction in Python. You’ll learn more about these libraries in an upcoming tutorial.
[ad_2]