4. Arbeiten mit Zahlen

In Kapitel 3 haben Sie gelernt, wie Sie Variablen erstellen und mit Pythons grundlegenden numerischen Typen arbeiten: Ganzzahlen (integers) und Gleitkommazahlen (floats). Jetzt ist es an der Zeit, diese Zahlen wirklich einzusetzen. In diesem Kapitel lernen Sie, wie Sie Berechnungen durchführen, Operationen kombinieren und Pythons eingebaute Werkzeuge für die Arbeit mit numerischen Daten nutzen.

Zahlen sind grundlegend für die Programmierung. Ob Sie Summen berechnen, Messwerte verarbeiten, Bestände verwalten oder Daten analysieren – Sie müssen arithmetische Operationen ausführen. Python macht numerische Operationen einfach und intuitiv, aber es gibt wichtige Details zu verstehen – insbesondere dazu, wie unterschiedliche Arten der Division funktionieren, wie Operatoren zusammenwirken und wie sich Gleitkommazahlen verhalten.

Am Ende dieses Kapitels werden Sie in der Lage sein, Berechnungen durchzuführen, das Verhalten von Operatoren zu verstehen und Pythons numerische Funktionen einzusetzen, um reale Probleme zu lösen.

4.1) Grundlegende Arithmetik: Addition, Subtraktion und Multiplikation

Beginnen wir mit den grundlegendsten Rechenoperationen. Python verwendet vertraute Symbole für die Grundrechenarten, und diese Operationen funktionieren so, wie Sie es aus der alltäglichen Mathematik erwarten.

4.1.1) Addition mit dem Operator +

Der Operator + addiert zwei Zahlen. Er funktioniert sowohl mit Ganzzahlen als auch mit Gleitkommazahlen:

python

# basic_addition.py
# Adding integers
total = 15 + 27
print(total)  # Output: 42
 
# Adding floats
price = 19.99 + 5.50
print(price)  # Output: 25.49
 
# You can add multiple numbers in one expression
sum_total = 10 + 20 + 30 + 40
print(sum_total)  # Output: 100

Addition ist unkompliziert, aber es gibt ein wichtiges Detail: Wenn Sie eine Ganzzahl und eine Gleitkommazahl addieren, wandelt Python das Ergebnis automatisch in eine Gleitkommazahl um, um die Dezimalgenauigkeit zu erhalten:

python

# mixed_addition.py
result = 10 + 3.5
print(result)  # Output: 13.5
print(type(result))  # Output: <class 'float'>

Diese automatische Umwandlung erfolgt, weil ein float sowohl ganze Zahlen als auch Dezimalzahlen darstellen kann, eine Ganzzahl jedoch keine Dezimalstellen darstellen kann. Python wählt den Typ, bei dem keine Informationen verloren gehen.

4.1.2) Subtraktion mit dem Operator -

Der Operator - subtrahiert die zweite Zahl von der ersten:

python

# basic_subtraction.py
# Subtracting integers
difference = 100 - 42
print(difference)  # Output: 58
 
# Subtracting floats
remaining = 50.75 - 12.25
print(remaining)  # Output: 38.5
 
# Subtraction can produce negative results
balance = 20 - 35
print(balance)  # Output: -15

Wie bei der Addition werden auch bei der Subtraktion Ganzzahlen zu Gleitkommazahlen befördert, wenn Sie Typen mischen:

python

# mixed_subtraction.py
result = 100 - 0.01
print(result)  # Output: 99.99
print(type(result))  # Output: <class 'float'>

4.1.3) Multiplikation mit dem Operator *

Der Operator * multipliziert zwei Zahlen:

python

# basic_multiplication.py
# Multiplying integers
product = 6 * 7
print(product)  # Output: 42
 
# Multiplying floats
area = 3.5 * 2.0
print(area)  # Output: 7.0
 
# Multiplying by zero always gives zero
result = 1000 * 0
print(result)  # Output: 0

Die Multiplikation folgt denselben Typumwandlungsregeln. Wenn Sie eine Ganzzahl mit einer Gleitkommazahl multiplizieren, ist das Ergebnis ein float:

python

# mixed_multiplication.py
result = 5 * 2.5
print(result)  # Output: 12.5
print(type(result))  # Output: <class 'float'>
 
# Even if the result is a whole number
result = 4 * 2.0
print(result)  # Output: 8.0 (note the .0)
print(type(result))  # Output: <class 'float'>

Beachten Sie im letzten Beispiel, dass Python das Ergebnis als 8.0 darstellt, obwohl 4 × 2.0 mathematisch 8 ergibt. Einer der Operanden war ein float, daher wird das Ergebnis als float dargestellt. Der Typ des Ergebnisses hängt von den Typen der Eingaben ab, nicht davon, ob das mathematische Ergebnis eine ganze Zahl ist.

4.1.4) Praktische Beispiele mit grundlegender Arithmetik

Sehen wir uns an, wie diese Operationen in realistischen Szenarien zusammenwirken:

python

# shopping_cart.py
# Calculate a shopping cart total
item1_price = 12.99
item2_price = 8.50
item3_price = 15.00
 
subtotal = item1_price + item2_price + item3_price
print(f"Subtotal: ${subtotal}")  # Output: Subtotal: $36.49
 
tax_rate = 0.08
tax = subtotal * tax_rate
print(f"Tax: ${tax}")  # Output: Tax: $2.9192
 
total = subtotal + tax
print(f"Total: ${total}")  # Output: Total: $39.4092

python

# temperature_change.py
# Calculate temperature change
morning_temp = 45.5
afternoon_temp = 68.2
 
change = afternoon_temp - morning_temp
print(f"Temperature increased by {change} degrees")
# Output: Temperature increased by 22.7 degrees

Diese grundlegenden Operationen bilden die Grundlage für komplexere Berechnungen. Zu verstehen, wie sie funktionieren – insbesondere, wie Python Typumwandlungen handhabt – hilft Ihnen, Überraschungen zu vermeiden, wenn Ihre Programme Berechnungen ausführen.

4.2) Division, Ganzzahldivision und Rest: /, // und %

Division in Python ist nuancierter als Addition, Subtraktion oder Multiplikation. Python stellt drei verschiedene divisionsbezogene Operatoren bereit, die jeweils einem eigenen Zweck dienen. Zu verstehen, wann Sie welchen verwenden, ist entscheidend, um korrekte Programme zu schreiben.

4.2.1) Normale Division mit /

Der Operator / führt eine „echte Division“ durch – er liefert immer ein Ergebnis vom Typ float, selbst wenn Sie zwei Ganzzahlen dividieren:

python

# true_division.py
# Dividing integers
result = 10 / 2
print(result)  # Output: 5.0 (note: float, not 5)
print(type(result))  # Output: <class 'float'>
 
# Division that doesn't result in a whole number
result = 10 / 3
print(result)  # Output: 3.3333333333333335
 
# Dividing floats
result = 15.5 / 2.5
print(result)  # Output: 6.2

Der entscheidende Punkt ist, dass / immer einen float erzeugt, selbst wenn beide Operanden Ganzzahlen sind und das Ergebnis mathematisch eine ganze Zahl ist. Das ist so vorgesehen: Python möchte, dass Division sich konsistent verhält und Dezimalgenauigkeit erhält.

Dieses Verhalten unterscheidet sich von manchen anderen Programmiersprachen, in denen die Division zweier Ganzzahlen ein ganzzahliges Ergebnis liefert. In Python 3 müssen Sie, wenn Sie ein Ganzzahlergebnis möchten, die Ganzzahldivision verwenden (die wir gleich behandeln) oder das Ergebnis explizit umwandeln.

4.2.2) Ganzzahldivision mit //

Der Operator // führt eine „Ganzzahldivision (floor division)“ durch – er dividiert und rundet anschließend auf die nächstkleinere ganze Zahl ab. Wenn beide Operanden Ganzzahlen sind, ist das Ergebnis eine Ganzzahl. Wenn einer der Operanden ein float ist, ist das Ergebnis ein float (aber weiterhin abgerundet):

python

# floor_division.py
# Floor division with integers
result = 10 // 3
print(result)  # Output: 3 (not 3.333...)
print(type(result))  # Output: <class 'int'>
 
# Even division still gives an integer
result = 10 // 2
print(result)  # Output: 5 (integer, not 5.0)
print(type(result))  # Output: <class 'int'>
 
# Floor division with floats gives a float
result = 10.0 // 3
print(result)  # Output: 3.0
print(type(result))  # Output: <class 'float'>

„Abrunden“ bedeutet hier, in Richtung negativer Unendlichkeit zu gehen, nicht einfach nur den Dezimalteil zu entfernen. Das ist für negative Zahlen wichtig:

python

# floor_division_negative.py
# Positive numbers: rounds down (toward negative infinity)
result = 7 // 2
print(result)  # Output: 3
 
# Negative numbers: still rounds toward negative infinity
result = -7 // 2
print(result)  # Output: -4 (not -3!)
 
# Why -4? Because -3.5 rounded down (toward negative infinity) is -4
# Think of the number line: ... -4, -3.5, -3, -2, -1, 0, 1, 2, 3, 3.5, 4 ...

Ganzzahldivision ist nützlich, wenn Sie Elemente in Gruppen aufteilen oder berechnen müssen, wie viele vollständige Einheiten in eine Menge passen:

python

# floor_division_practical.py
# How many complete dozens in 50 eggs?
eggs = 50
eggs_per_dozen = 12
complete_dozens = eggs // eggs_per_dozen
print(f"Complete dozens: {complete_dozens}")  # Output: Complete dozens: 4
 
# How many full hours in 150 minutes?
minutes = 150
full_hours = minutes // 60
print(f"Full hours: {full_hours}")  # Output: Full hours: 2

4.2.3) Rest (Modulo) mit %

