VS CODE vers ti 83 premium ce python

[Gregorubank]

Bonjour à tous,

j'ai un code qui fonctionne parfaitememt dans VC code, mais lorsque je le lis avec la TI 83, celui-ci ne se lance pas et affiche un message d'erreur.
je pensais simplement faire un copié collé mais non.

pouvez vous m'expliquer ? je vous remercie

[Bisam]

Tu utilises probablement une bibliothèque qui n'est pas disponible sur la calculatrice.

Poste ton code ici... et on pourra te dire ce qui ne va pas.

[Gregorubank]

Code: Tout sélectionner

# Variables pour la décote
plafond_decote_celibataire = 882  # Plafond de décote pour célibataire
plafond_decote_couple = 1458  # Plafond de décote pour couple
print("")
# Fonction pour vérifier si une chaîne est composée de chiffres positifs sans virgule
def est_chiffres_positifs(s):
    return s.isdigit() and "-" not in s

# Fonction pour vérifier si une chaîne est composée de chiffres positifs avec une seule virgule
def est_nombre_parts_valide(s):
    return s.replace('.', '', 1).replace('-', '', 1).isdigit() and (float(s) >= 1 or s.endswith("0.25") or s.endswith("0.5") or s.endswith("0.75"))

# Fonction pour calculer le taux d'imposition en fonction des tranches d'imposition
def calculer_taux_imposition(revenu_par_part, tranches_imposition):
    for limite, taux in tranches_imposition:
        limite_parts = limite.split(" ")
        if len(limite_parts) == 3:
            limite_num = int(limite_parts[2].replace(" ", "").replace("€", "").replace(",", ""))
        elif len(limite_parts) == 6:
            limite_num = int(limite_parts[5].replace(" ", "").replace("€", "").replace(",", ""))
        else:
            continue
       
        if revenu_par_part <= limite_num:
            return float(taux.replace(" %", ""))
   
    return 0.45

plafond_coef_familial = 1758

tranches_imposition = [
    ("Jusqu'à 11 294 €", "0 %"),
    ("De 11 294 € à 28 797 €", "11 %"),
    ("De 28 797 € à 82 341 €", "30 %"),
    ("De 82 341 € à 177 106 €", "41 %"),
    ("Supérieur à 177 106 €", "45 %")
]

print("")
# Affichage "IR"
print("IR")


# Affichage "Barème applicable aux revenus de 2022."
print("Barème applicable en 2024 sur les revenus de 2023.")

print("")
# Demande à l'utilisateur d'appuyer sur la touche Entrée pour valider
input("Appuyez sur la touche Entrée pour valider...")

print("Impôt sur le revenu avec application du plafonnement du quotient familial")

print("")
# Demande à l'utilisateur d'appuyer sur la touche Entrée pour valider
input("Appuyez sur la touche Entrée pour valider...")

print("")
# Affichage des choix d'état civil
print("Choisissez votre état civil :")
print("1- Célibataire, Séparé, Divorcé, Veuf")
print("2- Marié, Pacsé")

# Saisie de l'état civil
while True:
    etat_civil = input("Saisissez le numéro correspondant à votre état civil (1 ou 2) : ")
    if etat_civil in ["1", "2"]:
        break
    else:
        print("Veuillez saisir un numéro valide (1 ou 2).")

# Traduction de l'état civil en texte
if etat_civil == "1":
    etat_civil_str = "Célibataire, Séparé, Divorcé, Veuf"
elif etat_civil == "2":
    etat_civil_str = "Marié, Pacsé"

# Affichage de l'état civil
print("Vous êtes :", etat_civil_str)

# Demande à l'utilisateur de valider ou de modifier l'état civil
while True:
    validation_etat_civil = input("Appuyez sur la touche Entrée pour valider ou sur 'm' pour modifier : ")
    if validation_etat_civil == "m":
        while True:
            etat_civil = input("Saisissez le numéro correspondant à votre état civil (1 ou 2) : ")
            if etat_civil in ["1", "2"]:
                break
            else:
                print("Veuillez saisir un numéro valide (1 ou 2).")
       
        if etat_civil == "1":
            etat_civil_str = "Célibataire, Séparé, Divorcé, Veuf"
        elif etat_civil == "2":
            etat_civil_str = "Marié, Pacsé"
       
        print("Vous êtes :", etat_civil_str)
    elif validation_etat_civil == "":
        break
   


