Cours Python et technologies Web en PDF (Intermédiaire)

Python et technologies Web : Ce qu'il faut savoir. Compatible Python 3.x. Manuel centré sur la construction d'API HTTP avec Python et le micro‑framework Flask, présentant la terminologie (HTTP, URL, JSON, REST), des exemples de code et des conseils de déploiement. Le document justifie quand préférer une API à un data dump et fournit des exemples pratiques exécutables; le PDF est disponible en téléchargement gratuit.

🎯 Ce que vous allez apprendre

• Conception d'API HTTP et terminologie — définitions opérationnelles : HTTP, URL, endpoint et méthodes (GET/POST). Compréhension des implications de ces notions sur la conception d'API robustes et cohérentes pour l'exposition de ressources.
• Routage et gestion des requêtes avec Flask — maîtrise du décorateur @app.route(), des arguments methods=['GET', 'POST'] et du cycle de requête. Savoir relier des chemins d'URL à des fonctions Python, parser des paramètres via request et renvoyer des réponses JSON avec jsonify.
• Sérialisation JSON et formats de sortie — usage pratique de JSON comme format d'échange et comparaison avec XML/CSV/Sqlite pour les data dumps. Critères de choix entre endpoint et export selon volume et besoins temps réel.
• Bonnes pratiques de design REST — principes pour naming d'endpoints, granularité des ressources et idempotence des méthodes afin d'améliorer la maintenabilité et la prévisibilité côté client.
• Débogage et configuration d'application Flask — configuration via app.config["DEBUG"], exécution locale avec app.run() et workflow de prototypage sous Anaconda/Spyder. Diagnostiquer les erreurs courantes et rendre l'environnement de développement réplicable.
• Implémentation complète d'un cas pratique — construction d'un catalogue de livres (structure de données, routes de consultation) avec extraits de code réutilisables servant d'exercices guidés pour transformer une page web en API fonctionnelle.

📑 Sommaire du document

• Introduction au Web
• Installation de Flask
• Gestion des routes
• Templates Jinja2
• Interaction avec SQLAlchemy
• Déploiement

💡 Pourquoi choisir ce cours ?

Approche pragmatique par l'exemple : démarrage depuis une petite application exécutable puis évolution vers une API REST exploitant JSON. L'auteur, Salim Lardjane, propose une pédagogie axée sur des cas concrets — choix entre data dump et API, configuration avec Anaconda/Spyder, et politiques de design simples. Le contenu inclut des fragments de code réutilisables et des consignes pour un prototypage rapide et reproductible.

👤 À qui s'adresse ce cours ?

• Public cible : étudiants en développement web, ingénieurs débutant en back‑end, ou développeurs front‑end souhaitant exposer des services via des endpoints HTTP pour consommer des données dynamiques.
• Prérequis :
  • Notions de base en Python (structures de données, fonctions).
  • Compréhension élémentaire du protocole HTTP et des formats JSON/XML.
  • Familiarité avec la ligne de commande et un environnement Python (Anaconda/Spyder ou équivalent).
  • Installation d'un gestionnaire de paquets : pip (ou conda) pour installer Flask, SQLAlchemy et autres dépendances.

❓ Foire Aux Questions (FAQ)

Comment Flask associe-t-il un chemin d'URL à une fonction Python ? Flask utilise le décorateur @app.route(path, methods=['GET', 'POST']) pour enregistrer un endpoint : lorsqu'une requête HTTP correspond au chemin et à la méthode indiqués, Flask appelle la fonction associée. L'objet request permet de lire les paramètres et jsonify de formater la réponse en JSON.

Dans quelles situations préférer un data dump à une API REST ? Pour de faibles volumes de données (quelques gigaoctets), un export JSON/XML/CSV ou un fichier Sqlite peut suffire et économiser la charge serveur. Une API est préférable pour l'accès temps réel, les mises à jour fréquentes ou l'accès partiel aux ressources.

Comment gérer la persistance avec Flask ? Flask s'intègre couramment avec des ORM comme SQLAlchemy pour interagir avec des bases MySQL/PostgreSQL. Le manuel décrit les patterns d'intégration basiques : configuration de la chaîne de connexion, modèles de données et sessions, ainsi que les considérations de migration et verrouillage de transactions.

Installation et configuration de l'environnement

Instructions d'installation minimales et structure recommandée pour un projet intermédiaire. Installer Flask avec pip : pip install flask. Pour un environnement isolé, créer un venv ou utiliser conda, puis verrouiller les dépendances via pip freeze > requirements.txt. Le manuel fournit des templates de structure de projet et des conventions de nommage pour faciliter la montée en charge et les tests.

• project/
  • app/ — package principal (routes, modèles, blueprints)
  • tests/ — tests unitaires et d'intégration
  • config.py — configuration par environnement
  • requirements.txt — dépendances
  • run.py — point d'entrée local

