[100 jours de maîtrise de python] Jour 34 : Utiliser python pour faire fonctionner l'utilisation de la base de données_ORM (SQLAlchemy)

ORM (Object Relational Mapping) est une technologie de programmation utilisée pour établir une relation de mappage entre une base de données relationnelle et un langage de programmation orienté objet, afin que les tables et les enregistrements de la base de données puissent être mappés à des objets et des classes dans le langage de programmation. L'objectif d'un ORM est de simplifier les opérations de base de données, permettant aux développeurs de travailler avec des bases de données d'une manière orientée objet.

En Python, plusieurs bibliothèques ORM sont disponibles, dont la plus connue est SQLAlchemy. SQLAlchemy fournit un moyen d'établir une relation de mappage entre les objets Python et les tables de base de données, permettant aux développeurs d'utiliser des classes Python pour exploiter des bases de données.

Les avantages des ORM incluent :

Opérations de base de données abstraites : ORM masque les détails de la base de données sous-jacente et les développeurs peuvent se concentrer davantage sur la logique métier sans écrire de requêtes SQL complexes.

Programmation orientée objet : ORM permet aux développeurs de traiter les données de manière orientée objet, rendant le code plus clair et plus maintenable.

Prise en charge de bases de données croisées : les bibliothèques ORM fournissent généralement une prise en charge sur plusieurs bases de données, et les développeurs peuvent facilement changer de base de données sans modifier beaucoup de code.

Création et migration automatiques de tables : La bibliothèque ORM peut générer automatiquement des tables de base de données basées sur des classes Python définies et prend en charge la migration de base de données.

Générateur de requêtes : les bibliothèques ORM fournissent généralement un générateur de requêtes qui rend l'écriture des requêtes plus facile et plus intuitive.

Gestion des transactions : les bibliothèques ORM peuvent aider à gérer les transactions pour assurer la cohérence et l'intégrité des données.

2 Vue d'ensemble de SQLAlchemy

SQLAlchemy est une puissante boîte à outils Python SQL et une bibliothèque de mappage objet-relationnel (ORM) qui permet aux développeurs d'utiliser le langage de programmation Python pour interagir avec des bases de données relationnelles. SQLAlchemy fournit un moyen flexible et puissant d'effectuer des opérations telles que des requêtes SQL, des insertions, des mises à jour, des suppressions, etc., et prend également en charge le mappage des tables de base de données aux classes Python, permettant aux développeurs de manipuler les bases de données de manière orientée objet.

Voici les principales fonctionnalités et un aperçu de SQLAlchemy :

Fonctionnalité ORM : L'une des principales fonctionnalités de SQLAlchemy est sa fonctionnalité ORM. Il vous permet de mapper des tables et des enregistrements de base de données en définissant des classes Python, en transformant les opérations de base de données en opérations orientées objet, ce qui rend le code plus intuitif et plus facile à entretenir.

Prise en charge de plusieurs bases de données : SQLAlchemy prend en charge plusieurs bases de données relationnelles, notamment MySQL, SQLite, PostgreSQL, Oracle, etc., permettant aux développeurs de basculer entre différentes bases de données sans modifier la majeure partie du code.

Flexibilité : SQLAlchemy fournit une variété de façons d'effectuer des opérations SQL, y compris des requêtes SQL brutes, des générateurs de requêtes et des requêtes ORM. Cela permet aux développeurs de choisir une méthode appropriée en fonction de leurs besoins.

Gestion du pool de connexions : SQLAlchemy prend en charge la gestion du pool de connexions, qui peut maintenir un ensemble de connexions de base de données entre les applications et les bases de données pour améliorer les performances et l'efficacité.

Gestion des transactions : SQLAlchemy vous permet d'utiliser la gestion des transactions pour assurer la cohérence et l'intégrité des opérations de la base de données, vous pouvez valider, annuler et interrompre les transactions.

Migration de base de données : SQLAlchemy fournit l'outil Alembic pour la migration de base de données et la gestion des versions, rendant les modifications apportées à la structure de la base de données plus contrôlables.

Associations multiples : SQLAlchemy prend en charge plusieurs types d'associations, telles que les associations un-à-plusieurs, plusieurs-à-plusieurs et autres, ce qui rend la relation entre les bases de données plus claire.

Requête entre tables : SQLAlchemy permet d'effectuer des jointures entre tables dans les requêtes ORM, permettant des opérations de requête complexes.

Optimisation des performances : SQLAlchemy fournit diverses options d'optimisation des performances, telles que la mise en cache, les opérations par lots, etc., pour améliorer l'efficacité du traitement des données à grande échelle.

Documentation riche et support communautaire : SQLAlchemy dispose d'une documentation officielle riche et d'une communauté active, ce qui facilite l'apprentissage et la résolution des problèmes.

En conclusion, SQLAlchemy est une puissante boîte à outils de base de données Python adaptée aux projets de toutes tailles, des petites applications aux grands systèmes d'entreprise. Sa flexibilité, sa conception orientée objet et ses multiples fonctions en font l'un des outils préférés des développeurs Python pour effectuer des opérations de base de données.

3 ORM : utilisation de SQLAlchemy

Lorsque vous utilisez un ORM en Python (tel que SQLAlchemy), vous définissez vos modèles de base de données en créant des classes Python, puis utilisez ces objets de modèle pour effectuer des opérations de base de données. Voici un exemple détaillé utilisant SQLAlchemy :

3.1 Installer SQLAlchemy :

