# Python Zusammenfassung

Mit den folgenden sechs Merkmalen kannst du jedes Programm schreiben:

## The Big Six
### Variablen

In **Variablen** werden Werte gespeichert, die man im Laufe des Programms lesen oder verändern will. Variablen haben einen Namen und einen Wert. Den Namen der Variable darf man frei wählen. Nicht erlaubt sind allerdings die Schüsselwörter (z.B. *from*, *repeat*, ...) und Namen mit Sonderzeichen.

Variablen kannst du ganz einfach deklarieren: `<Name der Variablen> = <Wert der Variablen>`

Variablen haben jeweils einen **Typ**:

   * **Zahlen**: Mit Zahlen kann man rechnen.
   * Ein Text wird in der Informatik als **String** bezeichnet. In Python müssen Strings immer in Anführungs- und Schlusszeichen geschrieben werden. Zahlen sind keine Strings und benötigen deshalb keine Anführungs- und Schlusszeichen. Natürlich kann man mit Strings nicht rechnen.

**Beispiele:**

<code python>
x = 7 # Zahl

a = "Hallo, ich bin ein String!" # String
</code>
#### Operationen mit Zahlen
Betrachte als Beispiel den folgenden Code:

<code python>
x = 7

y = x*x

print(y)
</code>

Im ersten Schritte legen wir eine Variable mit Namen `x` fest und weisen ihr den Wert 7 zu. Danach quadrieren wir die Zahl und speichern diesen Wert in einer zweiten Variable mit Namen `y`. Nun geben wir in der Konsole den Wert der Variable `y` (also 49) aus. Die **Konsole** (auch **Terminal**) ist das Fenster unterhalb des Code-Fensters.
Um etwas in der Konsole auszugeben, schreiben wir dies in die `print(...)` Funktion.

Führe diesen Code (selber schreiben, nicht copy-paste!) nun selbst aus. Weise der Variablen `x` nun einen anderen Wert zu. Damit wird dann auch der Wert der Variablen `y` verändert und dementsprechend sieht die Ausgabe im Terminal anders aus.

Einige wichtige **mathematischen Operatoren** sind:

^ Funktion ^ Python-Code ^ Resultat ^
| Addition | `7+3` | `10` |
| Subtraktion | `7-3` | `4` |
| Multiplikation | `7*3` | `21` |
| Division (Nachkommastellen) | `7/3` | `2.3333333333...` |
| Ganzzahldivision | `7//3` | `2` |
| Hoch (z.B. 2 hoch 5) | `2**5` | `32` |
| Wurzel (z.B. Wurzel von 2, sqrt für square-root) | `sqrt(2)` | `1.4142135...` |
| Modulo (Rest der Ganzzahl-Division) | `7%3`| `1` |

#### Operationen mit Strings

^ Funktion            ^ Python-Code                 ^ Resultat             ^
| Länge               | `len("Eine Zeichenkette")`  | `17`                 |
| Buchstabe auslesen  | `"Hallo"[1]`                | `"a"`                |
| Aneinanderreihen    | `"Hallo" + "Welt"`          | `"HalloWelt"`        |
| _Multiplikation_    | `"lol" * 5`                 | `"lollollollollol"`  |


### Verzweigung

Ziel: Ein Stück Code nur ausführen, falls eine Bedingung erfüllt ist.

<code python>
if <Bedingung>:
    # Codeblock der ausgeführt wird,
    # falls (if) Bedingung erfüllt (True) ist
</code>

Wollen wir zwei Fälle unterscheiden, können wir mit `else` arbeiten. Achtung: `else` hat keine Bedingung - der Block wird dann ausgeführt, wenn die `if`-Bedingung nicht zutrifft.

<code python>
if <Bedingung>:
    # Codeblock der ausgeführt wird,
    # falls (if) Bedingung erfüllt (True) ist
else:
    # Codeblock der ausgeführt wird,
    # der ansonsten ausgeführt wird,
    # falls also Bedingung NICHT erfüllt ist (False)
</code>

Gibt es aber **drei oder mehr Fälle**, muss man `if`-`else`-Verzweigungen ineinander verschachteln. Dadurch wird der Code unübersichtlich und fehleranfällig. Es ist dann besser, mit `elif` die weiteren Fälle zu programmieren, da man mit dieser **beliebig viele Fälle** unterscheiden kann:
<code python>
if <Bedingung1>:
    # Code, falls <Bedingung1> erfüllt ist.
elif <Bedingung2>:
    # Code, falls <Bedingung2> erfüllt ist, aber nicht <Bedingung1>.
else:
    # Code, falls keine der Bedingungen erfüllt ist.
</code>

Bemerkungen:

   * Es gibt genau eine `if`-Anweisung!
   * Man kann **beliebig viele** (auch null) `elif`-Anweisungen hintereinander schalten.
   * Es gibt keine oder eine `else`-Anweisung.
   * Falls die Bedingung bei `if` oder einem `elif` erfüllt ist, werden alle darauffolgenden `elif` gar **nicht mehr überprüft**.

### Schleifen

Ziel: Ein Stück Code soll wiederholt ausgeführt werden, solange eine Bedingung erfüllt (`True`) ist.

<code python>

while <Bedingung>:
    # Dieser Codeblock wird solange ausgefuehrt,
    # wie die <Bedingung> True (also erfuellt) ist

# Dieser Code wird ausgeführt,
# sobald die <Bedingung> nicht mehr erfüllt ist
</code>

### Bedingungen

Sowohl in Schleifen wie auch in Verzweigungen werden Bedingungen überprüft. Bedingungen sind Code-Ausdrücke, die in einen Wahrheitswert (`True` - die Bedingung ist erfüllt, oder `False`, sie ist nicht erfüllt) umgewandelt werden können.