Der Operator % (genannt „Modulo“ oder „mod“) gibt den Rest nach einer Division zurück. Er beantwortet die Frage: „Was bleibt nach der Division übrig?“

python

# modulo_basic.py
# 10 divided by 3 is 3 with remainder 1
result = 10 % 3
print(result)  # Output: 1
 
# 10 divided by 2 is 5 with remainder 0 (even division)
result = 10 % 2
print(result)  # Output: 0
 
# Works with floats too
result = 10.5 % 3
print(result)  # Output: 1.5

Der Modulo-Operator ist für mehrere typische Programmiermuster äußerst nütlich:

Prüfen, ob eine Zahl gerade oder ungerade ist:

python

# even_odd_check.py
number = 17
 
if number % 2 == 0:
    print(f"{number} is even")
else:
    print(f"{number} is odd")
# Output: 17 is odd

Übrig gebliebene Elemente ermitteln:

python

# leftover_items.py
eggs = 50
eggs_per_dozen = 12
 
leftover = eggs % eggs_per_dozen
print(f"Leftover eggs: {leftover}")  # Output: Leftover eggs: 2

Werte innerhalb eines Bereichs „einfangen“ (wie bei einer Uhr):

python

# clock_arithmetic.py
# What hour is it 25 hours from now? (on a 12-hour clock)
current_hour = 10
hours_later = 25
future_hour = (current_hour + hours_later) % 12
print(f"Hour: {future_hour}")  # Output: Hour: 11

4.2.4) Beziehung zwischen //, % und /

Ganzzahldivision und Modulo hängen eng zusammen. Gemeinsam liefern sie das vollständige Ergebnis einer Division:

python

# division_relationship.py
dividend = 17
divisor = 5
 
quotient = dividend // divisor  # How many times 5 goes into 17
remainder = dividend % divisor  # What's left over
 
print(f"{dividend} ÷ {divisor} = {quotient} remainder {remainder}")
# Output: 17 ÷ 5 = 3 remainder 2
 
# You can verify: quotient * divisor + remainder should equal dividend
verification = quotient * divisor + remainder
print(f"Verification: {quotient} × {divisor} + {remainder} = {verification}")
# Output: Verification: 3 × 5 + 2 = 17

Diese Beziehung gilt immer: Für beliebige Zahlen a und b (wobei b nicht null ist) gilt a == (a // b) * b + (a % b).

4.2.5) Den richtigen Divisionsoperator wählen

Hier eine kurze Anleitung, welchen Operator Sie wann verwenden sollten:

Verwenden Sie /, wenn Sie das exakte mathematische Ergebnis mit Dezimalstellen benötigen (am häufigsten in Berechnungen)
Verwenden Sie //, wenn Sie zählen müssen, wie viele vollständige Gruppen hineinpassen (z. B. Dutzend, Stunden, Seiten)
Verwenden Sie %, wenn Sie den Rest oder die übrig gebliebene Menge benötigen (z. B. zur Prüfung auf gerade/ungerade, zum „Einfangen“ von Werten, zum Finden von Resten)

python

# choosing_operators.py
# Scenario: Distributing 47 candies among 6 children
 
candies = 47
children = 6
 
# How many candies per child? (use //)
per_child = candies // children
print(f"Each child gets {per_child} candies")  # Output: Each child gets 7 candies
 
# How many candies are left over? (use %)
leftover = candies % children
print(f"Leftover candies: {leftover}")  # Output: Leftover candies: 5
 
# What's the exact average? (use /)
average = candies / children
print(f"Average per child: {average}")  # Output: Average per child: 7.833333333333333

4.3) Erweiterte Zuweisungsoperatoren

In der Programmierung müssen Sie Variablen häufig aktualisieren, indem Sie eine Operation auf ihren aktuellen Wert anwenden. Zum Beispiel, wenn Sie eine laufende Summe erhöhen, einen Kontostand verringern oder einen Wert mit einem Faktor multiplizieren. Python stellt dafür eine kompakte Schreibweise mit erweiterten Zuweisungsoperatoren bereit.

4.3.1) Was erweiterte Zuweisungsoperatoren sind

Ein erweiterter Zuweisungsoperator kombiniert eine arithmetische Operation mit einer Zuweisung. Anstatt zu schreiben:

python

# traditional_update.py
count = 10
count = count + 5  # Add 5 to count
print(count)  # Output: 15

können Sie schreiben:

python

# augmented_update.py
count = 10
count += 5  # Same as: count = count + 5
print(count)  # Output: 15

Beide Varianten tun genau dasselbe, aber die erweiterte Version ist knapper und drückt die Absicht klarer aus: „Erhöhe count um 5.“

4.3.2) Alle erweiterten Zuweisungsoperatoren

Python stellt erweiterte Zuweisungsoperatoren für alle arithmetischen Operationen bereit:

python

# all_augmented_operators.py
# Addition
x = 10
x += 5  # x = x + 5
print(f"After += 5: {x}")  # Output: After += 5: 15
 
# Subtraction
x = 10
x -= 3  # x = x - 3
print(f"After -= 3: {x}")  # Output: After -= 3: 7
 
# Multiplication
x = 10
x *= 4  # x = x * 4
print(f"After *= 4: {x}")  # Output: After *= 4: 40
 
# Division
x = 10
x /= 2  # x = x / 2
print(f"After /= 2: {x}")  # Output: After /= 2: 5.0
 
# Floor division
x = 10
x //= 3  # x = x // 3
print(f"After //= 3: {x}")  # Output: After //= 3: 3
 
# Modulo
x = 10
x %= 3  # x = x % 3
print(f"After %= 3: {x}")  # Output: After %= 3: 1
 
# Exponentiation (we'll see more about ** in section 4.6)
x = 2
x **= 3  # x = x ** 3 (2 to the power of 3)
print(f"After **= 3: {x}")  # Output: After **= 3: 8

4.3.3) Häufige Anwendungsfälle für erweiterte Zuweisung

Erweiterte Zuweisungsoperatoren glänzen in mehreren typischen Programmiermustern:

Eine Summe aufsummieren:

python

# accumulating_total.py
total = 0
total += 10  # Add first item
total += 25  # Add second item
total += 15  # Add third item
print(f"Total: {total}")  # Output: Total: 50

Vorkommen zählen:

python

# counting.py
count = 0
# Imagine these happen as we process data
count += 1  # Found one
count += 1  # Found another
count += 1  # Found another
print(f"Count: {count}")  # Output: Count: 3

Einen Kontostand aktualisieren:

python

# balance_updates.py
balance = 100.00
balance -= 25.50  # Purchase
balance += 50.00  # Deposit
balance -= 10.00  # Purchase
print(f"Balance: ${balance}")  # Output: Balance: $114.5

Wiederholte Operationen anwenden:

python

# repeated_operations.py
value = 100
value *= 1.1  # Increase by 10%
value *= 1.1  # Increase by 10% again
value *= 1.1  # Increase by 10% again
print(f"Value after three 10% increases: {value}")
# Output: Value after three 10% increases: 133.10000000000002

4.3.4) Wichtige Details zu erweiterten Zuweisungen

Erweiterte Zuweisung erzeugt ein neues Objekt für unveränderliche Typen:

Erinnern Sie sich an Kapitel 3: Zahlen sind unveränderlich (immutable) – Sie können den Wert einer Zahl nicht ändern, sondern nur neue Zahlen erzeugen. Wenn Sie x += 5 schreiben, erzeugt Python ein neues Zahlenobjekt und weist es x zu. Das alte Zahlenobjekt wird verworfen (wir werden dieses Konzept in Kapitel 17 genauer untersuchen, wenn wir Pythons Objektmodell besprechen):

python

# augmented_with_immutables.py
x = 10
print(id(x))  # Output: (some memory address)
 
x += 5
print(id(x))  # Output: (different memory address)

Für jetzt reicht zu verstehen, dass x += 5 gleichbedeutend ist mit x = x + 5 – es ist eine bequeme Kurzschreibweise, aber keine grundlegend andere Operation.

Sie können erweiterte Zuweisung nicht verwenden, bevor eine Variable existiert:

python

# augmented_requires_existing.py
# This will cause an error:
# count += 1  # NameError: name 'count' is not defined
 
# You must initialize the variable first:
count = 0
count += 1  # Now this works
print(count)  # Output: 1

Typumwandlungen verhalten sich wie bei den normalen Operatoren:

python

# augmented_type_conversion.py
x = 10  # integer
x += 2.5  # Add a float
print(x)  # Output: 12.5
print(type(x))  # Output: <class 'float'>

Das Ergebnis folgt denselben Typumwandlungsregeln wie bei den regulären Operatoren: Wenn Sie Ganzzahlen und floats mischen, ist das Ergebnis ein float.

4.3.5) Wann Sie erweiterte Zuweisungen verwenden sollten

Verwenden Sie erweiterte Zuweisungsoperatoren immer dann, wenn Sie eine Variable basierend auf ihrem aktuellen Wert aktualisieren. Sie machen Ihren Code:

Kürzer: x += 5 ist kürzer als x = x + 5
Lesbarer: Die Absicht ist sofort klar
Weniger fehleranfällig: Sie laufen weniger Gefahr, den Variablennamen zu vertippen

Vergleichen Sie diese beiden Varianten:

python

# comparison.py
# Without augmented assignment
accumulated_distance_in_kilometers = 0
accumulated_distance_in_kilometers = accumulated_distance_in_kilometers + 10
accumulated_distance_in_kilometers = accumulated_distance_in_kilometers + 25
 
# With augmented assignment
accumulated_distance_in_kilometers = 0
accumulated_distance_in_kilometers += 10
accumulated_distance_in_kilometers += 25

Die erweiterte Version ist klarer und bietet weniger Gelegenheit für Tippfehler. Erweiterte Zuweisungsoperatoren sind eine kleine Spracheigenschaft, werden aber in echter Python-Praxis sehr häufig verwendet.

