VS CODE vers ti 83 premium ce python

[Gregorubank]

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

[Bisam]

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...

[Adriweb]

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.')

[Gregorubank]

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

[Adriweb]

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...

[Gregorubank]

j'ai 5.8.0

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

[Adriweb]

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...