Programmieren mit Python: Verzweigungen & while-Schleifen

name = input("Wie heisst du? ")
geburtsjahr = int(input("In welchem Jahr bist du geboren? "))
 
alter = 2026 - geburtsjahr
 
print("Hallo " + name + ", du wirst dieses Jahr " + str(alter) + " Jahre alt.")

Beachte: input() liefert immer einen String. Willst du damit rechnen, musst du ihn mit int() in eine Zahl umwandeln. Umgekehrt musst du beim Zusammenhängen mit + die Zahl mit str() wieder zu einem String machen.

Mit einem f-String geht es kürzer:

print(f"Hallo {name}, du wirst dieses Jahr {alter} Jahre alt.")

laenge = float(input("Länge: "))
breite = float(input("Breite: "))
 
flaeche = laenge * breite
umfang = 2 * (laenge + breite)
 
print("Fläche:", flaeche)
print("Umfang:", umfang)

Hier verwenden wir float() statt int(), damit auch Kommazahlen wie 3.5 eingegeben werden können.

total = int(input("Sekunden: "))
 
stunden = total // 3600          # wie viele ganze Stunden stecken drin?
rest = total % 3600              # was bleibt danach übrig?
 
minuten = rest // 60
sekunden = rest % 60
 
print(stunden, "h", minuten, "min", sekunden, "s")

Das Paar // und % ist eines der wichtigsten Werkzeuge überhaupt: // liefert, wie oft etwas hineinpasst, % liefert, was übrig bleibt. Wir werden es noch oft brauchen.

zahl = int(input("Zahl: "))
 
if zahl % 2 == 0:
    print("gerade")
else:
    print("ungerade")

Eine Zahl ist genau dann gerade, wenn sie bei der Division durch $2$ den Rest $0$ lässt. Der Test zahl % 2 == 0 ist der Standardtrick für „gerade“ und wird dir immer wieder begegnen.

zahl = int(input("Zahl: "))
 
if zahl > 0:
    print("positiv")
elif zahl < 0:
    print("negativ")
else:
    print("null")

Wichtig: Sobald ein Zweig zutrifft, werden alle folgenden elif/else übersprungen. Wenn also zahl > 0 wahr ist, wird zahl < 0 gar nicht mehr geprüft.

a = float(input("1. Zahl: "))
b = float(input("2. Zahl: "))
c = float(input("3. Zahl: "))
 
if a >= b and a >= c:
    print("Die grösste Zahl ist", a)
elif b >= a and b >= c:
    print("Die grösste Zahl ist", b)
else:
    print("Die grösste Zahl ist", c)

Eine elegantere Variante nach dem Maximum-Muster aus dem Werkzeugkasten – die wird später bei vielen Zahlen unentbehrlich:

maximum = a                  # a ist vorläufig die grösste
if b > maximum:
    maximum = b
if c > maximum:
    maximum = c
print("Die grösste Zahl ist", maximum)

punkte = int(input("Punkte: "))
 
if punkte < 0 or punkte > 100:
    print("Ungültige Eingabe!")
elif punkte >= 90:
    print("Note 6")
elif punkte >= 75:
    print("Note 5")
elif punkte >= 60:
    print("Note 4")
elif punkte >= 40:
    print("Note 3")
else:
    print("Note 2")

Der Trick bei einer solchen elif-Kette: Wir prüfen von oben nach unten und müssen die untere Grenze jeweils gar nicht mehr testen. Kommt Python zur Zeile elif punkte >= 75:, dann weiss es bereits, dass punkte < 90 gilt.

Die Reihenfolge ist entscheidend: Wir müssen die speziellste Regel zuerst prüfen.

jahr = int(input("Jahr: "))
 
if jahr % 400 == 0:
    print("Schaltjahr")
elif jahr % 100 == 0:
    print("kein Schaltjahr")
elif jahr % 4 == 0:
    print("Schaltjahr")
else:
    print("kein Schaltjahr")

Ergebnisse: $2024$ Schaltjahr, $1900$ kein Schaltjahr, $2000$ Schaltjahr, $2023$ kein Schaltjahr.

