Créer une API avec Flask et
renvoyer du JSON
1. HTML & CSS (le front-end)
•HTML (HyperText Markup Language) : c’est la forme de la page (titres, paragraphes, formulaires, bout
•CSS (Cascading Style Sheets) : le style (couleurs, polices, mise en page…)
HTML + CSS = ce que l’utilisateur voit et utilise
2. Flask (le back-end)
•C’est un framework Python qui sert à créer des applications web.
•Il reçoit des requêtes du navigateur ou de Postman, traite les données (par exemple : enregistrer
un utilisateur, afficher des infos…) et renvoie une réponse.
Flask = le cerveau qui traite les actions de l’utilisateur
3. Postman (outil de test d'API)
•C’est un outil utilisé pour tester les routes de ton API Flask sans passer par une vraie interface HTM
•Tu peux tester :
•GET → récupérer des données
•POST → envoyer des données
•PUT/PATCH → modifier des données
•DELETE → supprimer des données
Postman = comme un client sans interface graphique, parfait pour les tests
Récap:
Élément Rôle
HTML Affiche un formulaire
CSS Embellit le formulaire
Flask Gère l’envoi de ce formulaire
Postman Teste si le back-end fonctionne
Méthodes HTTP:
Flask supporte les méthodes HTTP standard telles que GET, POST, PUT, DELETE.
Par défaut, les routes sont associées à la méthode GET,
mais vous pouvez spécifier d'autres méthodes:
@[Link]('/submit', methods=['POST'])
def submit_form():
return "Formulaire soumis!"
Objectif de la séance
But
Créer une petite API en Flask
Renvoyer des données JSON
Comprendre la construction de
serveur back-end
# GET - Lire tous les utilisateurs
@[Link]('/utilisateurs',
methods=['GET'])
def get_utilisateurs():
return jsonify(utilisateurs)
# GET - Lire un seul utilisateur
@[Link]('/utilisateurs/<int:id>', methods=['GET'])
def get_utilisateur(id):
for utilisateur in utilisateurs:
if utilisateur['id'] == id:
return jsonify(utilisateur)
return jsonify({'message': 'Utilisateur non trouvé'}), 404
# POST - Créer un utilisateur
@[Link]('/utilisateurs', methods=['POST'])
def ajouter_utilisateur():
data = request.get_json()
nouveau = {
"id": utilisateurs[-1]['id'] + 1 if utilisateurs else 1,
"nom": data['nom'],
"email": data['email']
}
[Link](nouveau)
return jsonify(nouveau), 201
[-1] : en Python, cela permet d'accéder au dernier élément d'une liste. Si tu
veux accéder au dernier utilisateur dans la liste utilisateurs, tu utilises [-1].
# PUT - Remplacer un utilisateur
@[Link]('/utilisateurs/<int:id>', methods=['PUT'])
def remplacer_utilisateur(id):
data = request.get_json()
# Vérifie si les champs obligatoires sont présents
if 'nom' not in data or 'email' not in data:
return jsonify({'message': 'Les champs nom et email sont
requis'}), 400
for u in utilisateurs:
if u['id'] == id:
u['nom'] = data['nom']
u['email'] = data['email']
return jsonify(u)
return jsonify({'message': 'Utilisateur non trouvé'}), 404
# PATCH - Modifier un utilisateur
@[Link]('/utilisateurs/<int:id>', methods=[PATCH'])
def modifier_utilisateur(id):
data = request.get_json()
for u in utilisateurs:
if u['id'] == id:
u['nom'] = [Link]('nom', u['nom'])
u['email'] = [Link]('email', u['email'])
return jsonify(u)
return jsonify({'message': 'Utilisateur non trouvé'}), 404
Cela permet de ne modifier que les champs envoyés dans la requête.
# DELETE - Supprimer un utilisateur
@[Link]('/utilisateurs/<int:id>', methods=['DELETE'])
def supprimer_utilisateur(id):
global utilisateurs
utilisateurs = [u for u in utilisateurs if u['id'] != id]
return jsonify({'message': 'Utilisateur supprimé'}), 200
Sans global, Python croirait qu’on crée une nouvelle variable utilisateurs locale.
Après avoir arrêté le serveur ou l'application, les données
ajoutées ou modifiées ne seront plus présentes
Comment faire pour garder les utilisateurs même après
redémarrage ?
Solution 1 : Sauvegarder dans un fichier JSON
Si tu veux une solution simple pour débuter, tu peux enregistrer les utilisateurs dans un fichier .json
Quand tu démarres l'application, tu lis ce fichier, et quand tu ajoutes/supprimes un utilisateur,
tu mets à jour ce fichier.
Solution 2 : Utiliser une base de données
C’est la solution recommandée pour une vraie application.
Tu peux utiliser :SQLite (léger, parfait pour les tests),MySQL / PostgreSQL (plus robustes),
ou même une base NoSQL comme MongoDB.
# Fonction pour lire les données du fichier JSON
def read_data():
with open('[Link]', 'r') as f:
return [Link](f)
# Fonction pour écrire dans le fichier JSON
def write_data(data):
with open('[Link]', 'w') as f:
[Link](data, f, indent=4) # Fonction pour Récupérer la liste depuis le fichier
json
@[Link]('/products', methods=['GET'])
def get_products():
data = read_data()
return jsonify(data)
# Fonction pour ajouter un produit
@[Link]('/products', methods=['POST'])
def add_product():
new_product = request.get_json()
data = read_data()
if data:
new_id = max([Link]('id', 0) for product in
data) + 1
else:
new_id = 1
new_product['id'] = new_id
[Link](new_product)
write_data(data)
return jsonify(new_product), 201
En résumé
Flask + JSON Apps dynamiques Facile à apprendre
Mini-serveur intelligent Communication back-end & front- Base solide pour développeurs
end débutants