4.4) Operatorrangfolge und Klammern

Wenn Sie mehrere Operationen in einem einzigen Ausdruck kombinieren, benötigt Python Regeln, um die Auswertungsreihenfolge zu bestimmen. Soll 2 + 3 * 4 als (2 + 3) * 4 = 20 oder als 2 + (3 * 4) = 14 berechnet werden? Die Antwort hängt von der Operatorrangfolge ab – den Regeln, die bestimmen, welche Operationen zuerst ausgeführt werden.

4.4.1) Die Operatorrangfolge verstehen

Python folgt denselben Vorrangregeln, die Sie aus der Mathematik kennen: Multiplikation und Division werden vor Addition und Subtraktion ausgeführt. Dies wird oft mit dem Akronym PEMDAS (Parentheses, Exponents, Multiplication/Division, Addition/Subtraction) erinnert, wobei wir Potenzen in Abschnitt 4.6 behandeln.

python

# precedence_basic.py
# Multiplication happens before addition
result = 2 + 3 * 4
print(result)  # Output: 14 (not 20)
# Python calculates: 2 + (3 * 4) = 2 + 12 = 14
 
# Division happens before subtraction
result = 10 - 8 / 2
print(result)  # Output: 6.0 (not 1.0)
# Python calculates: 10 - (8 / 2) = 10 - 4.0 = 6.0

Hier ist die Rangfolge der Operatoren, die wir bisher kennengelernt haben (von höchster zu niedrigster Priorität):

Klammern () — höchste Priorität, immer zuerst ausgewertet
Potenzierung ** — (behandeln wir in Abschnitt 4.6)
Multiplikation, Division, Ganzzahldivision, Modulo *, /, //, % — gleiche Ebene, Auswertung von links nach rechts
Addition, Subtraktion +, - — gleiche Ebene, Auswertung von links nach rechts

Sehen wir uns weitere Beispiele an, wie die Rangfolge wirkt:

python

# precedence_examples.py
# Multiplication before addition
result = 5 + 2 * 3
print(result)  # Output: 11 (5 + 6)
 
# Division before subtraction
result = 20 - 10 / 2
print(result)  # Output: 15.0 (20 - 5.0)
 
# Multiple operations at the same level: left to right
result = 10 - 3 + 2
print(result)  # Output: 9 ((10 - 3) + 2)
 
result = 20 / 4 * 2
print(result)  # Output: 10.0 ((20 / 4) * 2)

4.4.2) Klammern verwenden, um die Reihenfolge zu steuern

Klammern setzen die Standardrangfolge außer Kraft. Operationen innerhalb von Klammern werden immer zuerst ausgeführt, unabhängig von den beteiligten Operatoren:

python

# parentheses_override.py
# Without parentheses: multiplication first
result = 2 + 3 * 4
print(result)  # Output: 14
 
# With parentheses: addition first
result = (2 + 3) * 4
print(result)  # Output: 20
 
# Another example
result = 10 - 8 / 2
print(result)  # Output: 6.0
 
result = (10 - 8) / 2
print(result)  # Output: 1.0

Sie können Klammern verschachteln, um komplexere Ausdrücke zu erstellen. Python wertet von den innersten Klammern nach außen aus:

python

# nested_parentheses.py
result = ((2 + 3) * 4) - 1
print(result)  # Output: 19
# Step 1: (2 + 3) = 5
# Step 2: (5 * 4) = 20
# Step 3: 20 - 1 = 19
 
result = 2 * (3 + (4 - 1))
print(result)  # Output: 12
# Step 1: (4 - 1) = 3
# Step 2: (3 + 3) = 6
# Step 3: 2 * 6 = 12

4.4.3) Wenn Operatoren denselben Vorrang haben

Wenn mehrere Operatoren mit derselben Priorität in einem Ausdruck vorkommen, wertet Python sie von links nach rechts aus (das nennt man „Linksassoziativität“):

python

# left_to_right.py
# Addition and subtraction: left to right
result = 10 - 3 + 2 - 1
print(result)  # Output: 8
# Evaluation: ((10 - 3) + 2) - 1 = (7 + 2) - 1 = 9 - 1 = 8
 
# Multiplication and division: left to right
result = 20 / 4 * 2
print(result)  # Output: 10.0
# Evaluation: (20 / 4) * 2 = 5.0 * 2 = 10.0
 
# This matters! Different order gives different result:
result = 20 / (4 * 2)
print(result)  # Output: 2.5

4.4.4) Praktische Beispiele zur Rangfolge

Sehen wir uns realistische Szenarien an, in denen das Verständnis der Rangfolge wichtig ist:

python

# temperature_conversion.py
# Convert Fahrenheit to Celsius: C = (F - 32) * 5 / 9
fahrenheit = 98.6
 
# Correct: parentheses ensure subtraction happens first
celsius = (fahrenheit - 32) * 5 / 9
print(f"{fahrenheit}°F = {celsius}°C")
# Output: 98.6°F = 37.0°C
 
# Wrong: without parentheses, multiplication happens first
# celsius = fahrenheit - 32 * 5 / 9  # This would be wrong!
# This would calculate: fahrenheit - ((32 * 5) / 9)

python

# calculate_average.py
# Calculate average of three numbers
num1 = 85
num2 = 92
num3 = 78
 
# Correct: parentheses ensure addition happens before division
average = (num1 + num2 + num3) / 3
print(f"Average: {average}")  # Output: Average: 85.0
 
# Wrong: without parentheses, only num3 is divided by 3
# average = num1 + num2 + num3 / 3  # This would be wrong!
# This would calculate: 85 + 92 + (78 / 3) = 85 + 92 + 26.0 = 203.0

python

# discount_calculation.py
# Calculate price after discount and tax
original_price = 100.00
discount_rate = 0.20
tax_rate = 0.08
 
# Calculate discount amount
discount = original_price * discount_rate
 
# Calculate price after discount
discounted_price = original_price - discount
 
# Calculate final price with tax
final_price = discounted_price * (1 + tax_rate)
print(f"Final price: ${final_price}")  # Output: Final price: $86.4
 
# Or in one expression (using parentheses to be clear):
final_price = (original_price * (1 - discount_rate)) * (1 + tax_rate)
print(f"Final price: ${final_price}")  # Output: Final price: $86.4

4.4.5) Best Practices für Operatorrangfolge

Verwenden Sie Klammern für Klarheit, auch wenn sie nicht strikt nötig sind:

Manchmal machen Klammern Ihre Absicht klarer, selbst wenn sie das Ergebnis nicht verändern:

python

# clarity_with_parentheses.py
# These are equivalent, but the second is clearer:
result = 2 + 3 * 4
result = 2 + (3 * 4)  # Clearer: shows you know multiplication happens first
 
# Complex expressions benefit from parentheses:
result = (subtotal * tax_rate) + (subtotal * tip_rate)  # Clear intent

Zerlegen Sie komplexe Ausdrücke in Schritte:

Wenn ein Ausdruck zu komplex wird, ist es oft besser, ihn in mehrere Zeilen aufzuteilen:

python

# breaking_into_steps.py
# Instead of this complex one-liner:
result = ((price * quantity) * (1 - discount)) * (1 + tax)
 
# Consider breaking it into steps:
subtotal = price * quantity
discounted = subtotal * (1 - discount)
final = discounted * (1 + tax)
result = final

Die mehrstufige Variante ist leichter zu lesen, zu debuggen und zu überprüfen. Opfern Sie Klarheit nicht zugunsten von Kürze.

Wenn Sie unsicher sind, verwenden Sie Klammern:

Wenn Sie sich über die Rangfolge nicht sicher sind, fügen Sie Klammern hinzu. Der Python-Interpreter hat nichts dagegen, und Ihr zukünftiges Selbst (oder andere Programmierer, die Ihren Code lesen) werden dankbar sein.

Das Verständnis der Operatorrangfolge hilft Ihnen, korrekte Ausdrücke zu schreiben und den Code anderer besser zu lesen. Der wichtigste Grundsatz: Wenn Sie Operationen kombinieren, denken Sie an die Auswertungsreihenfolge und verwenden Sie Klammern, um Ihre Absicht deutlich zu machen.

4.5) Ganzzahlen und Floats in Ausdrücken mischen

Sie haben bereits gesehen, dass Python das Mischen von Ganzzahlen und Gleitkommazahlen in einfachen Operationen automatisch handhabt. Nun betrachten wir dieses Verhalten systematischer und verstehen die Regeln, die die Typumwandlung in numerischen Ausdrücken steuern.

4.5.1) Die Typbeförderungsregel

Wenn Python eine arithmetische Operation mit einer Ganzzahl und einem float ausführt, wandelt es die Ganzzahl automatisch in einen float um („befördert“ sie), bevor die Operation ausgeführt wird. Das Ergebnis ist immer ein float:

python

# type_promotion.py
# Integer + Float = Float
result = 10 + 3.5
print(result)  # Output: 13.5
print(type(result))  # Output: <class 'float'>
 
# Float + Integer = Float (order doesn't matter)
result = 3.5 + 10
print(result)  # Output: 13.5
print(type(result))  # Output: <class 'float'>
 
# This applies to all arithmetic operators
result = 5 * 2.0
print(result)  # Output: 10.0 (float, not int)
print(type(result))  # Output: <class 'float'>

Warum macht Python das? Weil floats sowohl ganze Zahlen als auch Dezimalzahlen darstellen können, während Ganzzahlen keine Dezimalzahlen repräsentieren können. Die Umwandlung in float erhält alle Informationen und vermeidet Präzisionsverlust.

Hier ist eine visuelle Darstellung, wie Python den Ergebnistyp bestimmt:

4.5.2) Typbeförderung in komplexen Ausdrücken

