Nombres premiers en Python : programme complet en 3 étapes

Dans ce tutoriel, tu vas créer un programme de nombres premiers en Python : vérifier si un nombre est premier et afficher tous les nombres premiers jusqu’à une limite, avec un menu interactif dans le terminal et des résultats en couleur. Travailler sur les nombres premiers en Python est un exercice idéal pour maîtriser les boucles, les conditions, les fonctions et la gestion des erreurs.

Niveau : débutantDurée : ~30 minPython 3 · coloramaCode complet inclus

Sommaire

Ce que tu vas construire : un programme de nombres premiers en Python

Un nombre premier est un entier supérieur à 1 qui n’a que deux diviseurs : 1 et lui-même. Par exemple 2, 3, 5, 7, 11 ou 13. Ton programme de nombres premiers en Python saura les reconnaître et les lister.

✅ Vérifier un nombreIndique si le nombre saisi est premier ou non.

📋 Lister les premiersAffiche tous les nombres premiers jusqu’à une limite.

🧭 Menu interactifUn menu dans le terminal, jusqu’à ce que tu quittes.

🎨 Résultats colorésLes résultats s’affichent en jaune grâce à colorama.

Ce que tu vas apprendre

Boucles et conditions : répéter des actions et choisir le comportement selon les entrées
Fonctions : découper le code en blocs logiques et réutilisables
Interaction : lire les saisies de l’utilisateur avec input()
Gestion des erreurs : rendre le programme robuste avec try/except

Prérequis

Python 3 installé sur ton ordinateur
Un éditeur de code : VS Code, PyCharm ou IDLE
Le module colorama, pour les couleurs dans le terminal

Étape 1 : installer colorama

Le programme utilise colorama pour afficher des couleurs dans le terminal, y compris sous Windows. Installe-le avec pip :

pip install colorama

pip install colorama

terminal

💡

Bon réflexe

Installe tes modules dans un environnement dédié au projet. Suis le guide comment créer un environnement virtuel Python.

Étape 2 : le code complet

Crée un fichier nombres_premiers.py et copie ce code, qui contient toute la logique pour trouver les nombres premiers en Python :

import colorama
from colorama import Fore, Style

# Initialisation de colorama pour une utilisation multiplateforme des couleurs
colorama.init(autoreset=True)

def est_premier(nombre: int) -> bool:
    """
    Vérifie si un nombre est premier.
    
    Un nombre premier est un entier supérieur à 1 qui n'a que deux diviseurs :
    1 et lui-même.
    
    Paramètres :
        nombre (int) : Le nombre à vérifier.
    
    Retourne :
        bool : True si le nombre est premier, sinon False.
    """
    if nombre <= 1:
        return False
    for diviseur in range(2, int(nombre ** 0.5) + 1):
        if nombre % diviseur == 0:
            return False
    return True

def nombres_premiers_jusqua(limite: int) -> list:
    """
    Génère et retourne une liste de tous les nombres premiers entre 1 et une limite donnée.
    
    Paramètres :
        limite (int) : La limite supérieure pour la recherche des nombres premiers.
    
    Retourne :
        list : Une liste contenant tous les nombres premiers jusqu'à 'limite'.
    """
    liste_premiers = []
    for nombre in range(2, limite + 1):
        if est_premier(nombre):
            liste_premiers.append(nombre)
    return liste_premiers

def verifier_nombre_premier():
    """
    Demande à l'utilisateur d'entrer un nombre et affiche s'il est premier ou non.
    """
    try:
        nombre = int(input("Entrez un nombre pour vérifier s'il est premier : "))
        if est_premier(nombre):
            print(f"{Fore.YELLOW}{nombre} est un nombre premier.{Style.RESET_ALL}")
        else:
            print(f"{Fore.YELLOW}{nombre} n'est pas un nombre premier.{Style.RESET_ALL}")
    except ValueError:
        print("Entrée invalide. Veuillez entrer un nombre entier valide.")

def afficher_nombres_premiers():
    """
    Demande à l'utilisateur d'entrer une limite et affiche 
    tous les nombres premiers jusqu'à cette limite.
    """
    try:
        limite = int(input("Entrez une limite pour afficher tous les nombres premiers : "))
        if limite < 2:
            print("Il n'y a aucun nombre premier en dessous de 2.")
            return
        premiers = nombres_premiers_jusqua(limite)
        # Conversion de la liste en chaîne de caractères séparés par des virgules pour l'affichage
        premiers_str = ", ".join(str(p) for p in premiers)
        print(f"{Fore.YELLOW}Les nombres premiers entre 1 et {limite} sont : {premiers_str}{Style.RESET_ALL}")
    except ValueError:
        print("Entrée invalide. Veuillez entrer un nombre entier valide.")

