Générateur de mots de passe en Python : tuto en 4 étapes

Dans ce tutoriel, tu vas créer un générateur de mots de passe en Python avec Tkinter : choisir la longueur, inclure ou non des majuscules, des chiffres et des caractères spéciaux, puis générer un mot de passe aléatoire en un clic. Un projet utile au quotidien pour pratiquer les fonctions, les modules random et string, et les interfaces graphiques.

Niveau : débutantDurée : ~45 minPython 3 · TkinterCode complet inclus

Générateur de mots de passe en Python avec Tkinter : fenêtre avec longueur, bouton Générer et résultat — Aperçu de l’application : longueur, bouton « Générer » et mot de passe obtenu

Sommaire

Ce que tu vas construire : un générateur de mots de passe en Python

Un bon mot de passe est long, imprévisible et mélange plusieurs types de caractères. Ton générateur de mots de passe en Python va s’en charger à ta place, selon tes critères :

📏 Longueur au choixSaisis la longueur voulue (4 caractères minimum).

☑️ OptionsInclure ou non majuscules, chiffres et caractères spéciaux.

🔐 Au moins un de chaqueChaque type de caractère choisi est garanti dans le résultat.

🖥️ Interface claireLe mot de passe s’affiche dans un champ prêt à copier.

Prérequis

Python 3 installé sur ton ordinateur
Tkinter, inclus par défaut avec Python
Un éditeur de code : VS Code, PyCharm ou IDLE
Les bases de Python : variables, fonctions et conditions

💡

Première interface Tkinter ?

Découvre les bases avec la calculatrice Python avec Tkinter.

Étape 1 : importer les bibliothèques

tkinter : pour créer l’interface graphique
random : pour tirer des caractères au hasard
string : pour obtenir facilement les lettres, chiffres et symboles

import tkinter as tk
from tkinter import messagebox
import random
import string

import tkinter as tk
from tkinter import messagebox
import random
import string

generateur_mdp.py

Étape 2 : écrire la fonction de génération

La fonction generer_mot_de_passe() est le cœur de ton générateur de mots de passe en Python. Elle fonctionne en quatre temps, comme dans tout bon générateur de mots de passe en Python :

Elle vérifie que la longueur saisie est un nombre valide d’au moins 4 caractères
Elle construit la liste des caractères autorisés selon les cases cochées
Elle ajoute au moins un caractère de chaque type choisi
Elle complète avec des caractères aléatoires, puis mélange le tout

def generer_mot_de_passe():
    try:
        # Récupérer la longueur saisie
        longueur = int(entry_longueur.get())
        if longueur < 4:
            messagebox.showwarning("Erreur", "La longueur minimale est de 4 caractères.")
            return

        # Vérifier les options sélectionnées
        inclure_majuscules = var_majuscules.get()
        inclure_chiffres = var_chiffres.get()
        inclure_speciaux = var_speciaux.get()

        # Définir les caractères disponibles
        caracteres = string.ascii_lowercase
        if inclure_majuscules:
            caracteres += string.ascii_uppercase
        if inclure_chiffres:
            caracteres += string.digits
        if inclure_speciaux:
            caracteres += string.punctuation

        # Générer le mot de passe
        mot_de_passe = []
        if inclure_majuscules:
            mot_de_passe.append(random.choice(string.ascii_uppercase))
        if inclure_chiffres:
            mot_de_passe.append(random.choice(string.digits))
        if inclure_speciaux:
            mot_de_passe.append(random.choice(string.punctuation))

        # Compléter avec des caractères aléatoires
        mot_de_passe += random.choices(caracteres, k=longueur - len(mot_de_passe))
        random.shuffle(mot_de_passe)
        mot_de_passe = ''.join(mot_de_passe)

        # Afficher le mot de passe
        entry_resultat.delete(0, tk.END)
        entry_resultat.insert(0, mot_de_passe)

    except ValueError:
        messagebox.showerror("Erreur", "Veuillez entrer une longueur valide.")