Alternativ mit einer einzigen logischen Bedingung:

if (jahr % 4 == 0 and jahr % 100 != 0) or jahr % 400 == 0:
    print("Schaltjahr")
else:
    print("kein Schaltjahr")

i = 1                    # Initialisierung
while i <= 10:           # Bedingung
    print(i)
    i = i + 1            # Veränderung

Verfolge im Kopf, was passiert: i ist zuerst $1$, wird ausgegeben, dann auf $2$ erhöht. Beim Durchgang mit $i = 10$ wird noch ausgegeben, dann wird i auf $11$ gesetzt – und die Bedingung 11 <= 10 ist falsch. Die Schleife endet.

n = int(input("Von welcher Zahl soll der Countdown starten? "))
 
while n >= 0:
    print(n)
    n = n - 1
 
print("Start!")

Hier zählen wir rückwärts. Entsprechend dreht sich auch die Bedingung um: n >= 0 statt n <= 10.

Variante 1 – direkt in Siebnerschritten:

v = 7
while v < 100:
    print(v)
    v = v + 7

Variante 2 – jede Zahl prüfen:

i = 1
while i < 100:
    if i % 7 == 0:
        print(i)
    i = i + 1

Variante 1 ist deutlich effizienter (sie macht 14 statt 99 Durchgänge). Variante 2 ist dafür flexibler: Sie lässt sich sofort auf kompliziertere Bedingungen erweitern, etwa „durch 7 oder durch 5 teilbar“.

z = 1
while z <= 1000:
    print(z)
    z = z * 2

Ausgabe: $1, 2, 4, \ldots, 512$. Die Laufvariable muss sich nicht immer um einen festen Betrag ändern – hier wird sie verdoppelt. Dadurch wächst sie sehr schnell, und die Schleife ist nach 10 Durchgängen fertig.

print("n\tn^2\tn^3")
 
n = 1
while n <= 12:
    print(n, "\t", n**2, "\t", n**3)
    n = n + 1

Die Ausgabezeile lässt sich auch mit einem f-String schreiben, was besonders bei fixen Spaltenbreiten schöner aussieht:

    print(f"{n:3} {n**2:6} {n**3:6}")

Dabei bedeutet {n:3}, dass die Zahl auf eine Breite von 3 Zeichen rechtsbündig ausgerichtet wird.

n = int(input("n: "))
 
summe = 0                     # noch nichts addiert
i = 1
 
while i <= n:
    summe = summe + i         # das ist der Kern des Ganzen
    i = i + 1
 
print("Die Summe ist", summe)

Die Zeile summe = summe + i liest sich anfangs seltsam. In der Mathematik wäre das eine unlösbare Gleichung! In der Programmierung bedeutet = aber zuweisen, nicht „ist gleich“: Berechne die rechte Seite mit dem alten Wert von summe und speichere das Ergebnis als neuen Wert von summe.

Kürzer schreibt man dasselbe als summe += i.

Kontrolle: Für $n = 100$ muss $5050$ herauskommen (Gauss lässt grüssen).

n = int(input("n: "))
 
produkt = 1                   # Startwert 1, NICHT 0!
i = 1
 
while i <= n:
    produkt = produkt * i
    i = i + 1
 
print(n, "! =", produkt)

Der häufigste Fehler hier: produkt = 0 als Startwert. Dann bleibt das Ergebnis für immer $0$. Beim Summieren ist $0$ das neutrale Element, beim Multiplizieren ist es $1$.

Kontrolle: $5! = 120$, $10! = 3'628'800$.

n = int(input("n: "))
 
summe_gerade = 0
summe_ungerade = 0
i = 1
 
while i <= n:
    if i % 2 == 0:
        summe_gerade = summe_gerade + i
    else:
        summe_ungerade = summe_ungerade + i
    i = i + 1
 
print("gerade:  ", summe_gerade)
print("ungerade:", summe_ungerade)

Hier kombinieren wir zum ersten Mal Schleife und Verzweigung: Die Schleife besucht jede Zahl, die Verzweigung entscheidet, welcher Akkumulator erhöht wird. Zwei Akkumulatoren nebeneinander zu führen ist völlig üblich.

