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 couverts

• 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
• Utiliser 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.

Des 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 Posts
    {% for post in posts %}
        
{{ post.title }}
        
{{ post.content }}
        
Published on: {{ post.published_date }}
    {% endfor %}

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 informations d'identification 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.