Wenn ein Ausdruck mehrere Operationen mit gemischten Typen enthält, wendet Python die Beförderungsregel bei jedem Schritt an:

python

# complex_mixed_types.py
# Multiple operations with mixed types
result = 10 + 3.5 * 2
print(result)  # Output: 17.0
print(type(result))  # Output: <class 'float'>
 
# What happens step by step:
# 1. 3.5 * 2 → 3.5 * 2.0 (2 promoted to float) → 7.0 (float)
# 2. 10 + 7.0 → 10.0 + 7.0 (10 promoted to float) → 17.0 (float)
 
# Another example
result = 5 / 2 + 3
print(result)  # Output: 5.5
print(type(result))  # Output: <class 'float'>
 
# Step by step:
# 1. 5 / 2 → 2.5 (division always produces float)
# 2. 2.5 + 3 → 2.5 + 3.0 (3 promoted to float) → 5.5 (float)

Sobald eine Operation in einem Ausdruck einen float liefert, werden alle nachfolgenden Operationen, die dieses Ergebnis verwenden, ebenfalls floats produzieren.

4.5.3) Sonderfall: Normale Division liefert immer floats

Erinnern Sie sich aus Abschnitt 4.2, dass der Operator / immer einen float liefert, selbst wenn Sie zwei Ganzzahlen dividieren:

python

# division_always_float.py
# Even when the result is a whole number
result = 10 / 2
print(result)  # Output: 5.0 (not 5)
print(type(result))  # Output: <class 'float'>
 
# This means any expression with / will have a float result
result = 10 / 2 + 3  # 5.0 + 3 → 5.0 + 3.0 → 8.0
print(result)  # Output: 8.0
print(type(result))  # Output: <class 'float'>

Wenn Sie ein ganzzahliges Ergebnis aus einer Division möchten, verwenden Sie stattdessen die Ganzzahldivision // (denken Sie aber daran, dass sie abrundet):

python

# floor_division_integer.py
# Floor division with integers produces an integer
result = 10 // 2
print(result)  # Output: 5 (integer)
print(type(result))  # Output: <class 'int'>
 
# But floor division with any float produces a float
result = 10.0 // 2
print(result)  # Output: 5.0 (float)
print(type(result))  # Output: <class 'float'>

4.5.4) Praktische Auswirkungen des Typmischens

Das Verständnis der Typbeförderung hilft Ihnen, die Typen Ihrer Ergebnisse vorherzusagen und zu steuern:

python

# practical_type_mixing.py
# Calculating price per item
total_cost = 47.50
num_items = 5
 
price_per_item = total_cost / num_items  # Float / int → float
print(f"Price per item: ${price_per_item}")
# Output: Price per item: $4.75
 
# Calculating average (will be float even if inputs are integers)
total_points = 450
num_tests = 5
 
average = total_points / num_tests  # Int / int → float
print(f"Average: {average}")  # Output: Average: 90.0
 
# If you need an integer result, convert explicitly
average_rounded = int(total_points / num_tests)
print(f"Average (as integer): {average_rounded}")
# Output: Average (as integer): 90

4.5.5) Wenn ganzzahlige Ergebnisse wichtig sind

Manchmal benötigen Sie ganzzahlige Ergebnisse speziell für Zählungen, Indizes oder andere diskrete Operationen. So stellen Sie sicher, dass Sie Ganzzahlen erhalten:

python

# ensuring_integer_results.py
# Using floor division when you need integer results
items = 47
items_per_box = 12
 
# How many complete boxes?
complete_boxes = items // items_per_box  # Integer result
print(f"Complete boxes: {complete_boxes}")
# Output: Complete boxes: 3
 
# If you use regular division, you get a float
boxes_float = items / items_per_box
print(f"Boxes (float): {boxes_float}")
# Output: Boxes (float): 3.9166666666666665
 
# Converting float to integer (truncates toward zero)
boxes_truncated = int(boxes_float)
print(f"Boxes (truncated): {boxes_truncated}")
# Output: Boxes (truncated): 3

Beachten Sie den Unterschied: // rundet ab (in Richtung negativer Unendlichkeit), während int() in Richtung Null abschneidet. Für positive Zahlen ist das Ergebnis gleich, für negative Zahlen nicht:

python

# truncation_vs_floor.py
# For positive numbers: same result
print(7 // 2)    # Output: 3
print(int(7/2))  # Output: 3
 
# For negative numbers: different results
print(-7 // 2)    # Output: -4 (rounds down toward negative infinity)
print(int(-7/2))  # Output: -3 (truncates toward zero)

4.5.6) Unerwartete float-Ergebnisse vermeiden

Manchmal sind Sie überrascht, einen float zu erhalten, wenn Sie eine Ganzzahl erwartet haben. Das passiert gewöhnlich aufgrund von Division oder gemischten Typen:

python

# unexpected_floats.py
# Calculating average - result is always float because of division
count = 10
total = 100
average = total / count
print(average)  # Output: 10.0 (float, even though it's a whole number)
 
# If you need an integer and you know it divides evenly:
average_int = total // count
print(average_int)  # Output: 10 (integer)
 
# Or convert explicitly:
average_int = int(total / count)
print(average_int)  # Output: 10 (integer)

Die wichtigste Erkenntnis: Pythons Typbeförderungsregeln sind darauf ausgelegt, Präzision zu erhalten und Datenverlust zu vermeiden. Wenn Sie Ganzzahlen und floats mischen oder die normale Division verwenden, erwarten Sie float-Ergebnisse. Wenn Sie Ganzzahlen benötigen, verwenden Sie Ganzzahldivision oder explizite Umwandlung, seien Sie sich aber bewusst, wie sie runden.

4.6) Nützliche eingebaute numerische Funktionen: abs(), min(), max() und pow()

Python stellt mehrere eingebaute Funktionen zur Verfügung, die häufige numerische Operationen durchführen. Diese Funktionen arbeiten mit Ganzzahlen und Gleitkommazahlen und sind unverzichtbare Werkzeuge für die tägliche Programmierung. Schauen wir uns die am häufigsten verwendeten an.

4.6.1) Absolutwert mit abs()

Die Funktion abs() liefert den Absolutwert einer Zahl – ihren Abstand von Null, ohne Vorzeichen:

python

# absolute_value.py
# Absolute value of negative numbers
result = abs(-42)
print(result)  # Output: 42
 
# Absolute value of positive numbers (unchanged)
result = abs(42)
print(result)  # Output: 42
 
# Works with floats too
result = abs(-3.14)
print(result)  # Output: 3.14
 
# Absolute value of zero is zero
result = abs(0)
print(result)  # Output: 0

Die Absolutwertfunktion ist immer dann nützlich, wenn Sie sich für die Größe, aber nicht die Richtung interessieren:

python

# practical_abs.py
# Calculate temperature difference (magnitude only)
morning_temp = 45.5
evening_temp = 38.2
 
difference = abs(evening_temp - morning_temp)
print(f"Temperature changed by {difference} degrees")
# Output: Temperature changed by 7.3 degrees
 
# Calculate distance between two points (always positive)
position1 = 10
position2 = 25
 
distance = abs(position2 - position1)
print(f"Distance: {distance}")  # Output: Distance: 15
 
# Works the same regardless of order
distance = abs(position1 - position2)
print(f"Distance: {distance}")  # Output: Distance: 15

4.6.2) Minimum und Maximum mit min() und max() finden

Die Funktion min() liefert das kleinste ihrer Argumente, und max() liefert das größte:

python

# min_max_basic.py
# Find minimum of two numbers
smallest = min(10, 25)
print(smallest)  # Output: 10
 
# Find maximum of two numbers
largest = max(10, 25)
print(largest)  # Output: 25
 
# Works with more than two arguments
smallest = min(5, 12, 3, 18, 7)
print(smallest)  # Output: 3
 
largest = max(5, 12, 3, 18, 7)
print(largest)  # Output: 18
 
# Works with floats and mixed types
smallest = min(3.5, 2, 4.1, 1.9)
print(smallest)  # Output: 1.9

Diese Funktionen sind äußerst hilfreich, um Extremwerte in Daten zu finden:

python

# practical_min_max.py
# Find the best and worst test scores
test1 = 85
test2 = 92
test3 = 78
test4 = 95
 
highest_score = max(test1, test2, test3, test4)
lowest_score = min(test1, test2, test3, test4)
 
print(f"Highest score: {highest_score}")  # Output: Highest score: 95
print(f"Lowest score: {lowest_score}")    # Output: Lowest score: 78
 
# Clamp a value within a range
value = 150
minimum = 0
maximum = 100
 
# Ensure value is not below minimum
value = max(value, minimum)
# Ensure value is not above maximum
value = min(value, maximum)
 
print(f"Clamped value: {value}")  # Output: Clamped value: 100

Das „Clamp“-Muster (unter Verwendung von max() und min() gemeinsam) ist üblich, wenn Sie einen Wert auf einen bestimmten Bereich begrenzen müssen:

python

# clamping_pattern.py
def clamp(value, min_value, max_value):
    """Constrain value to be within [min_value, max_value]"""
    return max(min_value, min(value, max_value))
 
# Test the clamp function
print(clamp(150, 0, 100))   # Output: 100 (too high, clamped to max)
print(clamp(-10, 0, 100))   # Output: 0 (too low, clamped to min)
print(clamp(50, 0, 100))    # Output: 50 (within range, unchanged)

4.6.3) Potenzierung mit pow()

Die Funktion pow() hebt eine Zahl auf eine Potenz. Python bietet außerdem den Operator ** für Potenzierung, der häufiger verwendet wird, aber pow() hat zusätzliche Möglichkeiten:

python

# exponentiation.py
# Using the ** operator (most common)
result = 2 ** 3  # 2 to the power of 3
print(result)  # Output: 8
 
result = 5 ** 2  # 5 squared
print(result)  # Output: 25
 