def generer_mot_de_passe():
    try:
        # Récupérer la longueur saisie
        longueur = int(entry_longueur.get())
        if longueur < 4:
            messagebox.showwarning("Erreur", "La longueur minimale est de 4 caractères.")
            return

        # Vérifier les options sélectionnées
        inclure_majuscules = var_majuscules.get()
        inclure_chiffres = var_chiffres.get()
        inclure_speciaux = var_speciaux.get()

        # Définir les caractères disponibles
        caracteres = string.ascii_lowercase
        if inclure_majuscules:
            caracteres += string.ascii_uppercase
        if inclure_chiffres:
            caracteres += string.digits
        if inclure_speciaux:
            caracteres += string.punctuation

        # Générer le mot de passe
        mot_de_passe = []
        if inclure_majuscules:
            mot_de_passe.append(random.choice(string.ascii_uppercase))
        if inclure_chiffres:
            mot_de_passe.append(random.choice(string.digits))
        if inclure_speciaux:
            mot_de_passe.append(random.choice(string.punctuation))

        # Compléter avec des caractères aléatoires
        mot_de_passe += random.choices(caracteres, k=longueur - len(mot_de_passe))
        random.shuffle(mot_de_passe)
        mot_de_passe = ''.join(mot_de_passe)

        # Afficher le mot de passe
        entry_resultat.delete(0, tk.END)
        entry_resultat.insert(0, mot_de_passe)

    except ValueError:
        messagebox.showerror("Erreur", "Veuillez entrer une longueur valide.")

generateur_mdp.py

Étape 3 : créer l’interface et assembler le programme

L’interface de ton générateur de mots de passe en Python comprend la fenêtre principale, un champ pour la longueur, trois cases à cocher pour les options et un champ pour afficher le résultat. Voici le programme complet, prêt à copier dans generateur_mdp.py :

import tkinter as tk
from tkinter import messagebox
import random
import string

def generer_mot_de_passe():
    """
    Génère un mot de passe aléatoire basé sur les options de l'utilisateur:
      - longueur spécifiée,
      - inclusion de majuscules, chiffres et caractères spéciaux.
    La fonction garantit qu'au moins un caractère de chaque catégorie sélectionnée est présent,
    puis complète le reste du mot de passe avec des caractères aléatoires tirés du pool total.
    """
    try:
        # Récupération et vérification de la longueur saisie
        longueur = int(entry_longueur.get())
        if longueur < 4:
            messagebox.showwarning("Erreur", "La longueur minimale est de 4 caractères.")
            return

        # Récupération des options sélectionnées
        inclure_majuscules = var_majuscules.get()
        inclure_chiffres = var_chiffres.get()
        inclure_speciaux = var_speciaux.get()

        # Définition du pool initial de caractères (toujours en minuscules)
        caracteres = string.ascii_lowercase
        
        # Ajout des autres types de caractères selon les choix
        if inclure_majuscules:
            caracteres += string.ascii_uppercase
        if inclure_chiffres:
            caracteres += string.digits
        if inclure_speciaux:
            caracteres += string.punctuation

        # Préparation de la liste pour garantir la présence d'au moins un caractère par catégorie choisie
        mot_de_passe = []
        if inclure_majuscules:
            mot_de_passe.append(random.choice(string.ascii_uppercase))
        if inclure_chiffres:
            mot_de_passe.append(random.choice(string.digits))
        if inclure_speciaux:
            mot_de_passe.append(random.choice(string.punctuation))
        
        # Vérification de la cohérence de la longueur demandée vs. le nombre minimum de caractères requis
        if longueur < len(mot_de_passe):
            messagebox.showwarning("Erreur", "La longueur est insuffisante pour inclure tous les types de caractères sélectionnés.")
            return

        # Ajout de caractères supplémentaires choisis aléatoirement dans le pool complet
        mot_de_passe += random.choices(caracteres, k=longueur - len(mot_de_passe))
        random.shuffle(mot_de_passe)  # Mélange pour éviter que les caractères imposés soient toujours en début
        mot_de_passe = ''.join(mot_de_passe)

        # Affichage du mot de passe généré dans le champ de résultat
        entry_resultat.delete(0, tk.END)
        entry_resultat.insert(0, mot_de_passe)

    except ValueError:
        messagebox.showerror("Erreur", "Veuillez entrer une longueur valide.")