print("")
# Affichage "Revenus 2022"
print("Revenus 2023")

# Saisie du Revenu Net Global Imposable (RNGI)
while True:
    rngi = input("Veuillez saisir votre Revenu Net Global Imposable : ")
   
    if est_chiffres_positifs(rngi):
        break
    else:
        print("Veuillez saisir un montant valide.")

# Formatage du RNGI avec un espace comme séparateur de milliers
formatted_rngi = '{:,.0f} €'.format(float(rngi)).replace(',', ' ')

print(f"Votre Revenu Net Global Imposable est de : {formatted_rngi}.")

# Demande à l'utilisateur de valider en appuyant sur Entrée ou de modifier en appuyant sur "m"
while True:
    validation_rngi = input("Appuyez sur la touche Entrée pour valider ou sur 'm' pour modifier : ")
    if validation_rngi == "m":
        while True:
            rngi = input("Veuillez saisir votre Revenu Net Global Imposable : ")
   
            if est_chiffres_positifs(rngi):
                break
            else:
                print("Veuillez saisir un montant valide.")
       
        # Formatage du RNGI avec un espace comme séparateur de milliers
        formatted_rngi = '{:,.0f} €'.format(float(rngi)).replace(',', ' ')

        print(f"Votre Revenu Net Global Imposable est de : {formatted_rngi}.")
    elif validation_rngi == "":
        break


print("")
# Saisie du nombre de parts
# Fonction pour vérifier si une chaîne est composée de chiffres positifs sans virgule
def est_chiffres_positifs(s):
    return s.isdigit() and "-" not in s

# Fonction pour vérifier si une chaîne est composée de chiffres positifs avec une seule virgule
def est_nombre_parts_valide(s):
    return s.replace('.', '', 1).replace('-', '', 1).isdigit() and (float(s) >= 1 or s.endswith("0.25") or s.endswith("0.5") or s.endswith("0.75"))

# Saisie du nombre de parts
while True:
    nombre_parts = input("Votre nombre de part(s) : ")
   
    if est_nombre_parts_valide(nombre_parts):
        # Vérifie si le nombre de parts est un chiffre multiple de 0.25
        if float(nombre_parts) % 0.25 == 0:
            break
        else:
            print("Le nombre de parts doit être un multiple de 0.25.")
    else:
        print("Veuillez saisir un nombre de parts valide.")
print(f"Votre nombre de part(s) est de {nombre_parts}.")
# Demande à l'utilisateur de valider en appuyant sur Entrée ou de modifier en appuyant sur "m"
while True:
    validation_nombre_parts = input("Appuyez sur la touche Entrée pour valider ou sur 'm' pour modifier : ")
    if validation_nombre_parts == "m":
        continue
    elif validation_nombre_parts == "":
        break


    # Sortir de la boucle externe si l'utilisateur a validé
    if validation_nombre_parts == "":
        break




# Conversion des saisies en nombres
rngi = float(rngi)
nombre_parts = float(nombre_parts)

# Calcul du revenu par part
revenu_par_part = rngi / nombre_parts

# Calcul du taux d'imposition en utilisant les tranches d'imposition
taux = calculer_taux_imposition(revenu_par_part, tranches_imposition)

# Calcul de l'impôt brut pour une part en utilisant les tranches d'imposition
if revenu_par_part <= 11294:
    impot_brut_pour_une_part = 0
elif 11294 < revenu_par_part <= 28797:
    impot_brut_pour_une_part = (revenu_par_part * 0.11) - 1242.34
elif 28797 < revenu_par_part <= 82341:
    impot_brut_pour_une_part = (revenu_par_part * 0.30) - 6713.77
