Dans cette section, nous allons explorer quelques exemples d'applications que vous pouvez développer en utilisant le framework Django. Ces exemples vous aideront à comprendre les possibilités offertes par Django et à vous inspirer pour vos propres projets.

1. Application de blog

Une application de blog simple permet aux utilisateurs de créer, lire, mettre à jour et supprimer des articles. Vous pouvez utiliser une base de données pour stocker les articles et les commentaires.

•                 1️⃣ Fonctionnalités : Authentification des utilisateurs, création d'articles, commentaires.
•                 2️⃣ Technologies : Django, SQLite, HTML/CSS.

2. Application de gestion de tâches

Cette application permet aux utilisateurs de suivre leurs tâches quotidiennes. Les utilisateurs peuvent ajouter, supprimer et marquer les tâches comme complètes.

•                 1️⃣ Fonctionnalités : Ajout de tâches, mise à jour de l'état des tâches, filtrage par date.
•                 2️⃣ Technologies : Django, PostgreSQL, JavaScript.

3. Application de portfolio

Créez un site de portfolio personnel où les utilisateurs peuvent afficher leurs projets, compétences et expériences professionnelles.

•                 1️⃣ Fonctionnalités : Pages de projet, sections de compétences, formulaire de contact.
•                 2️⃣ Technologies : Django, HTML/CSS, Bootstrap.

4. Application de e-commerce

Développez une application de e-commerce où les utilisateurs peuvent parcourir, ajouter au panier et acheter des produits.

•                 1️⃣ Fonctionnalités : Navigation des produits, gestion du panier, traitement des paiements.
•                 2️⃣ Technologies : Django, SQLAlchemy, Stripe API.

5. Application de chat en temps réel

Cette application permet aux utilisateurs de discuter en temps réel à travers des salons de chat. Utilisez Django Channels pour la communication en temps réel.

•                 1️⃣ Fonctionnalités : Salons de discussion, notifications en temps réel.
•                 2️⃣ Technologies : Django, Django Channels, JavaScript.

6. Application de gestion d'événements

Développez une application pour créer et gérer des événements. Les utilisateurs peuvent s'inscrire et recevoir des notifications.

•                 1️⃣ Fonctionnalités : Création d'événements, inscriptions, notifications par e-mail.
•                 2️⃣ Technologies : Django, Celery, PostgreSQL.

7. Application de quiz en ligne

Créez une plateforme pour créer et passer des quiz. Les utilisateurs peuvent voir leurs résultats et des statistiques.

•                 1️⃣ Fonctionnalités : Création de quiz, résultats instantanés, tableau de classement.
•                 2️⃣ Technologies : Django, Redis, JavaScript.

8. Application de gestion de contacts

Développez une application pour stocker et gérer vos contacts personnels ou professionnels.

•                 1️⃣ Fonctionnalités : Ajout, suppression, recherche de contacts.
•                 2️⃣ Technologies : Django, SQLite, HTML/CSS.

9. Application de recettes

Créez une application où les utilisateurs peuvent partager et découvrir des recettes de cuisine.

•                 1️⃣ Fonctionnalités : Soumission de recettes, notation, commentaires.
•                 2️⃣ Technologies : Django, PostgreSQL, Bootstrap.

10. Application de suivi de dépenses

Développez une application pour suivre vos dépenses et établir un budget.

•                 1️⃣ Fonctionnalités : Ajout de dépenses, rapports, graphiques.
•                 2️⃣ Technologies : Django, Matplotlib, SQLite.

Conclusion

Ces exemples d'applications montrent la flexibilité et les capacités de Django. Que vous souhaitiez créer une application simple ou complexe, Django peut vous aider à réaliser vos idées. N'hésitez pas à explorer ces projets et à les adapter à vos besoins !

Activité : Création d'une Application de Blog avec Django

Dans cette activité, vous allez créer une application de blog simple en utilisant le framework Django. Cette application permettra aux utilisateurs de créer, lire, mettre à jour et supprimer des articles de blog.

1. Prérequis

•                 1️⃣ Python installé sur votre machine.
•                 2️⃣ Django installé. Si ce n'est pas fait, exécutez la commande suivante :

pip install Django

• SQLite pour la base de données (inclus par défaut avec Django).

2. Créer le projet Django

Créez un nouveau projet Django en exécutant la commande suivante :

django-admin startproject blog_project

