lehrkraefte:blc:informatik:ffprg1-2020:loops [https://fginfo.ksbg.ch Fachgruppe Informatik der KSBG]

This page is read only. You can view the source, but not change it. Ask your administrator if you think this is wrong.
====== Wiederholungen ======
Es gibt zwei grundlegende Typen von Wiederholungen: 
  * Die Anzahl Wiederholungen ist schon vor der Wiederholung bekannt: **for**-loops
  * Die Anzahl Wiederholungen ist nicht bekannt: **while**-loops

===== for-loops =====
Ein for-loop besteht aus zwei Elementen: Eine **Laufvariable** und einen Bereich.

==== Typischer Fall ====
<code python>
for i in range(10):
    print(i)
</code>
Gibt die Zahlen von 0 bis 9 aus (10 Wiederholungen). Die **Laufvariable** ist i, der **Bereich** range(10), was den Zahlen von 0 bis und mit 9 entspricht.
==== range-Varianten ====
  * range(n): Zahlen von 0 bis und mit n-1
  * range(a,b): Zahlen von a bis und mit b-1
  * range(a,b,s): Zahlen von a in s-Schritten bis zur grössten Zahl, die kleiner als b ist
<code python>
for i in range(10,20,3):
    print(i)
# Liefert 10,13,16,19
</code>

==== Iteration über Listen und Arrays ====
<code python>
prim = (2,3,5,7,11,13,17,19)
for p in prim:
    print("%d ist prim" % (p,))
</code>
Die Elemente des Arrays könnten auch beliebige Dinge sein.


===== while-loops =====
Ein while-loop wird so lange wiederholt, wie eine Bedingung wahr ist.
<code python>
n=0
k=100
p=1.01
while (k<200):   # Wiederhole solange wie k<200
    k*=p   # Kurzform für k = k*p
    n+=1   # Kurzform für n = n+1
print(n)
</code>
Was berechnet das obige Programm?

<hidden Lösung>
Das Programm berechnet die Anzahl Jahre, die nötig sind, bis das Ausgangskapital $k$ bei einem Zinsatz von $p-1$ auf über 200 angewachsen ist.
</hidden>
==== Endlos-Schleife ====
<code python>
import time
while True:
   print("immer und immer wieder")
   time.sleep(0.5)   # Ein bisschen Pause, damit die Ausgabe nicht komplett überläuft.
</code>

===== break, continue =====
Manchmal ist es wünschenswert, eine ''while''- oder ''for'-Schleife irgendwo innerhalb abzubrechen (**break**) oder direkt zur nächsten Wiederholung (**continue**) zu springen, ohne den Rest des Blocks auszuführen. 

<code python>
a = 1
while a<10:
    a+=1
    if a>5:
        break  # Sofort die while-Schlaufe beenden
    print("Sonst noch was mit %d tun" % a)
</code>

<code python>
a = 1
while a<10:
   if a%2==0:   # Wenn der Rest der Divison von a durch 2 Null ist, d.h. wenn a gerade ist.
       a+=3
       continue  # Nächste Wiederholung
   # Was kompliziertes mit a machen
   a+=1
</code>


===== Verschachtelte loops =====
<code python>
for i in range(5):
    for j in range(5):
        print("%d * %d = %d" %(i,j,i*j))
</code>        


===== Zeilenumbrüche =====
Sie können eine print-Ausgabe ohne Zeilenumbruch erreichen, indem Sie nach der schliessenden Klammer ein Komma anfügen:
<code python>
print("Es geht "),
print("noch weiter")
</code>
Leider wird damit auch ein Leerschlag eingefügt. 

Noch mehr Kontrolle hat man, wen man die ganze Zeile erst in einem String aufbaut und diesen am Schluss ausgibt:
<code python>
zeile = "Die Zahlen 1"
for i in range(2,5):
   zeile += ", %d" % (i*i)
print(zeile)                 # Ausgabe: Die Zahlen 1, 4, 9, 16
</code>

====== Aufgaben ======
Lesen Sie jeweils die Eingabe für das Programm von der Tastatur ein:
<code python>
z = int(raw_input("Zahl = "))
</code>

Sie können wie folgt überprüfen, ob eine Zahl a durch eine Zahl b teilbar ist:
<code python>
if a % b == 0:  # Wenn der Rest der Division von a durch b gleich Null ist, ist a durch b teilbar
    # Tu was
</code>


  * Schreiben Sie ein Programm, das sämtliche Teiler der eingegebenen Zahl ausgibt.
  * Schreiben Sie ein Programm, das überprüft, ob die eingegebene Zahl eine Primzahl ist.
  * Schreiben Sie ein Programm, das die Primfaktorenzerlegung der eingegeben Zahl ausgibt. In einem der beiden Formate
    * Primfaktorzerlegung von 123456 = 1 * 2 * 2 * 2 * 2 * 2 * 2 * 3 * 643
    * Primfaktorzerlegung von 123456 = 1 * 2^6 * 3 * 643
  * Schreiben Sie ein Programm, das eine Primzahl nach der anderen ausgibt.
  * Schreiben Sie ein Programm, das perfekte Zahlen sucht, d.h. solche, die gleich der Summe Ihrer Teiler (sich selbst ausgenommen) sind.

<hidden Lösungsvorschläge>
<code python teiler.py>
import sys
z = int(raw_input("Zahl = "))

sys.stdout.write("Teiler von %d: " % z)
for t in range(1,z):
    if (z % t == 0):
        sys.stdout.write("%d, " %t)
print(z)
</code>
<code python isprime.py>
z = int(raw_input("Zahl = "))
isprime = True
for t in range(2,int(z**0.5)+1):
    if (z%t==0):
        isprime = False
        print("%d ist nicht prim, weil durch %d teilbar!" % (z,t))
        break
if isprime:
    print("%d ist prim!" % z)
</code>
<code python faktorzerlegung1.py>
import sys
z = int(raw_input("Zahl = "))

sys.stdout.write("Primfaktorzerlegung von %d = 1" % z)
t =2 
while z>1:
    while (z % t == 0):
        z/=t
        sys.stdout.write(" * %d" % (t,))
    t+=1

</code>
<code python faktorzerlegung2.py>
import sys
z = int(raw_input("Zahl = "))

sys.stdout.write("Primfaktorzerlegung von %d = 1" % z)
t =2 
while z>1:
    e = 0
    while (z % t == 0):
        e+=1
        z/=t
    if e>1:
        sys.stdout.write(" * %d^%d" % (t,e))
    elif e>0:
        sys.stdout.write(" * %d" % (t,))
    t+=1
</code>

<code python primes1.py>
import sys
n = 0
z = 2
while True:
    prime = True
    for t in range(2,z):
        if (z % t==0):
            prime = False
    if prime:
        sys.stdout.write("%d " % z)
        n+=1
        if n%20 == 0:
            print
    z+=1
</code>

<code python primes2.py>
import sys
n = 0
z = 2
while True:
    prime = True
    for t in range(2,int(z**0.5)+1):
        if (z % t==0):
            prime = False
    if prime:
        sys.stdout.write("%d " % z)
        n+=1
        if n%20 == 0:
            print
    z+=1
</code>

<code python primes3.py>
import sys
n = 0
primes = [2]
sys.stdout.write("2 ")
z=3
while z<1000000:
    prime = True
    for p in primes:
        if p*p>z:
            break
        if (z % p==0):
            prime = False
    if prime:
        sys.stdout.write("%d " % z)
        n+=1
        primes.append(z)
        if n%20 == 0:
            print
    z+=2
</code>

<code python eratosthenes.py>
import sys
n = 1000000
primes = [i>1 for i in range(0,n+1)]
p = 2
while (p*p<=n):
    for i in range(p*p,n+1,p):
        primes[i]=False
    p+=1
    while (not primes[p]):
        p+=1
np=0
for i in range(0,n+1):
    if primes[i]:
        sys.stdout.write("%d " % i)
        np+=1
        if np%20 == 0:
            print
</code>

<code python perfektezahl.py>
z = 2
while True:
    s = 1
    t = 2
    while t*t<=z:
        if z%t == 0:
            s+=t
            if t!=z/t:
                s+=z/t
        t+=1
    if s==z:
        print("Perfekte Zahl %d" % z)
    z+=1
    if (z%100000==0):
        print("[%d]" % z)
</code>

</hidden>