Snippets/Python.md

# Python

# Variablen

### Zahlen

**Variablen** sind Container, die Datenwerte enthalten. Sie werden verwendet, um Informationen innerhalb eines Programms zu speichern, zu bearbeiten und anzuzeigen.

Kurz gesagt ist eine Variable wie eine Speichereinheit, auf die wir zugreifen können, indem wir den Namen der Variable eingeben. 

Jede Variable hat einen eindeutigen **Namen** und einen **Wert** , der von unterschiedlichen Typen sein kann. Python kann den Variablentyp automatisch erkennen, wodurch das Programmieren effizienter wird.

Um eine Variable zu initialisieren, verwenden wir das folgende **Format**:

```python
variable_name = value
```

Sehen wir uns die verschiedenen Zahlentypen an:

`int` – eine Ganzzahl, wie etwa `1` oder `-2`.

`float` – reelle Zahl, zum Beispiel `1.32` oder `0.98`.

Zum Beispiel:

Um eine Variable vom Typ `int` mit dem Namen `a` und dem Wert `3` zu initialisieren:

```python
a = 3
```

Um eine Variable vom Typ `float` mit dem Namen `b` und dem Wert `13.2` zu initialisieren:

```python
b = 13.2
```

**Hinweis:** Variablennamen dürfen nicht mit einer Zahl beginnen. Verwende Unterstriche, um Wörter zu trennen (z. B. `player_name`), keine Leerzeichen oder Bindestriche..

## Strings

Ein **Zeichen** ist ein einzelner Buchstabe, eine einzelne Ziffer oder ein einzelnes Symbol (zum Beispiel: 1, 6, %, b, p, ., T usw.). Python hat keinen separaten `char`-Typ: Ein einzelnes Zeichen ist einfach eine Zeichenkette der Länge 1.

Der Typ **str** (Zeichenkette) ist eine Folge aus einem oder mehreren Zeichen.

Um einen Zeichenfolgenwert in einer Variablen zu initialisieren, schließe ihn in einfache oder doppelte Anführungszeichen ein:

```python
s1 = 'This is a string's2 = "This is also a string"
```

Im obigen Beispiel werden zwei Zeichenfolgenvariablen initialisiert, die `s1` und `s2` heißen.

## Boolean

Ein **bool** (Boolean) Typ hat nur 2 mögliche Werte: `True` oder `False`.

Beachten Sie, dass bei diesen Werten die **Groß-/Kleinschreibung beachtet werden muss** (case-sensitive), was bedeutet, dass sie mit einem Großbuchstaben beginnen müssen.

Hier ist ein Beispiel für die Zuweisung eines booleschen Werts zu einer Variable:

```python
variable_true = Truevariable_false = False
```

Oben werden zwei Variablen namens `variable_true` und `variable_false` mit den Werten `True` bzw. `False` initialisiert.

> Booleans sind die Bausteine für das Erstellen von Logik in den Programmen, die wir schreiben. Wir haben ein ganzes Kapitel über Logik und Bedingungen.

## Benennungskonventionen

Namenskonventionen sind eine Reihe von Richtlinien, denen Entwickler folgen, um ihren Code lesbarer und wartbarer zu machen. Verschiedene Programmiersprachen haben oft unterschiedliche Namenskonventionen. In Python werden Variablen in `snake case` geschrieben – Wörter werden durch Unterstriche getrennt.

Beim Schreiben eines Variablennamens sei **beschreibend** und verwende **aussagekräftige** Wörter

### Zum Beispiel 

```python
# Schlechte Namensgebung
isActive = False # nicht im Snake-Case-Format
a = 10
b = "Hello"
x = True
# Gute Namensgebung
age = 10
greeting = "Hello"
is_active = True
```

## Leere Variablen

In Python ist `None` ein spezieller Wert, der „nichts“ oder „kein Wert“ darstellt. Es ist wie eine leere Box – sie existiert, aber in ihr befindet sich nichts. Zum Beispiel:

```python
empty_box = None
```

In einem realen Szenario könntest du `None` verwenden, um anzuzeigen, dass etwas noch nicht initialisiert wurde.

Zum Beispiel:

```python
score = None  # Score wurde noch nicht berechnet
name = None   # Name wurde noch nicht eingegeben 
```

**Hinweis:** `None` ist _nicht_ dasselbe wie `0`, eine leere Zeichenfolge `""` oder `False`. Das sind tatsächliche Werte: null, leerer Text und falsch. `None` bedeutet, dass _überhaupt kein Wert_ vorhanden ist. Das Fehlen eines Werts ist kein Fehler; es bedeutet einfach, dass bisher nichts zugewiesen wurde.

`0` ist ein echter numerischer Wert, zum Beispiel eine Punktzahl von genau null, während `None` bedeutet, dass überhaupt kein Wert vorhanden ist, etwa eine Punktzahl, die noch nicht berechnet wurde. Ein häufiges Missverständnis ist, dass `0` „nichts“ bedeutet, aber in Python steht nur `None` tatsächlich für das Fehlen eines Werts. Ebenso sind `""` (leere Zeichenkette) und `False` weiterhin echte Werte ihrer jeweiligen Typen. Sie sind nicht dasselbe wie `None`.

Die Verwendung von `None` signalisiert, dass die Variable als Platzhalter existiert, aber noch keinen sinnvollen berechneten Wert enthält.
## Arithmetische Operatoren

**Operatoren** werden verwendet, um Operationen mit Werten durchzuführen. 

Zuerst besprechen wir die grundlegendsten **arithmetischen Operatoren**, die dir vielleicht aus dem Mathematikunterricht bekannt sind.

|Operator|Operation|Beispiel|
|---|---|---|
|+|Addition|3 + 2 = 5|
|-|Subtraktion|3 - 2 = 1|
|*|Multiplikation|3 * 2 = 6|
|/|Division|4 / 2 = 2.0|

Sehen wir uns ein Anwendungsbeispiel an.

```python
a = 3
b = 5
c = a + b # c hält 8
```

Wenn ein Ausdruck mehrere Operatoren enthält, folgt Python der in der Mathematik verwendeten Reihenfolge: Multiplikation und Division werden vor Addition und Subtraktion berechnet, und alles innerhalb von Klammern wird zuerst berechnet.

```python
z = 7 + 3 * 2   # z hat den Wert 13, weil 3 * 2 zuerst berechnet wird
z = (7 + 3) * 2 # z hat den Wert 20
```
### Challenge

Schreibe einen Code, der zwei Variablen, `a` und `b`, mit den Werten `5.2` bzw. `2.6` initialisiert.

Initialisiere danach eine weitere Variable `c`, die das Ergebnis von `a / b` enthält.

```python
a = 5.2
b = 2.6
c = a / b

print(f"a = {a}, b = {b}, c = {c}");
```