Forum TI-Planet.org

Bonjour à tous,

J'ai un code qui fonctionne sur VS code mais qui ne peut être lu sur ma TI83 premium CE edition Python.

j'ai ce message :



le code est le suivant : quelqu'un peut me dépanner?

Code: Select all

# 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.")

Je pense que ton code est tout simplement trop gros !
Mon hypothèse est qu'il ne peut pas être chargé en mémoire de travail...

En effet, le MemoryError n'est pas bon signe...

Il se passe quoi si tu testes avec cette version minifiée du code (passage de 10204 octets a 3418 via ce site) ?

Code: Select all

A2='Décote : {} euros'
A1='Pas de plafonnement.'
A0='euros.'
z='Votre RNGI est de'
y='part(s)'
x='Vous avez {:.2f}'
w='Choix invalide. Veuillez saisir 1 pour valider ou 2 pour modifier.'
v='1 pour valider ou 2 pour modifier :'
u='Veuillez choisir 1 ou 2.'
t='Choisissez 1 ou 2 : '
s='2- Marié, Pacsé'
r='1- Célibataire, Séparé, Divorcé, Veuf'
q='Votre situation familiale :'
p='Entrée pour continuer'
i='Tranche immédiatement supérieure ='
h=True
g='Vous êtes'
f=max
Z='Tranche immédiatement inférieure ='
W='Marié, Pacsé'
U='Célibataire, Séparé, Divorcé, Veuf'
O='euros'
N=None
L='2'
J='1'
I=input
E='-------------------------------'
C=int
A=print
a=[(0,11294,0),(11294,28797,.11),(28797,82341,.3),(82341,177106,.41),(177106.,1e99,.45)]
b=11294
X=28797
Y=82341
c=177106
j=1769
AE=1930
AF=3172
P=873
Q=1444
def d(tmi,rngi,nombre_de_parts):
   A=tmi
   if A is not N:
      for(E,F,B)in a:
         if B==A:
            if A==.0:D=rngi*(a[0][2]/100)
            else:D=rngi*B-A3(A,nombre_de_parts)
            return C(D+.5)
def A3(tmi,nombre_de_parts):
   B=nombre_de_parts;A=tmi
   if A==.11:return 1242.34*B
   elif A==.3:return 6713.77*B
   elif A==.41:return 15771.28*B
   elif A==.45:return 25855.22*B
   else:return 0
A(E)
A('IR 2024 sur les revenus de 2023.')
A('--------------------------------')
I(p)
A(E)
A('IR avec application des effets du plafonnement du QF')
A('Sauf cas spécifiques : parents isolés; demie part guerre etc')
A('')
I(p)
A(E)
G=N
while G not in[J,L]:
   A(q);A('');A(r);A(s);A(E);G=I(t)
   if G not in[J,L]:A(u)
if G==J:D=U
elif G==L:D=W
A(g,D)
A(E)
while h:
   k=I(v)
   if k==J:A(E);break
   elif k==L:
      G=N
      while G not in[J,L]:
         A(q);A('');A(r);A(s);A(E);G=I(t)
         if G not in[J,L]:A(u)
      if G==J:D=U
      elif G==L:D=W
      A(g,D);A(E)
   else:A(w)
while h:
   B=I('Nombre de parts : ')
   if B.replace('.','',1).isdigit():
      B=float(B)
      if 0<=B<100 and B%.25==0:
         A(x.format(B),y);A(E);l=I('Appuyez sur 1 pour valider ou 2 pour modifier :')
         if l==J:A(E);break
         elif l==L:continue
         else:A(w)
      else:A('Le nombre de parts doit être positif, un multiple de 0.25, et limité à 2 chiffres après la virgule.')
   else:A('Saisie invalide. Veuillez saisir un nombre valide.')
while h:
   F=I('Saisissez le RNGI : ')
   if F.isdigit()and C(F)>=0:
      F=C(F);A(z,F,A0);A(E);A4=I(v)
      if A4==J:A(E);break
   else:A('Saisie invalide. ')
A('IR 2023 :')
A(E)
A(g,D)
A(x.format(B),y)
A(z,F,A0)
R=N
m=F/B
for(A5,A6,A7)in a:
   if m>=A5 and m<=A6:R=A7;break
if R is not N:A8=C(R*100);A('TMI : {}'.format(A8))
else:A("Tranche d'imposition inconnue")
K=d(R,F,B)
A('Impôt brut : {} euros'.format(K))
A9=round(K/F*100,2)
A("Pourcentage d'impôt : {}".format(A9))
AA=1
AB=d(R,F,AA)
AC=2
AD=d(R,F,AC)
if D==U:
   n=AB-2*(B-1)*j
   if n>K:S=C(n+.5);A('Impôts après plafonnement des effets du QF: {} euros'.format(S))
   else:S=K;A(A1)
else:S=K
if D==W:
   o=AD-2*(B-2)*j
   if o>K:T=C(o+.5);A('Impôts après plafonnement du QF : {} euros'.format(T))
   else:T=K;A(A1)
else:T=K
if D==U:P=f(0,P-.4525*S);P=min(P,S)
if D==W:Q=f(0,Q-.4525*T);Q=min(Q,T)
if D==U:A(A2.format(C(P+.5)))
if D==W:A(A2.format(C(Q+.5)))
e=S-P if D==U else T-Q
e=f(0,e)
A('Impôts après décote : {} euros'.format(C(e+.5)))
H=F/B
AG=N
AH=N
if H<b:A('Vous êtes dans la tranche minimale.')
elif b<=H<X:M=C((b-H)*B);V=C((X-H)*B);A(Z,M,O);A(i,V,O)
elif X<=H<Y:M=C((X-H)*B);V=C((Y-H)*B);A(Z,M,O);A(i,V,O)
elif Y<=H<c:M=C((Y-H)*B);V=C((c-H)*B);A(Z,M,O);A(i,V,O)
else:M=C((c-H)*B);A(Z,M,O);A('Vous êtes dans la tranche maximale.')

Merci déjà pour ce site !

mais j'ai toujours :



je me demande si j'ai toutes les mises a jours et les extensio Pour la TI

C'est surprenant.
La dernière version en date serait la 5.8.1. Tu as quoi ? Meme si a priori ca ne va pas changer ca...

j'ai 5.8.0

les codes fonctionnent nickel sur vs code, je ne comprends pas

Oui, normal, sur la calculatrice, il y a tres peu de memoire disponible. Cela dit, ca me semble deja court, donc je sais pas trop si on est vraiment deja (!) a la limite, ou s'il y a autre chose qui rentre en jeu...