Flask et Django : développement web

Qu'est-ce qu'un framework web ? Simplifier le développement

Un framework web est un ensemble d'outils et de bibliothèques qui facilitent le développement d'applications web. Il fournit une structure de base, des conventions, et des fonctionnalités courantes, ce qui permet aux développeurs de se concentrer sur la logique spécifique de leur application plutôt que sur les aspects techniques de bas niveau.

Les frameworks web gèrent généralement :

• Le routage des requêtes HTTP (associer des URL à des fonctions Python).
• La gestion des templates (générer du HTML dynamiquement).
• L'interaction avec des bases de données.
• La gestion des formulaires.
• L'authentification et la gestion des utilisateurs.
• La sécurité (protection contre les attaques courantes).
• Et bien d'autres aspects...

En utilisant un framework web, vous pouvez développer des applications web plus rapidement, plus proprement, et plus sûrement.

Python offre de nombreux frameworks web, allant de microframeworks légers (comme Flask) à des frameworks complets (comme Django).

Flask : un microframework flexible

Flask est un *microframework* web pour Python. Cela signifie qu'il est léger, flexible, et qu'il ne fournit que les fonctionnalités essentielles. Il vous laisse libre de choisir les bibliothèques et les outils que vous voulez utiliser pour les autres aspects de votre application (base de données, gestion des formulaires, etc.).

Flask est basé sur Werkzeug (une bibliothèque WSGI) et Jinja2 (un moteur de templates).

Flask est particulièrement adapté pour :

• Les petites applications web et les APIs.
• Les microservices.
• Les prototypes.
• Les projets où vous voulez avoir un contrôle total sur les composants utilisés.

Flask est facile à apprendre et à utiliser, mais il peut aussi être utilisé pour des projets plus complexes grâce à son système d'extensions.

Exemple simple avec Flask : "Hello, World!"

Voici un exemple simple d'application Flask qui affiche "Hello, World!" :

from flask import Flask

app = Flask(__name__)  # Crée une instance de l'application Flask

@app.route("/")  # Définit une route (URL) associée à la fonction
def hello_world():
    return "Hello, World!"  # La fonction retourne une chaîne de caractères

if __name__ == '__main__':
 app.run(debug=True) #Lance le serveur

Pour exécuter ce code :

1. Installez Flask : `pip install flask`
2. Enregistrez le code dans un fichier (par exemple, `app.py`).
3. Exécutez le fichier : `python app.py`
4. Ouvrez votre navigateur et allez à l'adresse `http://127.0.0.1:5000/` (ou `http://localhost:5000/`).

Vous devriez voir "Hello, World!" affiché dans votre navigateur.

Dans cet exemple :

• `from flask import Flask` importe la classe `Flask`.
• `app = Flask(__name__)` crée une instance de l'application Flask. `__name__` est une variable spéciale en Python qui contient le nom du module courant.
• `@app.route("/")` est un décorateur qui associe la route `/` (la racine du site web) à la fonction `hello_world`. Lorsque vous accédez à la racine du site, Flask appelle cette fonction.
• `def hello_world():` est la fonction qui est exécutée lorsque la route `/` est demandée. Elle retourne simplement la chaîne de caractères "Hello, World!".
• `if __name__ == '__main__':` et `app.run(debug=True)` démarre le serveur web de développement intégré à Flask (en mode débogage). N'utilisez pas ce serveur en production.

Django : un framework complet et "batteries included"

Django est un framework web Python de haut niveau, complet ("batteries included"). Il fournit une structure de projet, un ORM (Object-Relational Mapper) pour interagir avec les bases de données, un système de templates, un système d'authentification, des outils de sécurité, et bien d'autres fonctionnalités.

Django est basé sur le principe DRY (Don't Repeat Yourself) et sur le principe de la convention plutôt que la configuration.

Django est particulièrement adapté pour :

• Les sites web complexes (blogs, forums, sites d'e-commerce, etc.).
• Les applications web avec une base de données.
• Les projets où la rapidité de développement et la maintenabilité sont importantes.
• Les projets où la sécurité est une préoccupation majeure.

Django a une courbe d'apprentissage plus raide que Flask, mais il offre une structure plus complète et plus d'outils intégrés.

Exemple simple avec Django (très simplifié)

Contrairement à Flask, un exemple "Hello, World!" avec Django nécessite plusieurs fichiers et une certaine configuration. Voici une version *très simplifiée* pour illustrer le concept (ce n'est pas un exemple complet et fonctionnel) :

Structure du projet (simplifiée) :

mon_projet/
    mon_projet/
        __init__.py
        settings.py
        urls.py
        wsgi.py
    mon_app/
        __init__.py
        views.py
        models.py
        urls.py
    manage.py

`mon_app/views.py` :

# mon_app/views.py
from django.http import HttpResponse

def hello_world(request):
    return HttpResponse("Hello, World!")

`mon_app/urls.py` :

# mon_app/urls.py
from django.urls import path
from . import views

urlpatterns = [
    path('', views.hello_world, name='hello_world'),
]

`mon_projet/urls.py` :

# mon_projet/urls.py
from django.contrib import admin
from django.urls import include, path

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

Pour exécuter cet exemple, vous auriez besoin d'installer Django (`pip install django`), de créer un projet Django (`django-admin startproject mon_projet`), de créer une application (`python manage.py startapp mon_app`), de configurer les fichiers `settings.py`, `urls.py`, etc.

Cet exemple montre que Django est plus complexe que Flask pour une application simple. Cependant, cette complexité est justifiée pour des projets plus importants, car Django fournit une structure solide et de nombreux outils intégrés.

Flask vs. Django : quel framework choisir ?

Le choix entre Flask et Django dépend de vos besoins :

• Flask :
  • Plus léger, plus flexible.
  • Courbe d'apprentissage plus douce.
  • Plus de contrôle sur les composants utilisés.
  • Convient mieux aux petites applications, aux microservices, aux prototypes.
• Django :
  • Plus complet, "batteries included".
  • Courbe d'apprentissage plus raide.
  • Moins de contrôle sur les composants (mais plus d'outils intégrés).
  • Convient mieux aux sites web complexes, aux applications avec une base de données, aux projets où la rapidité de développement et la sécurité sont importantes.

Il n'y a pas de "meilleur" framework. Le meilleur choix dépend de la nature de votre projet, de vos préférences, et de votre expérience.

Vous pouvez même utiliser Flask et Django *ensemble* dans certains cas (par exemple, utiliser Flask pour créer des microservices qui communiquent avec une application Django principale).

Il existe également d'autres frameworks web Python, comme FastAPI (un framework moderne et performant pour les API), Pyramid (un framework flexible et configurable), et Tornado (un framework asynchrone).