kapital = 1000
jahre = 0
 
while kapital < 2000:
    kapital = kapital * 1.02
    jahre = jahre + 1
    print("Jahr", jahre, ":", round(kapital, 2))
 
print("Nach", jahre, "Jahren ist das Kapital verdoppelt.")

Antwort: nach 36 Jahren.

Das ist ein neuer Typ von Schleife! Bisher wussten wir vorher, wie oft sie läuft. Hier wissen wir es nicht – die Schleife läuft, bis eine Bedingung erfüllt ist. Genau dafür ist while gemacht, und genau hier wäre eine for-Schleife das falsche Werkzeug.

summe = 0
 
zahl = int(input("Zahl (0 = Ende): "))      # erste Eingabe VOR der Schleife
 
while zahl != 0:
    summe = summe + zahl
    zahl = int(input("Zahl (0 = Ende): "))  # nächste Eingabe am ENDE der Schleife
 
print("Summe:", summe)

Dieses Muster heisst „Lies vor der Schleife, lies am Ende der Schleife“. Es sieht unschön aus, weil die input()-Zeile zweimal vorkommt, ist aber der saubere Standardweg: Die Bedingung zahl != 0 kann nur geprüft werden, wenn bereits eine Zahl vorliegt.

Wichtig: Die $0$ selbst wird nicht mitgezählt – sobald sie eingegeben wird, bricht die Schleife ab, bevor sie addiert wird.

summe = 0
anzahl = 0
 
zahl = int(input("Zahl (0 = Ende): "))
 
while zahl != 0:
    summe = summe + zahl
    anzahl = anzahl + 1                     # der Zähler aus dem Werkzeugkasten
    zahl = int(input("Zahl (0 = Ende): "))
 
print("Anzahl:", anzahl)
print("Summe: ", summe)
 
if anzahl > 0:
    print("Mittelwert:", summe / anzahl)
else:
    print("Keine Zahlen eingegeben.")

Der Zähler und der Summierer laufen hier parallel mit. Die abschliessende Verzweigung ist kein Schönheitsfehler, sondern notwendig: Ohne sie würde summe / anzahl bei $0$ Eingaben eine Division durch null verursachen und das Programm abstürzen lassen. Solche Randfälle (engl. edge cases) mitzudenken gehört zum Handwerk.

zahl = int(input("Zahl (0 = Ende): "))
 
if zahl == 0:
    print("Keine Zahlen eingegeben.")
else:
    maximum = zahl               # die erste Zahl ist vorläufig grösste UND kleinste
    minimum = zahl
 
    while zahl != 0:
        if zahl > maximum:
            maximum = zahl
        if zahl < minimum:
            minimum = zahl
        zahl = int(input("Zahl (0 = Ende): "))
 
    print("Grösste:", maximum)
    print("Kleinste:", minimum)

Der entscheidende Punkt ist die Initialisierung: Wir setzen maximum = 0 nicht! Gibt der Benutzer nur negative Zahlen ein, wäre sonst $0$ das falsche Ergebnis. Der einzig sichere Startwert ist der erste tatsächlich eingegebene Wert.

Beachte auch, dass zwei aufeinanderfolgende if verwendet werden und kein elif. Beim allerersten Durchgang müssen ja beide Vergleiche stattfinden können.

passwort = "python"
versuche = 1
 
eingabe = input("Passwort: ")
 
while eingabe != passwort and versuche < 3:
    versuche = versuche + 1
    eingabe = input("Falsch. Passwort: ")
 
if eingabe == passwort:
    print("Willkommen!")
else:
    print("Zugang gesperrt.")

Neu ist hier die zusammengesetzte Bedingung: Die Schleife läuft nur weiter, wenn das Passwort falsch ist und noch Versuche übrig sind. Sobald eine der beiden Bedingungen kippt, ist Schluss.

Nach der Schleife wissen wir aber nicht, welche der beiden Bedingungen zum Abbruch geführt hat. Deshalb müssen wir das mit einem abschliessenden if nachträglich herausfinden. Das ist ein sehr typisches Vorgehen.