# Création de la fenêtre principale
fenetre = tk.Tk()
fenetre.title("Générateur de mots de passe")
fenetre.geometry("450x350")
fenetre.resizable(False, False)

# Titre de l'application
titre_label = tk.Label(fenetre, text="Générateur de mots de passe", font=("Arial", 16, "bold"))
titre_label.pack(pady=10)

# Section pour saisir la longueur du mot de passe
frame_longueur = tk.Frame(fenetre)
frame_longueur.pack(pady=5)
tk.Label(frame_longueur, text="Longueur du mot de passe :", font=("Arial", 12)).pack(side=tk.LEFT)
entry_longueur = tk.Entry(frame_longueur, width=5, font=("Arial", 12))
entry_longueur.pack(side=tk.LEFT, padx=5)

# Section des options (cases à cocher)
frame_options = tk.Frame(fenetre)
frame_options.pack(pady=10)

var_majuscules = tk.BooleanVar()
var_chiffres = tk.BooleanVar()
var_speciaux = tk.BooleanVar()

tk.Checkbutton(frame_options, text="Inclure des majuscules", variable=var_majuscules, font=("Arial", 12)).pack(anchor="w")
tk.Checkbutton(frame_options, text="Inclure des chiffres", variable=var_chiffres, font=("Arial", 12)).pack(anchor="w")
tk.Checkbutton(frame_options, text="Inclure des caractères spéciaux", variable=var_speciaux, font=("Arial", 12)).pack(anchor="w")

# Bouton pour générer le mot de passe
tk.Button(fenetre, text="Générer", command=generer_mot_de_passe, font=("Arial", 12), bg="green", fg="white").pack(pady=10)

# Section pour afficher le résultat
frame_resultat = tk.Frame(fenetre)
frame_resultat.pack(pady=5)
tk.Label(frame_resultat, text="Mot de passe généré :", font=("Arial", 12)).pack(side=tk.LEFT)
entry_resultat = tk.Entry(frame_resultat, width=30, font=("Arial", 12))
entry_resultat.pack(side=tk.LEFT, padx=5)

# Lancement de la boucle principale de l'interface
fenetre.mainloop()

import tkinter as tk
from tkinter import messagebox
import random
import string

def generer_mot_de_passe():
    """
    Génère un mot de passe aléatoire basé sur les options de l'utilisateur:
      - longueur spécifiée,
      - inclusion de majuscules, chiffres et caractères spéciaux.
    La fonction garantit qu'au moins un caractère de chaque catégorie sélectionnée est présent,
    puis complète le reste du mot de passe avec des caractères aléatoires tirés du pool total.
    """
    try:
        # Récupération et vérification de la longueur saisie
        longueur = int(entry_longueur.get())
        if longueur < 4:
            messagebox.showwarning("Erreur", "La longueur minimale est de 4 caractères.")
            return

        # Récupération des options sélectionnées
        inclure_majuscules = var_majuscules.get()
        inclure_chiffres = var_chiffres.get()
        inclure_speciaux = var_speciaux.get()

        # Définition du pool initial de caractères (toujours en minuscules)
        caracteres = string.ascii_lowercase
        
        # Ajout des autres types de caractères selon les choix
        if inclure_majuscules:
            caracteres += string.ascii_uppercase
        if inclure_chiffres:
            caracteres += string.digits
        if inclure_speciaux:
            caracteres += string.punctuation

        # Préparation de la liste pour garantir la présence d'au moins un caractère par catégorie choisie
        mot_de_passe = []
        if inclure_majuscules:
            mot_de_passe.append(random.choice(string.ascii_uppercase))
        if inclure_chiffres:
            mot_de_passe.append(random.choice(string.digits))
        if inclure_speciaux:
            mot_de_passe.append(random.choice(string.punctuation))
        
        # Vérification de la cohérence de la longueur demandée vs. le nombre minimum de caractères requis
        if longueur < len(mot_de_passe):
            messagebox.showwarning("Erreur", "La longueur est insuffisante pour inclure tous les types de caractères sélectionnés.")
            return

        # Ajout de caractères supplémentaires choisis aléatoirement dans le pool complet
        mot_de_passe += random.choices(caracteres, k=longueur - len(mot_de_passe))
        random.shuffle(mot_de_passe)  # Mélange pour éviter que les caractères imposés soient toujours en début
        mot_de_passe = ''.join(mot_de_passe)

        # Affichage du mot de passe généré dans le champ de résultat
        entry_resultat.delete(0, tk.END)
        entry_resultat.insert(0, mot_de_passe)

    except ValueError:
        messagebox.showerror("Erreur", "Veuillez entrer une longueur valide.")

