====== Python Repetition / Cheat Sheet ======

Eine minimalistische Version gibt es [[lehrkraefte:blc:informatik:glf4-20:simulation:python-mini-cheat-sheet|hier]].

  * Gehen Sie Beispiele von oben bis unten durch.
  * Kopieren Sie jeweils den Code in TigerJython und führen Sie das jeweilige Programm aus.
  * Versuchen Sie, jede Zeile der Programm zu verstehen. Wenn Sie nicht sicher sind, fügen sie ''print()''-Anweisungen ein, um besser zu verstehen, was das Programm tut.
  * Wenn Sie eine Zeile nicht verstehen, stellen Sie Fragen und/oder "googeln" sie.
  * Das Ziel ist nicht, alles auswendig zu wissen, aber zu wissen, was möglich ist und wo die Information zu finden ist.
===== Variablen, Strings vs. Zahlen =====
=== Variablen mit Zahlen ===
<code python>
foo = 42       # Zuweisung: Speichert die Zahl 42 in einen "Behälter", der mit "foo" angeschrieben ist.
bar = foo/2+2  # Verwendung der Variable foo. Diese wird durch den aktuellen Wert ersetzt. bar wird dann 23.
foo = foo + 1  # Rechts erst ausrechnen, Resultat in Variable vor dem = speichern. foo wird dann 43
print(bar)     # Ausgabe von bar (immer noch 23)
print(foo-bar) # Ausgabe 20
print("5 hoch 3 ist")
print(5**3)    # Potenzieren mit **
print("Wurzel 2 ist")
print(2**0.5)  # kurze Schreibweise zum Wurzeln ziehen (allerdings nicht schnell in der Ausführung)
</code>

=== Variablen mit Strings (Zeichenketten) ===
<code python>
foo = "42"        # Zeichenkette aus den Zeichen '4' und '2'.
bar = foo + "23"  # Ergibt "4223". String + String bedeutet Zeichenketten aneinander hängen.
print(bar)        # Gibt 4223 aus
baz = int(foo)+23 # int(String) wandelt in eine Zahl um. Resultat 65
print(baz)        # Gibt 65 aus
bla = str(baz)+"23"  # str(dings) wandelt dings in einen String (Zeichenkette) um. Resultat "6523"
print(bla)        # Gibt 6523 aus
</code>

=== Formatierte Ausgabe ===
<code python>
foo = 42
print("%d ist die Antwort und %d ist nur die halbe Wahrheit" % (foo, foo/2))
# Ausgabe 42 ist die Antwort und 21 ist nur die halbe Wahrheit
pi = 3.141529
print("pi als Ganzzahl: %d, als Dezimalzahl: %f, auf 2 Stellen %.2f und 20 Stellen %.20f" % (pi,pi,pi,pi))
# Ausgabe pi als Ganzzahl: 3, als Dezimalzahl: 3.141529, auf 2 Stellen 3.14 und 20 Stellen 3.14152899999999979386
</code>

===== Wiederholungen =====
=== Bekannte Anzahl ===
<code python>
for humpfdidumpf in range(10):   # humpfdidumpf wird Laufvariable genannt und wird für jede Wiederholung hochgezählt (hier von 0 bis und mit 9).
    print("Alles was einrückt ist")
    print("wird 10 mal wiederholt")
    print("humpfdidumpf ist jetzt %d" % humpfdidumpf)
print("Was nicht eingerückt wird, wird ausgeführt, wenn die Wiederholungen fertig sind")
</code>
Oder Anzahl in Variable:
<code python>
anzahl = 5
for i in range(anzahl):
    print("%d im Quadrat ist %d" % (i, i*i))
</code>

=== Unbekannte Anzahl ===
Bis zu welcher Zahl muss man natürliche Zahlen aufsummieren, um über 1000 zu kommen?
<code python>
summe = 0
zahl = 0
while summe < 1000:  # Wiederholen, so lange die Bedingung wahr ist
    zahl += 1        # Kurz für zahl = zahl+1   (Die Abstände sind optional, es kann aber die Lesbarkeit erhöhen).
    summe += zahl    # Kurz für summe = summe + zahl
print("Man muss die Zahlen von 1 bis %d addieren damit die Summe grösser als 1000 wird (nämlich %d)" % (zahl, summe))
</code>

===== Selektion (if, elif, else) =====
<code python>
for z in range(40):
    if z%15 == 0:   # z%15 ist der Rest der Division durch 15. Um Gleichheit zu prüfen wird das doppelte Gleichheitszeichen verwendet
        print("%d ist durch 15 teilbar" % z)
        print("    Alles was eingerückt ist, wird nur dann ausgeführt, wenn die Bedingung wahr ist")
    elif z%5 == 0:  # Wenn die erste Bedingung falsch ist, und z%5==0
        print("%d ist eine Fünferzahl" % z)
    elif z%3 == 0:
        print("Dreierzahl %d" % z)
    else:   # Wenn keine der obigen Bedingungen wahr ist
        print("%d ist weder durch 3 noch 5 teilbar" % z)
    print("  Das wird auf jeden Fall ausgeführt, weil bezüglich dem if nicht eingrückt, es wird aber wiederholt")
