readme.txt

Le programme se compose de 4 fichiers : 
- calculatrice.py    => correspond au programme à lancer
- calc_functions.py  => contient les fonctions appelées par le programme
- calc_label.py      => contient tous les libellés du programme
- logo.txt           => correspond au logo ascii affiché au lancement de l'application

La calculatrice permet d'effectuer les actions suivantes sur des entiers positifs et négatifs : 
- Addition d'un ensemble de nombres définis par l'utilisateur
- Soustraction d'un ensemble de nombres définis par l'utilisateur
- Multiplication d'un ensemble de nombres définis par l'utilisateur
- Division entre 2 nombres
- Modulo entre 2 nombres (en python le modulo prend toujours le signe du diviseur)
- Division entière entre 2 nombres
- Division euclidienne entre 2 nombres (au sens théorie des nombres avec un reste toujours positif)
- Puissance entre 2 nombres
- racine carré d'un nombre

calc_functions.py

import operator
from math import sqrt, fabs

from calc_label import *

##############################################################
##### Définition des couleurs possibles pour le terminal #####
##############################################################

COLORS = {
"red": "\033[31;1m",
"green":"\033[32m",
"white":"\033[37m",
"background-blue":"\033[44m",
"background-default":"\033[49m"
}

####################################
##### Définition des fonctions #####
####################################

# Fonction qui prend une chaine de caractère en entrée et remplace [[nom_couleur]] par le code couleur correspondant.
# renvoie une chaine de caractère formatée
def colorText(text):
    for color in COLORS:
        text = text.replace("[[" + color + "]]", COLORS[color])
    return text

# Fonction qui demande combien de nombres veut rentrer l'utilisateur
# renvoie un entier
def count_numbers():
    while True:
        try:
            numbers = int(input(how_many_numbers))             
            if numbers < 2:                                    # Pour faire une opération il faut au moins 2 nombres.
                print(colorText(how_many_numbers_warning))
            else:
                break
        except ValueError:                                     # on affiche un message d'erreur si l'entrée utilisateur ne peut pas être transformée en entier.
            print(colorText(int_nb_warning))
    print("\r")
    return(numbers) 

# Fonction qui demande à l'utilisateur de renseigner des nombres qui serviront à effectuer des opérations.
# Seuls des nombres entiers sont autorisés
# renvoie une liste de nombres 
def ask_numbers(nb):
    i = 0
    nombres = []
    while i < nb:
        try:
            nombres.append(int(input(number_asked.format(i+1,nb))))  
            i += 1
        except ValueError:
            print(colorText(int_nb_warning))
    return (nombres)

# Fonction principale comprenant toutes les fonctions de calculs.
# Certaines opérations couplées car il n'y a pas de spécificités de calcul.
# Renvoie une chaine de caractère formatée indiquant l'opération réalisée et le résultat.
def compute(numbers, func):
    # Addition / # Soustraction / # Multiplication
    if func in ("addition", "substract", "multiply"):
        result = numbers[0]
        i = 1
        while i < len(numbers):
            if func == "addition":
                result += numbers[i]
            elif func == "substract":
                result -= numbers[i]
            else:
                result *= numbers[i]
            i += 1
        return(eval(func + "_result").format(numbers, result))

    # Racine carrée
    elif func == "square_root":
        if numbers[0] >= 0:
            result = sqrt(numbers[0])
            return(square_root_result.format(numbers[0], result))
        else:
            return(square_root_negative_not_possible)

    # Division euclidienne au sens de la théorie des nombres (reste toujours positif)
    elif func == "euclidienne":
        i = 0
        quotient = 0
        dividende = numbers[0]
        diviseur = numbers[1]
        if diviseur == 0:
            return(divide_0_not_possible)
        
        else:
            while True:  # boucle qui permet d'itérer sur un multiple du diviseur jusqu'à avoir un reste tel que 0 <= reste < |quotient| et reste < |diviseur|
                i += diviseur
                if dividende > 0 and diviseur > 0:
                    quotient += 1
                    reste = dividende - i
                elif dividende > 0 and diviseur < 0:
                    quotient -= 1
                    reste = dividende + i
                elif dividende < 0 and diviseur > 0:
                    quotient -= 1
                    reste = dividende + i
                else:
                    quotient += 1
                    reste = dividende - i
                if reste >= 0 and reste < fabs(diviseur):
                    return(euclidienne_division_result.format(dividende, diviseur, quotient, reste))
    
    else:  # Division / Modulo / Division entière / Puissance
        try: 
            result = func(numbers[0], numbers[1]) # calcul de l'opération demandée, renvoi une erreur traitée dans le except si impossible.

            # Division
            if func == operator.truediv:
                if numbers[0] % numbers[1] == 0:  # dans le cas ou la division n'a pas de chiffre après la virgule on veut retourne un entier
                    result = int(result)
                return(divide_result.format(numbers[0], numbers[1], result))

            # Modulo
            if func == operator.mod:
                return(modulo_result.format(numbers[0], numbers[1], result))

            # Division entière
            if func == operator.floordiv:
                return(floor_division_result.format(numbers[0], numbers[1], result))

            # Puissance
            if func == operator.pow:
                return(pow_result.format(numbers[0], numbers[1], result))

        except ZeroDivisionError: # dans le cas où une division, un modulo ou division entière est demandée avec 0 comme diviseur
            return(divide_0_not_possible)

