madamasterclass.com
-
Connexion
Connexion
Voici un tutoriel complet pour apprendre CherryPy, structuré en sections progressives
Dans ce tutoriel, nous allons apprendre à utiliser CherryPy pour développer des applications web. Nous aborderons les concepts de base, la création de routes, la gestion des requêtes et des réponses, ainsi que la mise en œuvre de fichiers statiques.
Pour commencer, assurez-vous d'avoir CherryPy installé. Ouvrez votre terminal et exécutez la commande suivante :
pip install CherryPy
Nous allons créer une application web simple. Créez un fichier nommé app.py et ajoutez le code suivant :
import cherrypy
class HelloWorld:
@cherrypy.expose
def index(self):
return "Bienvenue sur mon site !"
if __name__ == '__main__':
cherrypy.quickstart(HelloWorld())
Ce code définit une classe HelloWorld avec une méthode index qui retourne un message d'accueil. La méthode est exposée en tant que route par le décorateur @cherrypy.expose.
Pour démarrer votre application, exécutez le fichier app.py :
python app.py
Accédez à http://127.0.0.1:8080 dans votre navigateur pour voir le message.
Ajoutons une nouvelle route à notre application. Modifiez la classe HelloWorld pour inclure une méthode about :
@cherrypy.expose
def about(self):
return "À propos de cette application"
Vous pouvez maintenant accéder à cette nouvelle route via http://127.0.0.1:8080/about.
CherryPy permet également de gérer les paramètres de requête. Ajoutons une méthode greet qui prend un paramètre name :
@cherrypy.expose
def greet(self, name):
return f"Bonjour, {name}!"
Testez la méthode en accédant à http://127.0.0.1:8080/greet?name=VotreNom.
Pour servir des fichiers statiques, créez un dossier static et ajoutez un fichier HTML. Modifiez votre application pour le servir :
@cherrypy.expose
def index(self):
return cherrypy.lib.static.serve_file('static/index.html')
Accédez au fichier via http://127.0.0.1:8080/static/index.html.
Vous avez maintenant les bases pour créer une application web avec CherryPy. Ce tutoriel vous a montré comment créer des routes, gérer des paramètres et servir des fichiers statiques. Explorez davantage les fonctionnalités de CherryPy pour développer des applications plus complexes !
Dans cette activité, vous allez créer un site statique simple en utilisant le framework CherryPy. Vous apprendrez à servir des fichiers HTML, CSS et JavaScript, et à configurer votre application pour qu'elle affiche correctement les ressources statiques.
Avant de commencer, assurez-vous d'avoir CherryPy installé. Si ce n'est pas le cas, exécutez la commande suivante :
pip install CherryPy
Créez un dossier pour votre projet, par exemple mon_site_statique, et à l'intérieur, créez les sous-dossiers suivants :
Éducation
static : pour vos fichiers statiques (CSS, JS, images).templates : pour vos fichiers HTML.Dans le dossier templates, créez un fichier nommé index.html avec le contenu suivant :
<!DOCTYPE html>
<html lang="fr">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Mon Site Statique</title>
<link rel="stylesheet" href="/static/style.css">
</head>
<body>
<h1>Bienvenue sur mon site statique</h1>
<p>Ceci est un exemple de site utilisant CherryPy.</p>
</body>
</html>
Dans le dossier static, créez un fichier nommé style.css avec le contenu suivant :
body {
font-family: Arial, sans-serif;
background-color: #f0f0f0;
color: #333;
}
h1 {
color: #007bff;
}
Dans le dossier principal, créez un fichier nommé app.py et ajoutez le code suivant :
import cherrypy
class MonSite:
@cherrypy.expose
def index(self):
return open("templates/index.html")
if __name__ == '__main__':
cherrypy.quickstart(MonSite())
Pour démarrer le serveur, exécutez le fichier Python :
python app.py
Accédez à http://127.0.0.1:8080 dans votre navigateur pour voir votre site statique.
Vous avez maintenant créé un site statique simple avec CherryPy. Cette activité vous a permis de comprendre comment servir des fichiers HTML et CSS. Explorez davantage en ajoutant des fichiers JavaScript ou des images pour enrichir votre site !
Dans cette activité, vous allez créer un site dynamique avec CherryPy. Vous implémenterez une page de login et de signup, en utilisant une base de données SQLite pour stocker les informations des utilisateurs.
Avant de commencer, assurez-vous d'avoir CherryPy et SQLite installés. Si ce n'est pas le cas, exécutez la commande suivante :
pip install CherryPy
Créez un dossier pour votre projet, par exemple mon_site_dynamique, et à l'intérieur, créez les sous-dossiers suivants :
static : pour vos fichiers CSS et JavaScript.templates : pour vos fichiers HTML.Utilisez SQLite pour créer une base de données simple. Créez un fichier nommé database.py avec le contenu suivant :
import sqlite3
def init_db():
conn = sqlite3.connect('users.db')
c = conn.cursor()
c.execute('''CREATE TABLE IF NOT EXISTS users (
id INTEGER PRIMARY KEY AUTOINCREMENT,
username TEXT UNIQUE,
password TEXT
)''')
conn.commit()
conn.close()
if __name__ == '__main__':
init_db()
Dans le dossier templates, créez les fichiers suivants :
signup.html : pour la page de signup.login.html : pour la page de login.Voici le contenu de signup.html :
<!DOCTYPE html>
<html lang="fr">
<head>
<meta charset="UTF-8">
<title>Inscription</title>
</head>
<body>
<h1>Créer un compte</h1>
<form action="/signup" method="post">
<label for="username">Nom d'utilisateur:</label>
<input type="text" id="username" name="username" required>
<label for="password">Mot de passe:</label>
<input type="password" id="password" name="password" required>
<input type="submit" value="S'inscrire">
</form>
</body>
</html>
Et voici le contenu de login.html :
<!DOCTYPE html>
<html lang="fr">
<head>
<meta charset="UTF-8">
<title>Connexion</title>
</head>
<body>
<h1>Se connecter</h1>
<form action="/login" method="post">
<label for="username">Nom d'utilisateur:</label>
<input type="text" id="username" name="username" required>
<label for="password">Mot de passe:</label>
<input type="password" id="password" name="password" required>
<input type="submit" value="Se connecter">
</form>
</body>
</html>
Dans le dossier principal, créez un fichier nommé app.py et ajoutez le code suivant :
import cherrypy
import sqlite3
class MonSite:
@cherrypy.expose
def signup(self, username=None, password=None):
if username and password:
conn = sqlite3.connect('users.db')
c = conn.cursor()
c.execute('INSERT INTO users (username, password) VALUES (?, ?)', (username, password))
conn.commit()
conn.close()
return "Inscription réussie !"
return open("templates/signup.html")
@cherrypy.expose
def login(self, username=None, password=None):
if username and password:
conn = sqlite3.connect('users.db')
c = conn.cursor()
c.execute('SELECT * FROM users WHERE username=? AND password=?', (username, password))
user = c.fetchone()
conn.close()
if user:
return "Connexion réussie !"
return "Nom d'utilisateur ou mot de passe incorrect."
return open("templates/login.html")
if __name__ == '__main__':
cherrypy.quickstart(MonSite())
Avant de démarrer votre application, assurez-vous d'initialiser la base de données. Exécutez le fichier database.py :
python database.py
Pour démarrer le serveur, exécutez le fichier Python principal :
python app.py
Accédez à http://127.0.0.1:8080/signup pour vous inscrire et à http://127.0.0.1:8080/login pour vous connecter.
Vous avez maintenant créé un site dynamique avec CherryPy, comprenant des pages de login et de signup, ainsi qu'une base de données pour gérer les utilisateurs. Explorez davantage en ajoutant des fonctionnalités comme la réinitialisation de mot de passe ou l'authentification par session !
Dans ce cours, nous allons examiner en détail l'activité 2, où vous avez créé un site dynamique avec CherryPy, comprenant des pages de login et de signup, ainsi qu'une base de données SQLite pour gérer les utilisateurs. Nous allons décomposer chaque partie du code et expliquer son fonctionnement.
Avant de commencer, assurez-vous d'avoir installé CherryPy et SQLite. Ces outils sont essentiels pour le développement de votre application web dynamique.
La structure de votre projet se compose de :
static : pour les fichiers CSS et JavaScript.templates : pour les fichiers HTML (signup et login).Le fichier database.py initialise la base de données SQLite :
import sqlite3
def init_db():
conn = sqlite3.connect('users.db')
c = conn.cursor()
c.execute('''CREATE TABLE IF NOT EXISTS users (
id INTEGER PRIMARY KEY AUTOINCREMENT,
username TEXT UNIQUE,
password TEXT
)''')
conn.commit()
conn.close()
if __name__ == '__main__':
init_db()
Ce code crée une table users pour stocker les informations des utilisateurs (nom d'utilisateur et mot de passe). La clé primaire est id, qui s'incrémente automatiquement.
Les fichiers signup.html et login.html contiennent des formulaires pour l'inscription et la connexion :
Voici le contenu de signup.html :
<form action="/signup" method="post">
<label for="username">Nom d'utilisateur:</label>
<input type="text" id="username" name="username" required>
<label for="password">Mot de passe:</label>
<input type="password" id="password" name="password" required>
<input type="submit" value="S'inscrire">
</form>
Ce formulaire envoie les données au serveur via la méthode POST à l'URL /signup.
Et voici le contenu de login.html :
<form action="/login" method="post">
<label for="username">Nom d'utilisateur:</label>
<input type="text" id="username" name="username" required>
<label for="password">Mot de passe:</label>
<input type="password" id="password" name="password" required>
<input type="submit" value="Se connecter">
</form>
Similairement, ce formulaire envoie les données de connexion à l'URL /login.
Le fichier app.py contient la logique de l'application :
class MonSite:
@cherrypy.expose
def signup(self, username=None, password=None):
if username and password:
conn = sqlite3.connect('users.db')
c = conn.cursor()
c.execute('INSERT INTO users (username, password) VALUES (?, ?)', (username, password))
conn.commit()
conn.close()
return "Inscription réussie !"
return open("templates/signup.html")
@cherrypy.expose
def login(self, username=None, password=None):
if username and password:
conn = sqlite3.connect('users.db')
c = conn.cursor()
c.execute('SELECT * FROM users WHERE username=? AND password=?', (username, password))
user = c.fetchone()
conn.close()
if user:
return "Connexion réussie !"
return "Nom d'utilisateur ou mot de passe incorrect."
return open("templates/login.html")
Décomposons le code de la classe MonSite :
class MonSite:
Ici, nous définissons une classe MonSite qui contiendra toutes les méthodes pour gérer les routes de notre application.
@cherrypy.expose
def signup(self, username=None, password=None):
Le décorateur @cherrypy.expose rend cette méthode accessible en tant que route. Les paramètres username et password sont optionnels et seront remplis par les données du formulaire.
if username and password:
Nous vérifions si les deux paramètres ont été fournis. Si oui, nous procédons à l'inscription.
conn = sqlite3.connect('users.db')
Nous établissons une connexion à la base de données users.db.
c = conn.cursor()
Nous créons un curseur qui nous permettra d'exécuter des requêtes SQL.
c.execute('INSERT INTO users (username, password) VALUES (?, ?)', (username, password))
Nous insérons les données de l'utilisateur dans la table users. Les ? sont des espaces réservés pour éviter les injections SQL.
conn.commit()
Nous engageons la transaction pour que les modifications soient enregistrées dans la base de données.
conn.close()
Nous fermons la connexion à la base de données.
return "Inscription réussie !"
Nous retournons un message de succès à l'utilisateur.
return open("templates/signup.html")
Si les informations ne sont pas fournies, nous retournons le formulaire d'inscription.
@cherrypy.expose
def login(self, username=None, password=None):
Cette méthode fonctionne de manière similaire à signup, mais elle vérifie si l'utilisateur existe déjà.
if username and password:
Nous vérifions si les paramètres ont été fournis.
c.execute('SELECT * FROM users WHERE username=? AND password=?', (username, password))
Nous exécutons une requête pour vérifier si un utilisateur avec le nom d'utilisateur et le mot de passe fournis existe.
user = c.fetchone()
Nous récupérons le premier résultat de la requête.
if user:
Si l'utilisateur existe, nous retournons un message de succès :
return "Connexion réussie !"
Sinon, nous retournons un message d'erreur :
return "Nom d'utilisateur ou mot de passe incorrect."
Si les informations ne sont pas fournies, nous retournons le formulaire de connexion.
Pour démarrer votre application, utilisez la commande suivante :
python app.py
Vous avez maintenant une compréhension détaillée de la façon dont le site dynamique fonctionne avec CherryPy. Vous avez créé des pages de login et de signup et utilisé SQLite pour gérer les utilisateurs. Explorez davantage en ajoutant des fonctionnalités avancées, comme l'authentification par session ou la gestion des mots de passe !
Vous avez maintenant une compréhension détaillée de la façon dont le site dynamique fonctionne avec CherryPy. Vous avez créé des pages de login et de signup et utilisé SQLite pour gérer les utilisateurs. Explorez davantage en ajoutant des fonctionnalités avancées, comme l'authentification par session ou la gestion des mots de passe !
Abonnez-vous maintenant et recevez notre newsletter hebdomadaire avec des matériaux éducatifs, de nouveaux cours, des articles intéressants, des livres populaires et bien plus encore !