def afficher_menu_principal():
    """
    Affiche le menu interactif et gère les choix de l'utilisateur.
    Le menu propose trois options :
      1. Vérifier si un nombre est premier
      2. Afficher tous les nombres premiers jusqu'à une limite
      3. Quitter l'application
    """
    while True:
        print("\n=== MENU PRINCIPAL ===")
        print("1. Vérifier si un nombre est premier")
        print("2. Afficher tous les nombres premiers jusqu'à une limite")
        print("3. Quitter")

        try:
            choix = int(input("Entrez votre choix : "))
            if choix == 1:
                verifier_nombre_premier()
            elif choix == 2:
                afficher_nombres_premiers()
            elif choix == 3:
                print(f"{Fore.YELLOW}Merci et à bientôt !{Style.RESET_ALL}")
                break
            else:
                print("Choix invalide. Veuillez entrer un numéro entre 1 et 3.")
        except ValueError:
            print("Entrée invalide. Veuillez entrer un numéro valide.")

def main():
    """
    Fonction principale qui démarre l'application.
    """
    afficher_menu_principal()

if __name__ == "__main__":
    main()

import colorama
from colorama import Fore, Style

# Initialisation de colorama pour une utilisation multiplateforme des couleurs
colorama.init(autoreset=True)

def est_premier(nombre: int) -> bool:
    """
    Vérifie si un nombre est premier.
    
    Un nombre premier est un entier supérieur à 1 qui n'a que deux diviseurs :
    1 et lui-même.
    
    Paramètres :
        nombre (int) : Le nombre à vérifier.
    
    Retourne :
        bool : True si le nombre est premier, sinon False.
    """
    if nombre <= 1:
        return False
    for diviseur in range(2, int(nombre ** 0.5) + 1):
        if nombre % diviseur == 0:
            return False
    return True

def nombres_premiers_jusqua(limite: int) -> list:
    """
    Génère et retourne une liste de tous les nombres premiers entre 1 et une limite donnée.
    
    Paramètres :
        limite (int) : La limite supérieure pour la recherche des nombres premiers.
    
    Retourne :
        list : Une liste contenant tous les nombres premiers jusqu'à 'limite'.
    """
    liste_premiers = []
    for nombre in range(2, limite + 1):
        if est_premier(nombre):
            liste_premiers.append(nombre)
    return liste_premiers

def verifier_nombre_premier():
    """
    Demande à l'utilisateur d'entrer un nombre et affiche s'il est premier ou non.
    """
    try:
        nombre = int(input("Entrez un nombre pour vérifier s'il est premier : "))
        if est_premier(nombre):
            print(f"{Fore.YELLOW}{nombre} est un nombre premier.{Style.RESET_ALL}")
        else:
            print(f"{Fore.YELLOW}{nombre} n'est pas un nombre premier.{Style.RESET_ALL}")
    except ValueError:
        print("Entrée invalide. Veuillez entrer un nombre entier valide.")

def afficher_nombres_premiers():
    """
    Demande à l'utilisateur d'entrer une limite et affiche 
    tous les nombres premiers jusqu'à cette limite.
    """
    try:
        limite = int(input("Entrez une limite pour afficher tous les nombres premiers : "))
        if limite < 2:
            print("Il n'y a aucun nombre premier en dessous de 2.")
            return
        premiers = nombres_premiers_jusqua(limite)
        # Conversion de la liste en chaîne de caractères séparés par des virgules pour l'affichage
        premiers_str = ", ".join(str(p) for p in premiers)
        print(f"{Fore.YELLOW}Les nombres premiers entre 1 et {limite} sont : {premiers_str}{Style.RESET_ALL}")
    except ValueError:
        print("Entrée invalide. Veuillez entrer un nombre entier valide.")

def afficher_menu_principal():
    """
    Affiche le menu interactif et gère les choix de l'utilisateur.
    Le menu propose trois options :
      1. Vérifier si un nombre est premier
      2. Afficher tous les nombres premiers jusqu'à une limite
      3. Quitter l'application
    """
    while True:
        print("\n=== MENU PRINCIPAL ===")
        print("1. Vérifier si un nombre est premier")
        print("2. Afficher tous les nombres premiers jusqu'à une limite")
        print("3. Quitter")

        try:
            choix = int(input("Entrez votre choix : "))
            if choix == 1:
                verifier_nombre_premier()
            elif choix == 2:
                afficher_nombres_premiers()
            elif choix == 3:
                print(f"{Fore.YELLOW}Merci et à bientôt !{Style.RESET_ALL}")
                break
            else:
                print("Choix invalide. Veuillez entrer un numéro entre 1 et 3.")
        except ValueError:
            print("Entrée invalide. Veuillez entrer un numéro valide.")

