getting started optimiert

2026-06-26 05:30:35 +02:00 · 2026-06-26 05:30:35 +02:00 · 197080826d
parent 3f06fe3e27
commit 197080826d
1 changed files with 217 additions and 210 deletions
--- a/getting_started/getting_started.md
+++ b/getting_started/getting_started.md
@ -1,269 +1,276 @@
-# Getting Started mit Python
+# Getting started-Präsentation
-## 1. Das erste Python-Programm
+- **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`).
-Das klassische erste Programm in Python lautet:
+Python
 ```python
 print("Hello World")
 ```
 ### Erklärung
 * `print()` gibt Text in der Konsole aus.
 * Zeichenketten (Strings) stehen in Anführungszeichen.
 * Nach dem Ausführen des Programms erscheint die Ausgabe auf dem Bildschirm.
 **Ausgabe:**
 ```text
 Hello World
 ```
 Ein weiteres Beispiel:
 ```python
 print("Hallo")
 print("Python")
 ```
 **Ausgabe:**
-```text
+Plaintext
 ```
 Hallo
 Python
 ```
---
+## 2. Variablen, Datentypen & Rechenoperationen
-## 2. Variablen und Datentypen
+### Variablen als Wegweiser
-Variablen werden verwendet, um Daten zu speichern.
+```
 ```python
 name = "Max"
 age = 22
 height = 1.80
 student = True
 ```
-### Häufige Datentypen
+### Die vier wichtigsten Basis-Datentypen:
-| Datentyp                | Beispiel |
+1. **String (`str`):** Textdaten, z. B. `"Max"`.
-| ----------------------- | -------- |
+2. **Integer (`int`):** Ganzzahlen ohne Komma, z. B. `22`. Kann beliebig groß werden.
-| String (Text)           | `"Max"`  |
+3. **Float (`float`):** Gleitkommazahlen, z. B. `1.80`. Wichtig: In der Programmierung wird das englische System mit einem **Punkt** statt einem Komma genutzt!
-| Integer (Ganzzahl)      | `22`     |
+4. **Boolean (`bool`):** Wahrheitswerte, existieren nur als `True` oder `False`. Wichtig für logische Entscheidungen.
 | Float (Kommazahl)       | `1.80`   |
 | Boolean (Wahrheitswert) | `True`   |
-### Besonderheit von Python
+### Dynamische Typisierung
-* Python erkennt den Datentyp automatisch.
+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).
 * Es ist keine explizite Typdeklaration notwendig.
---
+### Typumwandlung
-## 3. Arbeiten mit Variablen
+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:
-Variablen können ausgegeben und verändert werden.
+Python
-```python
+```
-name = "Max"
+text_zahl = "42"
-print(name)
+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"
 ```
-**Ausgabe:**
+### Mathematische Rechenoperationen
-```text
+Python beherrscht neben den Grundrechenarten mächtige Operatoren für den Programmieralltag:
-Max
+
 ```
 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)
 ```
-```python
+## 3. Arbeiten mit Listen
-age = 22
+
-print(age + 1)
+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)
 ```
-**Ausgabe:**
+### Wichtige Listen-Operationen & Methoden
-```text
+```
-23
+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)
 ```
-### Vorteile von Variablen
+## 4. Dictionaries
-* Daten können gespeichert werden.
+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.
 * Werte können jederzeit verändert werden.
 * Programme werden flexibler und übersichtlicher.
 ---
 ## 4. Listen (Lists)
 Listen dienen dazu, mehrere Werte in einer einzigen Variablen zu speichern.
 ```python
 fruits = ["Apple", "Banana", "Orange"]
 ```
-
+auto = {
-### Zugriff auf Elemente
+    "marke": "BMW",
-
+    "modell": "M3",
-```python
+    "baujahr": 2022
 print(fruits[0])
 ```
 **Ausgabe:**
 ```text
 Apple
 ```
 ### Element hinzufügen
 ```python
 fruits.append("Mango")
 ```
 ### Element ändern
 ```python
 fruits[1] = "Pear"
 ```
 ### Eigenschaften von Listen
 * Geordnete Sammlung von Daten
 * Veränderbar (mutable)
 * Beliebig viele Elemente möglich
 * Zugriff über einen Index
 **Wichtig:** Der erste Index beginnt bei `0`.
 ---
 ## 5. Dictionaries
 Dictionaries speichern Daten als Schlüssel-Wert-Paare.
 ```python
 student = {
    "name": "Max",
    "age": 22,
    "city": "Mannheim"
 }
 # Zugriff über den Schlüssel
 print("Modell:", auto["modell"])
 ```
-### Zugriff auf Werte
+## 5. Sets & Tuples (Mengen und unveränderliche Listen)
-```python
+### Tuples (Tupel)
-print(student["name"])
+
 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:**
-```text
+```
-Max
+Aktuelle Nummer: 1
 Aktuelle Nummer: 2
 Aktuelle Nummer: 4
 ```
-### Wert ändern
+## 7. Funktionen
-```python
+Funktionen kapseln Code-Blöcke, um Redundanzen zu vermeiden (DRY-Prinzip: Don't Repeat Yourself).
-student["age"] = 23
+
 ### 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
 ```
-### Neuen Eintrag hinzufügen
+### 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
 ```python
 student["email"] = "max@mail.com"
 ```
 def berechne_quadrat(zahl):
    ergebnis = zahl * zahl
    return ergebnis # Gibt das mathematische Objekt zurück
-### Listen und Dictionaries im Vergleich
+# Wert abfangen und in neuer Variable speichern
 meine_quadratzahl = berechne_quadrat(5)
-| Liste              | Dictionary             |
+# Jetzt können wir mit der Variable weiterrechnen!
-| ------------------ | ---------------------- |
+print("Das Doppelte der Quadratzahl ist:", meine_quadratzahl * 2) # 50
-| Zugriff über Index | Zugriff über Schlüssel |
+```
 | `fruits[0]`        | `student["name"]`      |
 | Geordnete Werte    | Schlüssel-Wert-Paare   |
 ---
 ## 6. Funktionen
 Funktionen ermöglichen die Wiederverwendung von Code.
 ### Einfache Funktion
 ```python
 def greet():
    print("Hallo")
 ```
 ### Funktionsaufruf
 ```python
 greet()
 ```
 **Ausgabe:**
 ```text
 Hallo
 ```
 ### Funktion mit Parameter
 ```python
 def greet(name):
    print("Hallo " + name)
 ```
 ### Funktionsaufruf
 ```python
 greet("Max")
 ```
 **Ausgabe:**
 ```text
 Hallo Max
 ```
 ### Vorteile von Funktionen
 * Wiederverwendbarer Code
 * Bessere Struktur
 * Weniger Wiederholungen
 * Einfachere Wartung von Programmen
 ---
 ## 7. Komplettes Beispiel
 Das folgende Beispiel kombiniert mehrere der bisher vorgestellten Konzepte.
 ```python
 students = ["Max", "Anna", "Tom"]
 def greet(name):
    print("Hallo " + name)
 for student in students:
    greet(student)
 ```
 **Ausgabe:**
 ```text
 Hallo Max
 Hallo Anna
 Hallo Tom
 ```
 ### Verwendete Konzepte
 * Variablen
 * Listen
 * Funktionen
 * Schleifen
 Dieses Beispiel zeigt, wie einzelne Sprachkonzepte in einem kleinen Programm zusammenarbeiten.