# Fonction demandant à l'utilisateur s'il veut continuer après la réalisation d'une opération
def ask_continue():
    while True:
        choice = input(colorText(ask_continue_question))
        if choice == 'o':
            print(colorText(operation_choice_list)) # On affiche de nouveau les opérations possibles
            break
        elif choice == 'n':
            exit()
        else:
            print(colorText(ask_continue_warning))

calc_label.py

attention = "\n[[red]]Attention : [[white]]Cette calculatrice ne fonctionne qu'avec des nombres entiers !"

operation_choice_list = """
[[green]]1 : [[white]]Pour une addition
[[green]]2 : [[white]]Pour une soustraction
[[green]]3 : [[white]]Pour une multiplication
[[green]]4 : [[white]]Pour une division
[[green]]5 : [[white]]Pour un modulo
[[green]]6 : [[white]]Pour une division entière
[[green]]7 : [[white]]Pour une division euclidienne
[[green]]8 : [[white]]Pour une puissance
[[green]]9 : [[white]]Pour une racine carrée

[[green]]q : [[red]]Quitter le programme[[white]]
"""
operation_choice = "[[green]]Votre choix d'opération: [[white]]"
addition_choice = "\n" + "[[background-blue]][[white]]" + " Addtition ".center(26, '-') + "[[white]][[background-default]]\n"
substract_choice = "\n" + "[[background-blue]][[white]]" + " Soustraction ".center(26, '-') + "[[white]][[background-default]]\n"
multiply_choice = "\n" + "[[background-blue]][[white]]" + " Multiplication ".center(26, '-') + "[[white]][[background-default]]\n"
divide_choice = "\n" + "[[background-blue]][[white]]" + " Division ".center(26, '-') + "[[white]][[background-default]]\n"
modulo_choice = "\n" + "[[background-blue]][[white]]" + " Modulo ".center(26, '-') + "[[white]][[background-default]]\n"
floor_division_choice = "\n" + "[[background-blue]][[white]]" + " Division entière ".center(26, '-') + "[[white]][[background-default]]\n"
euclidienne_division_choice = "\n" + "[[background-blue]][[white]]" + " Division euclidienne ".center(26, '-') + "[[white]][[background-default]]\n"
pow_choice = "\n" + "[[background-blue]][[white]]" + " Puissance ".center(26, '-') + "[[white]][[background-default]]\n"
square_root_choice = "\n" + "[[background-blue]][[white]]" + " Racine carrée ".center(26, '-') + "[[white]][[background-default]]\n"
warning_choice = "Ceci n'est pas un choix autorisé\n"
how_many_numbers = "Combien de nombres voulez-vous renseigner (2 minimum) ? : "
how_many_numbers_warning = "[[red]]L'opération nécessite au moins 2 nombres[[white]]"

number_asked = "Veuillez entrer un nombre ({}/{}) : "
int_nb_warning = "[[red]]Merci de renseigner un nombre entier[[white]]"