i = 1
anzahl = 0
 
while i <= 100:
    if i % 3 == 0 and i % 5 != 0:
        anzahl = anzahl + 1
    i = i + 1
 
print("Anzahl:", anzahl)

Antwort: 27.

Nachrechnen: Von $1$ bis $100$ gibt es $33$ Vielfache von $3$. Davon sind $6$ auch durch $5$ teilbar (nämlich die Vielfachen von $15$: $15, 30, 45, 60, 75, 90$). Bleiben $33 - 6 = 27$.

import random
 
zahl = random.randint(1, 100)
 
tipp = int(input("Dein Tipp: "))
versuche = 1
 
while tipp != zahl:
    if tipp < zahl:
        print("Zu klein!")
    else:
        print("Zu gross!")
    tipp = int(input("Dein Tipp: "))
    versuche = versuche + 1
 
print("Richtig! Du hast", versuche, "Versuche gebraucht.")

Wieder dasselbe Muster wie bei der Eingabeschleife: erste Eingabe vor der Schleife, weitere Eingaben am Ende des Schleifenkörpers.

Übrigens: Wer geschickt rät (immer in der Mitte des verbleibenden Bereichs), braucht nie mehr als 7 Versuche. Denn $2^7 = 128 > 100$. Diese Strategie heisst binäre Suche – sie kommt in der letzten Zusatzaufgabe wieder vor.

n = int(input("Startzahl: "))
schritte = 0
 
while n != 1:
    if n % 2 == 0:
        n = n // 2               # Ganzzahldivision, damit kein float entsteht
    else:
        n = 3 * n + 1
    schritte = schritte + 1
    print(n)
 
print("Anzahl Schritte:", schritte)

Für $n = 27$ braucht man 111 Schritte, und zwischendurch klettert die Zahl bis auf $9232$ hinauf – obwohl sie so klein startet.

Das Bemerkenswerte an dieser Aufgabe: Es ist bis heute unbewiesen, ob die Schleife für jede Startzahl überhaupt terminiert. Das ist die berühmte Collatz-Vermutung. Man hat sie für sehr grosse Zahlen per Computer überprüft, aber niemand konnte sie bisher allgemein beweisen. Du schreibst hier also ein Programm, von dem niemand weiss, ob es immer anhält.

n = int(input("Zahl: "))
 
quersumme = 0
 
while n > 0:
    quersumme = quersumme + n % 10      # letzte Ziffer dazuzählen
    n = n // 10                         # letzte Ziffer abschneiden
 
print("Quersumme:", quersumme)

Verfolge es an $4271$ Schritt für Schritt:

Sobald n den Wert $0$ erreicht, ist die Zahl „aufgebraucht“ und die Schleife endet. Diese Technik, eine Zahl ziffernweise zu zerlegen, ist extrem nützlich – merke sie dir gut.

n = int(input("Zahl: "))
 
rueckwaerts = 0
 
while n > 0:
    ziffer = n % 10
    rueckwaerts = rueckwaerts * 10 + ziffer   # bisheriges Ergebnis "nach links schieben"
    n = n // 10
 
print("Umgekehrt:", rueckwaerts)

Der Trick steckt in rueckwaerts * 10 + ziffer: Die Multiplikation mit $10$ schiebt alle bisherigen Ziffern eine Stelle nach links und macht rechts Platz für die neue.

Ablauf für $4271$: $0 \rightarrow 1 \rightarrow 17 \rightarrow 172 \rightarrow 1724$.

Zusatz: Baue das Programm so um, dass es prüft, ob eine Zahl ein Palindrom ist (vorwärts wie rückwärts gleich, z.B. $12321$). Du musst dir dazu die ursprüngliche Zahl in einer zweiten Variablen merken, bevor du sie in der Schleife zerstörst!

n = int(input("Zahl: "))
 
ist_prim = True              # Flag: wir gehen erst mal davon aus, dass es eine Primzahl ist
teiler = 2
 
while teiler < n:
    if n % teiler == 0:
        ist_prim = False     # ein Teiler gefunden -> doch keine Primzahl
    teiler = teiler + 1
 
