216 lines
7.5 KiB
Markdown
216 lines
7.5 KiB
Markdown
# 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}");
|
||
```
|
||
## Modulo-Operator
|
||
|
||
Der Modulo-Operator `%` gibt an, was nach der Division einer Zahl durch eine andere übrig bleibt.
|
||
|
||
```python
|
||
result = dividend % divisor
|
||
```
|
||
|
||
- **dividend:** Die zu teilende Zahl.
|
||
- **divisor:** Die Zahl, durch die der Dividend geteilt wird.
|
||
- **result:** Der Rest der Division.
|
||
|
||
Zum Beispiel
|
||
|
||
```python
|
||
result = 10 % 3
|
||
```
|
||
|
||
Hier wird 10 durch 3 geteilt. 3 passt dreimal in 10, mit einem Rest von 1. Somit wird `result` 1 sein.
|
||
|
||
Normalerweise wird Modulo verwendet, um zu prüfen, ob eine Zahl gerade oder ungerade ist:
|
||
|
||
- Wenn eine Zahl gerade ist, lässt die Division durch 2 einen Rest von 0.
|
||
- Wenn eine Zahl ungerade ist, lässt die Division durch 2 einen Rest von 1.
|
||
|
||
Um dies im Code zu prüfen, verwenden wir den `==` Operator, der prüft, ob zwei Werte zueinander **gleich** sind. Zum Beispiel fragt `result == 0` „ist `result` gleich 0?“
|
||
|
||
**Sonderfall:** Wenn der Dividend kleiner als der Divisor ist, ist das Ergebnis einfach der Dividend selbst.
|
||
|
||
Zum Beispiel:
|
||
`5 % 8 = 5`
|
||
Warum? Da die 8 nicht einmal in die 5 passt, bleibt die gesamte 5 als Rest übrig.
|
||
|
||
### Challenge
|
||
|
||
Schreibe einen Code, der drei Variablen, `a`, `b` und `c` mit den Werten `9`, `2` und `11` (beziehungsweise) initialisiert.
|
||
|
||
Initialisiere danach die folgenden Variablen:
|
||
|
||
- `d`, die das Ergebnis von `a` Modulo `2` enthalten wird
|
||
- `e`, die das Ergebnis von `b` Modulo `3` enthalten wird
|
||
- `f`, die das Ergebnis von `c` Modulo `10` enthalten wird
|
||
|
||
Sieh dir das Ergebnis an und beobachte, wie sich unterschiedliche Dividenden und Divisoren auf das Ergebnis auswirken.
|
||
|
||
|
||
```python
|
||
a = 9
|
||
b = 2
|
||
c = 11
|
||
d = a % 2
|
||
e = b % 3
|
||
f = c % 10
|
||
|
||
# Ändern Sie die folgende Zeile nicht
|
||
|
||
print(f"a = {a}")
|
||
print(f"b = {b}")
|
||
print(f"c = {c}")
|
||
print(f"d = {d}")
|
||
print(f"e = {e}")
|
||
print(f"f = {f}")
|
||
```
|