elif 82341 < revenu_par_part <= 177106:
    impot_brut_pour_une_part = (revenu_par_part * 0.41) - 15771.28
else:
    impot_brut_pour_une_part = (revenu_par_part * 0.45) - 22855.52

# Calcul de l'impôt brut
impot_brut = impot_brut_pour_une_part * nombre_parts

# Calculez le revenu imposable par part
revenu_par_part = rngi / nombre_parts

# Déterminez la tranche d'imposition en fonction du revenu par part
if revenu_par_part <= 11294:
    tranche_imposition = tranches_imposition[0]
elif revenu_par_part <= 28797:
    tranche_imposition = tranches_imposition[1]
elif revenu_par_part <= 82341:
    tranche_imposition = tranches_imposition[2]
elif revenu_par_part <= 177106:
    tranche_imposition = tranches_imposition[3]
else:
    tranche_imposition = tranches_imposition[4]


# Calcul de la tranche d'imposition en fonction du RNGI par part et du nombre de parts
rngi_par_part = rngi / nombre_parts

if rngi_par_part < 11294:
    tranche = "0 %"
    baisse_rngi = "Vous êtes dans la tranche minimale"
elif 11294 <= rngi_par_part <= 28797:
    tranche = "11 %"
    baisse_rngi = int((rngi_par_part - 11294) * nombre_parts)
elif 28797 < rngi_par_part <= 82341:
    tranche = "30 %"
    baisse_rngi = int((rngi_par_part - 28797) * nombre_parts)
elif 82341 < rngi_par_part <= 177106:
    tranche = "41 %"
    baisse_rngi = int((rngi_par_part - 82341) * nombre_parts)
else:
    tranche = "45 %"
    baisse_rngi = int((rngi_par_part - 177106) * nombre_parts)


if isinstance(baisse_rngi, int):
    formatted_baisse_rngi = '{:,.0f} €'.format(baisse_rngi).replace(',', ' ')
else:
    formatted_baisse_rngi = baisse_rngi

# Calcul de la hausse de revenu nécessaire pour atteindre la tranche d'imposition supérieure
if 0 <= rngi_par_part <= 11294:
    hausse_rngi = int((11294 - rngi_par_part) * nombre_parts)
elif 11294 < rngi_par_part <= 28797:
    hausse_rngi = int((28797 - rngi_par_part) * nombre_parts)
elif 28797 < rngi_par_part <= 82341:
    hausse_rngi = int((82341 - rngi_par_part) * nombre_parts)
elif 82341 < rngi_par_part <= 177106:
    hausse_rngi = int((177106 - rngi_par_part) * nombre_parts)
else:
    hausse_rngi = "Vous êtes déjà dans la tranche maximale"

# Formatage de la hausse du RNGI en euros avec un espace comme séparateur de milliers
if isinstance(hausse_rngi, int):
    formatted_hausse_rngi = '{:,.0f} €'.format(hausse_rngi).replace(',', ' ')
else:
    formatted_hausse_rngi = hausse_rngi



# impot pour une part de qf
# Calcul de l'impôt brut pour une part en utilisant les tranches d'imposition
if rngi <= 11294:
    impot_brut_pour_une_part = 0
elif 11294 < rngi <= 28797:
    impot_brut_pour_une_part = (rngi * 0.11) - 1242.34
elif 28797 < rngi <= 82341:
    impot_brut_pour_une_part = (rngi * 0.30) - 6713.17
elif 82341 < rngi <= 177106:
    impot_brut_pour_une_part = (rngi * 0.41) - 15771.28
else:
    impot_brut_pour_une_part = (rngi * 0.45) - 22855.52

# Calcul de la déduction maximale due au plafonnement du quotient familial
deduction_maximale = ((nombre_parts - 1) * plafond_coef_familial)*2


# Calcul de l'impôt plafonné pour une part
impot_plafonne_pour_une_part = impot_brut_pour_une_part - deduction_maximale

# Calcul de l'impôt brut pour deux parts en utilisant les tranches d'imposition
if rngi <= 22588:
    impot_brut_pour_deux_parts = 0
