Python Repetition / Cheat Sheet

Eine minimalistische Version gibt es 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.

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)

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

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

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")

Oder Anzahl in Variable:

anzahl = 5
for i in range(anzahl):
    print("%d im Quadrat ist %d" % (i, i*i))

Bis zu welcher Zahl muss man natürliche Zahlen aufsummieren, um über 1000 zu kommen?

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))

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")

Beachten Sie, dass elif und else optional sind.

Variablen, die Listen enthalten, sollten Bezeichnungen im plural erhalten.

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])

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)

Nur Elemente

zahlen = [42,23,12,1]   # Name ist Plural
for zahl in zahlen:     # Für jedes Element einmal wiederholen. Aktuelles Element in zahl
    print(zahl)

Nur Index

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])

Index und Element

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))

Ohne Argumente (Parameter) und ohne Rückgabewert.

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()

Mit Argumenten, ohne Rückgabewert

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

Ohne Argumente, mit Rückgabewert

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)

Mit Argumenten, mit Rückgabewert

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))

Uniform verteilte Ganzzahlen

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)

Uniform verteilte reelle Zahlen im Intervall $[0,1)$.

from random import random
for i in range(10):
    print(random())

Uniform verteilte reelle Zahlen im Intervall $[a,b)$.

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)