# Using pow() function (equivalent)
result = pow(2, 3)
print(result)  # Output: 8
 
result = pow(5, 2)
print(result)  # Output: 25
 
# Negative exponents give fractions
result = 2 ** -3  # 1 / (2^3) = 1/8
print(result)  # Output: 0.125
 
# Fractional exponents give roots
result = 9 ** 0.5  # Square root of 9
print(result)  # Output: 3.0
 
result = 8 ** (1/3)  # Cube root of 8
print(result)  # Output: 2.0

Die Funktion pow() kann ein optionales drittes Argument für modulare Potenzierung annehmen (nützlich in Kryptografie und Zahlentheorie, aber außerhalb des Umfangs der grundlegenden Arithmetik):

python

# modular_exponentiation.py
# pow(base, exponent, modulus) computes (base ** exponent) % modulus efficiently
result = pow(2, 10, 100)  # (2^10) % 100
print(result)  # Output: 24
 
# This is more efficient than computing separately for large numbers:
# result = (2 ** 10) % 100  # Same result, but less efficient for large numbers

Für die meisten Alltagsanwendungen ist der Operator ** bequemer als pow():

python

# practical_exponentiation.py
# Calculate compound interest: A = P(1 + r)^t
principal = 1000  # Initial amount
rate = 0.05       # 5% interest rate
years = 10
 
amount = principal * (1 + rate) ** years
print(f"Amount after {years} years: ${amount:.2f}")
# Output: Amount after 10 years: $1628.89
 
# Calculate area of a square
side_length = 5
area = side_length ** 2
print(f"Area: {area}")  # Output: Area: 25
 
# Calculate volume of a cube
side_length = 3
volume = side_length ** 3
print(f"Volume: {volume}")  # Output: Volume: 27

4.6.4) Eingebaute Funktionen kombinieren

Diese Funktionen arbeiten gut zusammen, um häufige Aufgaben zu lösen:

python

# combining_functions.py
# Find the range (difference between max and min)
values = [15, 42, 8, 23, 37]
value_range = max(values) - min(values)
print(f"Range: {value_range}")  # Output: Range: 34
 
# Note: We're using a list here (we'll learn about lists in detail in Chapter 13)
# For now, just understand that max() and min() can work with a list of values
 
# Calculate distance between two points in 2D space
x1, y1 = 3, 4
x2, y2 = 6, 8
 
# Distance formula: sqrt((x2-x1)^2 + (y2-y1)^2)
# We'll use ** for squaring (square root comes in section 4.11)
distance_squared = (x2 - x1) ** 2 + (y2 - y1) ** 2
distance = distance_squared ** 0.5  # Square root via fractional exponent
print(f"Distance: {distance}")  # Output: Distance: 5.0

Diese eingebauten Funktionen sind grundlegende Werkzeuge in der Python-Programmierung. Sie sind effizient, gut getestet und arbeiten konsistent über unterschiedliche numerische Typen hinweg. Verwenden Sie sie immer dann, wenn Sie diese typischen Operationen benötigen – es ist nicht nötig, eigene Implementierungen zu schreiben.

4.7) Zahlen mit round() runden

Wenn Sie mit Gleitkommazahlen arbeiten, müssen Sie Ergebnisse oft auf eine bestimmte Anzahl von Dezimalstellen runden – zur Anzeige, für Berechnungen oder zur Speicherung. Pythons Funktion round() bietet diese Möglichkeit.

4.7.1) Einfaches Runden mit round()

Die Funktion round() nimmt eine Zahl und rundet sie auf die nächste ganze Zahl:

python

# basic_rounding.py
# Round to nearest integer
result = round(3.7)
print(result)  # Output: 4
 
result = round(3.2)
print(result)  # Output: 3
 
# Exactly halfway rounds to nearest even number (banker's rounding)
result = round(2.5)
print(result)  # Output: 2 (rounds to even)
 
result = round(3.5)
print(result)  # Output: 4 (rounds to even)
 
# Negative numbers work too
result = round(-3.7)
print(result)  # Output: -4
 
result = round(-3.2)
print(result)  # Output: -3

Achten Sie auf das Verhalten beim Runden von Zahlen, die genau in der Mitte zwischen zwei ganzen Zahlen liegen (wie 2.5 oder 3.5). Python verwendet „Round half to even“ (auch „Banker's Rounding“ genannt), was zur nächstgelegenen geraden Zahl rundet. Dies reduziert Verzerrungen bei wiederholten Rundungen. Für die meisten Alltagsanwendungen spielt dieses Detail selten eine Rolle, aber es ist gut, es zu kennen.

4.7.2) Runden auf eine bestimmte Anzahl von Dezimalstellen

Die Funktion round() akzeptiert ein optionales zweites Argument, das angibt, wie viele Dezimalstellen beibehalten werden sollen:

python

# decimal_places.py
# Round to 2 decimal places
result = round(3.14159, 2)
print(result)  # Output: 3.14
 
# Round to 1 decimal place
result = round(3.14159, 1)
print(result)  # Output: 3.1
 
# Round to 3 decimal places
result = round(2.71828, 3)
print(result)  # Output: 2.718
 
# You can round to 0 decimal places (same as omitting the argument)
result = round(3.7, 0)
print(result)  # Output: 4.0 (note: returns float, not int)

Wenn Sie Dezimalstellen angeben, gibt round() einen float zurück (auch wenn Sie auf 0 Dezimalstellen runden). Wenn Sie das zweite Argument weglassen, wird eine Ganzzahl zurückgegeben.

4.7.3) Praktische Anwendungsfälle für Rundung

Runden ist essenziell für die Anzeige von Geldbeträgen, Messwerten und anderen Werten, bei denen übermäßige Präzision unnötig oder verwirrend ist:

python

# practical_rounding.py
# Display prices with 2 decimal places
price = 19.99
tax_rate = 0.08
total = price * (1 + tax_rate)
 
print(f"Total (unrounded): ${total}")  # Output: Total (unrounded): $21.5892
print(f"Total (rounded): ${round(total, 2)}")  # Output: Total (rounded): $21.59
 
# Calculate and display average
total_score = 456
num_tests = 7
average = total_score / num_tests
 
print(f"Average (unrounded): {average}")  # Output: Average (unrounded): 65.14285714285714
print(f"Average (rounded): {round(average, 2)}")  # Output: Average (rounded): 65.14
 
# Round measurements to reasonable precision
distance_meters = 123.456789
distance_rounded = round(distance_meters, 1)
print(f"Distance: {distance_rounded} meters")  # Output: Distance: 123.5 meters

4.7.4) Runden vs. Abschneiden vs. Floor/Ceiling

Es ist wichtig zu verstehen, dass Runden sich vom Abschneiden (Entfernen von Dezimalstellen) und von Floor/Ceiling-Operationen unterscheidet:

python

# rounding_vs_others.py
value = 3.7
 
# Rounding: nearest integer
rounded = round(value)
print(f"Rounded: {rounded}")  # Output: Rounded: 4
 
# Truncating: remove decimal part (convert to int)
truncated = int(value)
print(f"Truncated: {truncated}")  # Output: Truncated: 3
 
# We'll see floor and ceil in section 4.11, but briefly:
# Floor: largest integer <= value (always rounds down)
# Ceiling: smallest integer >= value (always rounds up)

Für negative Zahlen sind die Unterschiede deutlicher:

python

# negative_rounding.py
value = -3.7
 
# Rounding: nearest integer
rounded = round(value)
print(f"Rounded: {rounded}")  # Output: Rounded: -4
 
# Truncating: toward zero
truncated = int(value)
print(f"Truncated: {truncated}")  # Output: Truncated: -3
 
# Floor (rounds down toward negative infinity): -4
# Ceiling (rounds up toward positive infinity): -3

4.7.5) Wichtige Überlegungen beim Runden

Gleitkommapräzision kann zu Überraschungen führen:

Aufgrund der Art und Weise, wie Computer Gleitkommazahlen darstellen (was wir in Abschnitt 4.10 besprechen), liefert Runden nicht immer genau das erwartete Ergebnis:

python

# rounding_surprises.py
# Sometimes rounding doesn't give the exact decimal you expect
value = 2.675
rounded = round(value, 2)
print(rounded)  # Output: 2.67 (not 2.68 as you might expect)
 
# This happens because 2.675 can't be represented exactly in binary floating-point
# The actual stored value is slightly less than 2.675

Für die meisten praktischen Zwecke ist das kein Problem. Wenn Sie jedoch mit Finanzberechnungen arbeiten, bei denen exakte Dezimalarithmetik wichtig ist, könnten Sie Pythons Modul decimal benötigen (das wir in diesem Buch nicht behandeln, aber dessen Existenz Sie kennen sollten).

Runden zur Anzeige vs. Runden für Berechnungen:

Oft möchten Sie nur zur Anzeige runden, aber für Berechnungen die volle Präzision behalten:

python

# rounding_for_display.py
price1 = 19.99
price2 = 15.49
tax_rate = 0.08
 
# Calculate with full precision
subtotal = price1 + price2
tax = subtotal * tax_rate
total = subtotal + tax
 
# Round only for display
print(f"Subtotal: ${round(subtotal, 2)}")  # Output: Subtotal: $35.48
print(f"Tax: ${round(tax, 2)}")            # Output: Tax: $2.84
print(f"Total: ${round(total, 2)}")        # Output: Total: $38.32
 
# The variables still contain full precision
print(f"Total (full precision): ${total}")
# Output: Total (full precision): $38.3184

Die Funktion round() ist eine der am häufigsten verwendeten eingebauten Funktionen in Python. Verwenden Sie sie immer dann, wenn Sie numerische Ergebnisse in einem lesbaren Format darstellen oder die Präzision aus einem bestimmten Grund begrenzen müssen.

4.8) Häufige numerische Muster (Zähler, Summen, Durchschnitte)

