4. Unterrichtsblock

Kursinhalte

Rechnen mit Operatoren
Vergleichen und boolesche Werte
Bedingungen verknüpfen: and, or, not
in, not in und is
Übungsaufgaben

Rechnen mit Operatoren

Operatoren verknüpfen Werte und Variablen. Einige kennst du schon: Mit + rechnest du, mit < und == hast du in Block 3 Bedingungen für if und while gebaut. In diesem Block lernst du die Operatoren von Python vollständig kennen und siehst, wie Python jeden Vergleich zu True oder False auswertet.

Python teilt die Operatoren in Gruppen ein: Rechen-, Zuweisungs-, Vergleichs- und logische Operatoren, dazu Zugehörigkeit (in), Identität (is) und bitweise Operatoren.

Rechenoperatoren

Operator	Name	Beispiel
`+`	Addition	`x + y`
`-`	Subtraktion	`x - y`
`*`	Multiplikation	`x * y`
`/`	Division (Ergebnis immer Kommazahl)	`x / y`
`//`	Ganzzahldivision (ohne Rest)	`x // y`
`%`	Rest (Modulo)	`x % y`
`**`	Potenz	`x ** y`

a = 17
b = 5
print(a + b)
print(a - b)
print(a * b)
print(a / b)
print(a // b)
print(a % b)
print(a ** 2)

Ausgabe im Terminal

Merke: / liefert immer eine Kommazahl, auch 10 / 2 ergibt 5.0. // sagt, wie oft eine Zahl ganz in eine andere passt, % sagt, was übrig bleibt. Mit % prüfst du auch die Teilbarkeit: zahl % 2 == 0 heißt „zahl ist gerade“.

Zuweisungsoperatoren

Zuweisungsoperatoren ändern den Wert einer Variablen. Die Kurzformen wie += kennst du schon vom Zählen in Schleifen.

Operator	Beispiel	bedeutet
`=`	`x = 5`	`x = 5`
`+=`	`x += 3`	`x = x + 3`
`-=`	`x -= 3`	`x = x - 3`
`*=`	`x *= 3`	`x = x * 3`
`/=`	`x /= 3`	`x = x / 3`
`//=`	`x //= 3`	`x = x // 3`
`%=`	`x %= 3`	`x = x % 3`
`**=`	`x **= 3`	`x = x ** 3`

punkte = 10
punkte += 5
punkte *= 2
punkte -= 4
print(punkte)

Ausgabe im Terminal

Reihenfolge (Priorität)

Python rechnet wie in Mathe: Klammern zuerst, dann Potenzen, dann Punkt- vor Strichrechnung. Operatoren auf derselben Stufe werden von links nach rechts ausgewertet. Die Tabelle zeigt die Reihenfolge von oben (zuerst) nach unten (zuletzt):

Operator	Beschreibung
`()`	Klammern
`**`	Potenz
`+x` `-x` `~x`	Vorzeichen und bitweises NICHT
`*` `/` `//` `%`	Punktrechnung
`+` `-`	Strichrechnung
`<<` `>>`	Bits verschieben
`&`	bitweises UND
`^`	bitweises XODER
`\|`	bitweises ODER
`==` `!=` `>` `>=` `<` `<=` `is` `is not` `in` `not in`	Vergleiche, Identität, Zugehörigkeit
`not`	logisches NICHT
`and`	logisches UND
`or`	logisches ODER

print(100 + 5 * 3)
print((100 + 5) * 3)
print(5 + 4 - 7 + 3)

Ausgabe im Terminal

115
315
5

Merke: Im Zweifel Klammern setzen. Sie schaden nie und machen den Code für andere leichter lesbar.

Aufgabe 1 – Die Pizza-Party

Zeit: ca. 8 Minuten

Erst denken, dann tippen: Sage bei jeder Zeile das Ergebnis voraus, schreibe es als Kommentar dazu und prüfe es danach mit Python.

print(23 / 4)
print(23 // 4)
print(23 % 4)
print(2 + 3 * 4)
print((2 + 3) * 4)
print(2 ** 3 * 2)

Sage für jede Zeile das Ergebnis voraus und prüfe es. Notiere bei jedem Irrtum kurz, woran es lag.
Für eure Klassenparty bestellt ihr Pizza: 23 Personen essen je 3 Stücke, eine Pizza hat 8 Stücke. Berechne mit Python, wie viele Stücke ihr braucht, wie viele ganze Pizzen das sind (//) und wie viele Stücke dann noch fehlen (%).
Wie viele Pizzen müsst ihr bestellen und wie viele Stücke bleiben übrig? Gib beides aus. Kontrolle: 9 Pizzen, 3 Stücke bleiben übrig.

Vergleichen und boolesche Werte

Programme müssen ständig Ja-Nein-Fragen beantworten: Ist die Person volljährig? Reicht das Geld? Dafür gibt es den Datentyp bool mit genau zwei Werten: True und False (groß geschrieben).

Vergleichsoperatoren

Operator	Bedeutung	Beispiel
`==`	ist gleich	`x == y`
`!=`	ist ungleich	`x != y`
`>`	größer als	`x > y`
`<`	kleiner als	`x < y`
`>=`	größer oder gleich	`x >= y`
`<=`	kleiner oder gleich	`x <= y`

Jeder Vergleich ergibt True oder False. Das Ergebnis kannst du ausgeben oder in einer Variablen speichern und später in einem if verwenden:

alter = 17
volljaehrig = alter >= 18
print(volljaehrig)
print(type(volljaehrig))

if volljaehrig:
    print("Darf wählen")
else:
    print("Darf noch nicht wählen")

print(10 == 10.0)
print("Lina" == "lina")

Ausgabe im Terminal

False
<class 'bool'>
Darf noch nicht wählen
True
False

Wie in Mathe kannst du Vergleiche auch verketten. 13 <= alter <= 19 heißt: alter liegt zwischen 13 und 19.

alter = 15
print(13 <= alter <= 19)

Ausgabe im Terminal

True

Merke: = weist einen Wert zu, == vergleicht. Bei Texten zählt jedes Zeichen, auch Groß- und Kleinschreibung.

Wahrheitswerte mit bool()

Mit bool() bewertet Python jeden Wert als True oder False. Fast alles ist True. False sind nur „leere“ Werte: die Zahl 0, der leere Text "", der Wert None (bedeutet „noch nichts da“) und natürlich False selbst. Auch leere Listen gelten als False, Listen lernst du ab Block 6 kennen.

print(bool("Hallo"))
print(bool(""))
print(bool(42))
print(bool(0))
print(bool(None))

Ausgabe im Terminal

True
False
True
False
False

Das nutzt man in if-Abfragen: if name: bedeutet „wenn name nicht leer ist“, if not name: bedeutet „wenn name leer ist“.

Bedingungen verknüpfen: and, or, not

Oft hängt eine Entscheidung von mehreren Bedingungen ab. In Block 3 hast du and, or und not schon kurz gesehen, hier lernst du sie genau kennen.

Operator	ergibt True, wenn …	Beispiel
`and`	beide Bedingungen wahr sind	`x > 3 and x < 10`
`or`	mindestens eine Bedingung wahr ist	`x < 3 or x > 10`
`not`	die Bedingung falsch ist (kehrt um)	`not x > 3`

Die Wahrheitstabelle zeigt alle Möglichkeiten für zwei Bedingungen a und b:

`a`	`b`	`a and b`	`a or b`	`not a`
True	True	True	True	False
True	False	False	True	False
False	True	False	True	True
False	False	False	False	True

alter = 15
mit_eltern = True
darf_in_den_film = alter >= 16 or mit_eltern
print(darf_in_den_film)

ist_wochenende = False
schule_morgen = not ist_wochenende
print(schule_morgen)

Ausgabe im Terminal

True
True

Merke: Python wertet zuerst not, dann and, dann or aus. and bindet also stärker als or, so wie Punkt vor Strich. Setze Klammern, sobald du and und or mischst.

Aufgabe 2 – Darf ich ins Wasser?

Zeit: ca. 8 Minuten

Im Freibad gilt: Ins Wasser darf, wer mindestens 14 Jahre alt ist oder mit einem Erwachsenen kommt. Bei Gewitter darf niemand ins Wasser.

alter = 12
mit_erwachsenem = True
gewitter = False

alter	mit_erwachsenem	gewitter	erwartet
12	False	False	False
12	True	False	True
15	False	False	True
15	False	True	False

Schreibe einen einzigen booleschen Ausdruck, speichere ihn in darf_ins_wasser und gib ihn aus.
Teste die vier Fälle aus der Tabelle, indem du die drei Variablen änderst. Dein Programm muss genau die erwarteten Ergebnisse liefern.
Lass jetzt die Klammern weg: alter >= 14 or mit_erwachsenem and not gewitter. Welcher Fall aus der Tabelle geht schief? Erkläre in einem Kommentar, warum.

in, not in und is

Zugehörigkeit: in und not in

in prüft, ob etwas in etwas anderem enthalten ist, zum Beispiel ein Zeichen oder ein Wort in einem Text. not in prüft das Gegenteil. Später funktioniert das genauso mit Listen.

email = "lina@schule.de"
print("@" in email)
print(" " not in email)

satz = "Heute haben wir Python"
print("Python" in satz)
print("python" in satz)

Ausgabe im Terminal

True
True
True
False

Identität: is und is not

is prüft nicht, ob zwei Werte gleich sind, sondern ob zwei Namen auf dasselbe Objekt im Speicher zeigen. Im Alltag brauchst du is fast nur für einen Fall: die Prüfung auf None.

raum = None
print(raum is None)

raum = "R204"
print(raum is not None)

Ausgabe im Terminal

True
True

Merke: Werte vergleichst du immer mit ==. is verwendest du nur mit None: x is None oder x is not None.

Bitweise Operatoren (zum Nachschlagen)

Bitweise Operatoren arbeiten mit den einzelnen Bits (Nullen und Einsen) einer ganzen Zahl. Du brauchst sie selten, zum Beispiel bei Hardware, Rechten oder Netzwerken. Die Bonusaufgabe 2 am Ende zeigt, wofür sie gut sind.

Operator	Name	Beschreibung	Beispiel
`&`	UND	Bit ist 1, wenn beide Bits 1 sind	`5 & 3` → `1`
`\|`	ODER	Bit ist 1, wenn mindestens ein Bit 1 ist	`5 \| 3` → `7`
`^`	XODER	Bit ist 1, wenn genau ein Bit 1 ist	`5 ^ 3` → `6`
`~`	NICHT	kehrt alle Bits um	`~5` → `-6`
`<<`	nach links schieben	hängt rechts Nullen an (verdoppelt pro Schritt)	`5 << 1` → `10`
`>>`	nach rechts schieben	streicht rechte Bits (halbiert pro Schritt)	`5 >> 1` → `2`

Übungsaufgaben

Jetzt kombinierst du alles aus diesem Block mit if, while und for aus Block 3. Die Aufgaben 3 bis 7 sind die Kernaufgaben. Wer schneller fertig ist, macht mit den Bonusaufgaben weiter. Teste jedes Programm mit mehreren Werten.

Aufgabe 3 – Der Snack-Automat

Zeit: ca. 10 Minuten

Ein Snack-Automat rechnet in Cent, damit keine Rundungsfehler entstehen (probiere einmal print(0.1 + 0.2) aus).

preis_getraenk = 250      # Cent
preis_sandwich = 420      # Cent
anzahl_getraenke = 2
anzahl_sandwiches = 1
eingeworfen = 1500        # Cent

Berechne den Gesamtpreis in Cent und gib ihn aus.
Ein Freund will noch ein Getränk: Erhöhe anzahl_getraenke mit += und berechne den Gesamtpreis neu.
Speichere in geld_reicht, ob das eingeworfene Geld reicht, und gib den Wert aus.
Berechne das Rückgeld und gib es in Euro und Cent aus, zum Beispiel „Rückgeld: 3 Euro 30 Cent“ (Tipp: // und % mit 100).
Der Automat zahlt zuerst 2-Euro-Münzen aus. Wie viele 2-Euro-Münzen sind es und wie viele Cent bleiben danach noch übrig?

Zusatz: Setze eingeworfen = 500. Sorge dafür, dass dann „Bitte noch … Cent einwerfen“ erscheint statt eines negativen Rückgelds.

Aufgabe 4 – Das Zugangssystem

Zeit: ca. 10 Minuten

Der Computerraum hat ein Zugangssystem mit Benutzername und Passwort.

benutzername = "lina"
passwort = "python123"
gesperrt = False

Frage Benutzername und Passwort mit input() ab.
Speichere in name_korrekt und passwort_korrekt, ob die Eingaben stimmen.
Speichere in zugang, ob beides stimmt (and), und gib „Zugang erlaubt“ oder „Zugang verweigert“ aus.
Notfallregel: Der Hausmeister kommt immer hinein, auch ohne Passwort. Frage mit „j/n“ ab, ob der Hausmeister davorsteht, speichere das in ist_hausmeister und erweitere die Regel mit or.
Ist das Konto gesperrt (gesperrt = True), kommt mit Benutzername und Passwort niemand mehr hinein, nur noch der Hausmeister. Baue das mit not ein.

Test: Schreibe als Kommentar auf, mit welchen Eingaben du alle Fälle geprüft hast (mindestens vier).

Aufgabe 5 – Der Stundenplan-Check

Zeit: ca. 8 Minuten

Der heutige Stundenplan ist als Text gespeichert. Für Python steht noch kein Raum fest.

stundenplan = "Deutsch, Python, Mathematik, Sport, Englisch"
raum = None

Frage nach einem Fach und gib aus, ob es heute im Stundenplan steht (in).
Gib mit not in aus, ob Biologie heute ausfällt.
Gib bei Schritt 1 „python“ (klein geschrieben) ein. Was passiert? Erkläre in einem Kommentar, warum.
Prüfe mit is None, ob schon ein Raum feststeht. Gib „Raum steht noch nicht fest.“ oder den Raum aus. Setze danach raum = "R204" und prüfe erneut.

Zusatz: Was ergibt "Mathe" in stundenplan? Ist das ein Fehler? Erkläre in einem Kommentar.

Aufgabe 6 – Punkte und Rangliste

Zeit: ca. 10 Minuten

In einem Spiel bekommt jede Spielerin und jeder Spieler nach zwei Runden einen Rang.

runde_1 = 80
runde_2 = 65
bonus = 10
strafpunkte = 15

Berechne die Gesamtpunkte: beide Runden plus Bonus minus Strafpunkte.
Berechne den Durchschnitt der beiden Runden einmal mit / und einmal mit //. Erkläre den Unterschied in einem Kommentar.
Ränge: unter 50 Punkte „Anfänger“, 50 bis unter 100 „Fortgeschritten“, ab 100 „Profi“. Lege für jeden Rang eine boolesche Variable an, zum Beispiel ist_profi = gesamtpunkte >= 100. Für den mittleren Rang brauchst du zwei Vergleiche.
Gib mit if/elif/else den Rang aus. Teste mit 15, 60 und 110 Strafpunkten (Kontrolle: Profi, Fortgeschritten, Anfänger).

Zusatz: Gib aus, ob genau eine der beiden Runden mehr als 70 Punkte hatte. Tipp: Zwei boolesche Werte kann man mit != vergleichen.

Aufgabe 7 – Leer oder nicht leer?

Zeit: ca. 8 Minuten

Python kann jeden Wert als True oder False bewerten. Das nutzt man oft in if-Abfragen.

name = ""
punkte = 0
energie = 10
nachricht = "Hallo"
raum = None

Sage für jede der fünf Variablen voraus, was bool(...) ergibt. Schreibe es als Kommentar dazu und prüfe es mit print(bool(...)).
Vervollständige als Kommentar den Satz: „Als False gelten …“.
Eine Spielfigur lebt, solange energie größer als 0 ist. Speichere das in lebt und gib es aus. Setze danach energie = 0 und prüfe erneut.
Frage mit input() nach einem Namen. Drückt jemand nur Enter, gib „Bitte gib einen Namen ein.“ aus, sonst „Hallo …“. Verwende dafür if not name:.

Zusatz: Wiederhole die Frage nach dem Namen mit einer while-Schleife so lange, bis wirklich etwas eingegeben wurde.

Bonusaufgabe 1 – Der Schaltjahr-Rechner

Ein Jahr ist ein Schaltjahr, wenn es durch 4 teilbar ist. Ausnahme: Jahre, die durch 100 teilbar sind, sind keine Schaltjahre, außer sie sind auch durch 400 teilbar.

Frage nach einer Jahreszahl und speichere in ist_schaltjahr einen einzigen booleschen Ausdruck (mit %, ==, !=, and, or). Gib das Ergebnis aus.
Teste mit 2024 (ja), 2026 (nein), 1900 (nein) und 2000 (ja).
Gib mit einer for-Schleife alle Schaltjahre von 2000 bis 2050 aus und zähle sie (Kontrolle: 13).

Bonusaufgabe 2 – Die Bit-Schalter

Bitweise Operatoren arbeiten mit den einzelnen Bits einer Zahl. So kann eine einzige Zahl mehrere Schalter speichern.

wert_a = 5
wert_b = 3

Lass dir mit bin(wert_a) und bin(wert_b) die Binärdarstellung anzeigen.
Sage voraus und prüfe: wert_a & wert_b, wert_a | wert_b, wert_a ^ wert_b, wert_a << 1 und wert_a >> 1.
Eine Zahl lichter = 5 speichert drei Lampen: Bit 1 = Flur, Bit 2 = Küche, Bit 4 = Bad. Prüfe mit (lichter & 4) != 0, ob das Bad-Licht an ist, und genauso für Flur und Küche.

Frage an dich: Braucht man bei (lichter & 4) != 0 die Klammern überhaupt? Sieh in der Tabelle zur Reihenfolge nach und probiere es ohne Klammern aus.

Kurz zusammengefasst:

/ ergibt eine Kommazahl, // das ganzzahlige Ergebnis, % den Rest.
Vergleiche liefern True oder False. = weist zu, == vergleicht.
and: beide wahr · or: mindestens eine wahr · not: kehrt um. Beim Mischen Klammern setzen.
in und not in suchen in Texten (später auch in Listen), is nur mit None verwenden.
0, "" und None gelten als False, fast alles andere als True.