Ensuite, naviguez dans le dossier du projet :

cd blog_project

Créez une application pour le blog :

python manage.py startapp blog

3. Définir le modèle

Dans blog/models.py, définissez le modèle pour l'article de blog :

from django.db import models

class Post(models.Model):
    title = models.CharField(max_length=200)
    content = models.TextField()
    created_at = models.DateTimeField(auto_now_add=True)

    def __str__(self):
        return self.title

4. Migrer la base de données

Exécutez les commandes suivantes pour créer la table dans la base de données :

python manage.py makemigrations
python manage.py migrate

5. Créer les vues

Dans blog/views.py, ajoutez des vues pour afficher, créer, modifier et supprimer des articles :

from django.shortcuts import render, redirect
from .models import Post

def index(request):
    posts = Post.objects.all()
    return render(request, 'index.html', {'posts': posts})

def create(request):
    if request.method == 'POST':
        title = request.POST['title']
        content = request.POST['content']
        Post.objects.create(title=title, content=content)
        return redirect('index')
    return render(request, 'create.html')

def edit(request, id):
    post = Post.objects.get(id=id)
    if request.method == 'POST':
        post.title = request.POST['title']
        post.content = request.POST['content']
        post.save()
        return redirect('index')
    return render(request, 'edit.html', {'post': post})

def delete(request, id):
    post = Post.objects.get(id=id)
    post.delete()
    return redirect('index')

6. Configurer les URL

Dans blog/urls.py, ajoutez les routes pour les vues :

from django.urls import path
from . import views

urlpatterns = [
    path('', views.index, name='index'),
    path('create/', views.create, name='create'),
    path('edit//', views.edit, name='edit'),
    path('delete//', views.delete, name='delete'),
]

7. Créer les fichiers HTML

Dans le dossier blog/templates, créez les fichiers suivants :

•                 1️⃣ index.html : pour afficher la liste des articles.
•                 2️⃣ create.html : pour créer un nouvel article.
•                 3️⃣ edit.html : pour éditer un article existant.

Voici le contenu de index.html :

<!DOCTYPE html>
<html lang="fr">
<head>
    <meta charset="UTF-8">
    <title>Mon Blog</title>
</head>
<body>
    <h1>Articles de Blog</h1>
    <a href="{% url 'create' %}">Créer un nouvel article</a>
    <ul>
        {% for post in posts %}
            <li><a href="{% url 'edit' post.id %}">{{ post.title }}</a> - <a href="{% url 'delete' post.id %}">Supprimer</a></li>
        {% endfor %}
    </ul>
</body>
</html>

Voici le contenu de create.html :

<!DOCTYPE html>
<html lang="fr">
<head>
    <meta charset="UTF-8">
    <title>Créer un article</title>
</head>
<body>
    <h1>Nouvel Article</h1>
    <form action="{% url 'create' %}" method="post">
        <{% csrf_token %}>
        <label for="title">Titre:</label>
        <input type="text" id="title" name="title" required>

        <label for="content">Contenu:</label>
        <textarea id="content" name="content" required></textarea>

        <input type="submit" value="Créer">
    </form>
</body>
</html>

Voici le contenu de edit.html :

<!DOCTYPE html>
<html lang="fr">
<head>
    <meta charset="UTF-8">
    <title>Modifier l'article</title>
</head>
<body>
    <h1>Modifier l'article</h1>
    <form action="{% url 'edit' post.id %}" method="post">
        <{% csrf_token %}>
        <label for="title">Titre:</label>
        <input type="text" id="title" name="title" value="{{ post.title }}" required>

        <label for="content">Contenu:</label>
        <textarea id="content" name="content" required>{{ post.content }}</textarea>

        <input type="submit" value="Modifier">
    </form>
</body>
</html>

8. Démarrer le serveur

Pour démarrer votre application, exécutez la commande suivante :

python manage.py runserver

9. Conclusion

Vous avez maintenant créé une application de blog simple avec Django. Vous pouvez créer, lire, modifier et supprimer des articles de blog. Explorez davantage en ajoutant des fonctionnalités comme des commentaires ou une authentification des utilisateurs !

Activité : Création d'une Application de Gestion de Tâches avec Django

Dans cette activité, vous allez créer une application de gestion de tâches qui permettra aux utilisateurs de suivre leurs tâches quotidiennes. Cette application inclura des fonctionnalités pour ajouter, supprimer et marquer les tâches comme complètes.