if ist_prim:
    print(n, "ist eine Primzahl.")
else:
    print(n, "ist keine Primzahl.")

Das ist die erste Anwendung des Flag-Musters: Eine Wahrheitswert-Variable merkt sich, ob während der Schleife etwas passiert ist. Nach der Schleife wird sie ausgewertet.

Verbesserung: Man muss nur bis zur Wurzel von $n$ testen. Denn wenn $n = a \cdot b$ mit $a \leq b$, dann ist zwingend $a \leq \sqrt{n}$. Statt math.sqrt zu verwenden, quadriert man einfach den Teiler:

while teiler * teiler <= n:
    if n % teiler == 0:
        ist_prim = False
    teiler = teiler + 1

Für $n = 1'000'003$ sind das statt einer Million nur noch rund tausend Durchgänge. Ein spürbarer Unterschied!

n = 2                                    # äussere Schleife: die Kandidaten
 
while n <= 100:
 
    ist_prim = True
    teiler = 2                           # innere Schleife: die möglichen Teiler
 
    while teiler * teiler <= n:
        if n % teiler == 0:
            ist_prim = False
        teiler = teiler + 1
 
    if ist_prim:
        print(n, end=" ")
 
    n = n + 1

Ausgabe: 2 3 5 7 11 13 17 19 23 29 31 37 41 43 47 53 59 61 67 71 73 79 83 89 97

Der wichtigste Punkt bei verschachtelten Schleifen: Die Variablen der inneren Schleife (teiler und ist_prim) müssen innerhalb der äusseren Schleife zurückgesetzt werden. Setzt man sie versehentlich ganz nach oben, funktioniert nur der erste Durchgang – ein Klassiker unter den Fehlern.

a = int(input("a: "))
b = int(input("b: "))
 
while b != 0:
    rest = a % b
    a = b
    b = rest
 
print("Der ggT ist", a)

Die Hilfsvariable rest ist unverzichtbar: Würde man direkt a = b schreiben, wäre der alte Wert von a verloren, bevor man ihn für a % b braucht. Dieses Zwischenspeichern beim Vertauschen ist eine Standardtechnik.

Ablauf für $a = 48$, $b = 18$: $(48,18) \rightarrow (18,12) \rightarrow (12,6) \rightarrow (6,0)$. Ergebnis: $6$.

Der Algorithmus ist über 2000 Jahre alt und immer noch der schnellste bekannte Weg – er stammt aus Euklids Elementen.

x = float(input("Zahl: "))
 
g = x / 2
schritte = 0
 
while abs(g * g - x) > 0.000001:      # solange das Quadrat noch zu weit weg ist
    g = (g + x / g) / 2
    schritte = schritte + 1
    print(schritte, ":", g)
 
print("Wurzel aus", x, "ist ungefähr", g)

Für $x = 2$ ist man nach vier Schritten schon bei $1.41421356\ldots$ – das Verfahren verdoppelt die Anzahl korrekter Stellen mit jedem Schritt.

Zwei Dinge sind hier wichtig:

• Der Abbruch erfolgt über eine Toleranz, nicht über Gleichheit. while g * g != x würde bei Kommazahlen fast nie terminieren, weil floats gerundet gespeichert werden.
• Für $x = 0$ würde das Programm mit einer Division durch null abstürzen. Ein sauberes Programm fängt das vorher ab.

n = int(input("Dezimalzahl: "))
 
binaer = ""
 
while n > 0:
    binaer = str(n % 2) + binaer      # neue Ziffer VORNE anfügen
    n = n // 2
 
if binaer == "":                      # Sonderfall: die Eingabe war 0
    binaer = "0"
 
print("Binär:", binaer)

Der springende Punkt ist str(n % 2) + binaer statt binaer + str(n % 2): Die Reste fallen bei der Division von hinten nach vorne an, also müssen sie vorne angehängt werden.

Ablauf für $13$: Reste $1, 0, 1, 1$ – der String wächst als "1", "01", "101", "1101". Und tatsächlich ist $13 = 8 + 4 + 1 = 1101_2$.