def main():
    """
    Fonction principale qui démarre l'application.
    """
    afficher_menu_principal()

if __name__ == "__main__":
    main()

nombres_premiers.py

Lance ensuite le programme depuis un terminal :

python nombres_premiers.py

python nombres_premiers.py

terminal

Étape 3 : comprendre le code des nombres premiers en Python

La fonction est_premier(nombre)

Si le nombre est inférieur ou égal à 1, il n’est pas premier : la fonction renvoie False
Sinon, elle cherche un diviseur entre 2 et la racine carrée du nombre
Si aucun diviseur n’est trouvé, le nombre est premier : elle renvoie True

Exemple : est_premier(7) renvoie True, tandis que est_premier(8) renvoie False car 8 est divisible par 2.

ℹ️

Pourquoi s’arrêter à la racine carrée ?

Si un nombre a un diviseur plus grand que sa racine carrée, il en a forcément un autre plus petit, déjà testé. Pour 100, inutile d’aller au-delà de 10 : le programme est beaucoup plus rapide.

La fonction nombres_premiers_jusqua(limite)

Elle parcourt tous les nombres de 2 jusqu’à la limite et ajoute à une liste ceux pour lesquels est_premier() renvoie True. Par exemple, nombres_premiers_jusqua(10) renvoie [2, 3, 5, 7].

Le menu principal

Une boucle while True affiche le menu jusqu’à ce que tu choisisses de quitter
Option 1 : tu saisis un nombre et le programme indique s’il est premier
Option 2 : tu saisis une limite et le programme affiche tous les nombres premiers jusqu’à elle
Option 3 : le programme affiche un message d’au revoir et s’arrête
En cas de saisie invalide (texte, mauvaise option), un message d’erreur s’affiche et le menu revient

Aller plus loin : le crible d’Ératosthène

Pour calculer des nombres premiers en Python jusqu’à une grande limite (un million par exemple), le crible d’Ératosthène est bien plus rapide que de tester chaque nombre un par un. Il raye progressivement tous les multiples :

def crible_eratosthene(limite):
    if limite < 2:
        return []

    est_premier = [True] * (limite + 1)
    est_premier[0] = est_premier[1] = False

    for i in range(2, int(limite ** 0.5) + 1):
        if est_premier[i]:
            for multiple in range(i * i, limite + 1, i):
                est_premier[multiple] = False

    return [n for n, premier in enumerate(est_premier) if premier]


print(crible_eratosthene(30))  # [2, 3, 5, 7, 11, 13, 17, 19, 23, 29]

def crible_eratosthene(limite):
    if limite < 2:
        return []

    est_premier = [True] * (limite + 1)
    est_premier[0] = est_premier[1] = False

    for i in range(2, int(limite ** 0.5) + 1):
        if est_premier[i]:
            for multiple in range(i * i, limite + 1, i):
                est_premier[multiple] = False

    return [n for n, premier in enumerate(est_premier) if premier]


print(crible_eratosthene(30))  # [2, 3, 5, 7, 11, 13, 17, 19, 23, 29]

crible.py

D’autres idées pour continuer :

Afficher la décomposition en facteurs premiers d’un nombre
Mesurer le temps d’exécution avec le module time pour comparer les deux méthodes
Enregistrer les résultats dans un fichier texte
Passer à une interface graphique, comme dans la calculatrice Python avec Tkinter ou le générateur de mots de passe avec Tkinter

FAQ : questions fréquentes

Le nombre 1 est-il un nombre premier ?

Non. Un nombre premier doit avoir exactement deux diviseurs distincts, 1 et lui-même. Le nombre 1 n’en a qu’un seul.

Pourquoi les couleurs ne s’affichent pas dans mon terminal ?

Vérifie que colorama est bien installé avec pip install colorama. Certains terminaux très anciens ne gèrent pas les couleurs ANSI.

Mon programme de nombres premiers en Python est lent avec de grandes limites, que faire ?

Utilise le crible d’Ératosthène présenté dans la section « Aller plus loin » : il calcule tous les nombres premiers jusqu’à un million en une fraction de seconde.

Que se passe-t-il si je tape du texte au lieu d’un nombre ?

Le programme intercepte l’erreur avec try/except, affiche un message et te redemande une saisie, sans planter.

Bravo, ton programme de nombres premiers en Python est terminé ! Tu maîtrises maintenant les boucles, les fonctions et la gestion des erreurs. Une question ? Laisse un commentaire ci-dessous.