getting started optimiert
astroZehra
parent
3f06fe3e27
commit
197080826d
|
|
@ -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")
|
||||
# Jetzt können wir mit der Variable weiterrechnen!
|
||||
print("Das Doppelte der Quadratzahl ist:", meine_quadratzahl * 2) # 50
|
||||
```
|
||||
|
||||
### 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.
|
||||
Loading…
Reference in New Issue