# Getting started-Präsentation

- **Die `print()`Funktion:** `print()` ist eine eingebaute Funktion. Sie nimmt Daten entgegen, wandelt sie intern in Text um und sendet sie an den Standard-Ausgabekanal (die Konsole).
- **Automatischer Zeilenumbruch:** Jede `print()`Anweisung schließt standardmäßig mit einem unsichtbaren Zeilenumbruch-Zeichen (`\\n`) ab. Deshalb landen aufeinanderfolgende Aufrufe in neuen Zeilen.
- **Strings (Zeichenketten):** Text muss zwingend in Anführungszeichen (entweder `"..."` oder `'...'`) stehen. Vergisst man diese, sucht Python nach einer Variable mit diesem Namen und wirft einen Fehler (`NameError`).

Python

```
print("Hallo")
print("Python")
```

**Ausgabe:**

Plaintext

```
Hallo
Python
```

## 2. Variablen, Datentypen & Rechenoperationen

### Variablen als Wegweiser

```
name = "Max"
age = 22
height = 1.80
student = True
```

### Die vier wichtigsten Basis-Datentypen:

1. **String (`str`):** Textdaten, z. B. `"Max"`.
2. **Integer (`int`):** Ganzzahlen ohne Komma, z. B. `22`. Kann beliebig groß werden.
3. **Float (`float`):** Gleitkommazahlen, z. B. `1.80`. Wichtig: In der Programmierung wird das englische System mit einem **Punkt** statt einem Komma genutzt!
4. **Boolean (`bool`):** Wahrheitswerte, existieren nur als `True` oder `False`. Wichtig für logische Entscheidungen.

### Dynamische Typisierung

Python erkennt den Datentyp automatisch anhand des zugewiesenen Wertes. Man muss nicht vorab definieren, ob eine Variable ein `int` oder ein `str` ist. Man kann einer Variable später sogar einen völlig anderen Datentyp zuweisen (obwohl man das im Sinne der Lesbarkeit vermeiden sollte).

### Typumwandlung

Manchmal liegen Daten im falschen Typ vor (z. B. eine Zahl, die als Text `"42"` aus einer Datei gelesen wurde). Mit Casting-Funktionen konvertiert man diese manuell:

Python

```
text_zahl = "42"
echte_zahl = int(text_zahl)  # Macht aus dem String einen echten Integer

komma_zahl = float("3.14")   # Macht aus dem String einen Float
text_wieder = str(100)       # Macht aus der Zahl 100 den String "100"
```

### Mathematische Rechenoperationen

Python beherrscht neben den Grundrechenarten mächtige Operatoren für den Programmieralltag:

```
a = 10
b = 3

print("Addition:", a + b)         # 13
print("Subtraktion:", a - b)      # 7
print("Multiplikation:", a * b)   # 30
print("Normale Division:", a / b) # 3.3333333333333335 (Ergebnis ist IMMER ein Float!)

# Fortgeschrittene Operatoren:
print("Ganzzahldivision:", a // b) # 3 (Schneidet alle Kommastellen rigoros ab)
print("Exponent (Hoch-Rechnen):", a ** b) # 1000 (10 hoch 3)

# Der Modulo-Operator (%) - Berechnet den Rest einer Division
print("Modulo Rest:", a % b)      # 1 (Weil 10 geteilt durch 3 gleich 3 ist, mit Rest 1)
```

## 3. Arbeiten mit Listen

Listen sind geordnete, veränderbare Sammlungen von Elementen. Sie können beliebig wachsen und schrumpfen.

### Indexierung (Zugriff auf Elemente)

Der Zugriff erfolgt über eckige Klammern `[]`. Python nutzt ein **0-basiertes Indexsystem** (das erste Element hat den Index 0).
Python erlaubt auch **negative Indexierung**, um vom Ende der Liste rückwärts zu zählen.

```
fruechte = ["Apfel", "Banane", "Orange"]

print("Erstes Element:", fruechte[0])   # Apfel
print("Letztes Element:", fruechte[-1]) # Orange (Index -1 ist immer das letzte Element)
```

### Wichtige Listen-Operationen & Methoden

```
fruechte = ["Apfel", "Banane"]

# Element am Ende hinzufügen
fruechte.append("Mango")

# Element an einer exakten Position einschieben (Index, Objekt)
fruechte.insert(1, "Kiwi") # Schiebt "Kiwi" an Index 1, "Banane" rutscht nach hinten

# Element über den Namen löschen (entfernt das erste Vorkommen)
fruechte.remove("Apfel")

# Das letzte Element entfernen und gleichzeitig zurückgeben
letztes = fruechte.pop()

print("Verbleibende Liste:", fruechte)
print("Entferntes Element:", letztes)
```

## 4. Dictionaries

Dictionaries speichern Daten in **Schlüssel-Wert-Paaren (Key-Value)**. Unter der Haube arbeiten sie als *Hash-Tables*, wodurch Abfragen extrem schnell ausgeführt werden – unabhängig davon, wie groß das Dictionary ist.

```
auto = {
    "marke": "BMW",
    "modell": "M3",
    "baujahr": 2022
}

# Zugriff über den Schlüssel
print("Modell:", auto["modell"])
```

