Le framework Web Django a une architecture modèle-vue-modèle (MVT), ce qui en fait le seul framework dont vous aurez besoin pour créer un site Web ou une application Web complète. Ce framework Python vous permet de créer des modèles qui génèrent des bases de données et restituent des modèles HTML dynamiques à l'interface utilisateur à l'aide de vues.
La puissance de Django n'est pas un secret; c'est rapide, fiable, évolutif et sécurisé. La fiabilité, ainsi que l'évolutivité de ce logiciel, reposent sur son architecture MVT. Et dans cet article, vous apprendrez exactement comment fonctionne l'architecture MVT de Django.
Qu'est-ce que le modèle de Django ?
Le modèle de l'architecture MVT de Django définit la structure et le comportement des données que vous souhaitez stocker via votre site Web. Chaque modèle Django que vous créez génère une table de base de données correspondante, où chaque attribut du modèle devient un champ dans la table.
Poursuivant la configuration de notre article d'introduction sur Django
, vous pouvez créer un modèle pour les vendeurs. Un vendeur peut avoir un modèle de vendeur contenant des informations personnelles, telles qu'un nom et des coordonnées, et un modèle associé pour les articles que chaque vendeur vend.L'exemple de structure de fichier de projet Django existant
mon site/
mon site/
_pycache_
_init_.py
asgi.py
paramètres.py
urls.py
wsgi.py
les vendeurs/
migration
_init_.py
admin.py
apps.py
modèles.py
test.py
vues.py
db.sqlite3
manage.py
Création de modèles Django
Si vous regardez sous la section des applications des vendeurs dans la structure de fichiers ci-dessus, vous verrez un fichier appelé modèles.py. C'est ici que vous créerez tous vos modèles Django pour la section des vendeurs de votre site Web. Chaque modèle que vous créez sera une sous-classe de L'API modèle de Django, c'est pourquoi chaque produit généré par Django modèles.py le fichier a une importation de modèles par défaut.
Le fichier models.py
À partir de modèles d'importation django.db# Créez vos modèles ici.
vendeur de classe (modèles. Modèle):
prénom = modèles. CharField (max_length=30)
nom_de_famille = modèles. CharField (max_length=30)
contact_number = modèles. CharField (max_length=30)
produit de classe (modèles. Modèle):
vendeur = modèles. ForeignKey (Vendeur, on_delete=models. CASCADE)
item_name = modèles. CharField (max_length=100)
item_qantity = modèles. ChampEntier()
item_price = modèles. DecimalField (max_digits=9, decimal_places=2)
item_description = modèles. Champ de texte()
Le code ci-dessus est une copie du contenu mis à jour du modèle.py fichier. Le fichier crée maintenant deux modèles: Vendeur et Produit. Ces modèles partagent une relation un-à-plusieurs, où un vendeur peut avoir plusieurs produits en vente. Ainsi, le modèle de produit a un clé étrangère du vendeur et un on_delete attribut défini sur des modèles. CASCADE, ce qui signifie que lorsque vous supprimez un vendeur, vous supprimez automatiquement tous les produits qui l'ont clé primaire comme un clé étrangère.
En rapport: Apprenez Python et Django aujourd'hui avec ces cours incroyables Vous remarquerez peut-être également que chacun des modèles du code ci-dessus n'a pas de clé primaire. C'est parce que Django générera automatiquement un clé primaire si vous n'en créez pas explicitement un.
Avant de pouvoir utiliser un modèle que vous créez, vous devez indiquer à Django où le trouver. Pour ce faire, vous devrez naviguer vers le paramètres.py fichier et insérez le nom du module qui contient le modèles.py fichier, dans le INSTALLED_APP section.
Dans l'exemple de projet de cet article, le modèles.py le fichier se trouve dans le module des vendeurs. Par conséquent, la mise à jour INSTALLED_APP section se lira comme suit :
INSTALLED_APPS = [
'django.contrib.admin',
'django.contrib.auth',
'django.contrib.contenttypes',
'django.contrib.sessions',
'django.contrib.messages',
'django.contrib.staticfiles',
'les vendeurs',
]
Avec le code ci-dessus, les modèles de l'application des vendeurs sont désormais visibles sur le site Web de Django, et vous pouvez maintenant passer aux migrations.
La réalisation de migrations est importante car ce processus est un moyen de diffuser les modifications que vous apportez dans vos modèles au schéma de base de données correspondant. Ainsi, chaque fois que vous apporterez des modifications à votre modèle, vous devrez effectuer le processus de migration, qui comprend deux étapes.
La première étape consiste à effectuer des migrations, qui est une commande qui crée des migrations en fonction des modifications détectées dans le modèles.py fichier. Pour démarrer le processus de migration, vous devrez ouvrir votre terminal, accéder au répertoire contenant votre projet Django et lancer le serveur à l'aide de la commande suivante :
serveur d'exécution python manage.py
Avec le serveur en cours d'exécution dans un terminal, ouvrez un nouveau terminal et entrez la commande suivante :
python manage.py makemigrations
Après exécution, le terminal produira la sortie suivante :
Migrations pour les "vendeurs" :
vendeurs\migrations\0001_initial.py
- Créer un vendeur modèle
- Créer un produit modèle
La sortie ci-dessus indique clairement que vous avez maintenant des migrations pour deux modèles: le vendeur et le produit. Maintenant, si vous accédez au dossier de migration dans le module de vos vendeurs, vous verrez qu'il a maintenant un nouveau fichier appelé 0001_initial.py. Dans ce fichier, vous trouverez les migrations que vous venez de créer.
Le fichier 0001_initial.py
# Généré par Django 3.2.9 le 2022-02-26 16:06depuis django.db importer des migrations, des modèles
importer django.db.models.deletion
classe Migration (migrations. Migration):
initiale = Vrai
dépendances = [
]
opérations = [
migrations. CréerModèle(
nom='Vendeur',
champs=[
("id", modèles. BigAutoField (auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
('prénom', modèles. CharField (max_length=30)),
('nom_de_famille', modèles. CharField (max_length=30)),
('numéro_contact', modèles. CharField (max_length=30)),
],
),
migrations. CréerModèle(
nom='Produit',
champs=[
("id", modèles. BigAutoField (auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
('nom_élément', modèles. CharField (max_length=100)),
('item_qantity', modèles. ChampEntier()),
('item_price', modèles. DecimalField (decimal_places=2, max_digits=9)),
('item_description', modèles. Champ de texte()),
("vendeur", modèles. Clé étrangère (on_delete=django.db.models.deletion. CASCADE, to='sellers.seller')),
],
),
]
A chaque nouvelle migration, le dossier de migration génère une nouvelle version de ce fichier.
La deuxième étape du processus de migration consiste à migrer enfin les modèles. Cela signifie que vous synchronisez l'état de la base de données avec modèles.py fichier, en utilisant les migrations que vous venez de créer dans le 0001_initial.py fichier. Vous pouvez terminer ce processus (pendant que le serveur est toujours en cours d'exécution) avec la commande suivante :
python manage.py migrer
Qu'est-ce que le modèle de Django ?
Les modèles sont un moyen de générer dynamiquement du code HTML pour votre projet Django. Chaque modèle Django a le .html extension et une combinaison de contenu statique et dynamique. Les modèles Django ont une syntaxe unique qui inclut de nouvelles façons de créer des variables et des balises dans un document HTML.
Création d'un modèle Django
Pour introduire des modèles dans l'exemple de site Web de commerce électronique pour cet article, vous devrez créer un nouveau répertoire dans le module des vendeurs. Ce nouveau répertoire appelé "modèles" accueillera tous les documents HTML de l'application des vendeurs, à commencer par la page d'accueil.
Le fichier sellers_home.html
Vendeurs | Commerce électronique
Bienvenue aux vendeurs !
Après avoir créé vos modèles, vous devrez les rendre visibles pour Django en ajoutant le répertoire de vos modèles au dossier MODÈLES partie de la paramètres.py fichier. La mise à jour MODÈLES section ressemblera à ceci :
MODÈLES = [
{
'BACKEND': 'django.template.backends.django. DjangoTemplates',
'DIRS': [
# nouveau code qui pointe vers l'emplacement des templates
BASE_DIR / 'vendeurs' / 'modèles'
],
'APP_DIRS': Vrai,
'OPTIONS': {
'context_processors': [
'django.template.context_processors.debug',
'django.template.context_processors.request',
'django.contrib.auth.context_processors.auth',
'django.contrib.messages.context_processors.messages',
],
},
},
]
Maintenant que Django sait où trouver les modèles pour le site Web, vous pouvez continuer et les afficher dans l'interface utilisateur à l'aide de la vue.
Quel est le point de vue de Django ?
La vue est la deuxième couche de l'architecture MVT de Django, un modèle est inutile à moins qu'une vue ne le rende à l'interface utilisateur. La vue est chargée d'accepter les requêtes Web et de renvoyer les réponses appropriées (y compris les modèles). Dans sa forme la plus élémentaire, la vue est une fonction Python, stockée dans le vue.py fichier de votre projet Django.
Création de la vue Django
le vue.py se trouve dans le module des vendeurs de l'exemple de projet Django. Lorsqu'un vendeur visite votre site Web, vous souhaitez qu'il se rende sur la page d'accueil d'un vendeur. Cette page d'accueil que vous allez créer à l'aide d'un modèle HTML, un peu comme celui créé dans la section des modèles ci-dessus.
Le fichier view.py
depuis django.shortcuts importer le rendu
index def (requête):
renvoie le rendu (demande, 'sellers_home.html')
La vue ci-dessus prend une requête et renvoie le modèle HTML des vendeurs. Ainsi, chaque fois qu'un utilisateur visite (ou demande) http://127.0.0.1:8000/sellers/ ils verront la page d'accueil des vendeurs. C'est après avoir créé un urls.py fichier dans le module des vendeurs.
Le fichier urls.py des vendeurs
à partir du chemin d'importation django.urls
à partir de. importer des vues
modèles d'url = [
chemin('', vues.index, nom='index'),
]
Et inclure le chemin vers le module des vendeurs urls.py dossier dans le urls.py fichier situé dans le répertoire principal de Django.
Le fichier urls.py du site Web
depuis l'administrateur d'importation django.contrib
à partir de django.urls import include, path
modèles d'url = [
path('sellers/', include('sellers.urls')),
chemin('admin/', admin.site.urls),
]
Maintenant que la vue est configurée, vous pouvez vous assurer que le serveur Django est toujours en cours d'exécution et naviguer vers http://127.0.0.1:8000/sellers/ dans votre navigateur pour voir la page d'accueil des vendeurs.
La page d'accueil des vendeurs
L'architecture MVT de Django vs. Architecture MVC
L'architecture MVT de Django est assez différente de l'architecture MVC populaire.
La section modèle de l'architecture MVT fonctionne à peu près de la même manière que la vue dans l'architecture MVC, tandis que la vue dans l'architecture MVT affiche des qualités similaires au contrôleur dans le MVC architecture. Cependant, les modèles des deux architectures fonctionnent de manière identique.
Appliquez les principes de conception Modèle-Vue-Contrôleur à vos propres programmes pour des résultats immédiats. Voici comment commencer.
Lire la suite
- Programmation
- Programmation
- Python
Kadeisha Kean est un développeur de logiciels Full-Stack et un rédacteur technique/technologique. Elle a la capacité distincte de simplifier certains des concepts technologiques les plus complexes; produire du matériel facilement compréhensible par tout novice en technologie. Elle est passionnée par l'écriture, le développement de logiciels intéressants et le voyage à travers le monde (à travers des documentaires).
Abonnez-vous à notre newsletter
Rejoignez notre newsletter pour des conseils techniques, des critiques, des ebooks gratuits et des offres exclusives !
Cliquez ici pour vous abonner