Der Sonderfall $n = 0$ muss extra behandelt werden, weil die Schleife dann gar nie durchlaufen wird und der String leer bleibt.

Figur 1 – wachsendes Dreieck, ganz ohne innere Schleife:

n = int(input("Höhe: "))
 
zeile = 1
while zeile <= n:
    print("*" * zeile)
    zeile = zeile + 1

Figur 2 – schrumpfendes Dreieck:

zeile = n
while zeile >= 1:
    print("*" * zeile)
    zeile = zeile - 1

Figur 3 – die Pyramide braucht zusätzlich führende Leerzeichen. In Zeile $z$ stehen $n - z$ Leerzeichen und $2z - 1$ Sterne:

zeile = 1
while zeile <= n:
    print(" " * (n - zeile) + "*" * (2 * zeile - 1))
    zeile = zeile + 1

Wer den Trick "*" * zeile nicht verwenden darf, baut die Zeile mit einer inneren Schleife zusammen:

zeile = 1
while zeile <= n:
    ausgabe = ""
    spalte = 1
    while spalte <= zeile:
        ausgabe = ausgabe + "*"
        spalte = spalte + 1
    print(ausgabe)
    zeile = zeile + 1

Das ist wieder der Akkumulator – diesmal aber mit einem String statt einer Zahl.

zeile = 1
 
while zeile <= 10:
 
    ausgabe = ""
    spalte = 1
 
    while spalte <= 10:
        ausgabe = ausgabe + str(zeile * spalte) + "\t"
        spalte = spalte + 1
 
    print(ausgabe)
    zeile = zeile + 1

Zwei Beobachtungen:

• Die innere Schleife läuft vollständig durch, bevor die äussere einen Schritt weitergeht. Insgesamt gibt es $10 \cdot 10 = 100$ Durchgänge der inneren Schleife.
• Die Variable spalte und der String ausgabe werden bei jedem äusseren Durchgang neu initialisiert. Genau wie bei der Primzahl-Aufgabe.

Alternativ kann man auch direkt ausgeben und den Zeilenumbruch unterdrücken:

    while spalte <= 10:
        print(zeile * spalte, end="\t")
        spalte = spalte + 1
    print()                        # leeres print() erzeugt den Zeilenumbruch

koepfe = 35
beine = 94
 
huehner = 0
 
while huehner <= koepfe:
    kaninchen = koepfe - huehner              # der Rest muss Kaninchen sein
    if 2 * huehner + 4 * kaninchen == beine:
        print("Hühner:", huehner, " Kaninchen:", kaninchen)
    huehner = huehner + 1

Ergebnis: 23 Hühner und 12 Kaninchen.

Diese Technik heisst Brute Force (rohe Gewalt): Man probiert einfach alle Möglichkeiten durch und prüft jede. Für einen Menschen wäre das mühsam, für einen Computer sind $36$ Durchgänge ein Klacks.

Beachte den Trick, dass nur eine Grösse durchprobiert wird – die zweite ergibt sich aus der Kopfzahl. Mit zwei verschachtelten Schleifen ginge es auch, wäre aber unnötig aufwendig.

zahlen = []
 
zahl = int(input("Zahl (0 = Ende): "))
while zahl != 0:
    zahlen.append(zahl)
    zahl = int(input("Zahl (0 = Ende): "))
 
if len(zahlen) == 0:
    print("Keine Zahlen eingegeben.")
else:
    summe = 0
    maximum = zahlen[0]
    minimum = zahlen[0]
 
    i = 0
    while i < len(zahlen):
        summe = summe + zahlen[i]
        if zahlen[i] > maximum:
            maximum = zahlen[i]
        if zahlen[i] < minimum:
            minimum = zahlen[i]
        i = i + 1
 
    print("Anzahl:    ", len(zahlen))
    print("Summe:     ", summe)
    print("Mittelwert:", summe / len(zahlen))
    print("Maximum:   ", maximum)
    print("Minimum:   ", minimum)