Nachdem Sie nun Pythons numerische Operationen und Funktionen kennen, betrachten wir typische Muster, die Sie in realen Programmen immer wieder verwenden werden. Diese Muster bilden die Bausteine zur Verarbeitung numerischer Daten.

4.8.1) Zähler: Wie oft etwas passiert

Ein Zähler ist eine Variable, die mitzählt, wie oft etwas geschieht. Sie initialisieren ihn mit Null und erhöhen ihn jedes Mal, wenn ein Ereignis eintritt:

python

# basic_counter.py
# Count how many numbers we've processed
count = 0  # Initialize counter
 
# Process first number
count += 1
print(f"Processed {count} number(s)")  # Output: Processed 1 number(s)
 
# Process second number
count += 1
print(f"Processed {count} number(s)")  # Output: Processed 2 number(s)
 
# Process third number
count += 1
print(f"Processed {count} number(s)")  # Output: Processed 3 number(s)

In realen Programmen verwenden Sie Zähler typischerweise innerhalb von Schleifen (loops), die wir in den Kapiteln 10 und 11 kennenlernen. Für jetzt genügt das Muster: bei Null beginnen, bei jedem Ereignis eins addieren.

Zähler können verschiedene Arten von Ereignissen nachverfolgen:

python

# multiple_counters.py
# Track different categories
even_count = 0
odd_count = 0
 
# Check number 1
number = 4
if number % 2 == 0:
    even_count += 1
else:
    odd_count += 1
 
# Check number 2
number = 7
if number % 2 == 0:
    even_count += 1
else:
    odd_count += 1
 
# Check number 3
number = 10
if number % 2 == 0:
    even_count += 1
else:
    odd_count += 1
 
print(f"Even numbers: {even_count}")  # Output: Even numbers: 2
print(f"Odd numbers: {odd_count}")    # Output: Odd numbers: 1

4.8.2) Akkumulatoren: Summen aufbauen

Ein Akkumulator ist eine Variable, die eine laufende Summe sammelt. Wie bei einem Zähler initialisieren Sie ihn mit Null, aber statt jedes Mal eins hinzuzufügen, addieren Sie unterschiedliche Beträge:

python

# basic_accumulator.py
# Calculate total sales
total_sales = 0  # Initialize accumulator
 
# First sale
sale = 19.99
total_sales += sale
print(f"Total so far: ${total_sales}")  # Output: Total so far: $19.99
 
# Second sale
sale = 34.50
total_sales += sale
print(f"Total so far: ${total_sales}")  # Output: Total so far: $54.49
 
# Third sale
sale = 12.00
total_sales += sale
print(f"Total so far: ${total_sales}")  # Output: Total so far: $66.49

Akkumulatoren sind grundlegend für die Datenverarbeitung. Sie ermöglichen es Ihnen, Werte beim Durchlauf zu aggregieren:

python

# multiple_accumulators.py
# Track both total and count to calculate average later
total_score = 0
count = 0
 
# Process score 1
score = 85
total_score += score
count += 1
 
# Process score 2
score = 92
total_score += score
count += 1
 
# Process score 3
score = 78
total_score += score
count += 1
 
print(f"Total score: {total_score}")  # Output: Total score: 255
print(f"Number of scores: {count}")   # Output: Number of scores: 3

4.8.3) Durchschnitte berechnen

Ein Durchschnitt kombiniert die Muster Zähler und Akkumulator: Sie benötigen sowohl eine Summe (Akkumulator) als auch eine Anzahl (Zähler) und teilen dann:

python

# calculating_average.py
# Calculate average of test scores
total_score = 0
count = 0
 
# Add scores
total_score += 85
count += 1
 
total_score += 92
count += 1
 
total_score += 78
count += 1
 
total_score += 88
count += 1
 
# Calculate average
average = total_score / count
print(f"Average score: {average}")  # Output: Average score: 85.75
 
# Often you'll want to round the average
average_rounded = round(average, 2)
print(f"Average (rounded): {average_rounded}")  # Output: Average (rounded): 85.75

Wichtig: Immer auf Division durch Null prüfen:

Beim Berechnen von Durchschnitten müssen Sie sicherstellen, dass die Anzahl nicht null ist:

python

# safe_average.py
total_score = 0
count = 0
 
# If no scores were added, count is still 0
# Dividing by zero causes an error!
 
if count > 0:
    average = total_score / count
    print(f"Average: {average}")
else:
    print("No scores to average")
    # Output: No scores to average

Wir werden in Kapitel 8 mehr darüber lernen, wie man mit solchen Bedingungen umgeht.

4.8.4) Laufendes Maximum und Minimum finden

Manchmal müssen Sie den bisher größten oder kleinsten Wert nachverfolgen: Sie können die Funktionen max() und min() dafür nutzen:

python

# running_max_min_simplified.py
# Track highest and lowest using max() and min()
 
highest_temp = 72
lowest_temp = 72
 
# Update with new temperature
current_temp = 85
highest_temp = max(highest_temp, current_temp)
lowest_temp = min(lowest_temp, current_temp)
 
# Update with another temperature
current_temp = 68
highest_temp = max(highest_temp, current_temp)
lowest_temp = min(lowest_temp, current_temp)
 
print(f"High: {highest_temp}, Low: {lowest_temp}")
# Output: High: 85, Low: 68

4.9) Bitweise Operatoren für Ganzzahlen: &, |, ^, <<, >> (kurzer Überblick)

Bitweise Operatoren arbeiten auf den einzelnen Bits (Binärziffern) von Ganzzahlen. Auch wenn Sie diese Operatoren im Alltag seltener verwenden als arithmetische Operatoren, sind sie für bestimmte Aufgaben wichtig, etwa beim Arbeiten mit Flags, Berechtigungen, Low-Level-Datenmanipulation und Performance-Optimierung.

Dieser Abschnitt bietet einen kurzen Überblick. Bitweise Operationen setzen ein Verständnis binärer Darstellung voraus, das ein tieferes Thema ist, als wir in diesem einführenden Kapitel vollständig behandeln können.

4.9.1) Binärdarstellung verstehen (kurze Einführung)

Computer speichern Ganzzahlen als Folgen von Bits (0 und 1). Zum Beispiel:

Dezimal 5 ist binär 101 (1×4 + 0×2 + 1×1)
Dezimal 12 ist binär 1100 (1×8 + 1×4 + 0×2 + 0×1)

Pythons Funktion bin() zeigt die Binärdarstellung einer Ganzzahl:

python

# binary_representation.py
# See binary representation of integers
print(bin(5))   # Output: 0b101
print(bin(12))  # Output: 0b1100
print(bin(255)) # Output: 0b11111111
 
# The 0b prefix indicates binary notation

4.9.2) Bitweises UND (&)

Der Operator & führt ein bitweises UND (AND) aus: Jedes Bit im Ergebnis ist 1, nur wenn die entsprechenden Bits in beiden Operanden 1 sind:

python

# bitwise_and.py
# 12 is 1100 in binary
# 10 is 1010 in binary
result = 12 & 10
print(result)  # Output: 8
print(bin(result))  # Output: 0b1000
 
# How it works:
#   1100  (12)
# & 1010  (10)
# ------
#   1000  (8)

Bitweises UND wird häufig verwendet, um zu prüfen, ob bestimmte Bits gesetzt sind (Flags testen):

python

# checking_flags.py
# File permissions example (simplified)
READ = 4    # 100 in binary
WRITE = 2   # 010 in binary
EXECUTE = 1 # 001 in binary
 
permissions = 6  # 110 in binary (READ + WRITE)
 
# Check if READ permission is set
has_read = (permissions & READ) != 0
print(f"Has read: {has_read}")  # Output: Has read: True
 
# Check if EXECUTE permission is set
has_execute = (permissions & EXECUTE) != 0
print(f"Has execute: {has_execute}")  # Output: Has execute: False

4.9.3) Bitweises ODER (|)

Der Operator | führt ein bitweises ODER (OR) aus: Jedes Bit im Ergebnis ist 1, wenn das entsprechende Bit in mindestens einem der Operanden 1 ist:

python

# bitwise_or.py
# 12 is 1100 in binary
# 10 is 1010 in binary
result = 12 | 10
print(result)  # Output: 14
print(bin(result))  # Output: 0b1110
 
# How it works:
#   1100  (12)
# | 1010  (10)
# ------
#   1110  (14)

Bitweises ODER wird verwendet, um Flags zu kombinieren:

python

# combining_flags.py
READ = 4    # 100 in binary
WRITE = 2   # 010 in binary
EXECUTE = 1 # 001 in binary
 
# Grant READ and WRITE permissions
permissions = READ | WRITE
print(f"Permissions: {permissions}")  # Output: Permissions: 6
print(bin(permissions))  # Output: 0b110
 
# Add EXECUTE permission
permissions = permissions | EXECUTE
print(f"Permissions: {permissions}")  # Output: Permissions: 7
print(bin(permissions))  # Output: 0b111

4.9.4) Bitweises XOR (^)

Der Operator ^ führt ein bitweises XOR (exklusives ODER) aus: Jedes Bit im Ergebnis ist 1, wenn sich die entsprechenden Bits der Operanden unterscheiden:

python

# bitwise_xor.py
# 12 is 1100 in binary
# 10 is 1010 in binary
result = 12 ^ 10
print(result)  # Output: 6
print(bin(result))  # Output: 0b110
 
# How it works:
#   1100  (12)
# ^ 1010  (10)
# ------
#   0110  (6)

XOR hat interessante Eigenschaften, etwa zum Umschalten (Togglen) von Bits oder zum Vertauschen von Werten:

python

# xor_properties.py
# XOR with itself gives 0
result = 5 ^ 5
print(result)  # Output: 0
 
# XOR with 0 gives the original number
result = 5 ^ 0
print(result)  # Output: 5
 