Tout d'abord, vous devez installer la bibliothèque SQLAlchemy. Vous pouvez l'installer dans le terminal avec la commande suivante :

pip install sqlalchemy

3.2 Définir la classe du modèle de base de données :

Créez une classe Python pour définir le modèle de base de données. Chaque classe représente une table et les attributs de la classe représentent les colonnes de la table.

from sqlalchemy import create_engine, Column, Integer, String
from sqlalchemy.ext.declarative import declarative_base

# 创建数据库连接
engine = create_engine('sqlite:///example.db')
Base = declarative_base()

# 定义模型类
class User(Base):
    __tablename__ = 'users'
    id = Column(Integer, primary_key=True)
    name = Column(String)
    age = Column(Integer)

3.3 Créer un tableau de données :

Créez une table de base de données en appelant create_all()une méthode.

Base.metadata.create_all(engine)

3.4 Insérer des données :

Créez un objet modèle, puis ajoutez-le à la session et validez.

from sqlalchemy.orm import sessionmaker

# 创建会话
Session = sessionmaker(bind=engine)
session = Session()

# 添加数据
new_user = User(name='Alice', age=25)
session.add(new_user)
session.commit()

3.5 Données de requête :

Utilisez des sessions pour interroger des objets de modèle.

# 查询数据
user = session.query(User).filter_by(name='Alice').first()
if user:
    print("User found:", user.name, user.age)
else:
    print("User not found")

3.6 Mettre à jour les données :

Les propriétés des objets modèles peuvent être mises à jour, puis la session soumise pour mettre à jour la base de données.

user.age = 26
session.commit()

3.7 Supprimer des données :

Utilisez delete()la méthode pour supprimer l'objet de modèle, puis soumettez la session.

session.delete(user)
session.commit()

3.8 Clôture de la session :

N'oubliez pas de fermer la session lorsque vous avez terminé.

session.close()

4 combats

Concevoir un système de gestion de bibliothèque simple.

Voici un exemple complet d'un système de gestion de bibliothèque utilisant SQLAlchemy :

Assurez-vous que sqlalchemy est installé, pip install sqlalchemy

from sqlalchemy import create_engine, Column, Integer, String, ForeignKey
from sqlalchemy.orm import sessionmaker
from sqlalchemy.ext.declarative import declarative_base

# 创建数据库连接
engine = create_engine('sqlite:///library.db')
Base = declarative_base()

# 定义作者模型类
class Author(Base):
    __tablename__ = 'authors'
    id = Column(Integer, primary_key=True)
    name = Column(String)

# 定义图书模型类
class Book(Base):
    __tablename__ = 'books'
    id = Column(Integer, primary_key=True)
    title = Column(String)
    author_id = Column(Integer, ForeignKey('authors.id'))

# 创建数据表
Base.metadata.create_all(engine)

# 创建会话
Session = sessionmaker(bind=engine)
session = Session()

# 添加作者
author1 = Author(name='J.K. Rowling')
author2 = Author(name='George Orwell')

session.add_all([author1, author2])
session.commit()

# 添加图书
book1 = Book(title='Harry Potter and the Sorcerer\'s Stone', author_id=author1.id)
book2 = Book(title='1984', author_id=author2.id)

session.add_all([book1, book2])
session.commit()

# 查询数据
print("Authors:")
authors = session.query(Author).all()
for author in authors:
    print("Author:", author.name)

selected_author = session.query(Author).filter_by(name='J.K. Rowling').first()
if selected_author:
    print("\nBooks by", selected_author.name)
    books = session.query(Book).filter_by(author_id=selected_author.id).all()
    for book in books:
        print("Book:", book.title)

# 关闭会话
session.close()

L'exemple de code ci-dessus montre comment créer un système de gestion de livre simple à l'aide de la bibliothèque SQLAlchemy.

Importer les modules requis : Les modules SQLAlchemy requis sont importés au début du code, y compris la création de moteurs, la définition de classes de modèles, la création de tables de données et de sessions, etc.

Création d'une connexion à une base de données et d'une classe de base : create_enginecréation d'une connexion à une base de données SQLite à l'aide d'une fonction, puis declarative_basecréation d'une classe de base via Base.

Définir les classes de modèles : Deux classes de modèles sont définies, à savoir Author(Auteur) et Book(Livre). Chaque classe correspond à une table, et les attributs de la classe correspondent aux colonnes de la table.

Créer une table de données : En appelant Base.metadata.create_all(engine)une méthode, une table de données dans la base de données est créée en fonction de la classe du modèle.

Créer une session : utilisez pour sessionmakercréer une classe de session Session, puis Session()créez une instance de session session.

Ajout de données : création de deux instances d'auteur, session.add_all()ajout de celles-ci à la session à l'aide de et session.commit()validation de la base de données via .

Données de requête : session.query()Les informations sur l'auteur et le livre ont été interrogées et imprimées.

Fermeture de la session : Une fois toutes les opérations terminées, session.close()les ressources sont libérées en fermant la session.

Dans l'ensemble, cet exemple montre comment utiliser SQLAlchemy pour créer des modèles de base de données, effectuer des opérations de base de données, interroger des données et fermer des sessions. En utilisant ORM, vous pouvez convertir les opérations de base de données en une méthode orientée objet, rendant le code plus clair et plus maintenable. Vous pouvez étendre cet exemple plus loin, en ajoutant plus de fonctionnalités et de complexité si nécessaire.