addition_result = "\nLe résultat de l'addition des nombres {} est égal à {}"
substract_result = "\nLe résultat de la soustraction des nombres {} est égal à {}"
multiply_result = "\nLe résultat de la multiplication des nombres {} est égal à {}"
divide_0_not_possible = "\nLa division par 0 n'est pas possible."
divide_result = "\nLe résultat de la division du nombre {} avec le nombre {} est égal à {}"
modulo_result = "\nLe modulo du nombre {} avec le nombre {} est égal à {}"
floor_division_result = "\nLe quotient de la division entière du nombre {} avec le nombre {} est égal à {}"
euclidienne_division_result = "\nLe résultat de la division euclidienne de {0} par {1} est :\nQuotient : {2}\nReste : {3}\n\nTel que {0} = {2} * {1} + {3}"
pow_result = "\nLa puissance du nombre {} avec le nombre {} est égale à {}"
square_root_result = "\nLa racine carrée du nombre {} est égal à {}"
square_root_negative_not_possible = "\nLa racine carrée d'un nombre négatif n'existe pas."

ask_continue_question = "\n[[green]]Continuer ? (o/n) [[white]]: "
ask_continue_warning = "[[red]]Le choix entré est incorrect"

calculatrice.py

import os

from calc_label import *
from calc_functions import *

os.system('cls') # on vide le terminal pour que les couleurs puissent être prises en compte

this_folder = os.path.dirname(os.path.abspath(__file__))
my_file = os.path.join(this_folder, 'logo.txt')
f = open(my_file, "r")
logo_text = "".join(f.readlines())

print(colorText(logo_text))
print(colorText(attention))
print(colorText(operation_choice_list))

while True:
    choice = input(colorText(operation_choice))   # Affichage de l'opération choisie

    # Choix addition
    if choice == "1":             
        print(colorText(addition_choice))         # On rappelle l'opération choisie
        nb_numbers = count_numbers()              # On demande à l'utilisateur combien de nombre il veut additionner
        list_numbers = ask_numbers(nb_numbers)     # On demande à l'utilisateur de renseigner les nombres souhaités (nombres de chiffres à renseigner en argument)
        print(compute(list_numbers, "addition"))       # on réalise l'opération
        ask_continue()                            # on demande s'il souhaite continuer des opérations ou quitter le programme

    # Choix soustraction
    elif choice == "2":
        print(colorText(substract_choice))
        nb_numbers = count_numbers()
        list_numbers = ask_numbers(nb_numbers)
        print(compute(list_numbers, "substract"))
        ask_continue() 

    # Choix multiplication
    elif choice == "3":
        print(colorText(multiply_choice))
        nb_numbers = count_numbers()
        list_numbers = ask_numbers(nb_numbers)
        print(compute(list_numbers, "multiply"))
        ask_continue() 

    # Choix division
    elif choice == "4":
        print(colorText(divide_choice))
        numbers = ask_numbers(2)
        print(compute(numbers, operator.truediv))
        ask_continue()

    # Choix modulo
    elif choice == "5":
        print(colorText(modulo_choice))
        numbers = ask_numbers(2)
        print(compute(numbers, operator.mod))
        ask_continue() 

    # Choix division entière
    elif choice == "6":
        print(colorText(floor_division_choice))
        numbers = ask_numbers(2)
        print(compute(numbers, operator.floordiv))
        ask_continue()
    
    # Choix division euclidienne
    elif choice == "7":
        print(colorText(euclidienne_division_choice))
        numbers = ask_numbers(2)
        print(compute(numbers, "euclidienne"))
        ask_continue() 

    # Choix puissance
    elif choice == "8":
        print(colorText(pow_choice))
        numbers = ask_numbers(2)
        print(compute(numbers, operator.pow))
        ask_continue() 

    # Choix racine carré
    elif choice == "9":
        print(colorText(square_root_choice))
        numbers = ask_numbers(1)
        print(compute(numbers, "square_root"))
        ask_continue() 

    # Choix quitter
    elif choice == "q":
        break
    
    # Choix non valide
    else:
        print(warning_choice)

logo.txt

[[green]]
    __                          __              __        __         _           
   / /   ____ _   _____ ____ _ / /_____ __  __ / /____ _ / /_ _____ (_)_____ ___ 
  / /   / __ `/  / ___// __ `// // ___// / / // // __ `// __// ___// // ___// _ \
 / /___/ /_/ /  / /__ / /_/ // // /__ / /_/ // // /_/ // /_ / /   / // /__ /  __/
/_____/\__,_/   \___/ \__,_//_/ \___/ \__,_//_/ \__,_/ \__//_/   /_/ \___/ \___/ 

Tu peux eviter de faire un ask_continue a chaque fois, tu peux aussi t'amuser a faire un dictionnaire pour tout les choix et jouer avec des getattr

Je me le note à tester. Merci

super boulot 👍

Ton travail m'inspire et tes explications sont claires. Bravo