Explication détaillée de Django ORM, le framework ORM en Python

Django ORM est un framework ORM classique en Python. Il fait partie du framework Django Web et fournit un moyen pratique pour les opérations de base de données. ORM signifie Object Relational Mapping, qui peut mapper des tables de bases de données relationnelles avec des classes en Python, simplifiant ainsi le processus de développement et améliorant l'efficacité du développement. Cet article présentera Django ORM en détail.

I. Le concept de base d'ORM

ORM est une technologie qui mappe des objets à des bases de données relationnelles. Il implémente principalement les trois fonctions suivantes :

• Les tables de la base de données sont mappées aux classes en Python.
• Les champs de la base de données sont mappés. mappés aux attributs en Python
• Les enregistrements de la base de données sont mappés aux instances en Python

Le principal avantage de l'ORM est qu'il peut réduire le temps et les efforts des développeurs qui écrivent des instructions SQL répétitives et peut réduire les erreurs causées par les ajustements et les modifications de Instructions SQL.

II. Avantages de Django ORM

Par rapport aux autres frameworks ORM, Django ORM présente les avantages suivants :

• Simple et facile à utiliser : L'API de Django ORM est très simple et facile à maîtriser et à utiliser.
• API riche : Django ORM fournit une API riche pour effectuer les opérations courantes de base de données, telles que l'ajout, la suppression, la modification, la requête, etc. Il prend également en charge des opérations telles que les requêtes avancées et les requêtes d'agrégation.
• Bonne évolutivité : Django ORM peut être intégré de manière transparente à d'autres bibliothèques tierces, telles que le framework Django REST, Django-Oscar, etc.
• Mappage automatique : Django ORM prend en charge le mappage automatique. Les développeurs n'ont qu'à définir la structure de la table de la base de données, et la classe Python correspondante peut être automatiquement générée, réduisant ainsi la quantité de code répété pendant le processus de développement.

III. Comment utiliser Django ORM

1. Installer Django

Vous devez d'abord installer Django, vous pouvez utiliser pip pour installer :

pip install Django

2. Définir le modèle

Lorsque vous utilisez Django ORM, vous devez d'abord définir la classe modèle, classe modèle C'est une classe en Python qui définit les champs de la table de données et d'autres métadonnées de la table de données, telles que le nom de la table, l'index, etc. Ce qui suit est une définition simple de classe de modèle :

from django.db import models

class Book(models.Model):
    title = models.CharField(max_length=100)
    author = models.CharField(max_length=50)
    pub_date = models.DateTimeField()

Dans le code ci-dessus, nous utilisons le module models fourni par Django ORM pour définir une table de données nommée Book , qui contient trois champs : titre, auteur, pub_date. max_length est utilisé pour spécifier la longueur maximale des champs de type chaîne, et DateTimeField est utilisé pour stocker les champs de type heure. models模块来定义了一个名为Book的数据表，其中包含了三个字段：title、author、pub_date。max_length用于指定字符串类型字段的最大长度，DateTimeField用于存储时间类型字段。

3. 创建数据库表

在完成模型类的定义后，需要通过迁移生成数据库表。Django ORM提供了自动迁移功能，只需运行以下命令即可生成数据表：

python manage.py makemigrations
python manage.py migrate

以上命令创建了Book表，表结构与定义的模型类对应。

4. CRUD操作

a. 创建记录

通过模型类可以轻松地向数据表中添加新的记录，在以下代码中，我们创建了一条新的记录并将其保存到数据库中：

from datetime import datetime
book = Book(title='Django ORM Tutorial', author='Terry', pub_date=datetime.now())
book.save()

b. 更新记录

使用Django ORM更新记录非常简单，只需先查询记录，然后将其更新并保存即可。以下是一个简单的更新代码示例：

book = Book.objects.get(id=1)
book.title = 'Updated Title'
book.save()

c. 删除记录

删除记录也非常简单，只需执行以下代码即可：

book = Book.objects.get(id=1)
book.delete()

d. 查询记录

在Django ORM中，可以使用objects对象进行查询，以下是一个简单的查询示例代码：

books = Book.objects.all()
for book in books:
    print(book.title, book.author, book.pub_date)

该代码将输出Book表中所有记录的title、author和pub_date字段。

IV. 高级查询操作

除了基本的CRUD操作外，Django ORM还支持一些高级查询操作，如连表查询、查询条件组合、聚合操作等，以下是一些示例代码。

a. 连表查询

