Maison > Article > développement back-end > Comprendre les principes fondamentaux de Django
Comprendre les principes fondamentaux de Django
- 王林original
- 2024-07-26 11:15:21446parcourir
Dans le blog précédent, nous avons configuré notre environnement de développement et créé un projet et une application Django de base. Il est maintenant temps d'approfondir les aspects fondamentaux de Django, notamment sa structure de projet, son architecture Model-View-Template (MVT) et l'interface d'administration de Django. À la fin de cet article, vous devriez avoir une solide compréhension de ces concepts et être prêt à créer une application de blog simple.
Aperçu
Ce blog approfondira les aspects fondamentaux de Django, y compris sa structure de projet, son architecture MVT et l'interface d'administration de Django.
Sujets abordés
- Structure du projet Django
- Modèles, vues et modèles (MVT)
- Administrateur Django
Objectifs
- Comprendre l'architecture MVT
- Créer des modèles, des vues et des modèles dans Django
- Utilisez l'interface d'administration de Django
Structure du projet Django
Comprendre la structure du projet Django est crucial pour naviguer et organiser efficacement votre code. Lorsque vous créez un nouveau projet et une nouvelle application Django, la structure de répertoires suivante est générée :
myproject/
manage.py
myproject/
__init__.py
settings.py
urls.py
wsgi.py
asgi.py
blog/
__init__.py
admin.py
apps.py
models.py
tests.py
views.py
migrations/
- manage.py : un utilitaire de ligne de commande qui permet de gérer le projet Django.
- myproject/ : le répertoire principal du projet contenant les paramètres et la configuration.
- settings.py : Paramètres de configuration du projet.
- urls.py : déclarations d'URL pour le projet.
- wsgi.py et asgi.py : points d'entrée pour les serveurs Web compatibles WSGI/ASGI.
- blog/ : Un répertoire d'application Django contenant des fichiers spécifiques à l'application.
Modèles, vues et gabarits (MVT)
Django suit l'architecture Model-View-Template (MVT), qui est une variante du modèle MVC. Cette architecture favorise une séparation nette des préoccupations, rendant votre code plus organisé et maintenable.
Modèles
Les modèles définissent la structure des tables de votre base de données. Chaque modèle est une classe Python qui sous-classe django.db.models.Model.
# blog/models.py
from django.db import models
class Post(models.Model):
title = models.CharField(max_length=100)
content = models.TextField()
published_date = models.DateTimeField(auto_now_add=True)
def __str__(self):
return self.title
Vues
Les vues gèrent la logique et le traitement des données de votre application. Ils acceptent les demandes, interagissent avec les modèles et renvoient des réponses.
# blog/views.py
from django.shortcuts import render
from .models import Post
def home(request):
posts = Post.objects.all()
return render(request, 'blog/home.html', {'posts': posts})
Modèles
Les modèles définissent la structure HTML et la présentation de vos pages Web. Ils peuvent inclure du contenu dynamique en utilisant des balises et des filtres de modèle Django.
<!-- blog/templates/blog/home.html -->
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>Blog Home</title>
</head>
<body>
<h1>Blog Posts</h1>
{% for post in posts %}
<h2>{{ post.title }}</h2>
<p>{{ post.content }}</p>
<p>Published on: {{ post.published_date }}</p>
{% endfor %}
</body>
</html>
Configuration des URL
Pour mapper les URL aux vues, les modèles d'URL doivent être configurés dans urls.py.
# myproject/urls.py
from django.contrib import admin
from django.urls import path
from blog import views
urlpatterns = [
path('admin/', admin.site.urls),
path('', views.home, name='home'),
]
Administrateur Django
L'interface d'administration de Django est un outil puissant pour gérer les données de votre application sans écrire de code supplémentaire. Il génère automatiquement une interface conviviale pour vos modèles.
Configuration de l'administrateur Django
- Enregistrer les modèles : enregistrez vos modèles sur le site d'administration pour les rendre disponibles dans l'interface d'administration.
# blog/admin.py from django.contrib import admin from .models import Post admin.site.register(Post)
- Créer un superutilisateur : créez un superutilisateur pour accéder à l'interface d'administration.
python manage.py createsuperuser
- Accédez à l'interface d'administration : démarrez le serveur de développement et accédez à http://127.0.0.1:8000/admin/. Connectez-vous avec vos identifiants de superutilisateur pour gérer vos données.
Conclusion
Voici un aperçu du processus d'écriture d'une application dans Django. Restez à l'écoute pour la prochaine partie de la série, où nous appliquerons ce que nous avons appris pour créer une application de blog simple.
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!