elif 22588 < rngi <= 57594:
    impot_brut_pour_deux_parts = (rngi * 0.11) - 2484.68
elif 57594 < rngi <= 164682:
    impot_brut_pour_deux_parts = (rngi * 0.30) - 13426.34
elif 164682 < rngi <= 354214:
    impot_brut_pour_deux_parts = (rngi * 0.41) - 31542.56
else:
    impot_brut_pour_deux_parts = (rngi * 0.45) - 45711.04

# Calcul de la déduction maximale due au plafonnement du quotient familial pour deux parts
deduction_maximale_deux_parts = ((nombre_parts - 2) * plafond_coef_familial)*2

# Calcul de l'impôt plafonné pour deux parts
impot_plafonne_pour_deux_parts = impot_brut_pour_deux_parts - deduction_maximale_deux_parts

# Calcul de la décote pour un célibataire si IR à payer < 1840 €
if etat_civil == "1" and impot_brut < 1928 and impot_brut > 0:
    decote = plafond_decote_celibataire - (0.4525 * impot_brut)
    if decote > impot_brut:
        decote = impot_brut
else:
    decote = 0

# Calcul de la décote pour un couple si IR à payer < 3045 €
if etat_civil == "2" and impot_brut < 3191 and impot_brut > 0:
    decote = plafond_decote_couple - (0.4525 * impot_brut)
    if decote > impot_brut:
        decote = impot_brut

# Limiter la décote à l'impôt à payer
if decote > impot_brut:
    decote = impot_brut

# Arrondir la décote à l'entier le plus proche
decote_arrondie = round(decote)

# Formatage de la décote en euros avec un espace comme séparateur de milliers
formatted_decote = '{:,.0f} €'.format(decote_arrondie).replace(',', ' ')
print("")
print("-----------------------------------------------------------------------------")

# restitution finale :
print("Votre imposition de 2024 sur les revenus de 2023")
print("-----------------------------------------------------------------------------")
print(f"Votre Revenu Net Global Imposable est de : {formatted_rngi}.")
print(f"Votre nombre de part(s) est : {nombre_parts}")
print("Tranche Marginale d'imposition :", tranche_imposition[1])
taux_moyen_imposition = (impot_brut / rngi) * 100
formatted_impot_brut = '{:,.0f} €'.format(round(impot_brut)).replace(',', ' ')
print("Impôt avant plafonnement :", formatted_impot_brut)
if etat_civil == "1" and impot_brut > impot_plafonne_pour_une_part:  # Célibataire, Séparé, Divorcé, Veuf
    print("Pas d'effet du plafonnement du quotient familial.")
elif etat_civil == "2" and impot_brut > impot_plafonne_pour_deux_parts:  # Marié, Pacsé
    print("Pas d'effet du plafonnement du quotient familial.")
elif etat_civil == "1":  # Célibataire, Séparé, Divorcé, Veuf
    formatted_impot_plafonne_pour_une_part = '{:,.0f} €'.format(impot_plafonne_pour_une_part).replace(',', ' ')
    print("Impôt après plafonnement du quotient familial pour un célibataire :", formatted_impot_plafonne_pour_une_part)
elif etat_civil == "2":  # Marié, Pacsé
    formatted_impot_plafonne_pour_deux_parts = '{:,.0f} €'.format(impot_plafonne_pour_deux_parts).replace(',', ' ')
    print("Impôt après plafonnement du quotient familial pour un couple :", formatted_impot_plafonne_pour_deux_parts)
print("Décote :", formatted_decote)


formatted_taux_moyen_imposition = '{:.2f} %'.format(taux_moyen_imposition)


print("Taux moyen d'imposition :", formatted_taux_moyen_imposition)
print("Tranche Marginale d'imposition inférieure à :", formatted_baisse_rngi)
print("Tranche Marginale d'imposition supérieure à :", formatted_hausse_rngi)





# ...





[Bisam]