## 5. Sets & Tuples (Mengen und unveränderliche Listen)

### Tuples (Tupel)

Ein Tuple wird mit runden Klammern geschrieben. Es ist nach der Erstellung **unveränderlich (immutable)**. Elemente können weder hinzugefügt, entfernt noch überschrieben werden.

```
ordnungssystem = ("Nord", "Süd", "Ost", "West")
```

- **Praxisnutzen:** Datensicherheit. Sie garantieren im Code, dass diese Werte fix geschützt sind.
- **Tuple Unpacking:** Man kann Werte eines Tuples elegant in einzelne Variablen entpacken.

```
koordinaten = (49.48, 8.46)
breitengrad, laengengrad = koordinaten
print("Breite:", breitengrad)
print("Länge:", laengengrad)
```

### Sets (Mengen)

Ein Set wird mit geschweiften Klammern geschrieben, enthält aber keine Schlüssel-Wert-Paare, sondern nur einzelne Werte. Ein Set ist **ungeordnet** und enthält **jedes Element garantiert nur einmal** (Duplikate werden automatisch gelöscht).

Python

```
zahlen_set = {5, 1, 2, 2, 3, 3, 3, 4}
print("Set filtert Duplikate:", zahlen_set) # {1, 2, 3, 4, 5}
```

## 6. Logik & Schleifen (Control Flow)

### Wahrheitswert

In Python evaluieren nicht nur Booleans (`True`/`False`) in Bedingungen. Jedes Objekt besitzt eine eingebaute Wahrheit.

- **Als `False` gilt:** Die Zahl `0`, leere Strings `""`, leere Listen `[]`, leere Dictionaries `{}` und das Objekt `None`.
- **Als `True` gilt:** Alles, was Inhalt besitzt oder einen Wert ungleich Null hat.

Python

```
eingabe = "" # Ein leerer String

if not eingabe:
    print("Fehler: Es wurde nichts eingegeben!")
```

### Bedingungen (`if`, `elif`, `else`)

Python

```
note = 2

if note == 1:
    print("Ausgezeichnet")
elif note == 2 or note == 3:
    print("Bestanden")
else:
    print("Nicht bestanden")
```

### Schleifen

### For-Schleife

Verwendet man, wenn vorab bekannt ist, wie oft etwas wiederholt werden soll oder wenn eine Kollektion durchlaufen wird.

```
# range(start, stop) läuft vom Start-Wert bis exklusive Stop-Wert
for zaehler in range(1, 4):
    print("Durchgang Nummer:", zaehler)
```

### While-Schleife (Bedingungs-gesteuert)

Läuft unendlich lange, solange eine Bedingung auf `True` steht. Wichtig: Die Bedingung muss innerhalb der Schleife irgendwann geändert werden, sonst entsteht eine Endlosschleife.

```
countdown = 3
while countdown > 0:
    print("Countdown:", countdown)
    countdown = countdown - 1 # Bedingung verändern
```

### Schleifensteuerung: `break` und `continue`

- `continue` bricht den *aktuellen* Durchlauf ab und springt sofort zum nächsten Element.
- `break` bricht die *komplette* Schleife sofort rigoros ab.

```
for nummer in range(1, 6):
    if nummer == 3:
        continue # Die 3 wird übersprungen
    if nummer == 5:
        break    # Bei 5 wird die komplette Schleife beendet
    print("Aktuelle Nummer:", nummer)
```

**Ausgabe:**

```
Aktuelle Nummer: 1
Aktuelle Nummer: 2
Aktuelle Nummer: 4
```

## 7. Funktionen

Funktionen kapseln Code-Blöcke, um Redundanzen zu vermeiden (DRY-Prinzip: Don't Repeat Yourself).

### Parameter mit Standardwerten (Default Parameters)

Man kann Parametern Vorbelegungen mitgeben. Werden diese beim Aufruf weggelassen, greift der Standardwert.

```
def begrüßung(name="Gast"):
    print("Hallo,", name)

begrüßung("Julia") # Ausgabe: Hallo, Julia
begrüßung()        # Ausgabe: Hallo, Gast
```

### Der fundamentale Unterschied: `print` vs. `return`

Ein häufiger Konzeptfehler:

- `print()` wirft Daten nur visuell für den Menschen auf den Bildschirm. Das Programm kann mit diesem Wert danach **nicht** weiterarbeiten.
- `return` schickt ein echtes Datenobjekt zurück an die Stelle, wo die Funktion aufgerufen wurde. Der Wert kann in einer Variable gespeichert und weiterverwendet werden. Eine Funktion bricht sofort ab, sobald ein `return` erreicht wird.

Python

```
def berechne_quadrat(zahl):
    ergebnis = zahl * zahl
    return ergebnis # Gibt das mathematische Objekt zurück

# Wert abfangen und in neuer Variable speichern
meine_quadratzahl = berechne_quadrat(5)

# Jetzt können wir mit der Variable weiterrechnen!
print("Das Doppelte der Quadratzahl ist:", meine_quadratzahl * 2) # 50
```