Django ORM中支持两种方式的连表查询：一种是通过ForeignKey字段进行关联，另一种是通过自定义查询进行关联。

# 通过ForeignKey字段关联
class Author(models.Model):
    name = models.CharField(max_length=50)

class Book(models.Model):
    title = models.CharField(max_length=100)
    author = models.ForeignKey(Author, on_delete=models.CASCADE)

books = Book.objects.filter(author__name='Leo Tolstoy')
# 以上代码查询了作者名为'Leo Tolstoy'的所有图书

# 通过自定义查询进行关联
books = Book.objects.raw('SELECT * FROM app_book INNER JOIN app_author ON app_book.author_id = app_author.id WHERE app_author.name = %s', ['Leo Tolstoy'])

b. 查询条件组合

在Django ORM中，可以使用Q对象将多个查询条件进行组合，以实现更加复杂的查询。以下是一个示例代码：

from django.db.models import Q

books = Book.objects.filter(Q(title__contains='Django') | Q(author__contains='Guido'))
# 以上代码查询了标题中包含'Django'或作者名中包含'Guido'的所有图书

c. 聚合操作

聚合操作用于对数据进行分组或汇总统计。Django ORM中支持的聚合操作包括：Avg、Max、Min、Count、Sum

Créer une table de base de données

Après avoir terminé la définition de la classe modèle, vous devez générer la table de base de données via la migration. Django ORM fournit une fonction de migration automatique. Exécutez simplement la commande suivante pour générer une table de données :

from django.db.models import Avg

avg_pub_date = Book.objects.all().aggregate(Avg('pub_date'))
# 以上代码计算了所有图书的发布时间的平均值

🎜La commande ci-dessus crée la table Book, et la structure de la table correspond à la classe de modèle définie. 🎜
🎜Opération CRUD🎜🎜🎜a. Créer un enregistrement🎜🎜Vous pouvez facilement ajouter de nouveaux enregistrements à la table de données via la classe modèle. Dans le code suivant, nous créons un nouvel enregistrement et l'ajoutons. enregistré dans la base de données : 🎜rrreee🎜b. Mise à jour des enregistrements 🎜🎜La mise à jour des enregistrements à l'aide de Django ORM est très simple, il suffit d'interroger l'enregistrement d'abord, puis de le mettre à jour et de l'enregistrer. Voici un exemple de code de mise à jour simple : 🎜rrreee🎜c. Supprimer des enregistrements 🎜🎜 La suppression d'enregistrements est également très simple, exécutez simplement le code suivant : 🎜rrreee🎜d Requête d'enregistrements 🎜🎜 Dans Django ORM, vous pouvez utiliser . objets à interroger, voici un exemple de code de requête simple : 🎜rrreee🎜Ce code affichera le titre, le de tous les enregistrements du <code>Livre champs de la table >auteur et pub_date. 🎜🎜IV.Opérations de requête avancées🎜🎜En plus des opérations CRUD de base, Django ORM prend également en charge certaines opérations de requête avancées, telles que la requête de jointure de table, la combinaison de conditions de requête, l'opération d'agrégation, etc. Voici quelques exemples de codes. 🎜🎜a. Requête de jointure de table🎜🎜Django ORM prend en charge deux méthodes de requête de jointure de table : l'une consiste à s'associer via le champ ForeignKey et l'autre consiste à s'associer via une requête personnalisée. 🎜rrreee🎜b. Combinaison de conditions de requête🎜🎜Dans Django ORM, vous pouvez utiliser l'objet Q pour combiner plusieurs conditions de requête afin de réaliser des requêtes plus complexes. Voici un exemple de code : 🎜rrreee🎜c. Opération d'agrégation 🎜🎜L'opération d'agrégation est utilisée pour regrouper des données ou résumer des statistiques. Les opérations d'agrégation prises en charge dans Django ORM incluent : Avg, Max, Min, Count, Sumetc. Voici un exemple de code : 🎜rrreee🎜V. Résumé🎜🎜Cet article fournit une introduction détaillée au framework ORM Django ORM en Python. Django ORM est un framework ORM facile à utiliser, riche en fonctionnalités et évolutif qui peut aider les développeurs à réaliser un développement rapide et des opérations de base de données plus efficaces. En plus des opérations CRUD de base, Django ORM prend également en charge certaines opérations de requête avancées, telles que les requêtes de jointure de table, les combinaisons de conditions de requête, les opérations d'agrégation, etc., qui peuvent répondre aux besoins d'un plus grand nombre d'opérations de données. 🎜

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!