1. Prérequis

•                 1️⃣ Python installé sur votre machine.
•                 2️⃣ Django installé. Si ce n'est pas fait, exécutez la commande suivante :

pip install Django

• SQLite pour la base de données (inclus par défaut avec Django).

2. Créer le projet Django

Créez un nouveau projet Django en exécutant la commande suivante :

django-admin startproject task_manager

Ensuite, naviguez dans le dossier du projet :

cd task_manager

Créez une application pour la gestion des tâches :

python manage.py startapp tasks

3. Définir le modèle

Dans tasks/models.py, définissez le modèle pour la tâche :

from django.db import models

class Task(models.Model):
    title = models.CharField(max_length=200)
    completed = models.BooleanField(default=False)
    created_at = models.DateTimeField(auto_now_add=True)

    def __str__(self):
        return self.title

4. Migrer la base de données

Exécutez les commandes suivantes pour créer la table dans la base de données :

python manage.py makemigrations
python manage.py migrate

5. Créer les vues

Dans tasks/views.py, ajoutez des vues pour afficher, créer et supprimer des tâches :

from django.shortcuts import render, redirect
from .models import Task

def index(request):
    tasks = Task.objects.all()
    return render(request, 'index.html', {'tasks': tasks})

def create(request):
    if request.method == 'POST':
        title = request.POST['title']
        Task.objects.create(title=title)
        return redirect('index')
    return render(request, 'create.html')

def complete(request, id):
    task = Task.objects.get(id=id)
    task.completed = True
    task.save()
    return redirect('index')

def delete(request, id):
    task = Task.objects.get(id=id)
    task.delete()
    return redirect('index')

6. Configurer les URL

Dans tasks/urls.py, ajoutez les routes pour les vues :

from django.urls import path
from . import views

urlpatterns = [
    path('', views.index, name='index'),
    path('create/', views.create, name='create'),
    path('complete//', views.complete, name='complete'),
    path('delete//', views.delete, name='delete'),
]

N'oubliez pas d'inclure les URLs de l'application dans le urls.py principal :

from django.contrib import admin
from django.urls import path, include

urlpatterns = [
    path('admin/', admin.site.urls),
    path('', include('tasks.urls')),
]

7. Créer les fichiers HTML

Dans le dossier tasks/templates, créez les fichiers suivants :

•                 1️⃣ index.html : pour afficher la liste des tâches.
•                 2️⃣ create.html : pour créer une nouvelle tâche.

Voici le contenu de index.html :

<!DOCTYPE html>
<html lang="fr">
<head>
    <meta charset="UTF-8">
    <title>Gestion de Tâches</title>
</head>
<body>
    <h1>Liste de Tâches</h1>
    <a href="{% url 'create' %}">Ajouter une Tâche</a>
    <ul>
        {% for task in tasks %}
            <li>{{ task.title }} - <a href="{% url 'complete' task.id %}">Compléter</a> - <a href="{% url 'delete' task.id %}">Supprimer</a></li>
        {% endfor %}
    </ul>
</body>
</html>

Voici le contenu de create.html :

<!DOCTYPE html>
<html lang="fr">
<head>
    <meta charset="UTF-8">
    <title>Créer une Tâche</title>
</head>
<body>
    <h1>Nouvelle Tâche</h1>
    <form action="{% url 'create' %}" method="post">
        <{% csrf_token %}>
        <label for="title">Titre:</label>
        <input type="text" id="title" name="title" required>

        <input type="submit" value="Ajouter">
    </form>
</body>
</html>

8. Démarrer le serveur

Pour démarrer votre application, exécutez la commande suivante :

python manage.py runserver

9. Conclusion

Vous avez maintenant créé une application de gestion de tâches simple avec Django. Vous pouvez ajouter, supprimer et marquer des tâches comme complètes. Explorez davantage en ajoutant des fonctionnalités comme des dates d'échéance ou des catégories de tâches !

Activité : Création d'une Application de Portfolio avec Django

Dans cette activité, vous allez créer une application de portfolio personnel qui permettra aux utilisateurs de présenter leurs projets, compétences et expériences professionnelles. Cette application inclura des fonctionnalités pour ajouter, modifier et afficher des projets.

1. Prérequis

•                 1️⃣ Python installé sur votre machine.
•                 2️⃣ Django installé. Si ce n'est pas fait, exécutez la commande suivante :

