DE EN

Operatoren

Rechnen, vergleichen, logisch verknüpfen — die mathematische Grundlage der Programmierung.

40 Min Leicht

Lernziele dieses Kapitels

  • Du nutzt arithmetische Operatoren für Berechnungen und verstehst den Unterschied zwischen / und //
  • Du vergleichst Werte mit ==, !=, <, > und kombinierst Bedingungen mit and, or, not
  • Du kennst den Walrus-Operator := als Python-Spezialität
  • Du erweiterst PyBuddy um einen XP-Rechner

Arithmetische Operatoren

In Python kannst du wie im Taschenrechner rechnen. Die Grundrechenarten kennst du aus der Mathe — aber es gibt einige Python-Spezialitäten:

  • +, -, * — Addition, Subtraktion, Multiplikation
  • / — Division (gibt immer float zurück!)
  • // — Ganzzahlige Division (abgerundet)
  • % — Modulo (Rest einer Division)
  • ** — Potenzierung

Pro Tipp

In Spielen nutzt du % oft für Wrap-Around-Logik: Wenn ein Spieler am Ende der Karte ist und weiterläuft, landet er wieder am Anfang.

Python 
# Arithmetische Operatoren im Überblick
a = 17
b = 5

print(a + b)    # 22
print(a - b)    # 12
print(a * b)    # 85
print(a / b)    # 3.4  (immer float!)
print(a // b)   # 3    (ganzzahlig)
print(a % b)    # 2    (Rest)
print(a ** b)   # 1419857 (17 hoch 5)

# Praxis: XP-Berechnung
basis_xp = 100
bonus = 1.5
gesamt = int(basis_xp * bonus + 25)
print(f"Du erhältst {gesamt} XP!")
Ausgabe
22 12 85 3.4 3 2 1419857 Du erhältst 175 XP!
Python vs. JavaScript — Das kennst du schon!

Du kennst bereits JavaScript aus dem JS-Quest. Hier ist der direkte Vergleich:

Python
print(17 // 5)   # 3
print(17 % 5)    # 2
print(2 ** 8)    # 256
JavaScript
console.log(Math.floor(17 / 5));  // 3
console.log(17 % 5);                // 2
console.log(Math.pow(2, 8));        // 256
Merke: Python hat // und ** direkt als Operatoren. In JavaScript brauchst du Math.floor() und Math.pow() (oder ** mit ES6).

Vergleichsoperatoren

Vergleichsoperatoren prüfen Beziehungen zwischen Werten und geben immer True oder False zurück. Sie sind das Herzstück von Bedingungen (die du im nächsten Kapitel vertiefst).

  • == — gleich
  • != — ungleich
  • <, > — kleiner, größer
  • <=, >= — kleiner/gleich, größer/gleich

Wichtig: = ist Zuweisung, == ist Vergleich. Das verwechseln Anfänger oft!

Python 
# Vergleichsoperatoren
level = 10
print(level == 10)   # True
print(level != 5)    # True
print(level > 20)    # False
print(level <= 15)   # True

# Strings vergleichen
name = "PyBuddy"
print(name == "pybuddy")   # False (Groß-/Kleinschreibung!)
print(name == "PyBuddy")   # True
Ausgabe
True True False True False True
Python vs. JavaScript — Das kennst du schon!

Du kennst bereits JavaScript aus dem JS-Quest. Hier ist der direkte Vergleich:

Python
print(level == 10)
print(name != "Boss")
JavaScript
console.log(level === 10);
console.log(name !== "Boss");
Merke: Python nutzt == und !=. JavaScript hat zusätzlich === und !== für strikte Typgleichheit. Python vergleicht Werte und Typen automatisch korrekt.

Logische Operatoren

Mit logischen Operatoren verknüpfst du mehrere Bedingungen. Sie funktionieren wie Schalter in einer Stromkreis-Logik:

  • and — beide Bedingungen müssen True sein
  • or — mindestens eine Bedingung muss True sein
  • not — kehrt den Wert um (True wird False)
Python 
# Logische Operatoren
hp = 75
mana = 20
level = 12

# and: Beides muss stimmen
print(hp > 50 and mana > 10)   # True

# or: Eines reicht
print(hp > 100 or level > 10)  # True (level stimmt)

# not: Umkehrung
print(not hp > 50)             # False

# Kombiniert
kann_zaubern = mana >= 30 and level >= 10
print(f"Kann zaubern: {kann_zaubern}")  # False (mana zu niedrig)
Ausgabe
True True False Kann zaubern: False
Python vs. JavaScript — Das kennst du schon!

Du kennst bereits JavaScript aus dem JS-Quest. Hier ist der direkte Vergleich:

Python
print(hp > 50 and mana > 10)
print(not hp > 50)
JavaScript
console.log(hp > 50 && mana > 10);
console.log(!(hp > 50));
Merke: Python schreibt and, or, not aus — JavaScript nutzt Symbole &&, ||, !.

Der Walrus-Operator :=

Der Walrus-Operator := (weil er wie ein Walrus aussieht ) ist eine Python-Spezialität ab Version 3.8. Er weist einer Variablen einen Wert zu und gibt ihn gleichzeitig zurück.

Das spart Zeilen, wenn du einen Wert berechnen und sofort prüfen willst.

Python 
# Ohne Walrus-Operator
eingabe = input("Gib eine Zahl ein: ")
zahl = int(eingabe)
if zahl > 10:
    print(f"{zahl} ist größer als 10")

# Mit Walrus-Operator (kompakter!)
if (zahl := int(input("Gib eine Zahl ein: "))) > 10:
    print(f"{zahl} ist größer als 10")

# Praxis: Text einlesen, solange er nicht leer ist
while (name := input("Name (Enter zum Beenden): ")):
    print(f"Hallo {name}!")
Ausgabe
Gib eine Zahl ein: 15 15 ist größer als 10 Gib eine Zahl ein: 15 15 ist größer als 10 Name (Enter zum Beenden): Max Hallo Max! Name (Enter zum Beenden):

Operatoren in Aktion: RPG-Schaden

Stell dir vor, du programmierst ein Kampfsystem für ein RPG. Du musst Schaden berechnen, prüfen ob ein Treffer kritisch war, und XP vergeben. Operatoren sind dabei unverzichtbar.

Python 
# Kampfsystem für ein Mini-RPG
basis_schaden = 25
kritisch = True
gegner_level = 8
spieler_level = 10

# Kritischer Treffer verdoppelt den Schaden
schaden = basis_schaden * (2 if kritisch else 1)
print(f"Schaden: {schaden}")

# Level-Vorteil: 10% Bonus pro Level-Differenz
level_diff = spieler_level - gegner_level
if level_diff > 0:
    schaden = int(schaden * (1 + level_diff * 0.1))

print(f"Gesamtschaden: {schaden}")

# XP-Berechnung mit Modulo
xp = schaden * 2
bonus_xp = xp % 50  # Rest-XP als Bonus
print(f"XP: {xp}, Bonus-XP: {bonus_xp}")
print(f"Level aufgestiegen: {xp >= 100}")
Ausgabe
Schaden: 50 Gesamtschaden: 60 XP: 120, Bonus-XP: 20 Level aufgestiegen: True

Warm-Up: Taschenrechner

Schreibe ein Programm rechner.py, das zwei Zahlen einliest und alle Grundrechenarten ausführt.

Hinweis: a = float(input("Erste Zahl: ")) b = float(input("Zweite Zahl: ")) print(f"{a} + {b} = {a + b}") print(f"{a} - {b} = {a - b}") print(f"{a} * {b} = {a * b}") print(f"{a} / {b} = {a / b:.2f}") print(f"{a} // {b} = {a // b}") print(f"{a} % {b} = {a % b}") print(f"{a} ** {b} = {a ** b}")

Lösung 
a = float(input("Erste Zahl: "))
b = float(input("Zweite Zahl: "))

print(f"{a} + {b} = {a + b}")
print(f"{a} - {b} = {a - b}")
print(f"{a} * {b} = {a * b}")
print(f"{a} / {b} = {a / b:.2f}")
print(f"{a} // {b} = {a // b}")
print(f"{a} % {b} = {a % b}")
print(f"{a} ** {b} = {a ** b}")

Challenge: Würfel-Checker

Simuliere einen Würfelwurf (Zahl 1-6). Prüfe mit logischen Operatoren, ob die Zahl gerade, ungerade oder eine 6 (kritischer Treffer) ist.

Hinweis: import random wurf = random.randint(1, 6) print(f"Wurf: {wurf}") print(f"Gerade: {wurf % 2 == 0}") print(f"Kritischer Treffer: {wurf == 6}") print(f"Normaler Treffer: {wurf >= 2 and wurf <= 5}")

Lösung 
import random
wurf = random.randint(1, 6)
print(f"Wurf: {wurf}")
print(f"Gerade: {wurf % 2 == 0}")
print(f"Kritischer Treffer: {wurf == 6}")
print(f"Normaler Treffer: {wurf >= 2 and wurf <= 5}")

PyBuddy-Checkpoint: XP-Rechner

PyBuddy bekommt einen XP-Rechner: Basis-XP × Multiplikator + Bonus. Nutze arithmetische Operatoren und gib das Ergebnis formatiert aus.

Hinweis: # pybuddy/main.py basis_xp = 100 multiplikator = 1.5 bonus = 50 gesamt_xp = int(basis_xp * multiplikator + bonus) print(f" Basis-XP: {basis_xp}") print(f" Multiplikator: x{multiplikator}") print(f" Bonus: +{bonus}") print(f" Gesamt-XP: {gesamt_xp}")

Lösung 
# pybuddy/main.py
basis_xp = 100
multiplikator = 1.5
bonus = 50

gesamt_xp = int(basis_xp * multiplikator + bonus)
print(f"  Basis-XP: {basis_xp}")
print(f" Multiplikator: x{multiplikator}")
print(f" Bonus: +{bonus}")
print(f" Gesamt-XP: {gesamt_xp}")
Didaktische Pause

In World of Warcraft berechnet der Server jede Sekunde tausende von Operationen: Schaden = Waffenschaden × Krit-Multiplikator + Buff-Bonus. Das sind nichts anderes als die arithmetischen Operatoren, die du gerade gelernt hast — nur mit mehr Nullen dahinter!

Zusammenfassung

  • Arithmetik: +, -, *, /, //, %, ** für alle Berechnungen
  • Vergleiche: <code>==, !=, &lt;, &gt;, &lt;=, &gt;=</code> geben True/False zurück
  • Logik: and, or, not verknüpfen Bedingungen
  • Walrus := weist zu und gibt zurück — spart Zeilen
  • Operatoren sind das Fundament für Berechnungen und Entscheidungen