print("Und das wird nicht wiederholt, sondern nur ganz am Schluss einmal ausgegeben")
</code>
Beachten Sie, dass ''elif'' und ''else'' optional sind.

===== Listen =====
Variablen, die Listen enthalten, sollten Bezeichnungen im **plural** erhalten.
=== Elemente auslesen und zuweisen ===
<code python>
foos = [42,23,111]     # Liste mit 3 Elementen
print(foos)            # Ausgabe
print("Erstes Element foos[0] = %d" % foos[0])
# Ausgabe: Erstes Element foos[0] = 42
foos[2] = 12345        # Drittes Element überschreiben
print(foos)            # Ausgabe [42,23,12345]
print("foos hat %d Elemente." % len(foos))    # len(liste) liefert die Anzahl Elemente. Der Index vom letzten Element ist also len(foos)-1

print("Negative Indizies greifen von hinten auf die Liste zu, d.h. foos[-1]=%d ist das letzte Element" % foos[-1])
print("foos[-2]=%d ist das zweiletzte Element" % foos[-2])
</code>
=== Liste aufbauen mit .append ===
<code python>
quadratzahlen = []    # Leere Liste (Name ist plural!)
for i in range(30):
    quadratzahlen.append(i*i)     # Der Liste ein neues Element hinten anhängen
print("%d im Quadrat ist %d" % (7,quadratzahlen[7]))
print(quadratzahlen)
</code>

=== Elemente durchgehen ===
Nur Elemente
<code python>
zahlen = [42,23,12,1]   # Name ist Plural
for zahl in zahlen:     # Für jedes Element einmal wiederholen. Aktuelles Element in zahl
    print(zahl)
</code>
Nur Index
<code python>
zahlen = [42,23,12,1]            # Name ist Plural
for i in range(len(zahlen)):     # i läuft von 0 bis len(zahlen)-1, was dem Index des letzten Elements entspricht
    print(zahlen[i])
</code>
Index und Element
<code python>
zahlen = [42,23,12,1]            # Name ist Plural
for i,zahl in enumerate(zahlen): # i läuft von 0 bis len(zahlen)-1, zahl ist automatisch zahlen[i]
    print("Element %d ist %d" % (i,zahl))
</code>

===== Funktionen =====
Ohne Argumente (Parameter) und ohne Rückgabewert.
<code python>
def hallo():          # Definition einer Funktion ohne Argumente und ohne Rückgabewert, Der Name ist belibig, sollte mit einem Kleinbuchstaben beginnen und beschreibend sein.
   print("Gruss von der Funktion hallo()")

print("Programmstart ist hier!")   
hallo()
hallo()
</code>
Mit Argumenten, ohne Rückgabewert
<code python>
def plappermaul(was, wieviel):   # Die Variablen was und wieviel existieren nur in dieser Funktion und haben nichts mit Variablen vom gleichen Namen ausserhalb zu tun.
    for i in range(wieviel):     # Die Variable i lebt nur in dieser Funktion und beeinflusst Variablen mit gleichem Namen ausserhalb nicht.
        print(was)
    
plappermaul("hallo", 4)          # Schreib 4 mal hallo
</code>
Ohne Argumente, mit Rückgabewert
<code python>
def meineListe():
    zahlen = [1,1]
    for i in range(20):
        zahlen.append(zahlen[-1]+zahlen[-2])   # Summe der beiden letzten Elemente
    return zahlen                              # Funktion sofort beenden und Resultat zurückgegeben

foos = meineListe()   # Resultat der Funktion (in diesem Fall eine Liste) in die Variable foos spichern.
print(foos)
</code>
Mit Argumenten, mit Rückgabewert
<code python>
def quadrat(x):
    return x*x   # Quadrat von x berechnen und als Resultat zurückgeben.
z = 12
q = quadrat(z)   # Resultat der Funktion in q speichern.
print("Das Quadrat von %d ist %d" % (z,q))
</code>

===== Zufallszahlen =====
Uniform verteilte Ganzzahlen
<code python>
from random import randrange
for i in range(1,21):   # i läuft von 1 bis 20 (die obere Grenze exklusive)
    print("Wurf %2d: -> %d" % (i, randrange(1,7))  # Zufällige Ganzzahl von 1 bis und mit 6 (Parameter genau wie range, obere Grenze exklusive)
</code>
Uniform verteilte reelle Zahlen im Intervall $[0,1)$.
<code pyton>
from random import random
for i in range(10):
    print(random())
</code>
Uniform verteilte reelle Zahlen im Intervall $[a,b)$.
<code pyton>
from random import random
a = 2.71828
b = 3.14152
for i in range(10):
    print(random()*(b-a)+a)  # Intervall [0,1) auf [a,b) umrechnen (lineare Funktion)
</code>