276 lines
8.2 KiB
Markdown
276 lines
8.2 KiB
Markdown
# 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
|
||
``` |