Qu'est-ce que l'héritage de modèle dans Django ?

L'héritage de modèle est une fonctionnalité Django ORM qui permet aux développeurs de créer des relations hiérarchiques entre les modèles de base de données. Il permet la réutilisation du code, l'extensibilité et une base de code plus propre en exploitant les principes de la programmation orientée objet.

Que vous construisiez une application Web complexe ou que vous travailliez sur un projet plus petit, l'héritage de modèle peut offrir des avantages significatifs, tels que la réduction de la redondance et la garantie d'un comportement cohérent.

Types d'héritage de modèle dans Django

Django prend en charge trois types d'héritage de modèle :

1. Classes de base abstraites.
2. Héritage multi-tables.
3. Modèles de proxy.

Chacun de ces types d'héritage de modèle présente des avantages et vous les utiliserez à des fins spécifiques.

Classes de base abstraites

Les classes de base abstraites permettent de définir des champs et des méthodes communs dont plusieurs modèles peuvent hériter. Par exemple, si vous avez deux modèles partageant des champs similaires, vous pouvez utiliser une classe de base abstraite pour définir les champs similaires. Jetez un oeil à cet exemple:

classeClient(des modèles. Modèle):
 nom = modèles. CharField (max_length=50)
 e-mail = modèles. ChampEmail()
 id_client = modèles. ChampEntier() 
classeVendeur(des modèles. Modèle):
 nom = modèles. CharField (max_length=50)
 e-mail = modèles. ChampEmail()
 seller_id = modèles. ChampEntier()

L'extrait de code ci-dessus définit deux modèles Django: Client et Vendeur. Ces modèles partagent deux domaines communs, à savoir nom et e-mail. Pour éviter cette redondance, vous pouvez créer un modèle séparé pour contenir les champs communs dans le Client et Vendeur modèles et le rendre abstrait.

classeInformations utilisateur(des modèles. Modèle):
 nom = modèles. CharField (max_length=50)
 e-mail = modèles. ChampEmail()
classeMéta:
 abstrait = Vrai

L'extrait de code ci-dessus définit un nouveau modèle et définit le abstrait attribuer à Vrai. Cela signifie que le modèle sera abstrait et que Django ne créera pas de table dans la base de données.

Vous pouvez réécrire le Client et Vendeur des modèles comme celui-ci :

classeClient(Informations utilisateur):
 id_client = modèles. ChampEntier() 
classeVendeur(Informations utilisateur):
 seller_id = modèles. ChampEntier()

Dans l'extrait de code ci-dessus, le Client et Les vendeurs les modèles héritent de la Informations utilisateur modèle au lieu de des modèles. Modèle.

Vous pouvez afficher vos modèles dans le panneau d'administration en les enregistrant dans votre admin.py fichier comme celui-ci :

depuis .des modèles importer Client, Vendeur
admin.site.register (Client)
admin.site.register (Vendeur)

Migrez vos modes et démarrez votre serveur de développement en exécutant ce qui suit sur un ligne de commande:

python manage.py makemigrations \
 && python manage.py migre \
 && python manage.py serveur d'exécution

Accédez à votre site d'administration et connectez-vous avec vos informations de superutilisateur. Vous devriez voir les trois champs pour chaque modèle.

Dans cet exemple, Django a créé une table pour le Client et Vendeur des modèles. Vous pouvez voir que le Informations utilisateur le modèle n'a pas de table puisqu'il est abstrait.

Héritage multi-tables

Vous pouvez utiliser l'héritage multitable lorsque le modèle parent doit également exister en tant que table dans la base de données à côté du modèle enfant.

Contrairement à l'héritage de classe de base abstraite, où le modèle parent ne sera pas une table dans la base de données, l'héritage multi-table crée une table pour le modèle parent.

Dans l'héritage multi-tables, le modèle enfant hérite de tous les champs et méthodes de son modèle parent et ajoute ses champs spécifiques. Clés étrangères aider à établir le relation modèle entre les modèles parent et enfant.

Voici un exemple d'héritage multi-table :

classePersonne(des modèles. Modèle):
 prénom = modèles. CharField (max_length=100)
 nom_de_famille = modèles. CharField (max_length=100)
définitivementget_name(soi):
retourF"{self.first_name}{self.last_name}"
classeMéta:
 abstrait = Vrai
