Differences

This shows you the differences between two versions of the page.

--- lehrkraefte:blc:informatik:glf4-20:simulation:python-repe [2021/03/27 09:05] – [Selektion (if, elif, else)] Ivo Blöchliger
+++ lehrkraefte:blc:informatik:glf4-20:simulation:python-repe [2021/04/06 18:15] (current) – [Python Repetition / Cheat Sheet] Ivo Blöchliger
@@ Line 1: / Line 1: @@
+====== 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>