Je ne suis pas certain que le symbole de l'euro existe sur la calculatrice et je suis à peu près sûr que les f-strings ne sont pas prises en charge.

[Gregorubank]

Tu penses que cela peut bloquer le code.
Normalement je peux utiliser VS code pour créer et mettre dans la Ti?

[Bisam]

Oui, il y aura une erreur de syntaxe au niveau de la première f-string.
Il suffit de les remplacer par l'ancien formatage, comme utilisé dans les fonctions de la fin.

À part ça, le code est franchement améliorable.
En particulier, les fonctions calculant les tranches devraient utiliser un tableau de constantes et devraient être factorisées au lieu de repeter des bouts de code.

[Gregorubank]

Je te remercie pour tes conseils, je suis novice e python, j'apprends en autodidacte

[Gregorubank]

j'ai modifié le code, il passe nickel sur vs code mais pas sur la ti 83

Code: Tout sélectionner

# Constantes
tranches_imposition = [
    (0, 11294, 0),
    (11294, 28797, 0.11),
    (28797, 82341, 0.30),
    (82341, 177106, 0.41),
    (177106., 1E99, 0.45)
]

t1 = 11294
t2 = 28797
t3 = 82341
t4 = 177106

QF = 1769
#decote
plafond_impots_celibataire = 1930
plafond_impots_couple = 3172

decote_celibataire = 873
decote_couple = 1444

# Fonction pour calculer l'impôt brut
def calculer_impot_brut(tmi, rngi, nombre_de_parts):
    if tmi is not None:
        for limite_inf, limite_sup, pourcentage in tranches_imposition:
            if pourcentage == tmi:
                if tmi == 0.0:
                    impot_brut = rngi * (tranches_imposition[0][2] / 100)
                else:
                    impot_brut = rngi * (pourcentage) - (calculer_plafond(tmi, nombre_de_parts))
                return int(impot_brut + 0.5)

# Fonction pour calculer le plafond spécifique en fonction du TMI
def calculer_plafond(tmi, nombre_de_parts):
    if tmi == 0.11:
        return 1242.34 * nombre_de_parts
    elif tmi == 0.30:
        return 6713.77 * nombre_de_parts
    elif tmi == 0.41:
        return 15771.28 * nombre_de_parts
    elif tmi == 0.45:
        return 25855.22 * nombre_de_parts
    else:
        return 0

# Le reste du code
print("-------------------------------")
print("IR 2024 sur les revenus de 2023.")
print("--------------------------------")
input("Entrée pour continuer")
print("-------------------------------")
print("IR avec application des effets du plafonnement du QF")
print("Sauf cas spécifiques : parents isolés; demie part guerre etc")
print("")
input("Entrée pour continuer")
print("-------------------------------")

etat_civil = None

while etat_civil not in ["1", "2"]:
   
    print("Votre situation familiale :")
    print("")
    print("1- Célibataire, Séparé, Divorcé, Veuf")
    print("2- Marié, Pacsé")
    print("-------------------------------")
    etat_civil = input("Choisissez 1 ou 2 : ")

    if etat_civil not in ["1", "2"]:
        print("Veuillez choisir 1 ou 2.")

if etat_civil == "1":
    situation_familiale = "Célibataire, Séparé, Divorcé, Veuf"
elif etat_civil == "2":
    situation_familiale = "Marié, Pacsé"

print("Vous êtes", situation_familiale)
print("-------------------------------")

while True:
    validation = input("1 pour valider ou 2 pour modifier :")
   
    if validation == "1":
        print("-------------------------------")
       
        break  # Sort de la boucle de validation
   
    elif validation == "2":
        etat_civil = None
       
        while etat_civil not in ["1", "2"]:
            print("Votre situation familiale :")
            print("")
            print("1- Célibataire, Séparé, Divorcé, Veuf")
            print("2- Marié, Pacsé")
            print("-------------------------------")
            etat_civil = input("Choisissez 1 ou 2 : ")
   
            if etat_civil not in ["1", "2"]:
                print("Veuillez choisir 1 ou 2.")
   
        if etat_civil == "1":
            situation_familiale = "Célibataire, Séparé, Divorcé, Veuf"
        elif etat_civil == "2":
            situation_familiale = "Marié, Pacsé"
   
        print("Vous êtes", situation_familiale)
        print("-------------------------------")
   
    else:
        print("Choix invalide. Veuillez saisir 1 pour valider ou 2 pour modifier.")