Die einfachste Bedingung ist also gerade so ein Wahrheitswert. Eine `while True`-Schleife wird nie regulär beendet, wir verwenden Sie für einen Programmteil der nicht verlassen werden sollen (z.B. in der Robotik):

<code python>
while True:
    if button_a.is_pressed():
        display.show(Image.SMILE)
</code>

#### Vergleichs-Operatoren

Für komplexere Bedingungen in Verzweigungen und Schleifen benötigen wir **Vergleichsoperatoren:**

^ Operator ^ Erklärung ^
| `x == 4` | x ist Zahl und hat Wert von genau 4 |
| `s == "Hallo"` | s ist String und hat genau den Inhalt "Hallo" |
| `x != 4` | x ist NICHT eine Zahl vom Wert (Ungleich-Operator)|
| `x > 5` | x ist Zahl grösser als 5 |
| `x >= 5` | x ist Zahl grösser gleich 5 |
| `x < 5` | x ist Zahl kleiner als 5 |
| `x <= 5` | x ist Zahl kleiner gleich 5 |

#### Implizite Umwandlung in Wahrheitswert

Python kann alle Werte irgendwie in einen Wahrheitswert umwandeln:
  * `False` sind:
    * die Zahl `0` oder `0.0`
    * der leere String `""` und die leere Liste `[]`
    * `None`
    * `False` selbst
  * `True` ist alles andere:
    * alle anderen Zahlen ausser 0
    * alle nicht-leeren Strings und Listen
    * `True` selbst
    * alle anderen Objekte

#### Logik-Operatoren

Mit **Logikoperatoren** können mehrere Aussagen **verknüpft** (`and`, `or`) oder eine Aussage **negiert** (`not`) werden:
^ Operator ^ Erklährung ^
| `A and B` | ist `True` nur falls beide Aussagen `A` und `B` `True` sind |
| `A or B` | ist `True` nur falls mindestens eine der Aussagen `A` und `B` `True` ist |
| `not A` | negiert Aussage `A` |

### Listen

Eine Liste ist eine Sequenz von Werten, die in einer einzigen Variable gespeichert werden.

Eine Liste erstellt man wie folgt:
<code python>
L = ['a', 'b', 'c', 'd']
</code>
Eine Liste besteht aus **Elementen**, die Position eines Elements wird **Index** genannt. Die Elemente einer Liste kann man über ihren Index **auslesen**. Das erste Element hat den Index 0, das zweite den Index 1 usw. `print(L[2])` gibt also `c` in der Konsole aus. Ganz ähnlich kannst du auch einen **Wert ändern**: `L[2] = 'B'`.

Elemente hinten **hinzufügen** kann man mit append:
<code python>
L = ['a', 'b', 'c', 'd']
L.append('e')
</code>

Nach dem append-Befehl sieht die Liste wie folgt aus: `['a', 'b', 'c', 'd', 'e']`. Mit `print(L)` kannst du dich selbst davon überzeugen. Weitere wichtige Befehle sind
<code python>
L.insert(2,'z') # fügt an Index-Position 2 den Wert 'z' ein
L.pop(4) # Entfernt das Element mit Index 4
len(L) # Gibt an, wieviele Elemente sich in der Liste befinden. Diesen Wert kann man z.B. printen oder in einer Variablen speichern
</code>

#### Iteration

Iteration bedeutet, alle Elemente einer Liste durchzugehen. Mit einer `while`-Schleife könnte das so aussehen:
<code python>
i = 0
while i < len(L):
    print(L[i])
    i = i + 1
</code>

Noch etwas eleganter geht dasselbe mit einer `for`-Schleife. Dabei wird die Schleifen-Variable (im Beispiel `e`) in jedem Durchgang der Schleife auf das nächste Element der Liste gesetzt.
<code python>
for e in L:
    print(e)
</code>
### Funktionen

Eine **Funktion** verpackt ein Stück Code, das wir öfter benötigen. 

Die Funktion ist immer wie folgt aufgebaut:

<code python>
def name_der_funktion(PARAMETER): # Parameter sind optional, die Klammern nicht.
    # CODE DER FUNKTION
    return RETURN_WERT # ist optional
</code>

Wir verwenden Funktionen schon lange, viele kennst du: `print` und `input`, `random.randint`, `len`. Zudem gibt es Funktionen, die zu einem Objekt gehören:
<code python>
digits = [0, 1, 2, 3, 4, 5]
digits.append(6)  # Die Funktion append gehört zum Listen-Objekt

message = "Wir haben {0} Ziffern".format(7)  # Die Funktion format gehört zum String-Objekt
</code>

Gründe, um Funktionen zu benützen:
  * Effizienz: Wiederholung vermeiden, mehrfach benötigten Code nur einmal schreiben.
  * Klarheit: Der Name der Funktion dokumentiert, was hier passiert.
  * Isolation: Eine Funktion bearbeitet nur ihre Argumente, andere Variablen sind tabu!

Vergleich den folgenden Code und entscheide, was klarer ist:

<WRAP group>
<WRAP 45% column>
<code python>
numbers = [58, 100, 2, 24, 34, 34, 41, 46, 49, 45]

count = 0
for n in numbers:
   if n % 5 == 0:
       if n % 3 == 0:
           count = count + 1
print(count)
</code>
</WRAP>
<WRAP 45% column>
<code python>
def is_multiple(number, factor):
    return number % factor == 0
 
def count_multiples_of(candidates, x, y):
    count = 0
    for n in candidates:
       if is_multiple(n, x) and is_multiple(n, y):
           count = count + 1
    return count
 
numbers = [58, 100, 2, 24, 34, 34, 41, 46, 49, 45]
print(count_multiples_of(numbers, 5, 3))
</code>
</WRAP>
</WRAP>