pip install Django

• SQLite pour la base de données (inclus par défaut avec Django).

2. Créer le projet Django

Créez un nouveau projet Django en exécutant la commande suivante :

django-admin startproject portfolio_app

Ensuite, naviguez dans le dossier du projet :

cd portfolio_app

Créez une application pour le portfolio :

python manage.py startapp projects

3. Définir le modèle

Dans projects/models.py, définissez le modèle pour le projet :

from django.db import models

class Project(models.Model):
    title = models.CharField(max_length=200)
    description = models.TextField()
    url = models.URLField()
    created_at = models.DateTimeField(auto_now_add=True)

    def __str__(self):
        return self.title

4. Migrer la base de données

Exécutez les commandes suivantes pour créer la table dans la base de données :

python manage.py makemigrations
python manage.py migrate

5. Créer les vues

Dans projects/views.py, ajoutez des vues pour afficher, créer et modifier des projets :

from django.shortcuts import render, redirect
from .models import Project

def index(request):
    projects = Project.objects.all()
    return render(request, 'index.html', {'projects': projects})

def create(request):
    if request.method == 'POST':
        title = request.POST['title']
        description = request.POST['description']
        url = request.POST['url']
        Project.objects.create(title=title, description=description, url=url)
        return redirect('index')
    return render(request, 'create.html')

def edit(request, id):
    project = Project.objects.get(id=id)
    if request.method == 'POST':
        project.title = request.POST['title']
        project.description = request.POST['description']
        project.url = request.POST['url']
        project.save()
        return redirect('index')
    return render(request, 'edit.html', {'project': project})

def delete(request, id):
    project = Project.objects.get(id=id)
    project.delete()
    return redirect('index')

6. Configurer les URL

Dans projects/urls.py, ajoutez les routes pour les vues :

from django.urls import path
from . import views

urlpatterns = [
    path('', views.index, name='index'),
    path('create/', views.create, name='create'),
    path('edit//', views.edit, name='edit'),
    path('delete//', views.delete, name='delete'),
]

N'oubliez pas d'inclure les URLs de l'application dans le urls.py principal :

from django.contrib import admin
from django.urls import path, include

urlpatterns = [
    path('admin/', admin.site.urls),
    path('', include('projects.urls')),
]

7. Créer les fichiers HTML

Dans le dossier projects/templates, créez les fichiers suivants :

•                 1️⃣ index.html : pour afficher la liste des projets.
•                 2️⃣ create.html : pour ajouter un nouveau projet.
•                 3️⃣ edit.html : pour modifier un projet existant.

Voici le contenu de index.html :

<!DOCTYPE html>
<html lang="fr">
<head>
    <meta charset="UTF-8">
    <title>Mon Portfolio</title>
</head>
<body>
    <h1>Projets</h1>
    <a href="{% url 'create' %}">Ajouter un Projet</a>
    <ul>
        {% for project in projects %}
            <li><a href="{{ project.url }}">{{ project.title }}</a> - <a href="{% url 'edit' project.id %}">Modifier</a> - <a href="{% url 'delete' project.id %}">Supprimer</a></li>
        {% endfor %}
    </ul>
</body>
</html>

Voici le contenu de create.html :

<!DOCTYPE html>
<html lang="fr">
<head>
    <meta charset="UTF-8">
    <title>Ajouter un Projet</title>
</head>
<body>
    <h1>Nouveau Projet</h1>
    <form action="{% url 'create' %}" method="post">
        <{% csrf_token %}>
        <label for="title">Titre:</label>
        <input type="text" id="title" name="title" required>

        <label for="description">Description:</label>
        <textarea id="description" name="description" required></textarea>

        <label for="url">URL:</label>
        <input type="text" id="url" name="url" required>

        <input type="submit" value="Ajouter">
    </form>
</body>
</html>

Voici le contenu de edit.html :

<!DOCTYPE html>
<html lang="fr">
<head>
    <meta charset="UTF-8">
    <title>Modifier le Projet</title>
</head>
<body>
    <h1>Modifier le Projet</h1>
    <form action="{% url 'edit' project.id %}" method="post">
        <{% csrf_token %}>
        <label for="title">Titre:</label>
        <input type="text" id="title" name="title" value="{{ project.title }}" required>

        <label for="description">Description:</label>
        <textarea id="description" name="description" required>{{ project.description }}</textarea>

        <label for="url">URL:</label>
        <input type="text" id="url" name="url" value="{{ project.url }}" required>

        <input type="submit" value="Modifier">
    </form>
