Zahlen und Operatoren in Python

Arithmetische Operatoren

Python bietet alle grundlegenden mathematischen Operationen:

a = 15
b = 4

print(f"{a} + {b} = {a + b}")    # 15 + 4 = 19
print(f"{a} - {b} = {a - b}")    # 15 - 4 = 11
print(f"{a} * {b} = {a * b}")    # 15 * 4 = 60
print(f"{a} / {b} = {a / b}")    # 15 / 4 = 3.75
print(f"{a} // {b} = {a // b}")  # 15 // 4 = 3
print(f"{a} % {b} = {a % b}")    # 15 % 4 = 3
print(f"{a} ** {b} = {a ** b}")  # 15 ** 4 = 50625

Ganzzahldivision vs. echte Division

Das ist ein haeufiger Stolperstein fuer Anfaenger. Python hat zwei Divisionsoperatoren:

/ — Echte Division (ergibt immer float)

print(10 / 3)    # 3.3333333333333335
print(10 / 2)    # 5.0  -- auch bei glattem Ergebnis ein float!
print(15 / 5)    # 3.0

print(type(10 / 2))  # <class 'float'>

// — Ganzzahldivision (rundet ab)

print(10 // 3)   # 3   -- abgerundet
print(15 // 4)   # 3
print(7 // 2)    # 3

# Achtung bei negativen Zahlen: rundet IMMER ab!
print(-7 // 2)   # -4  (nicht -3!)
print(-10 // 3)  # -4  (nicht -3!)

Warum ist das wichtig?

# Beispiel: Minuten in Stunden und Minuten umrechnen
gesamt_minuten = 147

stunden = gesamt_minuten // 60    # 2
minuten = gesamt_minuten % 60     # 27

print(f"{gesamt_minuten} Minuten = {stunden} Stunden und {minuten} Minuten")
# 147 Minuten = 2 Stunden und 27 Minuten

Die Kombination von // und % ist ein klassisches Muster, das dir immer wieder begegnen wird.

Der Modulo-Operator %

Der Modulo-Operator gibt den Rest einer Division zurueck. Er ist unglaublich nuetzlich:

Gerade oder ungerade?

zahl = 17

if zahl % 2 == 0:
    print(f"{zahl} ist gerade")
else:
    print(f"{zahl} ist ungerade")
# 17 ist ungerade

Teilbarkeit pruefen

zahl = 15

print(f"Durch 3 teilbar: {zahl % 3 == 0}")  # True
print(f"Durch 5 teilbar: {zahl % 5 == 0}")  # True
print(f"Durch 7 teilbar: {zahl % 7 == 0}")  # False

Zyklische Operationen

# Wochentag berechnen (0 = Montag, 6 = Sonntag)
tage = ["Mo", "Di", "Mi", "Do", "Fr", "Sa", "So"]

heute = 2  # Mittwoch
in_10_tagen = (heute + 10) % 7
print(f"In 10 Tagen ist: {tage[in_10_tagen]}")  # Sa

Letzte Ziffern extrahieren

zahl = 12345

letzte_ziffer = zahl % 10       # 5
letzte_zwei = zahl % 100        # 45
letzte_drei = zahl % 1000       # 345

print(letzte_ziffer, letzte_zwei, letzte_drei)

Der Potenz-Operator **

Mit ** berechnest du Potenzen:

print(2 ** 3)      # 8       (2 hoch 3)
print(10 ** 6)     # 1000000 (eine Million)
print(3 ** 0)      # 1       (jede Zahl hoch 0 ist 1)
print(2 ** -1)     # 0.5     (negative Exponenten)

# Quadratwurzel ueber Potenz
print(9 ** 0.5)    # 3.0
print(16 ** 0.5)   # 4.0
print(2 ** 0.5)    # 1.4142135623730951

Grosse Zahlen? Kein Problem!

# Python kann mit beliebig grossen Ganzzahlen umgehen:
riesig = 2 ** 100
print(riesig)
# 1267650600228229401496703205376

print(2 ** 1000)  # Auch das geht problemlos!

Vergleichsoperatoren

Vergleichsoperatoren geben immer True oder False zurueck:

alter = 18

print(alter == 18)    # True
print(alter != 21)    # True
print(alter < 21)     # True
print(alter > 16)     # True
print(alter <= 18)    # True
print(alter >= 18)    # True

Verkettete Vergleiche

Python erlaubt elegante verkettete Vergleiche:

alter = 25

# Statt:
print(alter >= 18 and alter <= 65)  # True

# Geht auch so (pythonisch!):
print(18 <= alter <= 65)  # True

# Auch mit mehr als zwei Vergleichen:
x = 5
print(1 < x < 10)       # True
print(1 < x < 3)        # False

Achtung: == vs. =

x = 5      # Zuweisung: x bekommt den Wert 5
x == 5     # Vergleich: Ist x gleich 5? (True)

# Haeufiger Anfaengerfehler:
# if x = 5:    # SyntaxError! Zuweisung statt Vergleich
# if x == 5:   # Richtig!

Logische Operatoren

Logische Operatoren verknuepfen Wahrheitswerte:

and — Beide Bedingungen muessen wahr sein

alter = 25
hat_fuehrerschein = True

if alter >= 18 and hat_fuehrerschein:
    print("Du darfst Auto fahren!")
# Du darfst Auto fahren!

or — Mindestens eine Bedingung muss wahr sein

tag = "Samstag"

if tag == "Samstag" or tag == "Sonntag":
    print("Wochenende!")
else:
    print("Arbeitstag.")
# Wochenende!

not — Bedingung umkehren

ist_regen = False

if not ist_regen:
    print("Geh raus und geniess die Sonne!")
# Geh raus und geniess die Sonne!

Kurzschluss-Auswertung (Short-Circuit)

Python wertet logische Ausdruecke nur so weit wie noetig aus:

# Bei `and`: Wenn der erste Wert False ist, wird der zweite gar nicht geprueft
x = 0
if x != 0 and 10 / x > 2:  # Kein Fehler! 10/x wird nie berechnet
    print("Ja")

# Bei `or`: Wenn der erste Wert True ist, wird der zweite nicht geprueft
name = ""
anzeige = name or "Unbekannt"  # Wenn name leer (Falsy), nimm "Unbekannt"
print(anzeige)  # Unbekannt

Dieses Muster mit or als Standardwert ist ein haeufiger Python-Trick:

benutzername = input("Name (Enter fuer Standard): ") or "Gast"
print(f"Willkommen, {benutzername}!")

Zuweisungsoperatoren

Zuweisungsoperatoren sind Kurzformen fuer “berechne und weise zu”:

punkte = 100

punkte += 10    # 110
print(punkte)

punkte -= 25    # 85
print(punkte)

punkte *= 2     # 170
print(punkte)

punkte //= 3    # 56
print(punkte)

# Auch mit Strings:
text = "Hallo"
text += " Welt"    # "Hallo Welt"
print(text)

# Und mit Listen:
liste = [1, 2]
liste += [3, 4]    # [1, 2, 3, 4]
print(liste)

Hinweis: Python hat kein ++ oder -- wie C oder Java. Verwende stattdessen x += 1 und x -= 1.

Das math-Modul

Fuer fortgeschrittenere mathematische Operationen gibt es das eingebaute math-Modul:

import math

Wichtige Funktionen

import math

# Quadratwurzel
print(math.sqrt(16))     # 4.0
print(math.sqrt(2))      # 1.4142135623730951

# Auf- und Abrunden
print(math.ceil(3.2))    # 4   -- aufrunden
print(math.floor(3.8))   # 3   -- abrunden

# Absolutwert (geht auch ohne math)
print(abs(-42))           # 42
print(math.fabs(-42))     # 42.0

# Potenz und Logarithmus
print(math.pow(2, 10))    # 1024.0
print(math.log(100, 10))  # 2.0  (Logarithmus zur Basis 10)
print(math.log2(1024))    # 10.0

# Trigonometrie
print(math.sin(math.pi / 2))   # 1.0
print(math.cos(0))              # 1.0
print(math.tan(math.pi / 4))   # 0.9999999999999999 (ungefaehr 1)

Wichtige Konstanten

import math

print(math.pi)   # 3.141592653589793
print(math.e)    # 2.718281828459045
print(math.inf)  # inf (Unendlich)
print(math.nan)  # nan (Not a Number)
print(math.tau)  # 6.283185307179586 (2 * pi)

Praktisches Beispiel: Entfernungsberechnung

import math

def entfernung(x1, y1, x2, y2):
    """Berechnet die Entfernung zwischen zwei Punkten."""
    return math.sqrt((x2 - x1) ** 2 + (y2 - y1) ** 2)

# Entfernung zwischen (0, 0) und (3, 4)
d = entfernung(0, 0, 3, 4)
print(f"Entfernung: {d}")  # Entfernung: 5.0

Die round() Funktion

round() rundet eine Zahl auf die gewuenschte Anzahl Nachkommastellen:

print(round(3.14159))       # 3     -- ohne Angabe: auf Ganzzahl
print(round(3.14159, 2))    # 3.14  -- 2 Nachkommastellen
print(round(3.14159, 4))    # 3.1416
print(round(3.5))           # 4
print(round(4.5))           # 4     -- Ueberraschung! "Banker's Rounding"

Banker’s Rounding

Python verwendet Banker’s Rounding (auch “Round Half to Even”): Bei genau .5 wird auf die naechste gerade Zahl gerundet:

print(round(0.5))   # 0  (gerade)
print(round(1.5))   # 2  (gerade)
print(round(2.5))   # 2  (gerade)
print(round(3.5))   # 4  (gerade)
print(round(4.5))   # 4  (gerade)

Das ist mathematisch fairer als immer aufzurunden, weil es eine systematische Verzerrung vermeidet.

Runden auf negative Stellen

# Runden auf Zehner, Hunderter, etc.
print(round(1234, -1))    # 1230
print(round(1234, -2))    # 1200
print(round(1234, -3))    # 1000
print(round(1555, -2))    # 1600

Operator-Prioritaet

Wie in der Mathematik gibt es auch in Python eine Reihenfolge, in der Operatoren ausgewertet werden (von hoechster zu niedrigster Prioritaet):

# Beispiele zur Prioritaet:
print(2 + 3 * 4)        # 14  (nicht 20! Multiplikation zuerst)
print((2 + 3) * 4)      # 20  (Klammern aendern die Reihenfolge)

print(2 ** 3 ** 2)       # 512 (** ist rechts-assoziativ: 2 ** (3 ** 2) = 2 ** 9)
print((2 ** 3) ** 2)     # 64

print(10 - 3 - 2)        # 5  (links-assoziativ: (10 - 3) - 2)

# Vergleich + Logik
x = 5
print(x > 3 and x < 10)  # True (Vergleiche zuerst, dann and)

Faustregel: Wenn du dir unsicher bist, setze Klammern! Klammern machen den Code auch lesbarer.

# Lieber zu viele Klammern als zu wenige:
ergebnis = ((a + b) * c) / (d - e)

Uebungen

Uebung 1: Kleiner Taschenrechner

Schreibe einen einfachen Taschenrechner, der zwei Zahlen und eine Operation entgegennimmt:

print("=== Taschenrechner ===")
zahl1 = float(input("Erste Zahl: "))
operator = input("Operator (+, -, *, /): ")
zahl2 = float(input("Zweite Zahl: "))

if operator == "+":
    ergebnis = zahl1 + zahl2
elif operator == "-":
    ergebnis = zahl1 - zahl2
elif operator == "*":
    ergebnis = zahl1 * zahl2
elif operator == "/":
    if zahl2 != 0:
        ergebnis = zahl1 / zahl2
    else:
        ergebnis = "Fehler: Division durch Null!"
else:
    ergebnis = "Unbekannter Operator!"

print(f"{zahl1} {operator} {zahl2} = {ergebnis}")

Uebung 2: Temperatur-Umrechner

Schreibe Funktionen, die zwischen Celsius und Fahrenheit umrechnen:

def celsius_zu_fahrenheit(celsius):
    return celsius * 9 / 5 + 32

def fahrenheit_zu_celsius(fahrenheit):
    return (fahrenheit - 32) * 5 / 9

# Tests
print(f"0°C = {celsius_zu_fahrenheit(0):.1f}°F")       # 32.0°F
print(f"100°C = {celsius_zu_fahrenheit(100):.1f}°F")    # 212.0°F
print(f"98.6°F = {fahrenheit_zu_celsius(98.6):.1f}°C")  # 37.0°C

Uebung 3: Gerade/Ungerade + FizzBuzz

Schreibe ein Programm, das die Zahlen 1 bis 30 ausgibt. Aber:

• Bei Vielfachen von 3: gib “Fizz” aus
• Bei Vielfachen von 5: gib “Buzz” aus
• Bei Vielfachen von 3 UND 5: gib “FizzBuzz” aus
• Sonst: gib die Zahl aus

for zahl in range(1, 31):
    if zahl % 3 == 0 and zahl % 5 == 0:
        print("FizzBuzz")
    elif zahl % 3 == 0:
        print("Fizz")
    elif zahl % 5 == 0:
        print("Buzz")
    else:
        print(zahl)

Uebung 4: Zinseszins-Rechner

Berechne, wie sich ein Anfangskapital mit Zinseszins entwickelt:

import math

kapital = 1000       # Euro
zinssatz = 0.05      # 5% pro Jahr
jahre = 10

# Formel: K = K0 * (1 + p)^n
endkapital = kapital * (1 + zinssatz) ** jahre
gewinn = endkapital - kapital

print(f"Anfangskapital:  {kapital:>10.2f} EUR")
print(f"Zinssatz:        {zinssatz * 100:>9.1f}%")
print(f"Laufzeit:        {jahre:>9} Jahre")
print(f"Endkapital:      {endkapital:>10.2f} EUR")
print(f"Gewinn:          {gewinn:>10.2f} EUR")

Uebung 5: Zahlenraetsel

Schreibe ein Programm, das eine zufaellige Zahl zwischen 1 und 100 generiert, und lass den Benutzer raten:

import random

geheimzahl = random.randint(1, 100)
versuche = 0

print("Ich denke an eine Zahl zwischen 1 und 100...")

while True:
    tipp = int(input("Dein Tipp: "))
    versuche += 1

    if tipp < geheimzahl:
        print("Zu niedrig!")
    elif tipp > geheimzahl:
        print("Zu hoch!")
    else:
        print(f"Richtig! Du hast es in {versuche} Versuchen geschafft!")
        break

# Statt:
stunden = 147 // 60    # 2
minuten = 147 % 60     # 27

# Besser:
stunden, minuten = divmod(147, 60)
print(f"2 Stunden und 27 Minuten")

# Noch ein Beispiel: Sekunden umrechnen
gesamt_sekunden = 3725
minuten, sekunden = divmod(gesamt_sekunden, 60)
stunden, minuten = divmod(minuten, 60)
print(f"{stunden}h {minuten}m {sekunden}s")  # 1h 2m 5s