# Demande du nombre de parts
while True:
    nombre_de_parts = input("Nombre de parts : ")

    if nombre_de_parts.replace(".", "", 1).isdigit():  # Vérification que l'entrée est un nombre
        nombre_de_parts = float(nombre_de_parts)

        # Vérification que le nombre de parts est positif et avec deux décimales
        if 0 <= nombre_de_parts < 100 and nombre_de_parts % 0.25 == 0:
            print("Vous avez {:.2f}".format(nombre_de_parts), "part(s)")
            print("-------------------------------")

            validation_parts = input("Appuyez sur 1 pour valider ou 2 pour modifier :")

            if validation_parts == "1":
                print("-------------------------------")
                break  # Sort de la boucle de validation du nombre de parts
            elif validation_parts == "2":
                continue  # Répéter la saisie du nombre de parts
            else:
                print("Choix invalide. Veuillez saisir 1 pour valider ou 2 pour modifier.")
        else:
            print("Le nombre de parts doit être positif, un multiple de 0.25, et limité à 2 chiffres après la virgule.")
    else:
        print("Saisie invalide. Veuillez saisir un nombre valide.")
       
while True:
    rngi = input("Saisissez le RNGI : ")
   
    # Vérification que l'entrée est un nombre positif
    if rngi.isdigit() and int(rngi) >= 0:
        rngi = int(rngi)
        print("Votre RNGI est de", rngi, "euros.")
        print("-------------------------------")
       
        validation_rngi = input("1 pour valider ou 2 pour modifier :")
       
        if validation_rngi == "1":
            print("-------------------------------")
            break  # Sort de la boucle de validation du RNGI
       
    else:
        print("Saisie invalide. ")

print("IR 2023 :")
print("-------------------------------")
print("Vous êtes", situation_familiale)
print("Vous avez {:.2f}".format(nombre_de_parts), "part(s)")
print("Votre RNGI est de", rngi, "euros.")

# Calculer la tranche d'imposition
tmi = None
rngi_par_part = rngi / nombre_de_parts  # Calcul du RNGI par part
for limite_inf, limite_sup, pourcentage in tranches_imposition:
    if rngi_par_part >= limite_inf and rngi_par_part <= limite_sup:
        tmi = pourcentage
        break

if tmi is not None:
    tmi_int = int(tmi * 100)  # Tranche d'impôts sans virgule
    print("TMI : {}".format(tmi_int))
else:
    print("Tranche d'imposition inconnue")

# Calculer l'impôt brut pour le nombre de parts renseigné par l'utilisateur
impot_brut = calculer_impot_brut(tmi, rngi, nombre_de_parts)
print("Impôt brut : {} euros".format(impot_brut))


# Calcul du pourcentage d'impôt
pourcentage_impot = round((impot_brut / rngi) * 100, 2)

print("Pourcentage d'impôt : {}".format(pourcentage_impot))

# Calculer l'impôt brut pour 1 part
nombre_de_parts_1 = 1
impot_brut_1_part = calculer_impot_brut(tmi, rngi, nombre_de_parts_1)


# Calculer l'impôt brut pour 2 parts
nombre_de_parts_2 = 2
impot_brut_2_parts = calculer_impot_brut(tmi, rngi, nombre_de_parts_2)


# Calculer le plafonnement des effets du quotient familial pour un célibataire
if situation_familiale == "Célibataire, Séparé, Divorcé, Veuf":
    plafonnement_celibataire = impot_brut_1_part - (2 * (nombre_de_parts - 1) * QF)
    if plafonnement_celibataire > impot_brut:
        impots_a_payer_celibataire = int(plafonnement_celibataire + 0.5)
        print("Impôts après plafonnement des effets du QF: {} euros".format(impots_a_payer_celibataire))
    else:
        impots_a_payer_celibataire = impot_brut
        print("Pas de plafonnement.")