</body>
</html>

8. Démarrer le serveur

Pour démarrer votre application, exécutez la commande suivante :

python manage.py runserver

9. Conclusion

Vous avez maintenant créé une application de portfolio simple avec Django. Vous pouvez ajouter, modifier et supprimer des projets. Explorez davantage en ajoutant des sections pour vos compétences, expériences, et même un formulaire de contact !

Activité : Création d'une Application de E-commerce avec Django

Dans cette activité, vous allez créer une application de e-commerce qui permettra aux utilisateurs de parcourir des produits, d'ajouter des articles à leur panier et de passer des commandes. Cette application inclura des fonctionnalités de gestion des produits et du panier.

1. Prérequis

• Python installé sur votre machine.
• Django installé. Si ce n'est pas fait, exécutez la commande suivante :

pip install Django

• SQLite pour la base de données (inclus par défaut avec Django).

2. Créer le projet Django

Créez un nouveau projet Django en exécutant la commande suivante :

django-admin startproject ecommerce_app

Ensuite, naviguez dans le dossier du projet :

cd ecommerce_app

Créez une application pour l'e-commerce :

python manage.py startapp shop

3. Définir les modèles

Dans shop/models.py, définissez les modèles pour les produits et le panier :

from django.db import models

class Product(models.Model):
    name = models.CharField(max_length=200)
    description = models.TextField()
    price = models.DecimalField(max_digits=10, decimal_places=2)

class Cart(models.Model):
    product = models.ForeignKey(Product, on_delete=models.CASCADE)
    quantity = models.IntegerField(default=1)

    def __str__(self):
        return f"{self.product.name} - {self.quantity}"

4. Migrer la base de données

Exécutez les commandes suivantes pour créer les tables dans la base de données :

python manage.py makemigrations
python manage.py migrate

5. Créer les vues

Dans shop/views.py, ajoutez des vues pour afficher les produits et gérer le panier :

from django.shortcuts import render, redirect
from .models import Product, Cart

def index(request):
    products = Product.objects.all()
    return render(request, 'index.html', {'products': products})

def add_to_cart(request, product_id):
    product = Product.objects.get(id=product_id)
    cart_item, created = Cart.objects.get_or_create(product=product)
    if not created:
        cart_item.quantity += 1
    cart_item.save()
    return redirect('index')

def cart(request):
    cart_items = Cart.objects.all()
    return render(request, 'cart.html', {'cart': cart_items})

6. Configurer les URL

Dans shop/urls.py, ajoutez les routes pour les vues :

from django.urls import path
from . import views

urlpatterns = [
    path('', views.index, name='index'),
    path('add_to_cart//', views.add_to_cart, name='add_to_cart'),
    path('cart/', views.cart, name='cart'),
]

N'oubliez pas d'inclure les URLs de l'application dans le urls.py principal :

from django.contrib import admin
from django.urls import path, include

urlpatterns = [
    path('admin/', admin.site.urls),
    path('', include('shop.urls')),
]

7. Créer les fichiers HTML

Dans le dossier shop/templates, créez les fichiers suivants :

• index.html : pour afficher la liste des produits.
• cart.html : pour afficher le contenu du panier.

Voici le contenu de index.html :

<!DOCTYPE html>
<html lang="fr">
<head>
    <meta charset="UTF-8">
    <title>E-commerce</title>
</head>
<body>
    <h1>Produits</h1>
    <ul>
        {% for product in products %}
            <li>{{ product.name }} - {{ product.price }} € - <a href="{% url 'add_to_cart' product.id %}">Ajouter au Panier</a></li>
        {% endfor %}
    </ul>
    <a href="{% url 'cart' %}">Voir le Panier</a>
</body>
</html>

Voici le contenu de cart.html :

<!DOCTYPE html>
<html lang="fr">
<head>
    <meta charset="UTF-8">
    <title>Mon Panier</title>
</head>
<body>
    <h1>Contenu du Panier</h1>
    <ul>
        {% for item in cart %}
            <li>Produit: {{ item.product.name }} - Quantité: {{ item.quantity }}</li>
        {% endfor %}
    </ul>
    <a href="{% url 'index' %}">Retour à la Boutique</a>