# Création de la fenêtre principale
fenetre = tk.Tk()
fenetre.title("Générateur de mots de passe")
fenetre.geometry("450x350")
fenetre.resizable(False, False)

# Titre de l'application
titre_label = tk.Label(fenetre, text="Générateur de mots de passe", font=("Arial", 16, "bold"))
titre_label.pack(pady=10)

# Section pour saisir la longueur du mot de passe
frame_longueur = tk.Frame(fenetre)
frame_longueur.pack(pady=5)
tk.Label(frame_longueur, text="Longueur du mot de passe :", font=("Arial", 12)).pack(side=tk.LEFT)
entry_longueur = tk.Entry(frame_longueur, width=5, font=("Arial", 12))
entry_longueur.pack(side=tk.LEFT, padx=5)

# Section des options (cases à cocher)
frame_options = tk.Frame(fenetre)
frame_options.pack(pady=10)

var_majuscules = tk.BooleanVar()
var_chiffres = tk.BooleanVar()
var_speciaux = tk.BooleanVar()

tk.Checkbutton(frame_options, text="Inclure des majuscules", variable=var_majuscules, font=("Arial", 12)).pack(anchor="w")
tk.Checkbutton(frame_options, text="Inclure des chiffres", variable=var_chiffres, font=("Arial", 12)).pack(anchor="w")
tk.Checkbutton(frame_options, text="Inclure des caractères spéciaux", variable=var_speciaux, font=("Arial", 12)).pack(anchor="w")

# Bouton pour générer le mot de passe
tk.Button(fenetre, text="Générer", command=generer_mot_de_passe, font=("Arial", 12), bg="green", fg="white").pack(pady=10)

# Section pour afficher le résultat
frame_resultat = tk.Frame(fenetre)
frame_resultat.pack(pady=5)
tk.Label(frame_resultat, text="Mot de passe généré :", font=("Arial", 12)).pack(side=tk.LEFT)
entry_resultat = tk.Entry(frame_resultat, width=30, font=("Arial", 12))
entry_resultat.pack(side=tk.LEFT, padx=5)

# Lancement de la boucle principale de l'interface
fenetre.mainloop()

generateur_mdp.py

Étape 4 : lancer le générateur de mots de passe en Python

Ouvre un terminal dans le dossier du projet et lance :

python generateur_mdp.py

python generateur_mdp.py

terminal

Aller plus loin : un générateur encore plus sûr

🔐

random n’est pas fait pour la sécurité

Le module random est parfait pour les jeux et les simulations, mais ses tirages sont prévisibles pour un attaquant. Pour de vrais mots de passe, Python recommande le module secrets, conçu pour la cryptographie.

