Python-Division gründlich erklärt! Ganzzahlige Division, Aufrundung und Rest

1. Einführung

1-1. Grundlagen der Division in Python

In Python gibt es mehrere Wege, eine Division durchzuführen. Hauptsächlich gibt es die folgenden 3 Arten, die sich in der Form des Ergebnisses und den Anwendungen unterscheiden.

1. Normale Division (/)

• Das Ergebnis ist eine Gleitkommazahl (float)
• Beispiel: 10 / 3 → 3.3333333333333335

1. Abschneide-Division (Floor-Division //)

• Das Ergebnis ist eine Ganzzahl, bei der der Dezimalteil abgeschnitten wird
• Beispiel: 10 // 3 → 3

1. Division für den Rest (%)

• Berechnet den Rest der Division
• Beispiel: 10 % 3 → 1

Das Verständnis dieser Operationen und ihre angemessene Verwendung ist in der numerischen Verarbeitung in Python wichtig.

1-2. Methoden, um das Ergebnis der Division in eine Ganzzahl umzuwandeln

1-2-1. // (Floor-Division) verwenden

Die Floor-Division (//) schneidet den Dezimalteil ab und erhält nur den ganzzahligen Teil.

print(10 // 3)  # Ausgabe: 3
print(-10 // 3) # Ausgabe: -4  (Rundung in die negative Richtung)

1-2-2. int() verwenden

Es gibt auch eine Methode, das Ergebnis der normalen Division (/) explizit mit int() in eine Ganzzahl umzuwandeln.

print(int(10 / 3))  # Ausgabe: 3

Allerdings schneidet int() den Dezimalteil ab, daher ist Vorsicht geboten, wenn negative Zahlen behandelt werden.

1-3. Unterschiede zwischen Abschneiden und Runden

Wenn das Ergebnis der Division in eine Ganzzahl umgewandelt wird, ist es wichtig, den Unterschied zwischen „Abschneiden“ und „Runden“ zu verstehen.

• Abschneiden: Der Dezimalteil wird bedingungslos entfernt (Beispiel: 3.9 → 3)
• Runden: Der Dezimalteil wird berücksichtigt und gerundet (Beispiel: 3.5 → 4)

In Python kann durch die Verwendung von round() gerundet werden.

print(round(3.5))  # Ausgabe: 4
print(round(3.4))  # Ausgabe: 3

1-4. Was in diesem Artikel gelernt werden kann

In diesem Artikel werden die grundlegenden Konzepte der Division in Python erklärt, mit einem besonderen Fokus auf die „Abschneide-Division“. In den folgenden Abschnitten werden konkrete Code-Beispiele und Hinweise verwendet, um praktisches Wissen zu vertiefen.

2. Division in Python: Der grundlegende /-Operator

2-1. Grundlagen des / (Schrägstrich)-Operators

Wenn man in Python / verwendet, ist das Ergebnis immer eine Gleitkommazahl (float). Dies gilt auch für die Division zwischen Ganzzahlen.

Beispiel: Normale Division

print(10 / 3)  # Ausgabe: 3.3333333333333335
print(8 / 2)   # Ausgabe: 4.0
print(5 / 2)   # Ausgabe: 2.5

So ist das Berechnungsergebnis vom Typ float und behält die Nachkommastellen bei, was charakteristisch ist.

2-2. Unterschied zwischen int-Typ und float-Typ

Beim Einsatz des /-Operators in Python wird das Ergebnis zum float-Typ, auch wenn die Eingaben int-Typ sind.

Beispiel: Berechnung mit Ganzzahlen

a = 10
b = 2
c = a / b
print(c)           # Ausgabe: 5.0
print(type(c))     # Ausgabe: <class 'float'>

In diesem Code sind a und b Ganzzahlen (int), aber das Ergebnis von a / b ist 5.0 vom Typ float.

2-3. Umgang, wenn ein ganzzahliges Ergebnis benötigt wird

2-3-1. // (Floor-Division) verwenden

Mit // erhalten Sie ein ganzzahliges Ergebnis, bei dem der Dezimalteil abgeschnitten wird.

print(10 // 3)  # Ausgabe: 3
print(8 // 2)   # Ausgabe: 4

2-3-2. int() verwenden, um explizit in Ganzzahl umzuwandeln

Nach der Verwendung des normalen / und Anwendung von int() wird der Dezimalteil abgeschnitten und eine Ganzzahl erhalten.

print(int(10 / 3))  # Ausgabe: 3

Allerdings muss bei negativen Zahlen Vorsicht walten.

2-4. Vorsichtsmaßnahmen bei Berechnungen mit /

2-4-1. Division durch 0 führt zu einem Fehler

In Python führt die Division durch Null zu einem ZeroDivisionError und stoppt das Programm.

print(10 / 0)  # ZeroDivisionError: Division durch Null

Maßnahmen:
Um Division durch Null zu verhindern, ist es üblich, vorher mit einer if-Anweisung zu prüfen.

a, b = 10, 0
if b != 0:
    print(a / b)
else:
    print("Division durch Null ist nicht möglich")

2-4-2. Berechnung mit negativen Zahlen

Beim Teilen negativer Zahlen mit / wird gemäß den üblichen mathematischen Regeln ein float-Ergebnis zurückgegeben.

print(-10 / 3)  # Ausgabe: -3.3333333333333335
print(10 / -3)  # Ausgabe: -3.3333333333333335

Bei Berechnungen mit negativen Zahlen müssen Abschneiden oder Runden angemessen behandelt werden.

2-5. Anwendungen und Zusammenfassung des /-Operators

• Mit / wird immer ein float-Typ-Ergebnis erzeugt
• Für ein ganzzahliges Ergebnis verwenden Sie // oder int()
• Division durch 0 verursacht einen Fehler, daher muss sie angemessen behandelt werden
• Auf Berechnungsergebnisse mit negativen Zahlen achten

3. Ganzzahlige Division in Python (Floor-Division und Integerisierung)

3-1. // (Floor-Division) – Grundlagen

// ermöglicht es, das Ergebnis der Division als ganzzahliger Wert zu erhalten, bei dem der Dezimalteil abgeschnitten wird.

Beispiel: Floor-Division

print(10 // 3)  # Ausgabe: 3
print(8 // 2)   # Ausgabe: 4
print(5 // 2)   # Ausgabe: 2

Im Gegensatz zum normalen / (Schrägstrich)-Operator liefert // ein Integer (int) als Ergebnis.

print(10 / 3)   # Ausgabe: 3.3333333333333335
print(10 // 3)  # Ausgabe: 3

Auf diese Weise ignoriert // den Dezimalteil und gibt nur den ganzzahligen Teil zurück.

3-2. Unterschied zu int()

Statt // kann int() verwendet werden, um eine Integerisierung durchzuführen, aber es gibt Unterschiede zwischen ihnen.

Fall der Verwendung von int()

Mit dem normalen / kann ein Dezimalergebnis erhalten und dann int() angewendet werden, um es zu integerisieren.

print(int(10 / 3))  # Ausgabe: 3

Unterschied zu //

int() schneidet einfach den Dezimalteil ab, aber da während der Berechnung ein float-Typ entsteht, ist // in Bezug auf die Verarbeitungsgeschwindigkeit effizienter.

print(type(10 // 3))  # Ausgabe: <class 'int'>
print(type(int(10 / 3)))  # Ausgabe: <class 'int'>

Auf den ersten Blick sehen sie gleich aus, aber int() konvertiert das Ergebnis von / einmal zu float und integerisiert es dann, daher ist es angemessener, direkt // zu verwenden.

3-3. Vorsicht bei der Floor-Division negativer Zahlen (-10 // 3 Verhalten)

Beim Berechnen negativer Zahlen mit // kann das Ergebnis dem mathematischen „Floor-Funktion (Abschneiden nach unten)“-Verhalten folgen, was zu nicht intuitiven Ergebnissen führen kann.

Beispiel: Floor-Division negativer Zahlen

print(-10 // 3)  # Ausgabe: -4

In der normalen mathematischen Berechnung ist -10 ÷ 3 = -3.333..., daher würde man -3 erwarten, aber Pythons // schneidet immer in die kleinere Richtung ab, daher wird -4.

Vergleich positiver und negativer Zahlen

print(10 // 3)   # Ausgabe: 3
print(-10 // 3)  # Ausgabe: -4

Dies entspricht dem Verhalten „die Divisionsergebnis mit floor() (Abschneiden nach unten) zu behandeln“, daher ist Vorsicht geboten, wenn negative Zahlen verarbeitet werden.

3-4. Unterschied zu math.floor()

Python hat eine Funktion namens math.floor(), die ebenfalls verwendet werden kann, um den Dezimalteil abzuschneiden.

Grundlagen von math.floor()

import math
print(math.floor(10 / 3))  # Ausgabe: 3
print(math.floor(-10 / 3)) # Ausgabe: -4

math.floor() verhält sich wie // und schneidet den Dezimalteil nach unten ab, unterscheidet sich jedoch darin, dass der Rückgabewert vom Typ float ist.

print(type(10 // 3))  # Ausgabe: <class 'int'>
print(type(math.floor(10 / 3)))  # Ausgabe: <class 'float'>

Es ist wichtig, diesen Unterschied zu verstehen und die geeignete Methode auszuwählen.

3-5. Verwendungszwecke des //-Operators und Zusammenfassung

Mit der // (Floor-Division) in Python kann ein ganzzahliger Wert ohne Dezimalteil erhalten werden. Sie ist besonders in den folgenden Fällen nützlich.

• Wenn nur ein ganzzahliges Ergebnis benötigt wird
• Beispiel: Beim Berechnen der „Gesamtanzahl der Seiten“ in der Pagination

  items = 45
  per_page = 10
  total_pages = (items + per_page - 1) // per_page
  print(total_pages)  # Ausgabe: 5

• Wenn Vorsicht bei der Verarbeitung negativer Zahlen erforderlich ist
• // rundet immer in die kleinere Richtung, daher sollte bei der Verarbeitung negativer Zahlen im Voraus überprüft werden, ob das gewünschte Ergebnis erzielt wird.
• Wenn unnötige Dezimalberechnungen schnell verarbeitet werden sollen
• 10 // 3 ist schneller als int(10 / 3).

4. Aufwärtsdivision in Python (math.ceil())

4-1. Grundlagen von math.ceil()

Das math.ceil() in Python ist eine Funktion, die den Dezimalteil bedingungslos aufwärtsrundet und eine Ganzzahl zurückgibt. Diese Funktion ist im math-Modul enthalten, daher muss import math durchgeführt werden, um sie zu verwenden.

Beispiel: Verwendung von math.ceil()

import math

print(math.ceil(10 / 3))  # Ausgabe: 4
print(math.ceil(5 / 2))   # Ausgabe: 3
print(math.ceil(4.2))     # Ausgabe: 5

Dieser so, rundet math.ceil() den Dezimalteil vollständig auf zu einer Ganzzahl.

4-2. Unterschiede zwischen math.ceil() und // (Floordivision)

Aufwärtsrundung und Abwärtsrundung sind gegensätzliche Operationen, daher ist es wichtig, die Unterschiede zwischen beiden zu verstehen.

Floordivision (//)

print(10 // 3)  # Ausgabe: 3
print(-10 // 3) # Ausgabe: -4

• // schneidet den Dezimalteil ab (bei negativen Zahlen in die kleinere Richtung)
• Auf die Ergebnisse bei negativen Zahlen muss geachtet werden

Aufwärtsrundung (math.ceil())

import math
print(math.ceil(10 / 3))  # Ausgabe: 4
print(math.ceil(-10 / 3)) # Ausgabe: -3

• math.ceil() rundet den Dezimalteil auf
• Bei negativen Zahlen wird in die größere Richtung gerundet

4-3. Praktische Beispiele mit math.ceil()

4-3-1. Berechnung der Seitenzahl

Zum Beispiel, wenn Daten in Seiten unterteilt werden, muss unter Berücksichtigung der Anzahl der Elemente pro Seite die Seitenzahl aufgerundet werden, auch wenn ein Rest vorhanden ist.

import math

items = 45   # Gesamtzahl der Elemente
per_page = 10  # Anzahl der Elemente pro Seite

total_pages = math.ceil(items / per_page)
print(total_pages)  # Ausgabe: 5

4-3-2. Berechnung der benötigten Arbeitsdurchläufe

Zum Beispiel, wenn 100 Aufgaben von 6 Personen bearbeitet werden. Bei der Berechnung der Anzahl der Durchläufe pro Person muss bei einem Rest ein zusätzlicher Durchlauf durchgeführt werden.

import math

tasks = 100   # Gesamtzahl der Aufgaben
workers = 6   # Anzahl der Arbeiter

tasks_per_worker = math.ceil(tasks / workers)
print(tasks_per_worker)  # Ausgabe: 17

4-4. Methoden zur Aufwärtsrundung ohne math.ceil()

Es gibt auch eine Methode, um mit ganzzahliger Division aufwärts zu runden, ohne math.ceil() zu verwenden. Das ist die folgende „Integeroperation mit Addition und Subtraktion“.

Verwendung von (a + b – 1) // b

Diese Methode erzielen den Aufwirkungseffekt, indem die zu teilende Zahl a um (b - 1) erhöht und durch b geteilt wird.

def ceil_div(a, b):
    return (a + b - 1) // b

print(ceil_div(10, 3))  # Ausgabe: 4
print(ceil_div(5, 2))   # Ausgabe: 3

4-5. Anwendungen und Zusammenfassung von math.ceil()

Das math.ceil() in Python ist nützlich, um den Dezimalteil aufzurunden und eine Ganzzahl zu erhalten. Es ist besonders wirksam in Situationen wie den folgenden.

• Bei der Berechnung von Seitenzahlen oder Gruppenzahlen

  import math
  items = 45
  per_page = 10
  total_pages = math.ceil(items / per_page)
  print(total_pages)  # Ausgabe: 5

• Wenn bei einem Rest die Anzahl der Verarbeitungsdurchläufe erhöht werden soll

  import math
  tasks = 100
  workers = 6
  tasks_per_worker = math.ceil(tasks / workers)
  print(tasks_per_worker)  # Ausgabe: 17

• Wenn eine Aufwärtsdivision nur mit Ganzzahlen durchgeführt werden soll

  def ceil_div(a, b):
      return (a + b - 1) // b
  print(ceil_div(10, 3))  # Ausgabe: 4

5. Methode, um Division und Rest gleichzeitig zu berechnen

5-1. Berechnung des Rests mit % (Modulo-Operator)

Die grundlegende Methode, um in Python den Rest zu berechnen, besteht darin, den % (Modulo-Operator) zu verwenden.

Beispiel: Berechnung des Rests

print(10 % 3)  # Ausgabe: 1
print(20 % 7)  # Ausgabe: 6

a % b gibt den Rest der Division von a durch b zurück. Zum Beispiel ergibt 10 % 3 10 ÷ 3 = 3 ... 1, daher wird der Rest 1 ausgegeben.

Achtung bei Resten negativer Zahlen

Der %-Operator in Python ist vom Vorzeichen der zu teilenden Zahl (Dividende) beeinflusst, daher ist Vorsicht geboten, wenn negative Zahlen verarbeitet werden.

print(-10 % 3)  # Ausgabe: 2
print(10 % -3)  # Ausgabe: -2

Dies folgt der Regel, dass der %-Operator in Python den Rest mit demselben Vorzeichen wie der teilende Zahl (Divisor) zurückgibt.

5-2. Gleichzeitiges Erhalten von Quotient und Rest mit divmod()

Mit der divmod()-Funktion in Python können Quotient und Rest in einer einzigen Berechnung gleichzeitig erhalten werden.

Grundlagen von divmod()

quotient, remainder = divmod(10, 3)
print(quotient)  # Ausgabe: 3
print(remainder) # Ausgabe: 1

In diesem Code gibt divmod(10, 3) das Tupel (3, 1) zurück, das in quotient (Quotient) und remainder (Rest) aufgeteilt wird.

Im Fall negativer Zahlen

divmod() verhält sich wie der %-Operator und folgt den Regeln von Python.

print(divmod(-10, 3))  # Ausgabe: (-4, 2)
print(divmod(10, -3))  # Ausgabe: (-4, -2)

So verhält sich der Quotient wie bei //, und der Rest entspricht dem Ergebnis von %.

5-3. Vergleich mit separater Verwendung von // und %

divmod(a, b) berechnet a // b und a % b gleichzeitig, aber lassen Sie uns den Unterschied zur separaten Verwendung von // und % überprüfen.

Methode mit zwei Berechnungen

a = 10
b = 3
quotient = a // b
remainder = a % b

print(quotient)  # Ausgabe: 3
print(remainder) # Ausgabe: 1

Diese Methode ermöglicht es ebenfalls, Quotient und Rest zu erhalten, erfordert aber zwei Berechnungen.

Methode mit divmod()

quotient, remainder = divmod(10, 3)
print(quotient)  # Ausgabe: 3
print(remainder) # Ausgabe: 1

Bei dieser Methode werden beide Werte mit einem einzigen Funktionsaufruf erhalten, was weniger Berechnungen und somit effizienter ist.

5-4. Praktische Beispiele für divmod()

5-4-1. Umwandlung in Stunden und Minuten

Zum Beispiel kann divmod() verwendet werden, um insgesamt 145 Minuten in „Stunden“ und „Minuten“ aufzuteilen.

minutes = 145
hours, remainder_minutes = divmod(minutes, 60)

print(f"{hours} Stunden {remainder_minutes} Minuten")  # Ausgabe: 2 Stunden 25 Minuten

5-4-2. Berechnung von Münzen

Mit divmod() kann die Aufteilung eines Betrags in bestimmte Münzkombinationen einfach berechnet werden.

amount = 758  # 758 ¥
yen_100, remainder = divmod(amount, 100)  # Anzahl 100-¥-Münzen
yen_50, remainder = divmod(remainder, 50)  # Anzahl 50-¥-Münzen
yen_10, remainder = divmod(remainder, 10)  # Anzahl 10-¥-Münzen

print(f"100 ¥: {yen_100} Stück, 50 ¥: {yen_50} Stück, 10 ¥: {yen_10} Stück, Rest: {remainder} ¥")

5-5. Zusammenfassung der Methoden zur Berechnung von Division und Rest

Es ist wichtig, die Methoden zur Berechnung von Quotient und Rest in Python je nach Anwendungsfall zu wählen.

Insbesondere divmod() ermöglicht es, Quotient und Rest gleichzeitig zu erhalten, wodurch wiederholte Berechnungen reduziert und effizienterer Code geschrieben werden kann.

6. Häufig gestellte Fragen zur Division in Python (FAQ)

6-1. Wie macht man das Ergebnis einer Division in Python zu einer Ganzzahl?

Es gibt in Python hauptsächlich drei Methoden, um das Ergebnis einer Division zu einer Ganzzahl zu machen.

① // (Floor-Division) verwenden

Die Verwendung von // ergibt eine Ganzzahl, bei der der Dezimalteil abgeschnitten wird.

print(10 // 3)  # Ausgabe: 3
print(-10 // 3) # Ausgabe: -4

② int() verwenden

Es ist auch möglich, das Ergebnis der normalen Division (/) explizit mit int() in eine Ganzzahl umzuwandeln.

print(int(10 / 3))  # Ausgabe: 3

Allerdings schneidet int() den Dezimalteil ab, was bei negativen Zahlen anders als bei // wirken kann.

③ math.floor() verwenden

Die Verwendung der Funktion math.floor() in Python ermöglicht eine Umwandlung in eine Ganzzahl durch immer abrunden.

import math
print(math.floor(10 / 3))  # Ausgabe: 3
print(math.floor(-10 / 3)) # Ausgabe: -4

6-2. Was ist der Unterschied zwischen Abrunden und Runden?

• Abrunden (Floor-Division): // oder math.floor() verwenden
• Runden: round() verwenden

Beispiel: Runden

print(round(3.5))  # Ausgabe: 4
print(round(3.4))  # Ausgabe: 3

Die round()-Funktion in Python folgt der Regel des Banker’s Rounding (gerade Rundung), weshalb round(2.5) zu 2 und round(3.5) zu 4 wird.

6-3. Was ist der Unterschied zwischen int() und math.floor()?

Aufgrund der unterschiedlichen Behandlung negativer Zahlen ist es wichtig, den Unterschied zwischen int() und math.floor() zu verstehen und sie je nach Situation anzuwenden.

6-4. Worauf sollte man bei negativen Zahlen beim Abrunden achten?

Die // (Floor-Division) in Python ist so spezifiziert, dass sie in die negative Richtung abrundet.

print(-10 // 3)  # Ausgabe: -4

Dies folgt dem Verhalten der mathematischen ‚Floor‘-Funktion, daher ist Vorsicht geboten, wenn man negative Zahlen abrundet.

6-5. Wie rundet man mit Angabe der Dezimalstellen ab?

Mit der round()-Funktion in Python kann man die Anzahl der Dezimalstellen angeben und runden.

print(round(3.14159, 2))  # Ausgabe: 3.14
print(round(3.14159, 3))  # Ausgabe: 3.142

6-6. Was passiert bei Division durch Null?

In Python tritt bei Division durch Null ein ZeroDivisionError auf.

print(10 / 0)  # ZeroDivisionError: division by zero

Um diesen Fehler zu vermeiden, muss man vorher prüfen, ob der Divisor Null ist.

a, b = 10, 0
if b != 0:
    print(a / b)
else:
    print("Division durch Null ist nicht möglich")

6-7. Welche Vorteile hat divmod()?

Mit der divmod()-Funktion in Python kann man Quotient und Rest gleichzeitig erhalten, was die Anzahl der Berechnungen reduziert und zu effizienterem Code führt.

quotient, remainder = divmod(10, 3)
print(quotient)  # Ausgabe: 3
print(remainder) # Ausgabe: 1

6-8. Wie führt man in Python genaue Gleitkomma-Berechnungen durch?

Da Gleitkommazahlen in Python Rundungsfehler aufweisen können, ist es bei Bedarf an Präzision ratsam, das decimal-Modul zu verwenden.

from decimal import Decimal

 a = Decimal('10.1')
b = Decimal('3.3')
print(a / b)  # Genaue Berechnung möglich

6-9. Wie formatiert man das Ergebnis einer Division in Python als String?

Um das Ergebnis einer Division als formatierten String darzustellen, kann man f-strings oder format() verwenden.

result = 10 / 3
print(f"{result:.2f}")  # Ausgabe: 3.33
print("{:.2f}".format(result))  # Ausgabe: 3.33

7. Zusammenfassung

7-1. Auswahl der optimalen Methode je nach Situation

Python bietet verschiedene Methoden für die Division, und es ist wichtig, die optimale Technik je nach Situation auszuwählen.

7-2. Wichtige Hinweise beim Umgang mit Division

Beim Durchführen von Divisionen in Python müssen mehrere wichtige Punkte beachtet werden.

1. // (Floordivision) verhält sich bei negativen Zahlen anders

// (Floordivision) rundet in die kleinere Richtung, weshalb bei negativen Zahlen Ergebnisse entstehen können, die dem Intuitionsgefühl widersprechen.

print(-10 // 3)  # Ausgabe: -4

Dieses Verhalten verstehen und in manchen Fällen math.floor() verwenden ist angemessen.

2. Division durch Null führt zu einem Fehler

In Python löst eine Division durch Null einen ZeroDivisionError aus, daher muss vorher geprüft werden.

a, b = 10, 0
if b != 0:
    print(a / b)
else:
    print("Division durch Null ist nicht möglich")

3. round() führt zu Rundung auf die nächste gerade Zahl

Die round()-Funktion in Python folgt der Banker-Rundung (Rundung auf gerade Zahl), sodass round(2.5) zu 2 und round(3.5) zu 4 wird.

print(round(2.5))  # Ausgabe: 2
print(round(3.5))  # Ausgabe: 4

4. divmod() kann Berechnungen effizienter machen

Statt Quotient und Rest separat zu berechnen, spart divmod() Rechenoperationen und ermöglicht effizienten Code.

quotient, remainder = divmod(10, 3)
print(quotient)  # Ausgabe: 3
print(remainder) # Ausgabe: 1

7-3. Zusammenfassung des Artikels

Python bietet viele Methoden für die Division, die jeweils unterschiedliche Anwendungen haben. Die im Artikel erläuterten Inhalte lassen sich wie folgt zusammenfassen:

1. Normale Division (/) liefert ein Ergebnis vom Typ float.
2. Für Ganzzahlergebnisse // (Floordivision) verwenden.
3. Bei negativen Zahlen auf das Verhalten von // achten (Abrundung in negative Richtung).
4. Für Rundung round() einsetzen.
5. Für Aufrunden math.ceil(), für Abrunden math.floor() verwenden.
6. Für den Rest %, für Quotient und Rest gleichzeitig divmod() nutzen.
7. Für hochpräzise Berechnungen decimal.Decimal einsetzen.

Python-Divisionen richtig zu beherrschen ermöglicht flexiblere und genauere Datenverarbeitung und Berechnungen.

Damit endet der Artikel. Haben Sie Ihr Verständnis für Divisionen in Python vertieft und können Sie nun die passenden Berechnungsmethoden auswählen? Bei Fragen empfehle ich, die offizielle Python-Dokumentation zu konsultieren oder den Code selbst auszuprobieren.

Setzen Sie Ihr Lernen fort, um Python-Programmierung noch angenehmer zu gestalten!