Python-Kurs

Die Grundlagen: Variablen deklarieren, Typen erkennen, Berechnungen anstellen, Entscheidungen treffen und in der Konsole ausgeben.

1. 1.1Variablen und TypenEinen Wert benennen, den Typ mit type() ermitteln, int / float / str / bool / None kennenlernen.~10 Min
2. 1.2OperatorenArithmétique (y compris // et **), comparaison, logique booléenne avec and / or / not, précédence.~10 Min
3. 1.3Bedingte Anweisungen: if, elif, elseAusführen unterschiedlicher Codeblöcke je nach Bedingung; die Rolle der Einrückung.~10 Min
4. 1.4Ausgabe und f-Stringsprint() zur Ausgabe von Werten, f-Strings zur String-Formatierung mit Interpolation `{var}`.~8 Min

Wiederholen, Überspringen, Fehler behandeln: Die Konstrukte, mit denen dein Programm auf Daten und Probleme reagiert.

1. 2.1for-Schleifen und rangeIterieren über Sequenzen mit for, Generieren von Zahlenbereichen mit range(start, stop, step).~10 Min
2. 2.2while-SchleifenWiederholen, solange eine Bedingung wahr bleibt; wann while anstelle von for verwendet werden sollte.~8 Min
3. 2.3break, continue und else in SchleifenVorzeitiges Verlassen einer Schleife, Überspringen einer Iteration, Verwendung des speziellen for…else-Konstrukts.~10 Min
4. 2.4Fehlerbehandlung: try/exceptAbfangen spezifischer Exceptions, Unterscheidung von try/except/else/finally, Fehler auslösen mit raise.~12 Min

Die vier integrierten Datensammlungen: list (veränderliche Sequenz), tuple (unveränderliche Sequenz), dict (Schlüssel-Wert-Zuordnung) und set (Sammlung einzigartiger Elemente).

1. 3.1ListenErstellen, Zugriff über Index und Slice, Hinzufügen und Entfernen, Sortieren. Die am häufigsten genutzte Sequenz.~12 Min
2. 3.2Tuples und UnpackingUnveränderliche Sequenzen, Packing und Unpacking, Zuweisung (Tausch) ohne temporäre Variable, * für den Rest.~10 Min
3. 3.3DictionariesSchlüssel-Wert-Zuordnungen, Zugriff mit [] und .get, Iterieren über keys/values/items, dict.setdefault.~12 Min
4. 3.4SetsSammlungen einzigartiger Elemente, Mengenoperationen (& | - ^), Zugehörigkeitsprüfung in O(1)-Zeit.~10 Min

Idiomatisches Arbeiten mit Text (Methoden, Slicing) und Zahlen (math, Typkonvertierungen).

1. 4.1String-MethodenDie am häufigsten verwendeten Methoden: upper/lower, strip, split/join, replace, startswith/endswith, find/in.~12 Min
2. 4.2Slicing und IndizierungPositive und negative Indizes, Slice [start:stop:step], Umkehren von Strings, Substrings.~10 Min
3. 4.3Zahlen und math-Modulint, float, echte vs. Ganzzahldivision, Modulo %, abs/round/min/max, math.sqrt, math.pi.~10 Min
4. 4.4Typkonvertierungenint(), float(), str(), bool(): explizites Casting, Parsen von Eingaben, Truthiness von Werten.~10 Min

Definieren von Funktionen mit def, Rückgabe von Werten, Handhabung von Standardparametern, *args/**kwargs und Lambda.

1. 5.1def und returnSintaxis def, return (explizit und implizit None), Positions-Parameter, Docstrings.~12 Min
2. 5.2Standardparameter und Keyword-ArgumenteStandardwerte, Aufrufe mit Keyword-Argumenten, Reihenfolge (Positions- vor Keyword-Argumenten), die Falle veränderlicher Standardwerte.~12 Min
3. 5.3*args und **kwargsFunktionen mit einer variablen Anzahl von Argumenten: *args sammelt Positions-Argumente, **kwargs sammelt Keyword-Argumente. Unpacking beim Aufruf.~12 Min
4. 5.4Lambda-Funktionen und Funktionen höherer OrdnungAnonyme Funktionen mit lambda, Verwendung mit sorted/max/min, wann man def bevorzugt, sorted(..., key=...).~10 Min

List/Dict/Set Comprehensions, Generator-Ausdrücke und die wichtigen Werkzeuge des Moduls itertools.

1. 6.1List ComprehensionSyntax [Ausdruck for x in iter if cond], Transformation, Filtern, Verschachtelung.~12 Min
2. 6.2Dict und Set ComprehensionSyntax {k: v for ...} und {x for ...} zum dekorativen Erstellen von Dictionaries und Sets.~10 Min
3. 6.3Generator-AusdrückeSyntax (... for ... in ...), Lazy Evaluation, konstanter Speicherbedarf, sum/any/all mit Generatoren.~10 Min
4. 6.4Wichtige itertoolsDie am häufigsten verwendeten Funktionen: enumerate, zip, chain, count, repeat, combinations.~12 Min

Objektorientierte Programmierung in Python: Klassen, Vererbung, dunder-Methoden, import-Anweisungen und Modulorganisation.

1. 7.1Klassen und Instanzenclass, __init__, Instanzattribute und -methoden, self, Klassen- vs. Instanzattribute.~14 Min
2. 7.2VererbungUnterklassen, super(), Überschreiben von Methoden, isinstance, grundlegendes MRO.~12 Min
3. 7.3Spezielle Methoden (Dunder)__str__, __repr__, __eq__, __len__: Integration eigener Objekte in die Sprache.~12 Min
4. 7.4import und Moduleimport, from ... import, Aliasing mit as, Organisation in Modulen, if __name__ == "__main__".~10 Min

Module der Standardbibliothek, die man täglich braucht: json, datetime, collections, re.

1. 8.1JSON: Serialisierung und Parsenjson.dumps / json.loads, Typzuordnung Python ↔ JSON, indent, sort_keys, default.~10 Min
2. 8.2datetime: Datum und Uhrzeitdatetime.now(), date/time/datetime/timedelta, Formatierung mit strftime, Parsen mit strptime, Arithmetik.~12 Min
3. 8.3collections: Counter und defaultdictCounter zum Zählen, defaultdict für automatisch initialisierte Dictionaries, namedtuple als leichtgewichtiger Datensatz.~12 Min
4. 8.4re-Modul: Regex in Pythonre.search / re.match / re.findall / re.sub, Flags, Raw Strings r"...", benannte Gruppen.~12 Min

Moderne Best Practices in Python: Type Hints, Dataclasses, Context Manager und Deokaratoren. Der Code, den man heute schreibt.

1. 9.1Type Hints: TypanmerkungenAnmerkungen für Parameter und Rückgabewerte, list[int] / dict[str, int], Optional, Union, kurze Einführung in mypy.~12 Min
2. 9.2dataclasses: Datenklassen ohne Boilerplate@dataclass, field(default_factory=...), frozen=True, Äquivalent zu __init__/__repr__/__eq__.~12 Min
3. 9.3Context Manager: with und __enter__/__exit__with open(...), eigene Context Manager schreiben mit __enter__/__exit__, contextlib.contextmanager.~12 Min
4. 9.4Dekoratoren: Funktionen, die Funktionen modifizierenFunktionen höherer Ordnung, @decorator-Syntax, functools.wraps, Beispiel @timeit.~14 Min