else:
    impots_a_payer_celibataire = impot_brut

# Calculer le plafonnement des effets du quotient familial pour un couple
if situation_familiale == "Marié, Pacsé":
    plafonnement_couple = impot_brut_2_parts - (2 * (nombre_de_parts - 2) * QF)
    if plafonnement_couple > impot_brut:
        impots_a_payer_couple = int(plafonnement_couple + 0.5)
        print("Impôts après plafonnement du QF : {} euros".format(impots_a_payer_couple))
    else:
        impots_a_payer_couple = impot_brut
        print("Pas de plafonnement.")
else:
    impots_a_payer_couple = impot_brut

# Calcul de la décote pour un célibataire
if situation_familiale == "Célibataire, Séparé, Divorcé, Veuf":
    decote_celibataire = max(0, decote_celibataire - 0.4525 * impots_a_payer_celibataire)
    decote_celibataire = min(decote_celibataire, impots_a_payer_celibataire)  # Décote maximale

# Calcul de la décote pour un couple
if situation_familiale == "Marié, Pacsé":
    decote_couple = max(0, decote_couple - 0.4525 * impots_a_payer_couple)
    decote_couple = min(decote_couple, impots_a_payer_couple)  # Décote maximale

# Affichage de la décote pour un célibataire
if situation_familiale == "Célibataire, Séparé, Divorcé, Veuf":
    print("Décote : {} euros".format(int(decote_celibataire + 0.5)))

# Affichage de la décote pour un couple
if situation_familiale == "Marié, Pacsé":
    print("Décote : {} euros".format(int(decote_couple + 0.5)))

# Calcul de l'impôt après décote
impots_apres_decote = impots_a_payer_celibataire - decote_celibataire if situation_familiale == "Célibataire, Séparé, Divorcé, Veuf" else impots_a_payer_couple - decote_couple

# L'impôt après décote ne peut pas être négatif
impots_apres_decote = max(0, impots_apres_decote)

print("Impôts après décote : {} euros".format(int(impots_apres_decote + 0.5)))

# Montant du revenu actuel
revenu_par_part = rngi / nombre_de_parts

# Initialisation des tranches
tranche_inferieure = None
tranche_superieure = None



# Recherche de la tranche immédiatement inférieure
if revenu_par_part < t1:
    print("Vous êtes dans la tranche minimale.")
elif t1 <= revenu_par_part < t2:
    montant_inferieur = int((t1 - revenu_par_part) * nombre_de_parts)
    montant_superieur = int((t2 - revenu_par_part) * nombre_de_parts)
    print("Tranche immédiatement inférieure =", montant_inferieur, "euros")
    print("Tranche immédiatement supérieure =", montant_superieur, "euros")
elif t2 <= revenu_par_part < t3:
    montant_inferieur = int((t2 - revenu_par_part) * nombre_de_parts)
    montant_superieur = int((t3 - revenu_par_part) * nombre_de_parts)
    print("Tranche immédiatement inférieure =", montant_inferieur, "euros")
    print("Tranche immédiatement supérieure =", montant_superieur, "euros")
elif t3 <= revenu_par_part < t4:
    montant_inferieur = int((t3 - revenu_par_part) * nombre_de_parts)
    montant_superieur = int((t4 - revenu_par_part) * nombre_de_parts)
    print("Tranche immédiatement inférieure =", montant_inferieur, "euros")
    print("Tranche immédiatement supérieure =", montant_superieur, "euros")
else:
    montant_inferieur = int((t4 - revenu_par_part) * nombre_de_parts)
    print("Tranche immédiatement inférieure =", montant_inferieur, "euros")
    print("Vous êtes dans la tranche maximale.")


[Adriweb]

Je viens de tester, ca fonctionne chez moi.

En mettant des nombres "au hasard" :

[Gregorubank]

tu penses que cela peut provenir de quoi?