# création d'un environnement virtuel et installation
python -m venv venv
source venv/bin/activate
pip install flask
pip freeze > requirements.txt

Alternatives à Flask : Django et FastAPI

Comparaison synthétique et critères de choix pour des projets variés. Django se positionne comme un framework full-stack fournissant ORM, système d'admin et templating, adapté aux applications nécessitant une organisation stricte et des composants prêts à l'emploi. FastAPI met l'accent sur les performances et la génération automatique de schémas OpenAPI via Pydantic, utile pour des API asynchrones et fortement typées. Flask reste pertinent pour des micro‑services légers et des prototypes où l'on choisit explicitement ses composants.

Comparatif : Flask vs Django pour le développement Web

Flask offre une base minimaliste et flexible ; les développeurs assemblent les bibliothèques nécessaires, ce qui facilite les micro‑services et les prototypes. Django impose une architecture et fournit des briques immédiatement utilisables, ce qui accélère le développement d'applications complètes. Django suit le modèle MVT (Model‑View‑Template), qui sépare clairement les modèles de données, la logique de présentation et le contrôleur implicite. Le choix dépend des contraintes fonctionnelles, du besoin d'union entre composants et du volume d'évolutions prévues.

Architecture logicielle : Le modèle MVC avec Flask

Flask s'intègre dans des architectures inspirées du modèle MVC (ou variations proches). Dans ce contexte, le routing et les vues agissent comme contrôleurs, les templates correspondent aux vues et les modèles représentent la couche d'accès aux données. La séparation des responsabilités facilite les tests et la maintenabilité ; le manuel fournit des recommandations pour organiser les modules, isoler la logique métier et privilégier les Blueprints pour modulariser l'application.

Pour la conception et la communication d'architecture, le recours aux diagrammes UML (diagrammes de classes et de séquence) permet de formaliser les modèles de données et les interactions. Le document explique comment traduire un diagramme de classes en modèles SQLAlchemy : classes Python, attributs typés et relations (ForeignKey, relationship) pour une correspondance directe entre UML et schéma relationnel.

Patterns de conception

Bonnes pratiques couvertes : séparation des responsabilités, utilisation de Blueprints pour modulariser les routes, injection de dépendances légère pour faciliter les tests, et mise en place d'un gestionnaire de configuration par environnement. Ces patterns facilitent l'évolution d'un prototype vers une application plus structurée.

Différences entre Flask, Django et FastAPI

Les différences se situent sur la philosophie et les fonctionnalités intégrées. Django vise la productivité avec un cadre structuré et des conventions fortes; FastAPI mise sur les performances et la validation via Pydantic; Flask propose une incurvation minimale laissant le choix des composants. Les critères de sélection incluent taille de l'équipe, exigences de performance, besoin de génération de documentation OpenAPI et préférence pour une architecture imposée ou libre.

Intégration de bases de données avec Flask

La persistance est abordée via des exemples concrets d'intégration avec SQLAlchemy et des bases relationnelles comme MySQL. Le manuel détaille la configuration d'une chaîne de connexion compatible Python 3, la définition de modèles, la gestion des sessions et les opérations CRUD courantes. Des conseils sont fournis pour les migrations de schéma (Alembic), la gestion des index et la mise en production sécurisée des accès base de données afin de minimiser les risques de contention et d'injection SQL.

Conception de bases de données MySQL avec Python

Exemples de commandes et d'intégration MySQL, incluant l'utilisation de l'extension Flask-MySQLdb ou, préférentiellement pour la portabilité, de SQLAlchemy. Présentation d'un modèle de table simple et d'une connexion Flask‑MySQLdb pour des cas de maintenance légère. Le document propose aussi des modèles de migration et des recommandations pour les index et les transactions afin de garantir cohérence et performance.

CREATE TABLE books (
  id INT AUTO_INCREMENT PRIMARY KEY,
  title VARCHAR(255) NOT NULL,
  author VARCHAR(255),
  published_year INT
);

# exemple minimal avec Flask-MySQLdb (illustratif)
from flask import Flask
from flask_mysqldb import MySQL

app = Flask(__name__)
app.config['MYSQL_HOST'] = 'localhost'
app.config['MYSQL_USER'] = 'user'
app.config['MYSQL_PASSWORD'] = 'pass'
app.config['MYSQL_DB'] = 'catalogue'

mysql = MySQL(app)

@app.route('/books')
def list_books():
    cur = mysql.connection.cursor()
    cur.execute('SELECT id, title, author FROM books')
    rows = cur.fetchall()
    return jsonify([{'id': r[0], 'title': r[1], 'author': r[2]} for r in rows])

Exemple de routage (extrait)

from flask import Flask, request, jsonify

app = Flask(__name__)

@app.route('/books', methods=['GET', 'POST'])
def books():
    if request.method == 'GET':
        # retourner la liste des livres
        return jsonify({"books": []})
    # traitement POST pour créer un livre
    data = request.get_json()
    return jsonify(data), 201