Knowledge Hub

Learning Journey

Python – Klassen & Methoden

Backend-Unterkategorie: von der ersten Zeile bis zu Klassen, Vererbung und Fehlerbehandlung — Variable → Bedingung → Schleife → Funktion → Klasse.

Gesamtfortschritt

0%

Nächster Schritt: Erste Schritte

  1. 01

    Erste Schritte

    Datei anlegen, mit python3 ausführen und print() als Debug-Werkzeug nutzen.

    Offen · 1 Themen
    Öffnen
    • Eine Python-Datei erstellen und starten
    • `print()` für Ausgabe und Tests kennen
    touchpython3print

    Datei anlegen und ausführen

    Lesson · Anleitung · 3 min

    `touch main.py` und `python3 main.py` — Hallo Welt mit print().

    • `touch main.py` legt die Datei an
    • `python3 main.py` führt sie aus
    • `print("Hallo Welt")` gibt Text in der Konsole aus
    • `print()` ist dein wichtigstes Werkzeug zum Testen und Debuggen

  2. 02

    Variablen & Datentypen

    String, Integer, Float, Boolean, Liste — Typ prüfen und umwandeln.

    Offen · 2 Themen
    Öffnen
    • Die häufigsten Datentypen zuweisen
    • `type()` und Casts (`str`, `int`, `float`) nutzen
    strintfloatboollisttype

    Werte zuweisen

    Lesson · Anleitung · 5 min

    Von Text und Zahlen über Boolean bis zur Liste — jeder Wert hat einen Typ.

    • String: `name = "Nalan"`
    • Integer / Float: `alter = 30`, `groesse = 1.75`
    • Boolean: `ist_aktiv = True`
    • Liste: `liste = [1, 2, 3]`

    Typ prüfen und umwandeln

    Lesson · Anleitung · 3 min

    `type()` anzeigen; `str`/`int`/`float` für Umwandlungen.

    • `print(type(alter))` zeigt z. B. `<class 'int'>`
    • `str(123)`, `int("123")`, `float("1.5")`

  3. 03

    Grundoperatoren

    Rechnen, vergleichen und logisch verknüpfen — die Operatoren des Alltags.

    Offen · 1 Themen
    Öffnen
    • Arithmetik inkl. `//`, `%` und `**` anwenden
    • Vergleiche und `and` / `or` / `not` kombinieren
    +//%**==andor

    Rechnen, vergleichen, logisch

    Lesson · Anleitung · 6 min

    Von Addition bis Potenz, Gleichheit und boolesche Verknüpfungen.

    • `+ - * /` und `//` (Ganzzahl), `%` (Rest), `**` (Potenz)
    • `== != > <` für Vergleiche
    • `and` / `or` / `not` für Wahrheitswerte

  4. 04

    Kontrollstrukturen

    if / elif / else steuern den Ablauf — Einrückung ist in Python Pflicht.

    Offen · 1 Themen
    Öffnen
    • Verzweigungen mit if/elif/else schreiben
    • Einrückung (4 Leerzeichen) als Syntaxregel verstehen
    ifelifelseEinrückung

    if / elif / else

    Lesson · Anleitung · 5 min

    Beispiel Alter: Volljährig, Teenager oder Kind — abhängig von Bedingungen.

    • `if` / `elif` / `else` für Verzweigungen
    • Python nutzt Einrückung (4 Leerzeichen) statt `{ }` — Pflicht, kein Stilmittel

  5. 05

    Schleifen

    for über range/Listen, while mit Bedingung, plus break und continue.

    Offen · 1 Themen
    Öffnen
    • `for` und `while` gezielt einsetzen
    • `break` und `continue` zur Steuerung kennen
    forwhilerangebreakcontinue

    for und while

    Lesson · Anleitung · 7 min

    `for` bei bekannter Menge, `while` solange die Bedingung wahr ist.

    • `for i in range(5):` → 0…4
    • `for element in […]:` über Listen
    • `while zaehler < 5:` mit Zählererhöhung
    • `break` beendet, `continue` überspringt den Durchlauf

  6. 06

    Funktionen

    Mit def eigene Bausteine schreiben — return und Standardparameter.

    Offen · 1 Themen
    Öffnen
    • Funktionen mit `def` und `return` definieren
    • Parameter mit Standardwert nutzen
    defreturnParameterNone

    def und return

    Lesson · Anleitung · 6 min

    Begrüßungsfunktion mit Parameter; ohne return kommt `None` zurück.

    • `def` definiert eine Funktion
    • `return` gibt einen Wert zurück (sonst `None`)
    • Standardwert: `def addiere(a, b=5):`

  7. 07

    Eingebaute Funktionen

    print, len, input, type, range, sorted, sum, min/max, enumerate, zip.

    Offen · 1 Themen
    Öffnen
    • Die wichtigsten Built-ins im Alltag wiedererkennen
    • `enumerate` für Index + Wert nutzen
    leninputenumeratezipsorted

    Werkzeugkasten Built-ins

    Lesson · Anleitung · 8 min

    Von Ausgabe und Länge über Sortieren bis zu parallelen Listen mit zip.

    • `print`, `len`, `input`, `type`, `range`
    • `sorted`, `sum`, `min` / `max`
    • `enumerate` = Index + Wert gleichzeitig
    • `zip` kombiniert zwei Listen parallel

  8. 08

    Listen, Dictionaries & Methoden

    list- und dict-Methoden plus gängige String-Methoden für den Alltag.

    Offen · 2 Themen
    Öffnen
    • Listen verändern (append, remove, sort, …)
    • Dicts lesen/schreiben und Strings transformieren
    appenddictgetsplitreplace

    Listen-Methoden

    Lesson · Anleitung · 5 min

    append, remove, pop, sort, reverse und len für geordnete Sammlungen.

    • `append` / `remove` / `pop`
    • `sort` und `reverse`
    • `len(zahlen)` für die Anzahl

    Dictionaries und Strings

    Lesson · Anleitung · 6 min

    Schlüssel-Wert-Zugriff, `.get`, keys/values/items — plus lower/upper/split/replace.

    • `person["name"]` und `person.get("stadt", "unbekannt")`
    • `.keys()`, `.values()`, `.items()`
    • Strings: `lower`, `upper`, `strip`, `split`, `replace`

  9. 09

    Klassen

    class als Bauplan: __init__, Attribute, Methoden und self.

    Offen · 1 Themen
    Öffnen
    • Eine Klasse mit Konstruktor und Methoden schreiben
    • `self` als Verweis auf das aktuelle Objekt verstehen
    class__init__selfAttributMethode

    Klasse Person

    Lesson · Anleitung · 10 min

    Person mit name/alter, begruessen() und geburtstag() — Objekt erzeugen und nutzen.

    • `class Person:` definiert einen neuen Objekttyp
    • `__init__` = Konstruktor, läuft beim Erstellen
    • `self` = aktuelles Objekt, erstes Argument jeder Methode
    • Attribut = Eigenschaft (`self.name`), Methode = Funktion der Klasse

  10. 10

    Vererbung

    Eine Klasse baut auf einer anderen auf — super() und eigene Methoden.

    Offen · 1 Themen
    Öffnen
    • Eine Kindklasse von Person ableiten
    • `super().__init__` und geerbte Methoden nutzen
    Vererbungsuper()Mitarbeiter

    Mitarbeiter erbt von Person

    Lesson · Anleitung · 7 min

    `class Mitarbeiter(Person)` mit Position, `super().__init__` und eigener `info()`.

    • `class Mitarbeiter(Person):` erbt von Person
    • `super().__init__(name, alter)` ruft den Eltern-Konstruktor
    • Geerbte Methoden wie `begruessen()` bleiben nutzbar

  11. 11

    Fehlerbehandlung

    try / except / else / finally für robuste Eingaben und Divisionen.

    Offen · 1 Themen
    Öffnen
    • Typische Exceptions abfangen
    • else- und finally-Blöcke einordnen
    tryexceptValueErrorZeroDivisionError

    try / except

    Lesson · Anleitung · 6 min

    Zahl einlesen, Division absichern — ValueError und ZeroDivisionError getrennt behandeln.

    • `try` enthält riskanten Code
    • `except ValueError` / `except ZeroDivisionError`
    • `else` bei Erfolg, `finally` immer am Ende

  12. 12

    List Comprehension

    Kompakte Schleifen-Schreibweise: [x**2 for x in range(5)].

    Offen · 1 Themen
    Öffnen
    • Eine List Comprehension lesen und schreiben
    • Den Äquivalenz-Bezug zur for-Schleife kennen
    List Comprehensionfor

    Kompakte Listen erzeugen

    Lesson · Anleitung · 4 min

    Eine Zeile statt append-Schleife — gleiche Quadrate, weniger Boilerplate.

    • `[x**2 for x in range(5)]`
    • Entspricht einer for-Schleife mit `append`

  13. 13

    Cheatsheet & Merksatz

    Kompakte Übersicht und die Lernreihenfolge bis zu Klassen — self merken.

    Offen · 2 Themen
    Öffnen
    • Den Cheatsheet-Ablauf einmal nachvollziehen
    • Den Merksatz Variable → … → Klasse verinnerlichen
    CheatsheetMerksatzself

    Kompaktes Cheatsheet

    Practice · Anleitung · 5 min

    Variable, if, for/while, def und class Auto — alles auf einen Blick.

    • Variable → if → for/while → def → class
    • Objekt erzeugen: `auto = Auto("BMW")` dann `auto.info()`

    Merksatz

    Bridge · Anleitung · 1 min

    Variable → Bedingung → Schleife → Funktion → Klasse — jede Stufe baut auf der vorherigen auf.

    • Das ist die typische Lernreihenfolge
    • `self` bedeutet immer: „dieses eine Objekt, mit dem ich gerade arbeite“
Zurück zum Backend-Hub