Voici la fonction de ton générateur de mots de passe en Python réécrite avec secrets. Elle garantit aussi au moins une minuscule. Remplace l’ancienne fonction et ajoute import secrets en haut du fichier :

import secrets
import string

generateur = secrets.SystemRandom()


def generer_mot_de_passe():
    try:
        longueur = int(entry_longueur.get())
        if longueur < 4:
            messagebox.showwarning("Erreur", "La longueur minimale est de 4 caractères.")
            return

        caracteres = string.ascii_lowercase
        mot_de_passe = [secrets.choice(string.ascii_lowercase)]

        if var_majuscules.get():
            caracteres += string.ascii_uppercase
            mot_de_passe.append(secrets.choice(string.ascii_uppercase))
        if var_chiffres.get():
            caracteres += string.digits
            mot_de_passe.append(secrets.choice(string.digits))
        if var_speciaux.get():
            caracteres += string.punctuation
            mot_de_passe.append(secrets.choice(string.punctuation))

        while len(mot_de_passe) < longueur:
            mot_de_passe.append(secrets.choice(caracteres))

        generateur.shuffle(mot_de_passe)

        entry_resultat.delete(0, tk.END)
        entry_resultat.insert(0, ''.join(mot_de_passe))

    except ValueError:
        messagebox.showerror("Erreur", "Veuillez entrer une longueur valide.")

import secrets
import string

generateur = secrets.SystemRandom()


def generer_mot_de_passe():
    try:
        longueur = int(entry_longueur.get())
        if longueur < 4:
            messagebox.showwarning("Erreur", "La longueur minimale est de 4 caractères.")
            return

        caracteres = string.ascii_lowercase
        mot_de_passe = [secrets.choice(string.ascii_lowercase)]

        if var_majuscules.get():
            caracteres += string.ascii_uppercase
            mot_de_passe.append(secrets.choice(string.ascii_uppercase))
        if var_chiffres.get():
            caracteres += string.digits
            mot_de_passe.append(secrets.choice(string.digits))
        if var_speciaux.get():
            caracteres += string.punctuation
            mot_de_passe.append(secrets.choice(string.punctuation))

        while len(mot_de_passe) < longueur:
            mot_de_passe.append(secrets.choice(caracteres))

        generateur.shuffle(mot_de_passe)

        entry_resultat.delete(0, tk.END)
        entry_resultat.insert(0, ''.join(mot_de_passe))

    except ValueError:
        messagebox.showerror("Erreur", "Veuillez entrer une longueur valide.")

generateur_mdp.py

D’autres idées d’amélioration :

Ajouter un bouton « Copier » qui place le mot de passe dans le presse-papiers avec root.clipboard_append()
Afficher un indicateur de robustesse (faible, moyen, fort)
Exclure les caractères ambigus comme O, 0, l et 1
Découvrir d’autres projets Tkinter : le jeu de dames en Python ou la calculatrice graphique

FAQ : questions fréquentes

Quelle longueur choisir pour un mot de passe sûr ?

Vise au moins 12 à 16 caractères, en mélangeant majuscules, minuscules, chiffres et caractères spéciaux. Plus il est long, plus il est difficile à deviner.

Pourquoi utiliser secrets plutôt que random ?

Le module random est prévisible si l’on connaît son état interne. Le module secrets utilise une source d’aléatoire adaptée à la cryptographie : c’est celui qu’il faut pour les mots de passe.

Pourquoi la longueur minimale est-elle de 4 ?

Le programme garantit un caractère de chaque type choisi (jusqu’à quatre types). Une longueur inférieure ne permettrait pas de respecter toutes les options.

Mes mots de passe sont-ils enregistrés quelque part ?

Non. Ton générateur de mots de passe en Python fonctionne entièrement en local : le mot de passe est affiché uniquement dans la fenêtre. Rien n’est sauvegardé ni envoyé sur Internet.

Bravo, ton générateur de mots de passe en Python est prêt ! Pense à passer au module secrets pour un usage réel, et partage tes améliorations en commentaire.