</body>
</html>

8. Démarrer le serveur

Pour démarrer votre application, exécutez la commande suivante :

python manage.py runserver

9. Conclusion

Vous avez maintenant créé une application de e-commerce simple avec Django. Vous pouvez parcourir les produits, ajouter des articles au panier et consulter le contenu du panier. Explorez davantage en ajoutant des fonctionnalités comme le traitement des paiements et la gestion des utilisateurs !

Activité : Création d'une Application de Chat en Temps Réel avec Django

Dans cette activité, vous allez créer une application de chat en temps réel qui permettra aux utilisateurs d'échanger des messages dans des salons de discussion. Nous utiliserons Django pour le serveur web et Django Channels pour la communication en temps réel.

1. Prérequis

• Python installé sur votre machine.
• Django et Django Channels installés. Si ce n'est pas fait, exécutez la commande suivante :

pip install Django channels

2. Créer le projet Django

Créez un nouveau projet Django en exécutant la commande suivante :

django-admin startproject chat_app

Ensuite, naviguez dans le dossier du projet :

cd chat_app

Créez une application pour le chat :

python manage.py startapp chat

3. Configurer Django Channels

Ajoutez Django Channels à votre projet. Dans chat_app/settings.py, ajoutez 'channels' à la liste des INSTALLED_APPS :

INSTALLED_APPS = [
    ...
    'channels',
]

Définissez le ASGI_APPLICATION dans le même fichier :

ASGI_APPLICATION = 'chat_app.asgi.application'

4. Créer le fichier ASGI

Dans le dossier chat_app, créez un fichier nommé asgi.py avec le contenu suivant :

import os
from django.core.asgi import get_asgi_application
from channels.routing import ProtocolTypeRouter, URLRouter
from channels.auth import AuthMiddlewareStack
from chat.routing import websocket_urlpatterns

os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'chat_app.settings')

application = ProtocolTypeRouter({
    'http': get_asgi_application(),
    'websocket': AuthMiddlewareStack(
        URLRouter(websocket_urlpatterns)
    ),
})

5. Créer les fichiers de routage

Dans chat/routing.py, définissez les routes WebSocket :

from django.urls import path
from . import consumers

websocket_urlpatterns = [
    path('ws/chat/', consumers.ChatConsumer.as_asgi()),
]

6. Créer le consommateur WebSocket

Dans chat/consumers.py, ajoutez le code suivant :

from channels.generic.websocket import AsyncWebsocketConsumer
import json

class ChatConsumer(AsyncWebsocketConsumer):
    async def connect(self):
        await self.accept()

    async def disconnect(self, close_code):
        pass

    async def receive(self, text_data):
        text_data_json = json.loads(text_data)
        message = text_data_json['message']

        await self.send(text_data=json.dumps({
            'message': message
        }))

7. Créer les fichiers HTML

Dans le dossier chat/templates, créez un fichier nommé index.html avec le contenu suivant :

<!DOCTYPE html>
<html lang="fr">
<head>
    <meta charset="UTF-8">
    <title>Chat en Temps Réel</title>
    <script src="https://code.jquery.com/jquery-3.6.0.min.js"></script>
    <script>
        var ws = new WebSocket('ws://' + window.location.host + '/ws/chat/');
        ws.onmessage = function(event) {
            var data = JSON.parse(event.data);
            $('#messages').append('<p>' + data.message + '</p>');
        };
        function sendMessage() {
            var message = $('#message').val();
            ws.send(JSON.stringify({'message': message}));
            $('#message').val('');
        }
    </script>
</head>
<body>
    <h1>Salon de Chat</h1>
    <div id="messages"></div>
    <input type="text" id="message" placeholder="Votre message...">
    <button onclick="sendMessage()">Envoyer</button>
</body>
</html>

8. Démarrer le serveur

Pour démarrer votre application, exécutez la commande suivante :

python manage.py runserver

9. Accéder à l'application

Ouvrez votre navigateur et accédez à http://localhost:8000. Vous devriez voir votre application de chat. Ouvrez plusieurs onglets ou fenêtres pour tester le chat en temps réel.

10. Conclusion

Vous avez maintenant créé une application de chat en temps réel avec Django et Django Channels. Les utilisateurs peuvent échanger des messages instantanément dans le salon de discussion. Explorez davantage en ajoutant des fonctionnalités comme des salons privés ou des notifications !