8. Anwendungsaufgabe – Version 1
8.1. Das Problem
Anhand der obigen Tabelle lässt sich die Steuer im vereinfachten Fall eines Steuerpflichtigen berechnen, der lediglich sein Gehalt anzugeben hat. Wie in Anmerkung (1) angegeben, handelt es sich bei der so berechneten Steuer um die Steuer vor Berücksichtigung dreier Mechanismen:
- die Begrenzung des Familienquotienten, die bei hohen Einkommen zum Tragen kommt;
- dem Steuerabschlag und der Steuerermäßigung, die bei niedrigen Einkommen zum Tragen kommen;
Die Berechnung der Steuer umfasst somit die folgenden Schritte [http://impotsurlerevenu.org/comprendre-le-calcul-de-l-impot/1217-calcul-de-l-impot-2019.php]:
Wir wollen ein Programm schreiben, mit dem sich die Steuer eines Steuerpflichtigen im vereinfachten Fall berechnen lässt, in dem dieser lediglich sein Gehalt anzugeben hat:
8.1.1. Berechnung der Bruttosteuer
Die Bruttosteuer lässt sich wie folgt berechnen:
Zunächst wird die Anzahl der Anteile des Steuerpflichtigen berechnet:
- Jeder Elternteil bringt 1 Anteil mit;
- die ersten beiden Kinder bringen jeweils einen halben Anteil mit;
- die weiteren Kinder bringen jeweils einen Anteil mit:
Die Anzahl der Anteile beträgt somit:
- nbParts = 1 + nbEnfants * 0,5 + (AnzahlKinder – 2) * 0,5, wenn der Arbeitnehmer unverheiratet ist;
- AnzahlAnteile = 2 + AnzahlKinder * 0,5 + (AnzahlKinder – 2) * 0,5, wenn er verheiratet ist;
- wobei nbEnfants die Anzahl seiner Kinder ist;
- das zu versteuernde Einkommen R wird berechnet als R = 0,9 * S, wobei S das Jahresgehalt ist;
- man berechnet den Familienquotienten QF = R / nbParts;
- die Bruttosteuer I wird anhand der folgenden Daten (2019) berechnet:
9964 | 0 | 0 |
27519 | 0,14 | 1394,96 |
73779 | 0,3 | 5798 |
156.244 | 0,4 | 13.913,69 |
0 | 0,45 | 20163,45 |
Jede Zeile enthält drei Felder: champ1, champ2, champ3. Um die Steuer I zu berechnen, wird die erste Zeile gesucht, in der QF <= Feld 1 gilt, und man übernimmt die Werte dieser Zeile. Beispielsweise für einen verheirateten Arbeitnehmer mit zwei Kindern und einem Jahresgehalt S von 50.000 Euro:
Steuerpflichtiges Einkommen: R = 0,9 * S = 45.000
Anzahl der Anteile: nbParts = 2 + 2 * 0,5 = 3
Familienquotient: QF = 45.000 / 3 = 15.000
Die erste Zeile, in der QF <= Feld1 gilt, lautet wie folgt:
Die Steuer I beträgt somit 0,14*R – 1394,96*nbParts=[0,14*45000-1394,96*3]=2115. Die Steuer wird auf den nächsten ganzen Euro abgerundet.
Gilt bereits in der ersten Zeile die Bedingung QF <= Feld1, so beträgt die Steuer null.
Wenn QF so ist, dass die Bedingung QF <= Feld1 niemals erfüllt ist, dann werden die Koeffizienten der letzten Zeile verwendet. Hier:
was die Bruttosteuer I = 0,45 * R – 20163,45 * nbParts ergibt.
8.1.2. Obergrenze für den Familienquotienten
Um festzustellen, ob die Obergrenze für den Familienquotienten QF gilt, wird die Bruttosteuer erneut ohne die Kinder berechnet. Wiederum für den verheirateten Arbeitnehmer mit zwei Kindern und einem Jahresgehalt S von 50.000 Euro:
Steuerpflichtiges Einkommen: R = 0,9 * S = 45.000
Anzahl der Anteile: nbParts = 2 (die Kinder werden nicht mehr berücksichtigt)
Familienquotient: QF = 45.000 / 2 = 22.500
Die erste Zeile, in der QF <= Feld1 gilt, lautet wie folgt:
Die Steuer I beträgt somit 0,14*R – 1394,96*nbParts = [0,14*45000-1394,96*2] = 3510.
Maximaler Kinderfreibetrag: 1551 * 2 = 3102 Euro
Mindeststeuer: 3510 – 3102 = 408 Euro
Die bereits berechnete Bruttosteuer mit 3 Anteilen in Höhe von 2115 Euro liegt über der Mindeststeuer von 408 Euro, daher findet die Familienobergrenze hier keine Anwendung.
Im Allgemeinen gilt: Die Bruttosteuer ist größer als (Steuer1, Steuer2), wobei:
- [impôt1]: die mit den Kindern berechnete Bruttosteuer;
- [impôt2]: ist die Bruttosteuer, die ohne Kinder berechnet und um den maximalen Kinderfreibetrag (hier 1551 Euro pro Halbanteil) verringert wurde;
8.1.3. Berechnung des Steuerabschlags
Weiterhin für den verheirateten Arbeitnehmer mit zwei Kindern und einem Jahresgehalt S von 50.000 Euro:
Die aus dem vorherigen Schritt resultierende Bruttosteuer (2115) liegt unter 2627 Euro für ein Ehepaar (1595 Euro für einen Alleinstehenden): Der Steuerfreibetrag kommt daher zur Anwendung. Er ergibt sich aus folgender Berechnung:
Steuerermäßigung = Schwellenwert (Ehepaar = 1970 / Alleinstehender = 1196) – 0,75 * Bruttosteuer
Abschlag = 1970 – 0,75 × 2115 = 383,75, gerundet auf 384 Euro.
Neue Bruttosteuer = 2115 – 384 = 1731 Euro
8.1.4. Berechnung der Steuerermäßigung
Unterhalb einer bestimmten Schwelle wird eine Ermäßigung von 20 % auf die aus den vorangegangenen Berechnungen resultierende Bruttosteuer gewährt. Im Jahr 2019 gelten folgende Schwellenwerte:
- Alleinstehend: 21.037 Euro;
- Paar: 42.074 Euro; (die im obigen Beispiel verwendete Zahl 37.968 scheint falsch zu sein);
Dieser Schwellenwert wird um den Wert 3.797 * (Anzahl der durch die Kinder mitgebrachten halben Steueranteile) erhöht.
Beziehen wir uns weiterhin auf den verheirateten Arbeitnehmer mit zwei Kindern und einem Jahresgehalt S von 50.000 Euro:
- Sein zu versteuerndes Einkommen (45.000 Euro) liegt unter dem Schwellenwert (42.074 + 2 * 3.797) = 49.668 Euro;
- er hat daher Anspruch auf eine Ermäßigung seiner Steuer um 20 %: 1731 * 0,2 = 346,2 Euro, gerundet auf 347 Euro;
- die Bruttosteuer des Steuerpflichtigen beträgt somit: 1.731 – 347 = 1.384 Euro;
8.1.5. Berechnung der Nettosteuer
Unsere Berechnung endet hier: Die zu zahlende Nettosteuer beträgt 1384 Euro. In der Praxis kann der Steuerpflichtige weitere Ermäßigungen in Anspruch nehmen, insbesondere für Spenden an gemeinnützige oder öffentliche Einrichtungen.
8.1.6. Fallbeispiel: Hohe Einkommen
Unser vorangegangenes Beispiel entspricht den meisten Fällen von Arbeitnehmern. Bei hohen Einkommen sieht die Steuerberechnung jedoch anders aus.
8.1.6.1. Obergrenze für den 10-prozentigen Freibetrag auf das Jahreseinkommen
In den meisten Fällen ergibt sich das zu versteuernde Einkommen aus der Formel: R = 0,9 * S, wobei S das Jahresgehalt ist. Dies wird als 10-Prozent-Ermäßigung bezeichnet. Diese Ermäßigung ist begrenzt. Im Jahr 2019:
- darf sie nicht höher als 12.502 Euro sein;
- sie darf nicht unter 437 Euro liegen;
Nehmen wir den Fall eines unverheirateten Arbeitnehmers ohne Kinder mit einem Jahresgehalt von 200.000 Euro:
- Die 10-prozentige Kürzung beträgt 200.000 Euro > 12.502 Euro. Sie wird daher auf 12.502 Euro herabgesetzt;
8.1.6.2. Obergrenze des Familienquotienten
Nehmen wir einen Fall, in dem die im Abschnitt |Obergrenze des Familienquotienten| dargestellte Obergrenze zum Tragen kommt. Nehmen wir den Fall eines Paares mit drei Kindern und einem Jahreseinkommen von 100.000 Euro. Gehen wir die Berechnungsschritte noch einmal durch:
- Der Freibetrag von 10 % beträgt 10.000 Euro < 12.502 Euro. Das zu versteuernde Einkommen R beträgt somit 100.000 – 10.000 = 90.000 Euro;
- das Paar hat nbParts = 2 + 0,5 × 2 + 1 = 4 Anteile;
- sein Familienquotient beträgt somit QF = R / nbParts = 90.000 / 4 = 22.500 Euro;
- seine Bruttosteuer I1 mit Kindern beträgt I1 = 0,14 * 90.000 – 1.394,96 * 4 = 7.020 Euro;
- seine Bruttosteuer I2 ohne Kinder:
- QF = 90.000 / 2 = 45.000 Euro;
- I2 = 0,3 * 90.000 – 5.798 * 2 = 15.404 Euro;
- Die Regel zur Begrenzung des Familienquotienten besagt, dass der durch die Kinder erzielte Gewinn (1551 × 4 halbe Anteile) = 6204 Euro nicht überschreiten darf. Hier beträgt er jedoch I2-I1 = 15404 – 7020 = 8384 Euro und liegt somit über 6204 Euro;
- die Bruttosteuer wird daher neu berechnet als I3 = I2-6204 = 15.404 – 6.204 = 9.200 Euro;
Dieses Ehepaar erhält weder einen Steuerfreibetrag noch einen Steuerabzug, und seine endgültige Steuer beträgt 9200 Euro.
8.1.7. Offizielle Zahlen
Die Steuerberechnung ist komplex. Im gesamten Dokument werden die Berechnungen anhand der folgenden Beispiele durchgeführt. Die Ergebnisse stammen aus dem Simulator der Steuerbehörde |https://www3.impots.gouv.fr/simulateur/calcul_impot/2019/simplifie/index.htm|:
Steuerpflichtiger | Offizielle Ergebnisse | Ergebnisse des Algorithmus aus dem Dokument |
Paar mit 2 Kindern und einem Jahreseinkommen von 55.555 Euro | Steuer = 2815 Euro Steuersatz = 14 % | Steuer = 2814 Euro Steuersatz = 14 % |
Paar mit 2 Kindern und einem Jahreseinkommen von 50.000 Euro | Steuer = 1.385 Euro Steuerermäßigung = 720 Euro Ermäßigung = 0 Euro Steuersatz = 14 % | Steuer = 1.384 Euro Abzug = 384 Euro Ermäßigung = 347 Euro Steuersatz = 14 % |
Paar mit 3 Kindern und einem Jahreseinkommen von 50.000 Euro | Steuer = 0 Euro Abzug = 384 Euro Steuerermäßigung = 346 Euro Steuersatz = 14 % | Steuer = 0 Euro Abschlag = 720 Euro Abzug = 0 Euro Steuersatz = 14 % |
Alleinstehend mit 2 Kindern und einem Jahreseinkommen von 100.000 Euro | Steuer = 19.884 Euro Abzug = 0 Euro Steuerfreibetrag = 0 Euro Steuersatz = 41 % | Steuer = 19.884 Euro Zuschlag = 4.480 Euro Abschlag = 0 Euro Ermäßigung = 0 Euro Steuersatz = 41 % |
Alleinstehend mit 3 Kindern und einem Jahreseinkommen von 100.000 Euro | Steuer = 16.782 Euro Abzug = 0 Euro Steuerfreibetrag = 0 Euro Steuersatz = 41 % | Steuer = 16.782 Euro Zuschlag = 7.176 Euro Abschlag = 0 Euro Ermäßigung = 0 Euro Steuersatz = 41 % |
Ehepaar mit 3 Kindern und einem Jahreseinkommen von 100.000 Euro | Steuer = 9.200 Euro Abzug = 0 Euro Steuerermäßigung = 0 Euro Steuersatz = 30 % | Steuer = 9.200 Euro Zuschlag = 2.180 Euro Abschlag = 0 Euro Ermäßigung = 0 Euro Steuersatz = 30 % |
Paar mit 5 Kindern und einem Jahreseinkommen von 100.000 Euro | Steuer = 4.230 Euro Abzug = 0 Euro Steuerermäßigung = 0 Euro Steuersatz = 14 % | Steuer = 4.230 Euro Abschlag = 0 Euro Ermäßigung = 0 Euro Steuersatz = 14 % |
Alleinstehend, ohne Kinder und mit einem Jahreseinkommen von 100.000 Euro | Steuer = 22.986 Euro Abzug = 0 Euro Steuerfreibetrag = 0 Euro Steuersatz = 41 % | Steuer = 22.986 Euro Zuschlag = 0 Euro Abschlag = 0 Euro Ermäßigung = 0 Euro Steuersatz = 41 % |
Paar mit 2 Kindern und einem Jahreseinkommen von 30.000 Euro | Steuer = 0 Euro Abzug = 0 Euro Steuerermäßigung = 0 Euro Steuersatz = 0 % | Steuer = 0 Euro Abschlag = 0 Euro Ermäßigung = 0 Euro Steuersatz = 0 % |
Alleinstehend, ohne Kinder und mit einem Jahreseinkommen von 200.000 Euro | Steuer = 64.211 Euro Abzug = 0 Euro Steuerermäßigung = 0 Euro Steuersatz = 45 % | Steuer = 64.210 Euro Zuschlag = 7.498 Euro Abschlag = 0 Euro Ermäßigung = 0 Euro Steuersatz = 45 % |
Ehepaar mit 3 Kindern und einem Jahreseinkommen von 200.000 Euro | Steuer = 42.843 Euro Abzug = 0 Euro Steuerermäßigung = 0 Euro Steuersatz = 41 % | Steuer = 42.842 Euro Zuschlag = 17.283 Euro Abschlag = 0 Euro Ermäßigung = 0 Euro Steuersatz = 41 % |
Oben wird als Zuschlag bezeichnet, was Personen mit hohem Einkommen aufgrund zweier Faktoren zusätzlich zahlen:
- die Begrenzung des Freibetrags von 10 % auf das Jahreseinkommen;
- die Begrenzung des Familienquotienten;
Dieser Indikator konnte nicht überprüft werden, da er im Simulator der Steuerbehörde nicht angegeben ist.
Es zeigt sich, dass der Algorithmus des Dokuments jedes Mal eine korrekte Steuer angibt, allerdings mit einer Fehlermarge von 1 Euro. Diese Fehlermarge resultiert aus Rundungen. Alle Geldbeträge werden mal auf den nächsten höheren Euro, mal auf den nächsten niedrigeren Euro gerundet. Da mir die offiziellen Regeln nicht bekannt waren, wurden die Geldbeträge im Algorithmus des Dokuments wie folgt gerundet:
- bei Preisnachlässen und Rabatten auf den nächsten höheren Euro;
- auf den nächsten Euro nach unten bei Aufschlägen und der endgültigen Steuer;
Wir werden mehrere Versionen der Steuerberechnungs-App entwickeln.
8.2. Version 1
8.2.1. Das Hauptskript
Wir stellen ein erstes Programm vor, bei dem:
- die für die Steuerberechnung erforderlichen Daten fest im Code in Form von Listen und Konstanten hinterlegt sind;
- die Daten der Steuerzahler (verheiratet, Kinder, Gehalt) in einer ersten Textdatei [taxpayersdata.txt] gespeichert sind;
- die Ergebnisse der Steuerberechnung (verheiratet, Kinder, Gehalt, Steuer) in einer zweiten Textdatei [résultats.txt] gespeichert sind;
Das Skript [v-01/main.py] lautet wie folgt:
# Module
import sys
from impots.v01.shared.impôts_module_01 import *
# main -----------------------
# Konstanten
# Steuerzahlerdatei
DATA = "./data/taxpayersdata.txt"
# Ergebnisdatei
RESULTATS = "./data/résultats.txt"
try:
# Einlesen der Steuerpflichtigen-Daten
tax_payers = get_taxpayers_data(DATA)
# Ergebnisliste
results = []
# Berechnung der Steuer der Steuerzahler
for tax_payer in tax_payers:
# Die Steuerberechnung gibt ein Schlüsselwörterbuch zurück
# ['marié', 'enfants', 'salaire', 'impôt', 'surcôte', 'décôte', 'réduction', 'taux']
result = calcul_impôt(tax_payer['marié'], tax_payer['enfants'], tax_payer['salaire'])
# Das Wörterbuch wird zur Ergebnisliste hinzugefügt
results.append(result)
# Die Ergebnisse werden gespeichert
record_results(RESULTATS, results)
except BaseException as erreur:
# Es können verschiedene Fehler auftreten: fehlende Datei, falscher Dateiinhalt
# Der Fehler wird angezeigt und die Anwendung wird beendet
print(f"l'erreur suivante s'est produite : {erreur}]\n")
sys.exit()
Hinweise
- Zeile 4: Es wird das Modul [impots.v01.modules.impôts_module_01] verwendet. Zur Erinnerung: Dieser Pfad wird vom Stammverzeichnis des Projekts PyCharm aus gemessen;
- Zeile 10: Die Datei [data/taxpayersdata.txt] lautet wie folgt:
Jede Zeile stellt ein Tupel aus drei Elementen dar: [marié / pacsé ou pas, nombre d'enfants, salaire annuel en euros].
- Zeile 12: Die Datei, in der die Ergebnisse der Steuerberechnung für jeden Steuerpflichtigen aus der Datei [taxpayersdata.txt] gespeichert werden. Sie hat folgenden Inhalt:
- Zeile 16: Die in der Datei [taxpayersdata.txt] enthaltenen Steuerpflichtigen-Daten werden abgerufen. Es wird eine Liste von Schlüssel-Wörterbüchern [marié, enfants, salaire] abgerufen, wobei jedes Wörterbuch einen Steuerpflichtigen darstellt;
- Zeilen 17–25: Die Steuer der Steuerzahler aus der Liste [taxPayers] wird berechnet. Es wird eine Liste [results] abgerufen, deren jedes Element wiederum ein Schlüsselwörterbuch [marié, enfants, salaire, impôt, surcôte, décôte, réduction, taux] ist;
- Zeile 27: Die Ergebnisliste [results] wird in der Datei [résultats.txt] in der oben gezeigten Form gespeichert;
- Zeilen 28–32: Alle Ausnahmen, die aus dem Modul [impots.v01.modules.impôts_module_01] auftreten können, werden abgefangen;
Wir werden nun die drei Funktionen näher erläutern, die vom Skript [main] verwendet werden:
- [get_taxpayers_data]: zum Einlesen der Steuerpflichtigen-Daten;
- [calcul_impôt]: zur Berechnung der Steuer dieser Steuerzahler;
- [record_results]: zum Speichern der Ergebnisse in einer Textdatei;
Alle diese Funktionen befinden sich im Modul [impots.modules.impôts_module_01].
8.2.2. Das Modul [impots.v01.shared.impôts_module_01]
Die für die Steuerberechnung erforderlichen Funktionen wurden im Modul [impots.v01.shared.impôts_module_01] zusammengefasst:
- in [1]: Definition der Konstanten für die Steuerberechnung;
- in [2]: die Liste der Funktionen des Moduls;
8.2.3. Die Funktion [get_taxpayers_data]
Die Funktion [get_taxpayers_data] lautet wie folgt:
# Importe
import codecs
…
# Lesen der Steuerpflichtigen-Daten
# ----------------------------------------
def get_taxpayers_data(taxpayers_filename: str) -> list:
# Auslesen der Steuerzahlerdaten
file = None
try:
# Liste der Steuerzahler
taxpayers = []
# Öffnen der Datei
file = codecs.open(taxpayers_filename, "r", "utf8")
# Die erste Zeile der Steuerzahlerdatei wird gelesen
ligne = file.readline().strip()
# solange noch eine Zeile zu verarbeiten ist
while ligne != '':
# werden die drei Felder „verheiratet“, „Kinder“ und „Gehalt“ abgerufen, aus denen die Zeile besteht
(marié, enfants, salaire) = ligne.split(",")
# sie werden zur Liste der Steuerzahler hinzugefügt
taxpayers.append({'marié': marié.strip().lower(), 'enfants': int(enfants), 'salaire': int(salaire)})
# Es wird eine neue Zeile aus der Steuerzahlerdatei gelesen
ligne = file.readline().strip()
# Das Ergebnis wird ausgegeben
return taxpayers
finally:
# Die Datei wird geschlossen, falls sie geöffnet war
if file:
file.close()
Anmerkungen
- Zeile 7: [taxpayers_filename] ist der Name der zu verarbeitenden Datei. Die Funktion gibt eine Liste zurück;
- Zeilen 18–24: Die Schleife zur Verarbeitung der Zeilen [marié, enfants, salaire] aus der Textdatei;
- Zeile 20: Die drei Elemente der Zeile werden abgerufen. Dabei wird davon ausgegangen, dass die Zeile syntaktisch korrekt ist, d. h., dass sie tatsächlich die drei erwarteten Elemente enthält;
- Zeile 22: Es wird ein Wörterbuch mit den Schlüsseln [marié, enfants, salaire] erstellt, und dieses Wörterbuch wird der Liste [taxPayers] hinzugefügt;
- Zeile 26: Sobald die Datei verarbeitet ist, wird die Liste „[taxPayers]“ zurückgegeben;
- Zeilen 10–30: Es ist zu beachten, dass in Zeile 10 keine Klausel [catch] zu [try] hinzugefügt wurde. Die Klausel [catch] ist nicht zwingend erforderlich. In Zeile 27 wurde eine Klausel [finally] eingefügt, um die Textdatei in jedem Fall zu schließen, unabhängig davon, ob ein Fehler vorliegt oder nicht;
- diese try/finally-Struktur lässt eine mögliche Ausnahme durch (es gibt kein catch). Diese Ausnahme wird an das Hauptskript [main] weitergeleitet, das daraufhin beendet wird und die Ausnahme anzeigt (siehe Abschnitt |Das Hauptskript|). Dieser Mechanismus wurde für die meisten Funktionen des Moduls verwendet;
8.2.4. Die Funktion [calcul_impôt]
Die Funktion [calcul_impôt] lautet wie folgt:
# Importe
import codecs
import math
# Steuerklassen für das Jahr 2019
limites = [9964, 27519, 73779, 156244, 0]
coeffr = [0, 0.14, 0.3, 0.41, 0.45]
coeffn = [0, 1394.96, 5798, 13913.69, 20163.45]
# Konstanten für die Steuerberechnung 2019
PLAFOND_QF_DEMI_PART = 1551
PLAFOND_REVENUS_CELIBATAIRE_POUR_REDUCTION = 21037
PLAFOND_REVENUS_COUPLE_POUR_REDUCTION = 42074
VALEUR_REDUC_DEMI_PART = 3797
PLAFOND_DECOTE_CELIBATAIRE = 1196
PLAFOND_DECOTE_COUPLE = 1970
PLAFOND_IMPOT_COUPLE_POUR_DECOTE = 2627
PLAFOND_IMPOT_CELIBATAIRE_POUR_DECOTE = 1595
ABATTEMENT_DIXPOURCENT_MAX = 12502
ABATTEMENT_DIXPOURCENT_MIN = 437
…
# Steuerberechnung
# ----------------------------------------
def calcul_impôt(marié: str, enfants: int, salaire: int) -> dict:
# verheiratet: ja, nein
# Kinder: Anzahl der Kinder
# Gehalt: Jahresgehalt
# Grenzwerte, Koeffizient a, Koeffizient b: Datentabellen zur Steuerberechnung
#
# Steuerberechnung mit Kindern
result1 = calcul_impôt_2(marié, enfants, salaire)
impot1 = result1["impôt"]
# Steuerberechnung ohne Kinder
if enfants != 0:
result2 = calcul_impôt_2(marié, 0, salaire)
impot2 = result2["impôt"]
# Anwendung der Obergrenze für den Familienquotienten
if enfants < 3:
# PLAFOND_QF_DEMI_PART Euro für die ersten beiden Kinder
impot2 = impot2 - enfants * PLAFOND_QF_DEMI_PART
else:
# PLAFOND_QF_DEMI_PART Euro für die ersten beiden Kinder, das Doppelte für die folgenden
impot2 = impot2 - 2 * PLAFOND_QF_DEMI_PART - (enfants - 2) * 2 * PLAFOND_QF_DEMI_PART
else:
impot2 = impot1
result2 = result1
# Es gilt der höchste Steuersatz mit dem dazugehörigen Steuersatz und dem entsprechenden Zuschlag
if impot1 > impot2:
impot = impot1
taux = result1["taux"]
surcôte = result1["surcôte"]
else:
surcôte = impot2 - impot1 + result2["surcôte"]
impot = impot2
taux = result2["taux"]
# Berechnung eines eventuellen Steuerabzugs
décôte = get_décôte(marié, salaire, impot)
impot -= décôte
# Berechnung einer möglichen Steuerermäßigung
réduction = get_réduction(marié, salaire, enfants, impot)
impot -= réduction
# Ergebnis
return {"marié": marié, "enfants": enfants, "salaire": salaire, "impôt": math.floor(impot), "surcôte": surcôte,
"décôte": décôte, "réduction": réduction, "taux": taux}
Anmerkungen
- Zeilen 6–8: die Steuerklassen (siehe Abschnitt |Berechnung der Bruttosteuer|);
- Zeilen 11–20: die Konstanten für die Steuerberechnung;
- Es ist zu beachten, dass die in den Zeilen 5–20 initialisierten Elemente für die Funktionen, die wir beschreiben werden, global sind. Sie sind daher bekannt, solange die Funktion, die sie verwendet, keine Variablen mit denselben Namen deklariert;
- Die Zahlen in den Zeilen 5–20 ändern sich jedes Jahr. Hier handelt es sich um die Zahlen für 2019;
- Zeile 25: Die Funktion [calcul_impôt] erhält drei Parameter:
- [marié]: ja/nein, gibt an, ob der Steuerpflichtige verheiratet ist oder in einer eingetragenen Lebenspartnerschaft lebt;
- [enfants]: die Anzahl seiner Kinder;
- [salaire]: sein Jahresgehalt in Euro;
- Zeilen 31–33: Berechnung der Steuer unter Berücksichtigung der Kinder;
- Zeilen 34–47: Diese Zeilen dienen der Umsetzung der Obergrenze für den Familienquotienten (siehe Abschnitt |Obergrenze für den Familienquotienten|);
- Zeilen 49–57: Diese Zeilen berechnen den Steuersatz des Steuerpflichtigen sowie einen eventuellen Aufschlag (siehe Abschnitt |Fälle mit hohem Einkommen|);
- Zeilen 59–61: Berechnung eines eventuellen Steuerabzugs (siehe Abschnitt |Berechnung des Steuerabzugs|);
- Zeilen 62–64: Berechnung einer eventuellen Ermäßigung der zu zahlenden Steuer (siehe Abschnitt |Berechnung der Steuerermäßigung|);
Der Algorithmus ist recht komplex, weshalb wir nicht über die in den Kommentaren enthaltenen Angaben hinausgehen werden. Der Algorithmus implementiert die im Abschnitt |Das Problem| beschriebene Methode zur Steuerberechnung.
8.2.5. Die Funktion [calcul_impôt_2]
Die Funktion [calcul_impôt] ruft die folgende Funktion [calcul_impôt_2] auf:
def calcul_impôt_2(marié: str, enfants: int, salaire: int) -> list:
# verheiratet: ja, nein
# Kinder: Anzahl der Kinder
# Gehalt: Jahresgehalt
# Grenzen, Koeffizient, Koeffizient: die Datentabellen zur Berechnung der Steuer
#
# Anzahl der Anteile
marié = marié.strip().lower()
if marié == "oui":
nb_parts = enfants / 2 + 2
else:
nb_parts = enfants / 2 + 1
# 1 Anteil pro Kind ab dem dritten
if enfants >= 3:
# ein halber Anteil zusätzlich für jedes Kind ab dem dritten
nb_parts += 0.5 * (enfants - 2)
# steuerpflichtiges Einkommen
revenu_imposable = get_revenu_imposable(salaire)
# Zuschlag
surcôte = math.floor(revenu_imposable - 0.9 * salaire)
# für Rundungsprobleme
if surcôte < 0:
surcôte = 0
# Familienquotient
quotient = revenu_imposable / nb_parts
# wird am Ende der Grenzwertetabelle eingefügt, um die nachfolgende Schleife zu beenden
limites[len(limites) - 1] = quotient
# Steuerberechnung
i = 0
while quotient > limites[i]:
i += 1
# Da der Familienquotient am Ende des Grenzwert-Arrays platziert wurde, wird die vorherige Schleife
# kann nicht über die Grenzen des Grenzwert-Arrays hinausgehen
# Nun kann die Steuer berechnet werden
impôt = math.floor(revenu_imposable * coeffr[i] - nb_parts * coeffn[i])
# Ergebnis
return {"impôt": impôt, "surcôte": surcôte, "taux": coeffr[i]}
Dieser Algorithmus wurde in Abschnitt 8.1.1 beschrieben.
8.2.6. Die Funktion [get_décôte]
Die Funktion [get_décôte] implementiert die Berechnung eines eventuellen Steuerabschlags (Abschnitt |Berechnung des Steuerabschlags|):
# berechnet einen eventuellen Abschlag
def get_décôte(marié: str, salaire: int, impots: int) -> int:
# Anfangswert des Abschlags: Null
décôte = 0
# Höchststeuerbetrag für den Steuerabzug
plafond_impôt_pour_décôte = PLAFOND_IMPOT_COUPLE_POUR_DECOTE if marié == "oui" else PLAFOND_IMPOT_CELIBATAIRE_POUR_DECOTE
if impots < plafond_impôt_pour_décôte:
# Höchstbetrag des Abschlags
plafond_décôte = PLAFOND_DECOTE_COUPLE if marié == "oui" else PLAFOND_DECOTE_CELIBATAIRE
# Theoretischer Abschlag
décôte = plafond_décôte - 0.75 * impots
# Der Abschlag darf den Steuerbetrag nicht überschreiten
if décôte > impots:
décôte = impots
# kein Abschlag <0
if décôte < 0:
décôte = 0
# Ergebnis
return math.ceil(décôte)
8.2.7. Die Funktion [get_réduction]
Die Funktion [get_réduction] implementiert die Berechnung einer eventuellen Ermäßigung der zu zahlenden Steuer (Abschnitt |Berechnung der Steuerermäßigung|):
# berechnet eine eventuelle Ermäßigung
def get_réduction(marié: str, salaire: int, enfants: int, impots: int) -> int:
# Einkommensobergrenze für den Anspruch auf den 20-prozentigen Nachlass
plafond_revenu_pour_réduction = PLAFOND_REVENUS_COUPLE_POUR_REDUCTION if marié == "oui" else PLAFOND_REVENUS_CELIBATAIRE_POUR_REDUCTION
plafond_revenu_pour_réduction += enfants * VALEUR_REDUC_DEMI_PART
if enfants > 2:
plafond_revenu_pour_réduction += (enfants - 2) * VALEUR_REDUC_DEMI_PART
# steuerpflichtiges Einkommen
revenu_imposable = get_revenu_imposable(salaire)
# Ermäßigung
réduction = 0
if revenu_imposable < plafond_revenu_pour_réduction:
# Ermäßigung von 20 %
réduction = 0.2 * impots
# Ergebnis
return math.ceil(réduction)
8.2.8. Die Funktion [get_revenu_imposable]
Die Funktion [get_revenu_imposable] berechnet das zu versteuernde Einkommen aus dem Jahresgehalt:
# revenu_imposable = salaireAnnuel – Freibetrag
# Der Freibetrag hat einen Mindest- und einen Höchstwert
# ----------------------------------------
def get_revenu_imposable(salaire: int) -> int:
# Abzug von 10 % des Gehalts
abattement = 0.1 * salaire
# Dieser Abschlag darf ABATTEMENT_DIXPOURCENT_MAX nicht überschreiten
if abattement > ABATTEMENT_DIXPOURCENT_MAX:
abattement = ABATTEMENT_DIXPOURCENT_MAX
# Der Freibetrag darf nicht unter ABATTEMENT_DIXPOURCENT_MIN liegen
if abattement < ABATTEMENT_DIXPOURCENT_MIN:
abattement = ABATTEMENT_DIXPOURCENT_MIN
# steuerpflichtiges Einkommen
revenu_imposable = salaire - abattement
# Ergebnis
return math.floor(revenu_imposable)
8.2.9. Die Funktion [record_results]
Die Funktion [record_results] speichert die Ergebnisse der Steuerberechnung in einer Textdatei:
# Ergebnisse in eine Textdatei schreiben
# ----------------------------------------
def record_results(results_filename: str, results: list):
# results_filename: Name der Textdatei, in die die Ergebnisse geschrieben werden sollen
# results: die Liste der Ergebnisse in Form einer Liste von Wörterbüchern
# Jedes Wörterbuch wird in einer Textzeile geschrieben
résultats = None
try:
# Öffnen der Ergebnisdatei
résultats = codecs.open(results_filename, "w", "utf8")
# Auswertung der Steuerzahler
for result in results:
# Das Ergebnis wird in die Ergebnisdatei geschrieben
résultats.write(f"{result}\n")
# Nächster Steuerpflichtiger
finally:
# Die Datei wird geschlossen, falls sie geöffnet war
if résultats:
résultats.close()
8.2.10. Die Ergebnisse
Wie bereits erwähnt, mit der folgenden Steuerpflichtigen-Datei [taxpayersdata.txt]:
erstellt das Skript [main.py] die folgende Datei [résultats.txt]:
Diese Ergebnisse stimmen mit den offiziellen Zahlen im Abschnitt |Offizielle Zahlen| überein.
Führen wir nun diese Version in einem Konsolenfenster aus:
(venv) C:\Data\st-2020\dev\python\cours-2020\python3-flask-2020\impots\v01>python main.py
Traceback (most recent call last):
File "main.py", line 4, in <module>
from impots.v01.shared.impôts_module_01 import *
ModuleNotFoundError: No module named 'impots'
Es tritt ein bereits bekannter Fehler auf: Ein Modul wird nicht gefunden, in diesem Fall das Modul [impots]. Zur Erinnerung: Das bedeutet, dass
- der Python-Interpreter die Verzeichnisse des Python-Pfads nacheinander durchsucht hat;
- in keinem davon hat er einen Ordner gefunden, in dem sich ein Skript namens [impots.py] befindet;
Die Version [v02] wird dieses Problem beheben.