Achte auf die Bedingung i < len(zahlen) mit echt kleiner: Bei einer Liste mit $5$ Elementen sind die gültigen Indizes $0$ bis $4$. Ein <= würde einen Zugriffsfehler auslösen – der berühmte off-by-one error.

Der Vorteil der Liste: Wir können die Zahlen mehrfach durchgehen. Ohne Liste ist jede Zahl nach der Verarbeitung für immer weg.

zahlen = [5, 2, 9, 1, 7, 3]
 
getauscht = True                              # Flag
 
while getauscht:
    getauscht = False                         # Annahme: diesmal ist alles sortiert
 
    i = 0
    while i < len(zahlen) - 1:
        if zahlen[i] > zahlen[i + 1]:
            merker = zahlen[i]                # Vertauschen mit Hilfsvariable
            zahlen[i] = zahlen[i + 1]
            zahlen[i + 1] = merker
            getauscht = True                  # doch nicht sortiert!
        i = i + 1
 
    print(zahlen)                             # Zwischenstand anschauen
 
print("Sortiert:", zahlen)

Das Flag getauscht steuert hier die äussere Schleife. Solange in einem Durchgang noch getauscht wurde, kann die Liste nicht sortiert sein. Ging ein ganzer Durchgang ohne Tausch vorbei, sind wir fertig.

In Python kann man übrigens eleganter tauschen: zahlen[i], zahlen[i+1] = zahlen[i+1], zahlen[i]. Die Variante mit dem Merker funktioniert dafür in jeder Programmiersprache – und du solltest sie kennen.

n = 100
 
ist_prim = [True] * (n + 1)       # ist_prim[k] sagt, ob k prim ist
ist_prim[0] = False
ist_prim[1] = False
 
p = 2
while p * p <= n:
    if ist_prim[p]:
        vielfaches = p * p        # alles Kleinere wurde schon gestrichen
        while vielfaches <= n:
            ist_prim[vielfaches] = False
            vielfaches = vielfaches + p     # ADDIEREN, nicht dividieren!
    p = p + 1
 
k = 2
while k <= n:
    if ist_prim[k]:
        print(k, end=" ")
    k = k + 1

Der Clou ist die Zeile vielfaches = vielfaches + p: Statt für jede Zahl zu prüfen, ob sie durch $p$ teilbar ist, springen wir direkt von Vielfachem zu Vielfachem. Das Sieb ist deshalb dramatisch schneller als das Durchprobieren aller Teiler.

Warum startet die innere Schleife bei $p \cdot p$ und nicht bei $2p$? Weil alle kleineren Vielfachen von $p$ bereits einen kleineren Primfaktor haben und darum schon gestrichen wurden. Zum Beispiel wurde $3 \cdot 5 = 15$ schon beim Sieben mit $3$ erwischt.

unten = 1
oben = 1000
versuche = 0
antwort = ""
 
while antwort != "r":
    tipp = (unten + oben) // 2            # immer die Mitte des Bereichs!
    versuche = versuche + 1
 
    print("Ist es", tipp, "?")
    antwort = input("k = zu klein, g = zu gross, r = richtig: ")
 
    if antwort == "k":
        unten = tipp + 1                  # untere Hälfte ausschliessen
    elif antwort == "g":
        oben = tipp - 1                   # obere Hälfte ausschliessen
 
print("Gefunden nach", versuche, "Versuchen!")

Das ist die binäre Suche. Bei jedem Tipp halbiert sich der verbleibende Bereich: $1000 \rightarrow 500 \rightarrow 250 \rightarrow 125 \rightarrow \ldots$ Nach höchstens 10 Versuchen ist die Zahl gefunden, denn $2^{10} = 1024 > 1000$.

Zum Vergleich: Würde der Computer stur $1, 2, 3, \ldots$ durchprobieren, bräuchte er im Mittel $500$ Versuche. Ein gut gewählter Algorithmus schlägt rohe Rechenkraft um Längen.

Zum Weiterdenken: Was passiert, wenn du beim Antworten schummelst? Der Bereich schrumpft dann irgendwann auf nichts zusammen, und unten wird grösser als oben. Ein robustes Programm würde das erkennen und dich des Betrugs bezichtigen.