From 197080826de13bc1b2824e3e614c96046bc16c84 Mon Sep 17 00:00:00 2001 From: astroZehra Date: Fri, 26 Jun 2026 05:30:35 +0200 Subject: [PATCH] getting started optimiert --- getting_started/getting_started.md | 427 +++++++++++++++-------------- 1 file changed, 217 insertions(+), 210 deletions(-) diff --git a/getting_started/getting_started.md b/getting_started/getting_started.md index d23e9cb..58cefb8 100644 --- 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 | -| ----------------------- | -------- | -| String (Text) | `"Max"` | -| Integer (Ganzzahl) | `22` | -| Float (Kommazahl) | `1.80` | -| Boolean (Wahrheitswert) | `True` | +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. -### Besonderheit von Python +### Dynamische Typisierung -* Python erkennt den Datentyp automatisch. -* Es ist keine explizite Typdeklaration notwendig. +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 -## 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" -print(name) +``` +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" ``` -**Ausgabe:** +### Mathematische Rechenoperationen -```text -Max +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) ``` -```python -age = 22 -print(age + 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) ``` -**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. -* Werte können jederzeit verändert werden. -* Programme werden flexibler und übersichtlicher. +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. ---- - -## 4. Listen (Lists) - -Listen dienen dazu, mehrere Werte in einer einzigen Variablen zu speichern. - -```python -fruits = ["Apple", "Banana", "Orange"] ``` - -### Zugriff auf Elemente - -```python -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" +auto = { + "marke": "BMW", + "modell": "M3", + "baujahr": 2022 } + +# Zugriff über den Schlüssel +print("Modell:", auto["modell"]) ``` -### Zugriff auf Werte +## 5. Sets & Tuples (Mengen und unveränderliche Listen) -```python -print(student["name"]) +### 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:** -```text -Max +``` +Aktuelle Nummer: 1 +Aktuelle Nummer: 2 +Aktuelle Nummer: 4 ``` -### Wert ändern +## 7. Funktionen -```python -student["age"] = 23 +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 ``` -### 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 | -| ------------------ | ---------------------- | -| 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. \ No newline at end of file +# Jetzt können wir mit der Variable weiterrechnen! +print("Das Doppelte der Quadratzahl ist:", meine_quadratzahl * 2) # 50 +``` \ No newline at end of file