# XOR is its own inverse (useful for simple encryption)
original = 42
key = 123
encrypted = original ^ key
decrypted = encrypted ^ key
print(f"Original: {original}, Encrypted: {encrypted}, Decrypted: {decrypted}")
# Output: Original: 42, Encrypted: 81, Decrypted: 42

4.9.5) Linksschieben (<<) und Rechtsschieben (>>)

Der Operator << verschiebt Bits nach links, und >> verschiebt Bits nach rechts:

python

# bit_shifting.py
# Left shift: multiply by powers of 2
result = 5 << 1  # Shift left by 1 bit
print(result)  # Output: 10
# 5 is 101 in binary, shifted left becomes 1010 (10)
 
result = 5 << 2  # Shift left by 2 bits
print(result)  # Output: 20
# 5 is 101 in binary, shifted left becomes 10100 (20)
 
# Right shift: divide by powers of 2 (floor division)
result = 20 >> 1  # Shift right by 1 bit
print(result)  # Output: 10
# 20 is 10100 in binary, shifted right becomes 1010 (10)
 
result = 20 >> 2  # Shift right by 2 bits
print(result)  # Output: 5
# 20 is 10100 in binary, shifted right becomes 101 (5)

Linksschieben um n Bits multipliziert mit 2^n, und Rechtsschieben dividiert durch 2^n (Ganzzahldivision):

python

# shift_as_multiplication.py
# Left shift multiplies by powers of 2
print(3 << 1)  # Output: 6 (3 * 2^1 = 3 * 2)
print(3 << 2)  # Output: 12 (3 * 2^2 = 3 * 4)
print(3 << 3)  # Output: 24 (3 * 2^3 = 3 * 8)
 
# Right shift divides by powers of 2
print(24 >> 1)  # Output: 12 (24 // 2^1 = 24 // 2)
print(24 >> 2)  # Output: 6 (24 // 2^2 = 24 // 4)
print(24 >> 3)  # Output: 3 (24 // 2^3 = 24 // 8)

4.9.6) Wann man bitweise Operatoren verwendet

Bitweise Operatoren sind in bestimmten Szenarien nützlich:

Arbeit mit binären Flags und Berechtigungen (z. B. Dateirechte unter Unix/Linux)
Low-Level-Datenmanipulation (mehrere Werte in einer Ganzzahl packen)
Netzwerkprogrammierung (IP-Adressen, Protokollflags manipulieren)
Grafik- und Spieleprogrammierung (Farben, Kollisionserkennung)
Performance-Optimierung (Bitverschiebung ist schneller als Multiplikation/Division durch Potenzen von 2)

Für die meisten alltäglichen Programmieraufgaben benötigen Sie bitweise Operatoren nicht. Aber wenn Sie sie benötigen – insbesondere in Systemprogrammierung, Netzwerken oder performancekritischem Code – sind sie unverzichtbare Werkzeuge.

Hinweis: Dieser Überblick deckt die Grundlagen ab. Bitweise Operationen werden bei negativen Zahlen komplexer (Stichwort Zweierkomplementdarstellung), was über den Rahmen dieser Einführung hinausgeht. Konzentrieren Sie sich vorerst darauf, dass diese Operatoren existieren und was sie im Groben tun.

4.10) Gleitkommapräzision und Rundungsfehler (einfache Erklärung)

Gleitkommazahlen in Python (und in den meisten Programmiersprachen) können einen enormen Wertebereich darstellen – von winzigen Brüchen bis hin zu riesigen Zahlen. Sie haben jedoch eine Einschränkung, die Anfänger überraschen kann: Sie können nicht alle Dezimalzahlen exakt darstellen. In diesem Abschnitt erklären wir, warum dies geschieht und was es für Ihre Programme bedeutet.

4.10.1) Warum Gleitkommazahlen nicht immer exakt sind

Computer speichern Gleitkommazahlen binär (zur Basis 2), nicht dezimal (zur Basis 10). Einige Dezimalbrüche, die für uns einfach wirken, lassen sich in Binärform nicht exakt darstellen – so wie 1/3 in Dezimalform nicht exakt darstellbar ist (0,333333... geht unendlich weiter).

Hier ein überraschendes Beispiel:

python

# floating_point_surprise.py
# This seems like it should be exactly 0.3
result = 0.1 + 0.2
print(result)  # Output: 0.30000000000000004 (not exactly 0.3!)
 
# Check if it equals 0.3
print(result == 0.3)  # Output: False

Das ist kein Fehler in Python – es ist eine grundlegende Einschränkung der Art, wie Computer Gleitkommazahlen darstellen. Die Dezimalzahl 0.1 lässt sich in binärer Gleitkommadarstellung nicht exakt darstellen, genauso wie 1/3 in Dezimaldarstellung nicht exakt dargestellt werden kann.

4.10.2) Das Darstellungsproblem verstehen

Sehen wir uns weitere Beispiele für dieses Verhalten an:

python

# more_precision_examples.py
# Simple decimal values that aren't exact in binary
print(0.1)  # Output: 0.1 (Python rounds for display)
print(repr(0.1))  # Output: 0.1 (still rounded)
 
# But the actual stored value has tiny errors
print(0.1 + 0.1 + 0.1)  # Output: 0.30000000000000004
 
# Multiplication can accumulate these errors
result = 0.1 * 3
print(result)  # Output: 0.30000000000000004
 
# Some numbers are exact (powers of 2)
print(0.5)  # Output: 0.5 (exact)
print(0.25)  # Output: 0.25 (exact)
print(0.125)  # Output: 0.125 (exact)

Zahlen, die Potenzen von 2 sind (wie 0.5, 0.25, 0.125) oder Summen solcher Potenzen, können exakt dargestellt werden. Die meisten Dezimalbrüche jedoch nicht.

4.10.3) Praktische Auswirkungen

Für die meisten Alltagsanwendungen spielen diese winzigen Fehler keine Rolle. Es gibt jedoch Situationen, in denen Sie sich ihrer bewusst sein sollten:

Vergleich von Gleitkommazahlen:

python

# comparing_floats.py
# Direct equality comparison can fail
a = 0.1 + 0.2
b = 0.3
 
print(a == b)  # Output: False (due to tiny difference)
 
# Better: check if they're close enough
difference = abs(a - b)
tolerance = 0.0001  # How close is "close enough"?
 
print(difference < tolerance)  # Output: True (they're close enough)
 
# Python 3.5+ provides math.isclose() for this (we'll see in section 4.11)

Fehlerakkumulation bei wiederholten Berechnungen:

python

# accumulated_errors.py
# Adding 0.1 ten times
total = 0.0
for i in range(10):
    total += 0.1
 
print(total)  # Output: 0.9999999999999999 (not exactly 1.0)
print(total == 1.0)  # Output: False
 
# The error accumulates with each addition

Finanzberechnungen:

python

# financial_calculations.py
# Money calculations can have surprising results
price = 0.10
quantity = 3
total = price * quantity
 
print(total)  # Output: 0.30000000000000004
 
# For financial calculations, consider rounding to cents
total_cents = round(total * 100)  # Convert to cents
total_dollars = total_cents / 100
print(total_dollars)  # Output: 0.3
 
# Or use Python's decimal module for exact decimal arithmetic
# (beyond the scope of this chapter, but worth knowing about)

4.10.4) Strategien im Umgang mit Gleitkommazahlen

Ergebnisse zur Anzeige runden:

python

# rounding_for_display.py
result = 0.1 + 0.2
print(f"Result: {round(result, 2)}")  # Output: Result: 0.3
 
# Or use formatted output (we'll learn more in Chapter 6)
print(f"Result: {result:.2f}")  # Output: Result: 0.30

Gleitkommazahlen nicht auf exakte Gleichheit prüfen:

python

# safe_float_comparison.py
a = 0.1 + 0.2
b = 0.3
 
# Instead of: if a == b:
# Use: if they're close enough
if abs(a - b) < 0.0001:
    print("Close enough to equal")
# Output: Close enough to equal

Sich bewusst sein, wann Präzision wichtig ist:

Für wissenschaftliches Rechnen, Finanzberechnungen oder Bereiche, in denen exakte Dezimalarithmetik entscheidend ist, könnten Sie benötigen:

Pythons Modul decimal für exakte Dezimalarithmetik
Pythons Modul fractions für exakte Brucharithmetik
Sorgfältiges Runden an geeigneten Stellen innerhalb Ihrer Berechnungen

Diese Module liegen außerhalb des Umfangs dieses Kapitels, aber es ist nützlich zu wissen, dass es sie gibt.

4.10.5) Wann Gleitkommapräzision keine Rolle spielt

Für die meisten alltäglichen Programmieraufgaben ist die Gleitkommapräzision völlig ausreichend:

python

# when_precision_is_fine.py
# Calculating area
length = 5.5
width = 3.2
area = length * width
print(f"Area: {area:.2f} square meters")  # Output: Area: 17.60 square meters
 
# Converting temperature
fahrenheit = 98.6
celsius = (fahrenheit - 32) * 5 / 9
print(f"Temperature: {celsius:.1f}°C")  # Output: Temperature: 37.0°C
 
# Calculating average
total = 456.78
count = 7
average = total / count
print(f"Average: {average:.2f}")  # Output: Average: 65.25

Wenn Sie Ergebnisse für die Anzeige runden oder wenn winzige Fehler im Vergleich zur Genauigkeit Ihrer Messungen unbedeutend sind, funktionieren Gleitkommazahlen hervorragend.

4.10.6) Die zentrale Erkenntnis

Gleitkommazahlen sind Annäherungen an reelle Zahlen. Für die meisten Programmieraufgaben sind sie genau genug. Merken Sie sich jedoch:

Vergleichen Sie floats nicht auf exakte Gleichheit – prüfen Sie stattdessen, ob sie „nah genug“ beieinander liegen
Runden Sie Ergebnisse bei der Anzeige, um bedeutungslose Präzision zu vermeiden
Seien Sie sich über Fehlerakkumulation bei wiederholten Berechnungen im Klaren
Verwenden Sie für Finanzberechnungen gegebenenfalls geeignete Rundung oder das Modul decimal

Wenn Sie diese Einschränkungen kennen, können Sie robustere Programme schreiben und überraschende Fehler vermeiden. Die gute Nachricht ist: Für die allermeisten Aufgaben „funktioniert“ Gleitkommaarithmetik einfach, wenn Sie diese einfachen Richtlinien befolgen.

4.11) (Optional) Grundlegende mathematische Funktionen mit dem math-Modul (sqrt, floor, ceil, pi)

Pythons eingebaute Operatoren und Funktionen decken die grundlegende Arithmetik ab, aber für weitergehende mathematische Operationen stellt Python das Modul math bereit. Ein Modul ist eine Sammlung verwandter Funktionen und Werte, die Sie in Ihren Programmen verwenden können. Wir werden in Kapitel 22 deutlich mehr über Module lernen, aber fürs Erste stellen wir die Grundlagen vor, die Sie brauchen, um das math-Modul zu nutzen.

4.11.1) Das math-Modul importieren

Um das math-Modul zu verwenden, müssen Sie es am Anfang Ihres Programms importieren:

python

# importing_math.py
import math
 
# Now you can use functions from the math module
# by writing math.function_name()

Wenn Sie ein Modul importieren, erhalten Sie Zugriff auf alle seine Funktionen und Werte. Sie verwenden sie, indem Sie den Modulnamen, einen Punkt und dann den Funktions- oder Wertnamen schreiben.

4.11.2) Mathematische Konstanten: pi und e

Das math-Modul stellt präzise Werte für wichtige mathematische Konstanten bereit:

python

# math_constants.py
import math
 
# Pi (π): ratio of circle's circumference to diameter
print(math.pi)  # Output: 3.141592653589793
 
# Euler's number (e): base of natural logarithms
print(math.e)  # Output: 2.718281828459045
 
# Using pi to calculate circle properties
radius = 5
circumference = 2 * math.pi * radius
area = math.pi * radius ** 2
 
print(f"Circumference: {circumference:.2f}")  # Output: Circumference: 31.42
print(f"Area: {area:.2f}")  # Output: Area: 78.54

4.11.3) Quadratwurzel mit sqrt()

Die Funktion sqrt() berechnet die Quadratwurzel einer Zahl:

python

# square_root.py
import math
 
# Square root of perfect squares
result = math.sqrt(16)
print(result)  # Output: 4.0
 
result = math.sqrt(25)
print(result)  # Output: 5.0
 
# Square root of non-perfect squares
result = math.sqrt(2)
print(result)  # Output: 1.4142135623730951
 
# Using sqrt in calculations
# Distance formula: sqrt((x2-x1)^2 + (y2-y1)^2)
x1, y1 = 3, 4
x2, y2 = 6, 8
 
distance = math.sqrt((x2 - x1) ** 2 + (y2 - y1) ** 2)
print(f"Distance: {distance}")  # Output: Distance: 5.0

Beachten Sie, dass sqrt() immer einen float zurückgibt, selbst bei Quadratzahlen. Außerdem können Sie mit sqrt() keine Quadratwurzel negativer Zahlen ziehen (es würde einen Fehler auslösen).

4.11.4) Floor und Ceiling mit floor() und ceil()

Die Funktion floor() rundet auf die nächstkleinere ganze Zahl ab (in Richtung negativer Unendlichkeit), und ceil() rundet auf (in Richtung positiver Unendlichkeit):

python

# floor_and_ceil.py
import math
 
# Floor: rounds down
result = math.floor(3.7)
print(result)  # Output: 3
 
result = math.floor(3.2)
print(result)  # Output: 3
 
# Ceiling: rounds up
result = math.ceil(3.7)
print(result)  # Output: 4
 
result = math.ceil(3.2)
print(result)  # Output: 4
 
# With negative numbers
result = math.floor(-3.7)
print(result)  # Output: -4 (rounds toward negative infinity)
 
result = math.ceil(-3.7)
print(result)  # Output: -3 (rounds toward positive infinity)

Diese Funktionen sind nützlich, wenn Sie sicherstellen müssen, dass ein Wert innerhalb eines bestimmten Bereichs liegt oder wenn Sie ganzzahlige Ergebnisse mit bestimmtem Rundungsverhalten benötigen:

python

# practical_floor_ceil.py
import math
 
# How many boxes needed to pack all items?
items = 47
items_per_box = 12
 
# Use ceil to round up (need a full box even if not completely filled)
boxes_needed = math.ceil(items / items_per_box)
print(f"Boxes needed: {boxes_needed}")  # Output: Boxes needed: 4
 
# How many complete pages for a document?
total_lines = 250
lines_per_page = 30
 
# Use floor to count only complete pages
complete_pages = math.floor(total_lines / lines_per_page)
print(f"Complete pages: {complete_pages}")  # Output: Complete pages: 8

4.11.5) floor(), ceil(), round() und int() vergleichen

Es ist hilfreich zu verstehen, wie sich diese unterschiedlichen Rundungsansätze unterscheiden:

python

# comparing_rounding_methods.py
import math
 
value = 3.7
 
print(f"Original: {value}")
print(f"floor(): {math.floor(value)}")  # Output: floor(): 3
print(f"ceil(): {math.ceil(value)}")    # Output: ceil(): 4
print(f"round(): {round(value)}")       # Output: round(): 4
print(f"int(): {int(value)}")           # Output: int(): 3
 
# With negative numbers, the differences are more apparent
value = -3.7
 
print(f"\nOriginal: {value}")
print(f"floor(): {math.floor(value)}")  # Output: floor(): -4
print(f"ceil(): {math.ceil(value)}")    # Output: ceil(): -3
print(f"round(): {round(value)}")       # Output: round(): -4
print(f"int(): {int(value)}")           # Output: int(): -3

Hier ist eine visuelle Darstellung, wie sich diese Funktionen verhalten:

4.11.6) Weitere nützliche Funktionen des math-Moduls

Das math-Modul enthält viele weitere Funktionen. Hier sind einige, die häufig nützlich sind:

python

# other_math_functions.py
import math
 
# Absolute value (also available as built-in abs())
result = math.fabs(-5.5)
print(result)  # Output: 5.5
 
# Power function (also available as ** operator)
result = math.pow(2, 3)
print(result)  # Output: 8.0
 
# Trigonometric functions (angles in radians)
result = math.sin(math.pi / 2)  # sin(90 degrees)
print(result)  # Output: 1.0
 
result = math.cos(0)  # cos(0 degrees)
print(result)  # Output: 1.0
 
# Logarithms
result = math.log(math.e)  # Natural log (base e)
print(result)  # Output: 1.0
 
result = math.log10(100)  # Log base 10
print(result)  # Output: 2.0
 
# Check if a float is close to another (Python 3.5+)
a = 0.1 + 0.2
b = 0.3
result = math.isclose(a, b)
print(result)  # Output: True

Die Funktion isclose() ist besonders nützlich zum Vergleichen von Gleitkommazahlen (wie in Abschnitt 4.10 besprochen):

python

# isclose_example.py
import math
 
# Instead of direct equality comparison
a = 0.1 + 0.2
b = 0.3
 
# Don't do this:
# if a == b:  # This would be False
 
# Do this instead:
if math.isclose(a, b):
    print("Values are close enough")
# Output: Values are close enough
 
# You can specify the tolerance
if math.isclose(a, b, rel_tol=1e-9):  # Very strict tolerance
    print("Values are very close")
# Output: Values are very close

4.11.7) Wann Sie das math-Modul verwenden sollten

Verwenden Sie das math-Modul, wenn Sie benötigen:

Mathematische Konstanten (π, e)
Quadratwurzeln und andere Wurzeln
Trigonometrische Funktionen (sin, cos, tan)
Logarithmus- und Exponentialfunktionen
Präzise Rundungssteuerung (floor, ceil)
Vergleich von Gleitkommazahlen (isclose)

Für grundlegende Arithmetik (+, -, *, /, //, %, **) verwenden Sie Pythons eingebaute Operatoren. Für weitergehende mathematische Operationen importieren und verwenden Sie das math-Modul.

Das math-Modul ist Teil der Python-Standardbibliothek, d. h. es ist immer verfügbar – Sie müssen es nur importieren. Wir werden weitere Module erkunden und das Importsystem in Kapitel 22 im Detail kennenlernen.

In diesem Kapitel haben Sie gelernt, wie Sie mit Zahlen in Python arbeiten: arithmetische Operationen durchführen, unterschiedliche Arten der Division verstehen, die Operatorrangfolge nutzen, Ganzzahlen und floats mischen, eingebaute numerische Funktionen verwenden, häufige numerische Muster erkennen, mit bitweisen Operatoren arbeiten, Gleitkommapräzision verstehen und das math-Modul für weitergehende Operationen einsetzen.

Diese numerischen Operationen bilden die Grundlage für unzählige Programmieraufgaben – von einfachen Berechnungen bis hin zu komplexer Datenanalyse. Während Sie Python weiter erlernen, werden Sie diese Operationen ständig verwenden, oft in Kombination mit den Kontrollstrukturen und Datensammlungen, die Sie in den nächsten Kapiteln kennenlernen.

Üben Sie diese Operationen so lange, bis sie Ihnen in Fleisch und Blut übergegangen sind. Versuchen Sie, kleine Programme zu schreiben, die reale Größen berechnen: Temperaturen umrechnen, Flächen und Volumina berechnen, Finanzdaten verarbeiten oder Messwerte analysieren. Je mehr Sie üben, desto vertrauter werden Ihnen Pythons numerische Möglichkeiten.