classeEmployé(Personne):
 employee_id = modèles. CharField (max_length=20)
 département = modèles. CharField (max_length=100)
 salaire = modèles. ChampFlottant()
 dob = modèles. ChampDate()
classeDirecteur(Employé):
 titre = modèles. CharField (max_length=100)

Cet extrait de code définit trois modèles. Le premier modèle, appelé Personne, est abstrait. Il définit uniquement le prénom et le nom d'une personne.

Le deuxième modèle, appelé Employé, hérite des champs de Personne mais définit des champs supplémentaires. Le Employé modèle n'est pas abstrait, il aura donc sa table dans la base de données.

Le modèle final, appelé Directeur, hérite des champs de la Employé modèle et ajoute un champ appelé titre.

La relation entre le Employé et Directeur les modèles s'appellent Héritage multi-tables. Migrez vos modèles, enregistrez-les dans admin.py, démarrez votre serveur et accédez au panneau d'administration. Vous devriez voir deux tables créées par Django.

Lorsque vous essayez d'ajouter un nouveau gestionnaire, vous remarquerez qu'il contient tous les champs du Employé modèle ainsi que son propre champ personnalisé.

Modèles de proxy

Un modèle de proxy vous aide à créer un nouveau modèle qui s'étend à partir d'un modèle existant sans créer de nouvelle table de base de données. Dans ce type d'héritage de modèle, les modèles proxy et d'origine partageront la même table. À l'aide de modèles de proxy, vous pouvez par exemple créer des modèles personnalisés et modifier les gestionnaires par défaut.

Vous pouvez créer un modèle de proxy en ajoutant proxy=Vrai dans le Méta classe. Voici un exemple :

classeProxyModel(Modèle de base):
classeMéta:
 mandataire = Vrai

L'utilisation typique d'un modèle de proxy est appropriée lorsqu'un modèle de base existe et qu'il est nécessaire d'en créer une version spécialisée avec des fonctionnalités supplémentaires. Voici un exemple de base :

classePoste(des modèles. Modèle):
 titre = modèles. CharField (max_length=30)
 auteur = modèles. CharField (max_length=30)
définitivement__str__(soi):
retour auto.titre
classeProxyPost(Poste):
classeMéta:
 mandataire = Vrai

Cet extrait de code définit deux modèles: Poste et Mon message. Le Poste model définit deux champs pour le titre et l'auteur. Le ProxyPost modèle hérite du Poste modèle.

Migrez les modèles ci-dessus et ajoutez un nouveau message au tableau créé pour le Poste modèle.

Après avoir ajouté le message, ouvrez le Messages proxy tableau. Vous devriez trouver le message que vous avez ajouté à la Poste table dedans.

Les modifications que vous apportez aux messages dans le Messages proxy table affectera le poste correspondant dans le Poste tableau, et inversement. Cela prouve qu'ils partagent vraiment la même table.

Vous pouvez modifier le chaîne() méthode du modèle proxy :

classeProxyPost(Poste):
classeMéta:
 mandataire = Vrai
 commande = ["titre"]
définitivement__str__(soi):
retour auto.auteur

Avec cette modification, un ProxyPost's la représentation sous forme de chaîne sera son auteur, pas le titre. L'ordre du modèle de proxy sera également par le titre au lieu du champ d'ID par défaut.

Lorsque vous utilisez des modèles de proxy, vous devez garder à l'esprit que vous ne pouvez pas ajouter de champs personnalisés à votre modèle de proxy. Le principal cas d'utilisation des modèles de proxy est lorsque vous souhaitez qu'un modèle prenne en charge plusieurs comportements.

Les modèles proxy vous aident à modifier le comportement d'un modèle existant sans modifier ses champs ou la structure sous-jacente des tables de la base de données.

Utiliser l'héritage de modèle pour la réutilisabilité du code et la structure organisationnelle

En utilisant les différentes techniques d'héritage de modèle, vous pouvez facilement créer du code réutilisable et organisé pour votre projet.

L'héritage de modèle évite le code redondant et améliore la maintenabilité et l'évolutivité de votre code. Il facilite également la navigation dans votre code, favorisant ainsi une collaboration efficace entre les équipes de développement.

Outre l'héritage de modèle, Django propose l'héritage de modèle, qui est un excellent moyen de gérer et d'organiser des modèles pour vos projets.