From 294285b063f3e3c229877b75bf693725729588d8 Mon Sep 17 00:00:00 2001 From: KatCat2 <166694207+KatCat2@users.noreply.github.com> Date: Sat, 28 Mar 2026 10:53:23 +0100 Subject: [PATCH 1/3] Create test.md --- German/test.md | 1 + 1 file changed, 1 insertion(+) create mode 100644 German/test.md diff --git a/German/test.md b/German/test.md new file mode 100644 index 000000000..8b1378917 --- /dev/null +++ b/German/test.md @@ -0,0 +1 @@ + From 82121d606086cf004f9c6c740c7f6cb8c05267ea Mon Sep 17 00:00:00 2001 From: KatCat2 <166694207+KatCat2@users.noreply.github.com> Date: Sat, 28 Mar 2026 10:54:09 +0100 Subject: [PATCH 2/3] Add files via upload --- German/02_variables_builtin_functions_de.md | 195 ++++++++++++ German/03_operators_de.md | 144 +++++++++ German/04_strings_de.md | 184 +++++++++++ German/05_lists_de.md | 174 +++++++++++ German/06_tuples_de.md | 146 +++++++++ German/07_sets_de.md | 179 +++++++++++ German/08_dictionaries_de.md | 155 ++++++++++ German/09_conditionals_de.md | 145 +++++++++ German/10_loops_de.md | 145 +++++++++ German/11_functions_de.md | 155 ++++++++++ German/12_modules_de.md | 137 +++++++++ German/13_list_comprehension_de.md | 116 +++++++ German/14_higher_order_functions_de.md | 157 ++++++++++ German/15_python_type_errors_de.md | 121 ++++++++ German/16_python_datetime_de.md | 126 ++++++++ German/17_exception_handling_de.md | 118 +++++++ German/18_regular_expressions_de.md | 118 +++++++ German/19_file_handling_de.md | 119 +++++++ German/20_python_package_manager_de.md | 110 +++++++ German/21_classes_and_objects_de.md | 119 +++++++ German/22_web_scraping_de.md | 79 +++++ German/23_virtual_environment_de.md | 76 +++++ German/24_statistics_de.md | 118 +++++++ German/25_pandas_de.md | 118 +++++++ German/26_python_web_de.md | 124 ++++++++ German/27_python_with_mongodb_de.md | 123 ++++++++ German/28_API_de.md | 81 +++++ German/29_building_API_de.md | 101 ++++++ German/30_conclusions_de.md | 42 +++ German/README.md | 324 ++++++++++++++++++++ 30 files changed, 4049 insertions(+) create mode 100644 German/02_variables_builtin_functions_de.md create mode 100644 German/03_operators_de.md create mode 100644 German/04_strings_de.md create mode 100644 German/05_lists_de.md create mode 100644 German/06_tuples_de.md create mode 100644 German/07_sets_de.md create mode 100644 German/08_dictionaries_de.md create mode 100644 German/09_conditionals_de.md create mode 100644 German/10_loops_de.md create mode 100644 German/11_functions_de.md create mode 100644 German/12_modules_de.md create mode 100644 German/13_list_comprehension_de.md create mode 100644 German/14_higher_order_functions_de.md create mode 100644 German/15_python_type_errors_de.md create mode 100644 German/16_python_datetime_de.md create mode 100644 German/17_exception_handling_de.md create mode 100644 German/18_regular_expressions_de.md create mode 100644 German/19_file_handling_de.md create mode 100644 German/20_python_package_manager_de.md create mode 100644 German/21_classes_and_objects_de.md create mode 100644 German/22_web_scraping_de.md create mode 100644 German/23_virtual_environment_de.md create mode 100644 German/24_statistics_de.md create mode 100644 German/25_pandas_de.md create mode 100644 German/26_python_web_de.md create mode 100644 German/27_python_with_mongodb_de.md create mode 100644 German/28_API_de.md create mode 100644 German/29_building_API_de.md create mode 100644 German/30_conclusions_de.md create mode 100644 German/README.md diff --git a/German/02_variables_builtin_functions_de.md b/German/02_variables_builtin_functions_de.md new file mode 100644 index 000000000..7bebbb9ec --- /dev/null +++ b/German/02_variables_builtin_functions_de.md @@ -0,0 +1,195 @@ +
+

30 Tage Python: Tag 2 - Variablen, Eingebaute Funktionen

+ + + + + Twitter Follow + + +Autor: +Asabeneh Yetayeh
+ Zweite Edition: Juli 2021 + + +
+ +[<< Tag 1](./README.md) | [Tag 3 >>](./03_operators_de.md) + +![30DaysOfPython](../images/30DaysOfPython_banner3@2x.png) + +- [📘 Tag 2](#-tag-2) + - [Eingebaute Funktionen (Built-in functions)](#eingebaute-funktionen-built-in-functions) + - [Variablen](#variablen) + - [Mehrere Variablen in einer Zeile deklarieren](#mehrere-variablen-in-einer-zeile-deklarieren) + - [Datentypen](#datentypen) + - [Datentypen prüfen und Umwandlung (Casting)](#datentypen-prüfen-und-umwandlung-casting) + - [Zahlen](#zahlen) + - [💻 Übungen - Tag 2](#-übungen---tag-2) + - [Übungen: Level 1](#übungen-level-1) + - [Übungen: Level 2](#übungen-level-2) + +# 📘 Tag 2 + +## Eingebaute Funktionen (Built-in functions) + +In Python gibt es viele eingebaute Funktionen. Diese sind global verfügbar, was bedeutet, dass du sie nutzen kannst, ohne etwas zu importieren oder zu konfigurieren. Einige der am häufigsten verwendeten Funktionen sind: _print()_, _len()_, _type()_, _int()_, _float()_, _str()_, _input()_, _list()_, _dict()_, _min()_, _max()_, _sum()_, _sorted()_, _open()_, _help()_ und _dir()_. Eine vollständige Liste findest du in der [Python-Dokumentation](https://docs.python.org/3/library/functions.html). + +![Built-in Functions](../images/builtin-functions.png) + +Lass uns die Python-Shell öffnen und einige dieser Funktionen ausprobieren. + +![Eingebaute Funktionen Übung](../images/builtin-functions_practice.png) + +Probieren wir weitere Funktionen aus: + +![Help und Dir Funktionen](../images/help_and_dir_builtin.png) + +Wie du im Terminal sehen kannst, hat Python reservierte Wörter (Keywords). Wir verwenden diese nicht als Namen für Variablen oder Funktionen. + +![Min Max Sum](../images/builtin-functional-final.png) + +## Variablen + +Variablen speichern Daten im Computerspeicher. Es wird empfohlen, aussagekräftige Namen (mnemonische Variablen) zu verwenden, die leicht zu merken sind. Eine Variable verweist auf eine Speicheradresse, an der die Daten abgelegt sind. + +Regeln für Variablennamen in Python: +- Ein Variablenname muss mit einem Buchstaben oder einem Unterstrich (_) beginnen. +- Er darf nicht mit einer Zahl beginnen. +- Er darf nur alphanumerische Zeichen und Unterstriche enthalten (A-z, 0-9 und _). +- Variablennamen sind fallsensitiv (`firstname`, `Firstname`, `FirstName` und `FIRSTNAME` sind unterschiedliche Variablen). + +Gültige Variablennamen: +```shell +firstname +lastname +age +country +first_name +last_name +_if # Wenn wir ein reserviertes Wort verwenden müssen +year_2021 +num1 +``` + +Ungültige Variablennamen: +```shell +first-name # Bindestrich nicht erlaubt +first@name # Sonderzeichen nicht erlaubt +1num # Beginnt mit einer Zahl +``` + +In Python verwenden wir den **snake_case**. Das bedeutet, wir nutzen Unterstriche, um Wörter zu trennen (z.B. `first_name`, `last_name`). + +Das Zuweisen eines Wertes zu einer Variable nennt man Deklaration. Das Gleichheitszeichen (=) ist der Zuweisungsoperator. + +**Beispiel:** +```python +# Variablen in Python +first_name = 'Asabeneh' +last_name = 'Yetayeh' +country = 'Finnland' +city = 'Helsinki' +age = 250 +is_married = True +skills = ['HTML', 'CSS', 'JS', 'React', 'Python'] +person_info = { + 'firstname':'Asabeneh', + 'lastname':'Yetayeh', + 'country':'Finnland', + 'city':'Helsinki' + } +``` + +Die Funktion `print()` kann eine unbegrenzte Anzahl von Argumenten entgegennehmen. Ein Argument ist ein Wert, den wir der Funktion übergeben. + +**Beispiel:** +```python +print('Hallo, Welt!') # 'Hallo, Welt!' ist ein Argument +print('Hallo', ',', 'Welt', '!') # Vier Argumente übergeben +print(len('Hallo, Welt!')) # len() nimmt nur ein Argument +``` + +### Mehrere Variablen in einer Zeile deklarieren + +Du kannst mehrere Variablen gleichzeitig deklarieren: + +**Beispiel:** +```python +first_name, last_name, country, age, is_married = 'Asabeneh', 'Yetayeh', 'Finnland', 250, True + +print(first_name, last_name, country, age, is_married) +``` + +Benutzereingaben mit `input()` abfragen: +```python +name = input('Wie heißt du? ') +alter = input('Wie alt bist du? ') + +print(name) +print(alter) +``` + +## Datentypen prüfen und Umwandlung (Casting) + +- **Datentypen prüfen:** Nutze `type()`. +```python +print(type('Asabeneh')) # +print(type(10)) # +print(type(3.14)) # +``` + +- **Casting:** Umwandlung eines Typs in einen anderen mit `int()`, `float()`, `str()`, `list()`, `set()`. + Bei Berechnungen müssen Zahlen in Strings erst konvertiert werden. + +**Beispiele:** +```python +# int zu float +num_int = 10 +num_float = float(num_int) # 10.0 + +# float zu int +gravity = 9.81 +print(int(gravity)) # 9 + +# int zu str +num_str = str(10) # '10' + +# str zu list +name = 'Python' +print(list(name)) # ['P', 'y', 't', 'h', 'o', 'n'] +``` + +## Zahlen + +In Python gibt es drei Haupttypen von Zahlen: +1. **Integers:** Ganze Zahlen (positiv, negativ, Null). +2. **Floating Point (Float):** Dezimalzahlen (z.B. 9.81, -2.5). +3. **Complex:** Komplexe Zahlen (z.B. 1 + j). + +--- + +## 💻 Übungen - Tag 2 + +### Übungen: Level 1 +1. Erstelle im Ordner `30DaysOfPython` einen Unterordner `day_2` und darin eine Datei `variables.py`. +2. Füge einen Kommentar hinzu: 'Tag 2: 30 Tage Python Programmierung'. +3. Deklariere Variablen für Vorname, Nachname, vollständiger Name, Land, Stadt, Alter, Jahr, `is_married`, `is_true`, `is_light_on`. +4. Deklariere mehrere Variablen in einer Zeile. + +### Übungen: Level 2 +1. Überprüfe den Datentyp all deiner Variablen mit `type()`. +2. Ermittle die Länge deines Vornamens mit `len()`. +3. Vergleiche die Länge deines Vornamens mit der deines Nachnamens. +4. Deklariere 5 als `num_one` und 4 als `num_two`. + - Berechne Summe, Differenz, Produkt, Division, Rest (Modulo), Potenz und Ganzzahl-Division. +5. Ein Kreis hat einen Radius von 30 Metern. + - Berechne die Fläche (`area_of_circle`). + - Berechne den Umfang (`circum_of_circle`). + - Nimm den Radius als Benutzereingabe (`input`) und berechne die Fläche. +6. Nutze `input()`, um Vorname, Nachname, Land und Alter abzufragen. +7. Führe `help('keywords')` aus, um die reservierten Wörter in Python zu sehen. + +🎉 HERZLICHEN GLÜCKWUNSCH! 🎉 + +[<< Tag 1](./README.md) | [Tag 3 >>](./03_operators_de.md) diff --git a/German/03_operators_de.md b/German/03_operators_de.md new file mode 100644 index 000000000..8c4724947 --- /dev/null +++ b/German/03_operators_de.md @@ -0,0 +1,144 @@ +
+

30 Tage Python: Tag 3 - Operatoren

+ + + + + Twitter Follow + + +Autor: +Asabeneh Yetayeh
+ Zweite Edition: Juli 2021 + +
+ +[<< Tag 2](./02_variables_builtin_functions_de.md) | [Tag 4 >>](./04_strings_de.md) + +![30DaysOfPython](../images/30DaysOfPython_banner3@2x.png) + +- [📘 Tag 3](#-tag-3) + - [Boolean (Wahrheitswerte)](#boolean-wahrheitswerte) + - [Operatoren](#operatoren) + - [Zuweisungsoperatoren](#zuweisungsoperatoren) + - [Arithmetische Operatoren](#arithmetische-operatoren) + - [Vergleichsoperatoren](#vergleichsoperatoren) + - [Logische Operatoren](#logische-operatoren) + - [💻 Übungen - Tag 3](#-übungen---tag-3) + +# 📘 Tag 3 + +## Boolean (Wahrheitswerte) + +Ein Boolean-Datentyp repräsentiert einen von zwei Werten: _True_ (Wahr) oder _False_ (Falsch). Diese Datentypen werden besonders wichtig, wenn wir Vergleichsoperatoren nutzen. Beachte, dass in Python der erste Buchstabe immer großgeschrieben werden muss (**T**rue, **F**alse), anders als zum Beispiel in JavaScript. + +**Beispiel: Boolean-Werte** +```python +print(True) +print(False) +``` + +## Operatoren + +Python unterstützt verschiedene Arten von Operatoren. In diesem Abschnitt konzentrieren wir uns auf die wichtigsten. + +### Zuweisungsoperatoren + +Zuweisungsoperatoren werden verwendet, um Variablen Werte zuzuweisen. Das bekannteste Beispiel ist das Gleichheitszeichen (=). Während es in der Mathematik zeigt, dass zwei Werte gleich sind, bedeutet es in Python, dass wir einen Wert in einer Variablen speichern. + +![Zuweisungsoperatoren](../images/assignment_operators.png) + +### Arithmetische Operatoren: + +- **Addition (+):** `a + b` +- **Subtraktion (-):** `a - b` +- **Multiplikation (*):** `a * b` +- **Division (/):** `a / b` (Ergibt immer eine Fließkommazahl) +- **Modulo (%):** `a % b` (Ergibt den Rest der Division) +- **Ganzzahl-Division (//):** `a // b` (Entfernt den Rest nach dem Komma) +- **Potenzierung (**):** `a ** b` (a hoch b) + +![Arithmetische Operatoren](../images/arithmetic_operators.png) + +**Beispiel: Ganze Zahlen (Integers)** +```python +# Arithmetische Operationen in Python +print('Addition: ', 1 + 2) # 3 +print('Subtraktion: ', 2 - 1) # 1 +print('Multiplikation: ', 2 * 3) # 6 +print('Division: ', 4 / 2) # 2.0 (Division ergibt immer einen Float) +print('Ganzzahl-Division: ', 7 // 2) # 3 (Gibt das Ergebnis ohne Rest zurück) +print('Modulo: ', 3 % 2) # 1 (Gibt den Rest zurück) +print('Potenzierung: ', 2 ** 3) # 8 (2 * 2 * 2) +``` + +### Vergleichsoperatoren + +In der Programmierung vergleichen wir ständig Werte. Wir prüfen, ob ein Wert größer, kleiner oder gleich einem anderen Wert ist. + +![Vergleichsoperatoren](../images/comparison_operators.png) + +**Beispiel: Vergleichsoperatoren** +```python +print(3 > 2) # True, da 3 größer als 2 ist +print(3 == 2) # False, da 3 nicht gleich 2 ist +print(len('mango') == len('avocado')) # False +print('python' > 'dragon') # False +``` + +Zusätzlich zu den Standards nutzt Python: +- _is_: Gibt True zurück, wenn beide Variablen dasselbe Objekt sind. +- _is not_: Gibt True zurück, wenn sie nicht dasselbe Objekt sind. +- _in_: Gibt True zurück, wenn ein Element in einer Liste/String enthalten ist. +- _not in_: Gibt True zurück, wenn ein Element nicht enthalten ist. + +### Logische Operatoren + +Anders als viele andere Sprachen nutzt Python die Wörter _and_, _or_ und _not_ als logische Operatoren. + +![Logische Operatoren](../images/logical_operators.png) + +```python +print(3 > 2 and 4 > 3) # True - beide Aussagen sind wahr +print(3 > 2 or 4 < 3) # True - eine der Aussagen ist wahr +print(not 3 > 2) # False - Verneinung von True ergibt False +``` + +--- + +## 💻 Übungen - Tag 3 + +1. Deklariere dein Alter als Integer-Variable. +2. Deklariere deine Größe als Float-Variable. +3. Deklariere eine Variable für eine komplexe Zahl. +4. Berechne die Fläche eines Dreiecks (Fläche = 0.5 * Basis * Höhe). Frage den Benutzer nach Basis und Höhe. +5. Berechne den Umfang eines Dreiecks (Umfang = a + b + c). +6. Berechne Fläche und Umfang eines Rechtecks (Länge und Breite per `input`). +7. Berechne Fläche und Umfang eines Kreises (Radius per `input`, pi = 3.14). +8. Berechne Steigung, x-Schnittpunkt und y-Schnittpunkt von `y = 2x - 2`. +9. Berechne die Steigung und den [Euklidischen Abstand](https://de.wikipedia.org/wiki/Euklidischer_Abstand) zwischen Punkt (2, 2) und Punkt (6, 10). +10. Vergleiche die Steigungen aus Aufgabe 8 und 9. +11. Berechne den Wert von y (`y = x^2 + 6x + 9`). Probiere verschiedene x-Werte aus, um zu sehen, wann y Null wird. +12. Finde die Länge von 'python' und 'dragon' und erstelle eine falsche Vergleichsaussage. +13. Prüfe mit `and`, ob 'on' sowohl in 'python' als auch in 'dragon' vorkommt. +14. Prüfe mit `in`, ob das Wort 'jargon' im Satz "I hope this course is not full of jargon" vorkommt. +15. Prüfe, ob 'on' nicht in 'dragon' und 'python' vorkommt. +16. Ermittle die Länge von 'python', wandle den Wert in einen Float und dann in einen String um. +17. Wie prüft man mit Python, ob eine Zahl gerade ist (durch 2 teilbar)? +18. Prüfe, ob die Ganzzahl-Division von 7 durch 3 gleich dem Integer-Wert von 2.7 ist. +19. Prüfe, ob der Typ von '10' gleich dem Typ von 10 ist. +20. Prüfe, ob `int('9.8')` gleich 10 ist (Hinweis: Du musst eventuell erst in Float umwandeln). +21. Berechne den Wochenlohn (Stunden * Stundensatz per `input`). +22. Berechne die gelebten Sekunden eines Menschen basierend auf seinen Lebensjahren (per `input`). +23. Schreibe ein Skript, das folgende Tabelle ausgibt: +``` +1 1 1 1 1 +2 1 2 4 8 +3 1 3 9 27 +4 1 4 16 64 +5 1 5 25 125 +``` + +🎉 HERZLICHEN GLÜCKWUNSCH! 🎉 + +[<< Tag 2](./02_variables_builtin_functions_de.md) | [Tag 4 >>](./04_strings_de.md) diff --git a/German/04_strings_de.md b/German/04_strings_de.md new file mode 100644 index 000000000..f86e462de --- /dev/null +++ b/German/04_strings_de.md @@ -0,0 +1,184 @@ +
+

30 Tage Python: Tag 4 - Zeichenketten (Strings)

+ + + + + Twitter Follow + + +Autor: +Asabeneh Yetayeh
+ Zweite Edition: Juli 2021 + + +
+ +[<< Tag 3](./03_operators_de.md) | [Tag 5 >>](./05_lists_de.md) + +![30DaysOfPython](../images/30DaysOfPython_banner3@2x.png) + +- [Tag 4](#tag-4) + - [Zeichenketten (Strings)](#zeichenketten-strings) + - [Einen String erstellen](#einen-string-erstellen) + - [String-Konkatenation (Verknüpfung)](#string-konkatenation-verknüpfung) + - [Escape-Sequenzen in Strings](#escape-sequenzen-in-strings) + - [String-Formatierung](#string-formatierung) + - [Alter Stil (% Operator)](#alter-stil--operator) + - [Neuer Stil (str.format)](#neuer-stil-strformat) + - [String Interpolation / f-Strings (Python 3.6+)](#string-interpolation--f-strings-python-36) + - [Python Strings als Sequenzen von Zeichen](#python-strings-als-sequenzen-von-zeichen) + - [Zeichen entpacken (Unpacking)](#zeichen-entpacken-unpacking) + - [Zugriff auf Zeichen per Index](#zugriff-auf-zeichen-per-index) + - [Slicing (Teilstücke extrahieren)](#slicing-teilstücke-extrahieren) + - [Einen String umkehren](#einen-string-umkehren) + - [Zeichen beim Slicing überspringen](#zeichen-beim-slicing-überspringen) + - [String-Methoden](#string-methoden) + - [💻 Übungen - Tag 4](#-übungen---tag-4) + +# Tag 4 + +## Zeichenketten (Strings) + +Text wird in Python als Datentyp "String" bezeichnet. Jede Information, die als Text geschrieben wird, ist ein String. Alles, was in einfachen ('), doppelten (") oder dreifachen (""") Anführungszeichen steht, wird als String behandelt. Es gibt viele Methoden und Funktionen, um mit Strings zu arbeiten. Mit `len()` kannst du die Länge eines Strings ermitteln. + +### Einen String erstellen + +```python +letter = 'P' # Ein String kann ein einzelnes Zeichen sein... +greeting = 'Hallo, Welt!' # ...oder ein ganzer Satz. +sentence = "Ich hoffe, dir macht die 30 Tage Python Herausforderung Spaß" +``` + +Mehrzeilige Strings werden mit dreifachen Anführungszeichen erstellt: +```python +multiline_string = '''Ich bin Lehrer und liebe das Unterrichten. +Es gibt nichts Schöneres, als Menschen zu helfen, ihr Potenzial zu entfalten. +Deshalb habe ich 30 Tage Python erstellt.''' +``` + +### String-Konkatenation (Verknüpfung) + +Du kannst Strings miteinander verbinden. Das nennt man Konkatenation. +```python +first_name = 'Asabeneh' +last_name = 'Yetayeh' +full_name = first_name + ' ' + last_name +print(full_name) # Asabeneh Yetayeh +``` + +### Escape-Sequenzen in Strings + +Ein Backslash (`\`) gefolgt von einem Zeichen ist eine Escape-Sequenz: +- `\n`: Neue Zeile +- `\t`: Tabulator (8 Leerzeichen) +- `\\`: Backslash selbst +- `\'`: Einfaches Anführungszeichen +- `\"`: Doppeltes Anführungszeichen + +### String-Formatierung + +#### Alter Stil (% Operator) +Hierbei werden Platzhalter wie `%s` (String), `%d` (Integer) oder `%f` (Float) genutzt. +```python +first_name = 'Asabeneh' +last_name = 'Yetayeh' +language = 'Python' +formatted_string = 'Ich bin %s %s. Ich unterrichte %s' %(first_name, last_name, language) +``` + +#### Neuer Stil (str.format) +Eingeführt mit Python 3. Nutzt geschweifte Klammern `{}`. +```python +formatted_string = 'Ich bin {} {}. Ich unterrichte {}'.format(first_name, last_name, language) +``` + +#### String Interpolation / f-Strings (Python 3.6+) +Der modernste und am einfachsten zu lesende Weg. Strings beginnen mit einem `f`. +```python +a, b = 4, 3 +print(f'{a} + {b} = {a + b}') # 4 + 3 = 7 +``` + +### Python Strings als Sequenzen von Zeichen + +Strings sind geordnete Sequenzen. Du kannst auf einzelne Zeichen zugreifen. + +#### Zugriff per Index +In der Programmierung beginnt das Zählen bei **Null**. +```python +language = 'Python' +first_letter = language[0] # P +last_letter = language[-1] # n (negativer Index zählt von hinten) +``` + +#### Slicing (Teilstücke) +Du kannst Bereiche eines Strings extrahieren: `string[start:stop:step]`. +```python +language = 'Python' +first_three = language[0:3] # Pyt (bis Index 3, aber ohne 3) +reverse_string = language[::-1] # nohtyP (String umdrehen) +``` + +### String-Methoden + +Es gibt unzählige Methoden. Hier die wichtigsten: +- `capitalize()`: Erster Buchstabe groß. +- `upper()`: Alles groß. +- `lower()`: Alles klein. +- `count(substring)`: Zählt Vorkommen eines Teilstrings. +- `endswith(substring)`: Prüft, ob der String so endet. +- `find(substring)`: Findet den ersten Index des Teilstrings (sonst -1). +- `replace(old, new)`: Ersetzt Textteile. +- `split(separator)`: Teilt den String in eine Liste auf. +- `strip()`: Entfernt Leerzeichen am Anfang und Ende. +- `join(list)`: Verbindet Listenelemente zu einem String. + +--- + +## 💻 Übungen - Tag 4 + +1. Verbinde 'Thirty', 'Days', 'Of', 'Python' zu einem einzigen String 'Thirty Days Of Python'. +2. Verbinde 'Coding', 'For', 'All' zu 'Coding For All'. +3. Deklariere eine Variable `company` mit dem Wert "Coding For All". +4. Gib die Variable `company` aus. +5. Gib die Länge des Strings `company` aus. +6. Wandle alle Zeichen in Großbuchstaben um (`upper()`). +7. Wandle alle Zeichen in Kleinbuchstaben um (`lower()`). +8. Nutze `capitalize()`, `title()`, `swapcase()`, um "Coding For All" zu formatieren. +9. Schneide das erste Wort von "Coding For All" ab. +10. Prüfe, ob "Coding For All" das Wort "Coding" enthält (nutze `index` oder `find`). +11. Ersetze 'Coding' in 'Coding For All' durch 'Python'. +12. Ändere "Python for Everyone" zu "Python for All" mit `replace`. +13. Teile 'Coding For All' an den Leerzeichen auf (`split`). +14. Teile "Facebook, Google, Microsoft, Apple, IBM, Oracle, Amazon" an den Kommas auf. +15. Welches Zeichen ist bei Index 0 in "Coding For All"? +16. Was ist der letzte Index in "Coding For All"? +17. Welches Zeichen ist bei Index 10? +18. Erstelle ein Akronym für 'Python For Everyone' (PFE). +19. Erstelle ein Akronym für 'Coding For All' (CFA). +20. Nutze `index`, um das erste Vorkommen von 'C' in 'Coding For All' zu finden. +21. Nutze `index`, um das erste Vorkommen von 'F' zu finden. +22. Nutze `rfind`, um das letzte Vorkommen von 'l' in 'Coding For All People' zu finden. +23. Finde das erste Vorkommen von 'because' in: 'You cannot end a sentence with because because because is a conjunction'. +24. Finde das letzte Vorkommen von 'because'. +25. Schneide den Teil 'because because because' aus dem Satz heraus. +26. Prüfe, ob 'Coding For All' mit 'Coding' beginnt. +27. Prüfe, ob es mit 'coding' endet. +28. Entferne führende und abschließende Leerzeichen von '   Coding For All      '. +29. Welche Variable gibt bei `isidentifier()` True zurück: `30DaysOfPython` oder `thirty_days_of_python`? +30. Verbinde die Liste `['Django', 'Flask', 'Bottle', 'Pyramid', 'Falcon']` mit einem `# ` zu einem String. +31. Nutze `\n`, um zwei Sätze in verschiedenen Zeilen auszugeben. +32. Nutze `\t`, um eine Tabelle mit Name, Alter, Land und Stadt zu erstellen. +33. Nutze String-Formatierung, um die Fläche eines Kreises mit Radius 10 anzuzeigen. +34. Erstelle die folgende Ausgabe mit f-strings: +``` +8 + 6 = 14 +8 - 6 = 2 +... +8 ** 6 = 262144 +``` + +🎉 HERZLICHEN GLÜCKWUNSCH! 🎉 + +[<< Tag 3](./03_operators_de.md) | [Tag 5 >>](./05_lists_de.md) diff --git a/German/05_lists_de.md b/German/05_lists_de.md new file mode 100644 index 000000000..39313ad6a --- /dev/null +++ b/German/05_lists_de.md @@ -0,0 +1,174 @@ +
+

30 Tage Python: Tag 5 - Listen (Lists)

+ + + + + Twitter Follow + + +Autor: +Asabeneh Yetayeh
+ Zweite Edition: Juli 2021 + + +
+ +[<< Tag 4](./04_strings_de.md) | [Tag 6 >>](./06_tuples_de.md) + +![30DaysOfPython](../images/30DaysOfPython_banner3@2x.png) + +- [Tag 5](#tag-5) + - [Listen (Lists)](#listen-lists) + - [Wie man eine Liste erstellt](#wie-man-eine-liste-erstellt) + - [Zugriff auf Listenelemente per Index](#zugriff-auf-listenelemente-per-index) + - [Negativer Index](#negativer-index) + - [Entpacken von Listenelementen (Unpacking)](#entpacken-von-listenelementen-unpacking) + - [Slicing (Teilstücke extrahieren)](#slicing-teilstücke-extrahieren) + - [Listen modifizieren](#listen-modifizieren) + - [Elemente in einer Liste prüfen](#elemente-in-einer-liste-prüfen) + - [Elemente hinzufügen (Append & Insert)](#elemente-hinzufügen-append--insert) + - [Elemente entfernen (Remove, Pop, Del)](#elemente-entfernen-remove-pop-del) + - [Listen kopieren](#listen-kopieren) + - [Listen verbinden (Join)](#listen-verbinden-join) + - [Sortieren von Listen](#sortieren-von-listen) + - [💻 Übungen - Tag 5](#-übungen---tag-5) + +# Tag 5 + +## Listen (Lists) + +In Python gibt es vier primäre Datentypen für Sammlungen: +- **List (Liste):** Geordnet und veränderbar (mutable). Erlaubt doppelte Einträge. +- **Tuple (Tupel):** Geordnet und unveränderbar (immutable). Erlaubt doppelte Einträge. +- **Set (Menge):** Ungeordnet, nicht indiziert und unveränderbar (man kann jedoch neue Elemente hinzufügen). Keine doppelten Einträge erlaubt. +- **Dictionary (Wörterbuch):** Ungeordnet, veränderbar und indiziert (per Schlüssel). Keine doppelten Einträge. + +Eine Liste ist eine geordnete Sammlung verschiedener Datentypen. Sie ist "mutable", was bedeutet, dass wir ihren Inhalt nach der Erstellung verändern können. + +### Wie man eine Liste erstellt + +In Python gibt es zwei Wege: +1. Mit der Funktion `list()`: +```python +lst = list() +``` +2. Mit eckigen Klammern `[]`: +```python +lst = [] +``` + +Beispiel für eine Liste mit Werten: +```python +fruits = ['Banane', 'Orange', 'Mango', 'Zitrone'] +print('Früchte:', fruits) +print('Anzahl der Früchte:', len(fruits)) +``` + +### Zugriff auf Listenelemente per Index + +Der Index beginnt bei **0**. +```python +fruits = ['Banane', 'Orange', 'Mango', 'Zitrone'] +first_fruit = fruits[0] # Banane +last_fruit = fruits[3] # Zitrone +``` + +**Negativer Index:** Zählt von hinten rückwärts. `-1` ist das letzte Element. +```python +last_fruit = fruits[-1] # Zitrone +``` + +### Entpacken von Listenelementen (Unpacking) + +```python +lst = ['Element1','Element2','Element3', 'Element4', 'Element5'] +item1, item2, item3, *rest = lst +print(item1) # Element1 +print(rest) # ['Element4', 'Element5'] +``` + +### Slicing (Teilstücke extrahieren) + +Format: `liste[start:stop:step]` +```python +fruits = ['Banane', 'Orange', 'Mango', 'Zitrone'] +all_fruits = fruits[0:4] # Alle Früchte +some_fruits = fruits[1:3] # ['Orange', 'Mango'] - Index 3 ist nicht dabei +``` + +### Listen modifizieren + +Da Listen veränderbar sind, können wir Werte einfach überschreiben: +```python +fruits = ['Banane', 'Orange', 'Mango'] +fruits[0] = 'Avocado' +print(fruits) # ['Avocado', 'Orange', 'Mango'] +``` + +### Elemente hinzufügen + +- `append(item)`: Fügt ein Element am **Ende** hinzu. +- `insert(index, item)`: Fügt ein Element an einer **bestimmten Stelle** ein. Alle nachfolgenden Elemente verschieben sich nach rechts. + +```python +fruits.append('Apfel') +fruits.insert(1, 'Limette') +``` + +### Elemente entfernen + +- `remove(item)`: Entfernt das **erste Vorkommen** eines bestimmten Wertes. +- `pop(index)`: Entfernt das Element am angegebenen Index (Standard: das letzte). +- `del liste[index]`: Löscht das Element am Index oder die ganze Liste. +- `clear()`: Leert die Liste komplett. + +### Listen verbinden (Join) + +- Mit dem `+` Operator: `list3 = list1 + list2` +- Mit der `extend()` Methode: `list1.extend(list2)` + +### Sortieren von Listen + +- `sort()`: Sortiert die **Original-Liste** (aufsteigend oder absteigend mit `reverse=True`). +- `sorted()`: Gibt eine **neue sortierte Liste** zurück, ohne das Original zu ändern. + +--- + +## 💻 Übungen - Tag 5 + +### Level 1 +1. Deklariere eine leere Liste. +2. Deklariere eine Liste mit mehr als 5 Elementen. +3. Ermittle die Länge der Liste. +4. Gib das erste, das mittlere und das letzte Element aus. +5. Erstelle eine Liste `it_companies` mit: Facebook, Google, Microsoft, Apple, IBM, Oracle, Amazon. +6. Gib die Liste und die Anzahl der Unternehmen aus. +7. Gib das erste, mittlere und letzte Unternehmen aus. +8. Ändere eines der Unternehmen in der Liste. +9. Füge ein neues IT-Unternehmen hinzu (`append`). +10. Füge ein IT-Unternehmen in der Mitte der Liste ein (`insert`). +11. Wandle eines der Unternehmen (außer IBM) in Großbuchstaben um. +12. Verbinde die Liste mit einem String '#;  '. +13. Prüfe, ob ein bestimmtes Unternehmen in der Liste existiert (`in`). +14. Sortiere die Liste mit `sort()`. +15. Kehre die Liste um (`reverse()`). +16. Schneide die ersten 3 Unternehmen ab. +17. Schneide die letzten 3 Unternehmen ab. +18. Entferne das erste Unternehmen. +19. Entferne alle Unternehmen aus der Liste. + +### Level 2 +1. Gegeben ist eine Liste mit Alterswerten: `ages = [19, 22, 19, 24, 20, 25, 26, 24, 25, 24]` + - Sortiere die Liste und finde das Minimum und Maximum. + - Füge das Minimum und Maximum erneut zur Liste hinzu. + - Finde den Median (den mittleren Wert). + - Finde den Durchschnittswert. + - Finde die Spannweite (Maximum minus Minimum). +2. Finde das mittlere Land/die mittleren Länder in der [Länderliste](https://github.com/Asabeneh/30-Days-Of-Python/tree/master/data/countries.py). +3. Teile die Länderliste in zwei hälften auf. +4. Entpacke die ersten drei Länder und den Rest als "skandinavische Länder". + +🎉 HERZLICHEN GLÜCKWUNSCH! 🎉 + +[<< Tag 4](./04_strings_de.md) | [Tag 6 >>](./06_tuples_de.md) diff --git a/German/06_tuples_de.md b/German/06_tuples_de.md new file mode 100644 index 000000000..a6ae97e68 --- /dev/null +++ b/German/06_tuples_de.md @@ -0,0 +1,146 @@ +
+

30 Tage Python: Tag 6 - Tupel (Tuples)

+ + + + + Twitter Follow + + +Autor: +Asabeneh Yetayeh
+ Zweite Edition: Juli 2021 + + +
+ +[<< Tag 5](./05_lists_de.md) | [Tag 7 >>](./07_sets_de.md) + +![30DaysOfPython](../images/30DaysOfPython_banner3@2x.png) + +- [Tag 6:](#tag-6) + - [Tupel (Tuples)](#tupel-tuples) + - [Ein Tupel erstellen](#ein-tupel-erstellen) + - [Länge eines Tupels](#länge-eines-tupels) + - [Zugriff auf Tupel-Elemente](#zugriff-auf-tupel-elemente) + - [Slicing (Teilstücke extrahieren)](#slicing-teilstücke-extrahieren) + - [Tupel in Listen umwandeln](#tupel-in-listen-umwandeln) + - [Prüfen auf Elemente](#prüfen-auf-elemente) + - [Tupel verbinden](#tupel-verbinden) + - [Tupel löschen](#tupel-löschen) + - [💻 Übungen - Tag 6](#-übungen---tag-6) + +# Tag 6: + +## Tupel (Tuples) + +Ein Tupel ist eine geordnete Sammlung verschiedener Datentypen, die **unveränderbar** (immutable) ist. Tupel werden mit runden Klammern `()` geschrieben. Sobald ein Tupel erstellt wurde, können wir seinen Inhalt nicht mehr ändern. Methoden wie `add`, `insert` oder `remove` funktionieren hier nicht. Im Gegensatz zu Listen haben Tupel nur sehr wenige Methoden: + +- `tuple()`: Erstellt ein leeres Tupel. +- `count()`: Zählt das Vorkommen eines bestimmten Elements. +- `index()`: Findet den Index eines Elements. +- `+` Operator: Verbindet zwei oder mehr Tupel zu einem neuen Tupel. + +### Ein Tupel erstellen + +- Leeres Tupel: + ```python + empty_tpl = () + # oder mit dem Konstruktor + empty_tpl = tuple() + ``` + +- Tupel mit Werten: + ```python + fruits = ('Banane', 'Orange', 'Mango', 'Zitrone') + ``` + +### Länge eines Tupels + +Wie bei anderen Sequenzen nutzen wir `len()`: +```python +tpl = ('Element1', 'Element2', 'Element3') +print(len(tpl)) # 3 +``` + +### Zugriff auf Tupel-Elemente + +- **Positiver Index:** Beginnt bei 0. +- **Negativer Index:** Beginnt am Ende bei -1. + +```python +fruits = ('Banane', 'Orange', 'Mango', 'Zitrone') +first_fruit = fruits[0] # Banane +last_fruit = fruits[-1] # Zitrone +``` + +### Slicing (Teilstücke extrahieren) + +Wir können Teilstücke extrahieren, was ein **neues Tupel** zurückgibt: +```python +fruits = ('Banane', 'Orange', 'Mango', 'Zitrone') +orange_mango = fruits[1:3] # Index 1 bis 3 (ohne 3) +``` + +### Tupel in Listen umwandeln + +Da Tupel unveränderbar sind, müssen wir sie in eine Liste umwandeln, wenn wir sie modifizieren wollen: +```python +fruits = ('Banane', 'Orange', 'Mango') +fruits_list = list(fruits) +fruits_list[0] = 'Apfel' +fruits = tuple(fruits_list) +print(fruits) # ('Apfel', 'Orange', 'Mango') +``` + +### Prüfen auf Elemente + +Mit dem `in` Operator prüfen wir, ob ein Wert im Tupel existiert: +```python +fruits = ('Banane', 'Orange', 'Mango') +print('Orange' in fruits) # True +``` + +### Tupel verbinden + +Wir können Tupel mit dem `+` Operator verknüpfen: +```python +fruits = ('Banane', 'Orange') +vegetables = ('Tomate', 'Kartoffel') +food = fruits + vegetables +``` + +### Tupel löschen + +Es ist nicht möglich, einzelne Elemente zu entfernen, aber man kann das gesamte Tupel mit `del` löschen: +```python +fruits = ('Banane', 'Orange') +del fruits +``` + +--- + +## 💻 Übungen - Tag 6 + +### Level 1 +1. Erstelle ein leeres Tupel. +2. Erstelle ein Tupel mit den Namen deiner Geschwister. +3. Verbinde die Tupel deiner Brüder und Schwestern zu einem `siblings` Tupel. +4. Wie viele Geschwister hast du? (Länge von `siblings`). +5. Füge die Namen deiner Eltern hinzu und erstelle ein neues Tupel `family_members`. + +### Level 2 +1. Entpacke (`Unpacking`) Geschwister und Eltern aus `family_members`. +2. Erstelle Tupel für Früchte, Gemüse und Tierprodukte. Verbinde sie zu `food_stuff_tp`. +3. Wandle `food_stuff_tp` in eine Liste `food_stuff_lt` um. +4. Schneide das mittlere Element (oder die mittleren zwei) aus. +5. Schneide die ersten drei und die letzten drei Elemente aus `food_stuff_lt` heraus. +6. Lösche das Tupel `food_stuff_tp` vollständig. +7. Prüfe, ob 'Island' ein nordisches Land ist: + ```python + nordic_countries = ('Dänemark', 'Finnland', 'Island', 'Norwegen', 'Schweden') + ``` + +🎉 HERZLICEN GLÜCKWUNSCH! 🎉 + +[<< Tag 5](./05_lists_de.md) | [Tag 7 >>](./07_sets_de.md) diff --git a/German/07_sets_de.md b/German/07_sets_de.md new file mode 100644 index 000000000..d6a9471e0 --- /dev/null +++ b/German/07_sets_de.md @@ -0,0 +1,179 @@ +
+

30 Tage Python: Tag 7 - Mengen (Sets)

+ + + + + Twitter Follow + + +Autor: +Asabeneh Yetayeh
+ Zweite Edition: Juli 2021 + + +
+ +[<< Tag 6](./06_tuples_de.md) | [Tag 8 >>](./08_dictionaries_de.md) + +![30DaysOfPython](../images/30DaysOfPython_banner3@2x.png) + +- [📘 Tag 7](#-tag-7) + - [Mengen (Sets)](#mengen-sets) + - [Eine Menge erstellen](#eine-menge-erstellen) + - [Länge einer Menge](#länge-einer-menge) + - [Zugriff auf Elemente](#zugriff-auf-elemente) + - [Prüfen auf Elemente](#prüfen-auf-elemente) + - [Elemente hinzufügen](#elemente-hinzufügen) + - [Elemente entfernen](#elemente-entfernen) + - [Mengen leeren und löschen](#mengen-leeren-und-löschen) + - [Liste in Menge umwandeln](#liste-in-menge-umwandeln) + - [Mengen verbinden (Union & Update)](#mengen-verbinden-union--update) + - [Schnittmenge finden (Intersection)](#schnittmenge-finden-intersection) + - [Teilmengen und Obermengen prüfen](#teilmengen-und-obermengen-prüfen) + - [Differenz zwischen Mengen finden](#differenz-zwischen-mengen-finden) + - [Symmetrische Differenz](#symmetrische-differenz) + - [Disjunkte Mengen](#disjunkte-mengen) + - [💻 Übungen - Tag 7](#-übungen---tag-7) + +# 📘 Tag 7 + +## Mengen (Sets) + +Eine Menge (Set) ist eine Sammlung von Elementen. Erinnere dich an deinen Mathematikunterricht in der Schule – die Definition einer Menge lässt sich direkt auf Python übertragen. Ein Set ist eine ungeordnete und nicht indizierte Sammlung von **eindeutigen** Elementen. In Python werden Sets verwendet, um Duplikate zu vermeiden und mathematische Operationen wie *Vereinigung*, *Schnittmenge*, *Differenz* und *Teilmengen* durchzuführen. + +### Eine Menge erstellen + +Um eine leere Menge zu erstellen, nutzen wir die Funktion `set()`. Achtung: Leere geschweifte Klammern `{}` erstellen ein Dictionary, kein Set! + +- Leere Menge erstellen: +```python +st = set() +``` + +- Menge mit Werten erstellen: +```python +fruits = {'Banane', 'Orange', 'Mango', 'Zitrone'} +``` + +### Länge einer Menge + +Wie gewohnt mit `len()`: +```python +print(len(fruits)) # 4 +``` + +### Zugriff auf Elemente + +Da Sets ungeordnet sind, gibt es keinen Index-Zugriff (`st[0]` funktioniert nicht). Wir greifen auf Elemente meist über Schleifen zu (siehe Kapitel Schleifen). + +### Prüfen auf Elemente + +Mit dem `in` Operator: +```python +fruits = {'Banane', 'Orange', 'Mango'} +print('Mango' in fruits) # True +``` + +### Elemente hinzufügen + +- `add(item)`: Fügt **ein** Element hinzu. +- `update(list)`: Fügt **mehrere** Elemente (z. B. aus einer Liste) hinzu. + +```python +fruits.add('Limette') +fruits.update(['Apfel', 'Pfirsich']) +``` + +### Elemente entfernen + +- `remove(item)`: Entfernt ein Element. Wirft einen Fehler, wenn das Element nicht existiert. +- `discard(item)`: Entfernt ein Element, wirft aber **keinen Fehler**, falls es fehlt. +- `pop()`: Entfernt ein **zufälliges** Element und gibt es zurück. + +### Mengen leeren und löschen + +- `clear()`: Macht die Menge leer (`set()`). +- `del st`: Löscht die Variable komplett. + +### Liste in Menge umwandeln + +Dies ist der schnellste Weg, um Duplikate aus einer Liste zu entfernen: +```python +lst = ['Apfel', 'Banane', 'Apfel'] +st = set(lst) # {'Apfel', 'Banane'} +``` + +### Mengen verbinden (Union & Update) + +- `union()`: Gibt eine **neue Menge** zurück, die alle Elemente beider Mengen enthält. (Symbol: `|`) +- `update()`: Fügt die Elemente einer anderen Menge zur **aktuellen Menge** hinzu. + +### Schnittmenge finden (Intersection) + +Gibt die Elemente zurück, die in **beiden** Mengen vorhanden sind. (Symbol: `&`) +```python +A = {1, 2, 3} +B = {2, 3, 4} +C = A.intersection(B) # {2, 3} +``` + +### Teilmengen und Obermengen prüfen + +- `issubset()`: Ist A eine Teilmenge von B? +- `issuperset()`: Ist A eine Obermenge von B? + +### Differenz zwischen Mengen finden + +Gibt die Elemente zurück, die in A, aber **nicht** in B sind. (Symbol: `-`) +```python +A = {1, 2, 3} +B = {2, 3, 4} +diff = A.difference(B) # {1} +``` + +### Symmetrische Differenz + +Gibt alle Elemente zurück, die in A oder B sind, aber **nicht in beiden**. (Symbol: `^`) +Mathematisch: (A \ B) ∪ (B \ A). + +### Disjunkte Mengen + +Zwei Mengen sind disjunkt, wenn sie **keine gemeinsamen Elemente** haben. Prüfung mit `isdisjoint()`. + +--- + +## 💻 Übungen - Tag 7 + +```python +# Daten für die Übungen +it_companies = {'Facebook', 'Google', 'Microsoft', 'Apple', 'IBM', 'Oracle', 'Amazon'} +A = {19, 22, 24, 20, 25, 26} +B = {19, 22, 20, 25, 26, 24, 28, 27} +age = [22, 19, 24, 25, 26, 24, 25, 24] +``` + +### Level 1 +1. Ermittle die Länge des Sets `it_companies`. +2. Füge 'Twitter' zu `it_companies` hinzu. +3. Füge mehrere IT-Unternehmen gleichzeitig hinzu. +4. Entferne eines der Unternehmen aus dem Set. +5. Was ist der Unterschied zwischen `remove` und `discard`? + +### Level 2 +1. Verbinde A und B (`union`). +2. Finde die Schnittmenge von A und B (`intersection`). +3. Ist A eine Teilmenge von B? +4. Sind A und B disjunkte Mengen? +5. Verbinde A mit B und B mit A. +6. Was ist die symmetrische Differenz zwischen A und B? +7. Lösche die Mengen A und B vollständig. + +### Level 3 +1. Wandle die Liste `age` in ein Set um und vergleiche die Länge der Liste mit der des Sets. Welche ist größer? +2. Erkläre den Unterschied zwischen: String, List, Tuple und Set. +3. "I am a teacher and I love to inspire and teach people." -> Wie viele einzigartige Wörter wurden in diesem Satz verwendet? Nutze `split` und `set`. + +🎉 HERZLICHEN GLÜCKWUNSCH! 🎉 + +[<< Tag 6](./06_tuples_de.md) | [Tag 8 >>](./08_dictionaries_de.md) diff --git a/German/08_dictionaries_de.md b/German/08_dictionaries_de.md new file mode 100644 index 000000000..07c0ecdc5 --- /dev/null +++ b/German/08_dictionaries_de.md @@ -0,0 +1,155 @@ +
+

30 Tage Python: Tag 8 - Wörterbücher (Dictionaries)

+ + + + + Twitter Follow + + +Autor: +Asabeneh Yetayeh
+ Zweite Edition: Juli 2021 + + +
+ +[<< Tag 7](./07_sets_de.md) | [Tag 9 >>](./09_conditionals_de.md) + +![30DaysOfPython](../images/30DaysOfPython_banner3@2x.png) + +- [📘 Tag 8](#-tag-8) + - [Wörterbücher (Dictionaries)](#wörterbücher-dictionaries) + - [Ein Dictionary erstellen](#ein-dictionary-erstellen) + - [Länge eines Dictionaries](#länge-eines-dictionaries) + - [Zugriff auf Elemente](#zugriff-auf-elemente) + - [Elemente hinzufügen](#elemente-hinzufügen) + - [Elemente modifizieren](#elemente-modifizieren) + - [Schlüssel prüfen](#schlüssel-prüfen) + - [Elemente entfernen](#elemente-entfernen) + - [Dictionary in eine Liste umwandeln](#dictionary-in-eine-liste-umwandeln) + - [Dictionary leeren und löschen](#dictionary-leeren-und-löschen) + - [Dictionary kopieren](#dictionary-kopieren) + - [Schlüssel und Werte als Listen abrufen](#schlüssel-und-werte-als-listen-abrufen) + - [💻 Übungen - Tag 8](#-übungen---tag-8) + +# 📘 Tag 8 + +## Wörterbücher (Dictionaries) + +Ein Dictionary ist eine ungeordnete, veränderbare (mutable) Sammlung von Daten, die in **Schlüssel-Wert-Paaren** (key: value) organisiert sind. + +### Ein Dictionary erstellen + +Wir nutzen geschweifte Klammern `{}` oder die Funktion `dict()`. + +- Leeres Dictionary: +```python +empty_dict = {} +# Dictionary mit Daten +dct = {'key1':'value1', 'key2':'value2', 'key3':'value3'} +``` + +**Beispiel:** +```python +person = { + 'first_name':'Asabeneh', + 'last_name':'Yetayeh', + 'age':250, + 'country':'Finnland', + 'is_married':True, + 'skills':['JavaScript', 'React', 'Node', 'MongoDB', 'Python'], + 'address':{ + 'street':'Weltraumstraße', + 'zipcode':'02210' + } +} +``` +Ein Wert kann jeder Datentyp sein: String, Zahl, Liste, Tupel oder sogar ein weiteres Dictionary. + +### Länge eines Dictionaries + +Gibt die Anzahl der Schlüssel-Wert-Paare zurück: +```python +print(len(person)) # 7 +``` + +### Zugriff auf Elemente + +Wir greifen über den **Schlüsselnamen** auf die Werte zu. +```python +print(person['first_name']) # Asabeneh +print(person['skills'][0]) # JavaScript +``` +Achtung: Wenn ein Schlüssel nicht existiert, stürzt das Programm ab. Sicherer ist die Methode `get()`: +```python +print(person.get('city')) # Gibt None zurück, statt abzustürzen +``` + +### Elemente hinzufügen + +```python +person['job_title'] = 'Dozent' +person['skills'].append('HTML') +``` + +### Elemente modifizieren + +```python +person['first_name'] = 'Eyob' +person['age'] = 252 +``` + +### Schlüssel prüfen + +Mit dem `in` Operator prüfen wir, ob ein Schlüssel existiert: +```python +print('country' in person) # True +``` + +### Elemente entfernen + +- `pop(key)`: Entfernt das Element mit dem angegebenen Schlüssel. +- `popitem()`: Entfernt das letzte Element. +- `del dct[key]`: Löscht das Element mit dem Schlüssel. + +### Dictionary in eine Liste umwandeln + +Die Methode `items()` wandelt das Dictionary in eine Liste von Tupeln um: +```python +print(person.items()) # [('first_name', 'Eyob'), ...] +``` + +### Dictionary leeren und löschen + +- `clear()`: Entfernt alle Elemente. +- `del dct`: Löscht das gesamte Dictionary-Objekt. + +### Dictionary kopieren + +Nutze `copy()`, um eine unabhängige Kopie zu erstellen und das Original nicht versehentlich zu verändern. + +### Schlüssel und Werte als Listen abrufen + +- `keys()`: Gibt alle Schlüssel zurück. +- `values()`: Gibt alle Werte zurück. + +--- + +## 💻 Übungen - Tag 8 + +1. Erstelle ein leeres Dictionary namens `dog`. +2. Füge Name, Farbe, Rasse, Beine und Alter zum `dog` Dictionary hinzu. +3. Erstelle ein `student` Dictionary mit: Vorname, Nachname, Geschlecht, Alter, Familienstand, Fähigkeiten (Skills), Land, Stadt und Adresse. +4. Ermittle die Länge des `student` Dictionaries. +5. Rufe den Wert von `skills` ab und prüfe den Datentyp (es sollte eine Liste sein). +6. Modifiziere die `skills`, indem du ein oder zwei neue Fähigkeiten hinzufügst. +7. Rufe alle Schlüssel des Dictionaries als Liste ab. +8. Rufe alle Werte des Dictionaries als Liste ab. +9. Wandle das Dictionary mit `items()` in eine Liste von Tupeln um. +10. Lösche eines der Elemente im Dictionary. +11. Lösche eines der Dictionaries komplett. + +🎉 HERZLICHEN GLÜCKWUNSCH! 🎉 + +[<< Tag 7](./07_sets_de.md) | [Tag 9 >>](./09_conditionals_de.md) diff --git a/German/09_conditionals_de.md b/German/09_conditionals_de.md new file mode 100644 index 000000000..2ad0ca043 --- /dev/null +++ b/German/09_conditionals_de.md @@ -0,0 +1,145 @@ +
+

30 Tage Python: Tag 9 - Bedingte Anweisungen (Conditionals)

+ + + + + Twitter Follow + + +Autor: +Asabeneh Yetayeh
+ Zweite Edition: Juli 2021 + + +
+ +[<< Tag 8](./08_dictionaries_de.md) | [Tag 10 >>](./10_loops_de.md) + +![30DaysOfPython](../images/30DaysOfPython_banner3@2x.png) + +- [📘 Tag 9](#-tag-9) + - [Bedingte Anweisungen](#bedingte-anweisungen) + - [If Bedingung](#if-bedingung) + - [If Else](#if-else) + - [If Elif Else](#if-elif-else) + - [Kurzschreibweise (Short Hand)](#kurzschreibweise-short-hand) + - [Verschachtelte Bedingungen](#verschachtelte-bedingungen) + - [Logische Operatoren in Bedingungen](#logische-operatoren-in-bedingungen) + - [💻 Übungen - Tag 9](#-übungen---tag-9) + +# 📘 Tag 9 + +## Bedingte Anweisungen + +Standardmäßig werden Anweisungen in einem Python-Skript nacheinander von oben nach unten ausgeführt. Wenn die Logik es erfordert, kann dieser sequentielle Fluss auf zwei Arten geändert werden: + +- **Bedingte Ausführung:** Ein Codeblock wird nur ausgeführt, wenn eine bestimmte Bedingung wahr (True) ist. +- **Wiederholte Ausführung:** Ein Codeblock wird wiederholt ausgeführt, solange eine Bedingung wahr ist (siehe Kapitel Schleifen). + +In diesem Abschnitt behandeln wir `if`, `else` und `elif`. Die Vergleichs- und Logikoperatoren aus den vorherigen Kapiteln sind hierbei sehr nützlich. + +### If Bedingung + +Das Schlüsselwort `if` wird verwendet, um eine Bedingung zu prüfen. Beachte unbedingt die **Einrückung** nach dem Doppelpunkt. + +```python +# Syntax +if bedingung: + dieser Teil läuft, wenn die Bedingung wahr ist +``` + +**Beispiel:** +```python +a = 3 +if a > 0: + print('A ist eine positive Zahl') +``` + +### If Else + +Wenn die Bedingung wahr ist, wird der erste Block ausgeführt, andernfalls der `else`-Block. + +```python +a = 3 +if a < 0: + print('A ist eine negative Zahl') +else: + print('A ist eine positive Zahl') +``` + +### If Elif Else + +Im Alltag treffen wir Entscheidungen oft basierend auf vielen verschiedenen Bedingungen. In Python nutzen wir dafür `elif` (short for "else if"). + +```python +a = 0 +if a > 0: + print('A ist positiv') +elif a < 0: + print('A ist negativ') +else: + print('A ist Null') +``` + +### Kurzschreibweise (Short Hand) + +Für sehr einfache Bedingungen gibt es den Ternary Operator: +```python +a = 3 +print('Positiv') if a > 0 else print('Negativ') +``` + +### Verschachtelte Bedingungen (Nested) + +Du kannst Bedingungen innerhalb anderer Bedingungen platzieren: +```python +a = 0 +if a > 0: + if a % 2 == 0: + print('A ist positiv und gerade') + else: + print('A ist positiv und ungerade') +elif a == 0: + print('A ist Null') +else: + print('A ist negativ') +``` + +### Logische Operatoren in Bedingungen + +Verschachtelte Bedingungen lassen sich oft durch `and` oder `or` vermeiden: +```python +if a > 0 and a % 2 == 0: + print('A ist eine positive gerade Zahl') +``` + +--- + +## 💻 Übungen - Tag 9 + +### Level 1 +1. Frage den Nutzer nach seinem Alter (`input`). Wenn er 18 oder älter ist: "Du bist alt genug zum Autofahren." Wenn jünger: "Du musst noch X Jahre warten." +2. Vergleiche dein Alter mit dem eines Nutzers. Wer ist älter? Berücksichtige auch den Fall, dass beide gleich alt sind. +3. Frage nach zwei Zahlen (a und b). Gib aus, ob a größer, kleiner oder gleich b ist. + +### Level 2 +1. Schreibe ein Programm, das Noten (Grades) basierend auf Punktzahlen vergibt: + - 90-100: A + - 80-89: B + - 70-79: C + - 60-69: D + - 0-59: F +2. Frage nach einem Monat und gib die Jahreszeit aus (Herbst, Winter, Frühling, Sommer). +3. Gegeben ist eine Liste: `fruits = ['banana', 'orange', 'mango', 'lemon']`. Frage den Nutzer nach einer Frucht. Wenn sie nicht in der Liste ist, füge sie hinzu. Wenn sie existiert, gib eine entsprechende Meldung aus. + +### Level 3 +1. Gegeben ist ein `person` Dictionary (siehe Original-Aufgabe). + - Prüfe, ob die Person Fähigkeiten (`skills`) hat und gib die mittlere Fähigkeit aus. + - Prüfe, ob die Person die Fähigkeit 'Python' besitzt. + - Erstelle eine Logik, die die Person als "Frontend-Entwickler", "Backend-Entwickler" oder "Fullstack-Entwickler" einstuft, basierend auf ihren Skills. + - Wenn die Person verheiratet ist und in Finnland lebt, gib die Infos in einem schönen Satz aus. + +🎉 HERZLICEN GLÜCKWUNSCH! 🎉 + +[<< Tag 8](./08_dictionaries_de.md) | [Tag 10 >>](./10_loops_de.md) diff --git a/German/10_loops_de.md b/German/10_loops_de.md new file mode 100644 index 000000000..f6657a9f5 --- /dev/null +++ b/German/10_loops_de.md @@ -0,0 +1,145 @@ +
+

30 Tage Python: Tag 10 - Schleifen (Loops)

+ + + + + Twitter Follow + + +Autor: +Asabeneh Yetayeh
+ Zweite Edition: Juli 2021 + + +
+ +[<< Tag 9](./09_conditionals_de.md) | [Tag 11 >>](./11_functions_de.md) + +![30DaysOfPython](../images/30DaysOfPython_banner3@2x.png) + +- [📘 Tag 10](#-tag-10) + - [Schleifen (Loops)](#schleifen-loops) + - [While-Schleife](#while-schleife) + - [Break und Continue](#break-und-continue) + - [For-Schleife](#for-schleife) + - [Die Range-Funktion](#die-range-funktion) + - [Verschachtelte Schleifen](#verschachtelte-schleifen) + - [For-Else und Pass](#for-else-und-pass) + - [💻 Übungen - Tag 10](#-übungen---tag-10) + +# 📘 Tag 10 + +## Schleifen (Loops) + +Das Leben ist voll von Routinen. Auch in der Programmierung müssen wir oft Aufgaben wiederholen. Um solche repetitiven Aufgaben effizient zu bewältigen, nutzen wir Schleifen. Python bietet zwei Hauptarten von Schleifen: + +1. **while** Schleife +2. **for** Schleife + +### While-Schleife + +Das Schlüsselwort `while` wird verwendet, um einen Codeblock so lange zu wiederholen, wie eine bestimmte Bedingung wahr (`True`) ist. + +```python +# Syntax +while bedingung: + code +``` + +**Beispiel:** +```python +count = 0 +while count < 5: + print(count) + count = count + 1 +# Gibt 0 bis 4 aus +``` + +### Break und Continue + +- **Break:** Bricht die Schleife sofort ab. +- **Continue:** Überspringt den aktuellen Durchlauf und macht mit dem nächsten weiter. + +```python +count = 0 +while count < 5: + if count == 3: + break # Stoppt bei 3 + print(count) + count += 1 +``` + +### For-Schleife + +Das Schlüsselwort `for` wird verwendet, um über eine Sequenz (Liste, Tupel, Dictionary, Set oder String) zu iterieren. + +- **Über eine Liste:** +```python +numbers = [0, 1, 2, 3, 4, 5] +for number in numbers: + print(number) +``` + +- **Über ein Dictionary:** +Iterieren über ein Dictionary gibt standardmäßig die **Schlüssel** zurück. Mit `.items()` erhält man Schlüssel und Werte. +```python +person = {'name': 'Asabeneh', 'country': 'Finnland'} +for key, value in person.items(): + print(key, value) +``` + +### Die Range-Funktion + +Die Funktion `range(start, stop, step)` erzeugt eine Sequenz von Zahlen. Standardmäßig startet sie bei 0. +```python +for i in range(11): + print(i) # 0 bis 10 +``` + +### Verschachtelte Schleifen (Nested Loops) + +Man kann Schleifen innerhalb anderer Schleifen verwenden. Dies ist nützlich für komplexe Datenstrukturen oder Muster. + +### For-Else und Pass + +- **For-Else:** Der `else`-Block wird ausgeführt, wenn die Schleife regulär beendet wurde (ohne `break`). +- **Pass:** Ein Platzhalter, wenn syntaktisch ein Codeblock erforderlich ist, man aber noch keinen Code schreiben möchte. + +--- + +## 💻 Übungen - Tag 10 + +### Level 1 +1. Iteriere von 0 bis 10 mit einer `for`-Schleife und dann mit einer `while`-Schleife. +2. Iteriere von 10 bis 0. +3. Schreibe eine Schleife, die folgendes Muster ausgibt: + ``` + # + ## + ### + #### + ##### + ###### + ####### + ``` +4. Nutze verschachtelte Schleifen, um ein 8x8 Gitter aus `#` zu erzeugen. +5. Gib das Einmaleins (0 bis 10) in folgendem Format aus: `0 x 0 = 0`, `1 x 1 = 1`, etc. +6. Iteriere durch die Liste `['Python', 'Numpy', 'Pandas', 'Django', 'Flask']` und gib die Elemente aus. +7. Gib alle geraden Zahlen von 0 bis 100 aus. + +### Level 2 +1. Berechne die Summe aller Zahlen von 0 bis 100. +2. Berechne separat die Summe aller geraden und aller ungeraden Zahlen von 0 bis 100. + +### Level 3 +1. Gehe zur `countries.py` Datei und gib alle Länder aus, die das Wort "land" enthalten. +2. Kehre die Liste `['banana', 'orange', 'mango', 'lemon']` mit einer Schleife um. +3. Nutze die `countries_data.py` Datei: + - Wie viele Sprachen gibt es insgesamt? + - Finde die 10 am häufigsten gesprochenen Sprachen. + - Finde die 10 bevölkerungsreichsten Länder. + +🎉 HERZLICEN GLÜCKWUNSCH! 🎉 + +[<< Tag 9](./09_conditionals_de.md) | [Tag 11 >>](./11_functions_de.md) diff --git a/German/11_functions_de.md b/German/11_functions_de.md new file mode 100644 index 000000000..f92522ed0 --- /dev/null +++ b/German/11_functions_de.md @@ -0,0 +1,155 @@ +
+

30 Tage Python: Tag 11 - Funktionen (Functions)

+ + + + + Twitter Follow + + +Autor: +Asabeneh Yetayeh
+ Zweite Edition: Juli 2021 + + +
+ +[<< Tag 10](./10_loops_de.md) | [Tag 12 >>](./12_modules_de.md) + +![30DaysOfPython](../images/30DaysOfPython_banner3@2x.png) + +- [📘 Tag 11](#-tag-11) + - [Funktionen](#funktionen) + - [Eine Funktion definieren](#eine-funktion-definieren) + - [Funktionen deklarieren und aufrufen](#funktionen-deklarieren-und-aufrufen) + - [Funktionen ohne Parameter](#funktionen-ohne-parameter) + - [Funktionen mit Rückgabewerten (Return)](#funktionen-mit-rückgabewerten-return) + - [Funktionen mit Parametern](#funktionen-mit-parametern) + - [Standardparameter](#standardparameter) + - [Variable Anzahl an Argumenten (*args & **kwargs)](#variable-anzahl-an-argumenten-args--kwargs) + - [Funktion als Parameter](#funktion-als-parameter) + - [💻 Übungen - Tag 11](#-übungen---tag-11) + +# 📘 Tag 11 + +## Funktionen + +Bisher haben wir viele eingebaute Funktionen genutzt. Jetzt lernen wir, wie wir unsere eigenen Funktionen erstellen. Eine Funktion ist ein wiederverwendbarer Codeblock, der eine bestimmte Aufgabe erfüllt. + +### Eine Funktion definieren + +Python nutzt das Schlüsselwort `def`, um eine Funktion zu deklarieren. Der Codeblock innerhalb der Funktion wird nur ausgeführt, wenn die Funktion **aufgerufen** (invoked) wird. + +```python +# Syntax +def funktions_name(): + code +``` + +### Funktionen deklarieren und aufrufen + +```python +def generate_full_name(): + first_name = 'Asabeneh' + last_name = 'Yetayeh' + print(first_name + ' ' + last_name) + +generate_full_name() # Aufruf der Funktion +``` + +### Funktionen mit Rückgabewerten (Return) + +Mit `return` gibt eine Funktion ein Ergebnis an den Aufrufer zurück. Ohne `return` gibt die Funktion standardmäßig `None` zurück. + +```python +def add_two_numbers(): + return 2 + 3 + +result = add_two_numbers() +print(result) # 5 +``` + +### Funktionen mit Parametern + +Parameter ermöglichen es uns, Daten in die Funktion einzuspeisen. + +- **Einzelner Parameter:** +```python +def greetings(name): + return f'{name}, willkommen zu Python!' + +print(greetings('Asabeneh')) +``` + +- **Mehrere Parameter:** +```python +def calculate_age(current_year, birth_year): + return current_year - birth_year + +print(calculate_age(2021, 1990)) +``` + +### Standardparameter + +Wir können Parametern Standardwerte zuweisen. Diese werden genutzt, wenn beim Aufruf kein Argument übergeben wird. +```python +def weight_of_object(mass, gravity = 9.81): + return mass * gravity + +print(weight_of_object(100)) # Nutzt 9.81 +print(weight_of_object(100, 1.62)) # Nutzt Mond-Gravitation +``` + +### Variable Anzahl an Argumenten (*args & **kwargs) + +- `*args`: Wenn du nicht weißt, wie viele Argumente übergeben werden, nutzt du `*args`. Sie werden als **Tupel** behandelt. +- `**kwargs`: Für eine variable Anzahl an **benannten Argumenten**. Sie werden als **Dictionary** behandelt. + +```python +def sum_all_nums(*nums): + total = 0 + for num in nums: + total += num + return total + +print(sum_all_nums(1, 2, 3, 4)) # 10 +``` + +### Funktion als Parameter + +In Python sind Funktionen "First-Class Citizens", was bedeutet, dass man sie wie Variablen behandeln und an andere Funktionen übergeben kann. + +--- + +## 💻 Übungen - Tag 11 + +### Level 1 +1. Deklariere eine Funktion `add_two_numbers`. +2. Berechne die Fläche eines Kreises (`area_of_circle`). +3. Schreibe `add_all_nums`, die eine beliebige Anzahl an Zahlen summiert. Prüfe, ob die Eingaben Zahlen sind. +4. Wandle Celsius in Fahrenheit um. +5. Schreibe `check_season`, die basierend auf einem Monat die Jahreszeit zurückgibt. +6. Berechne die Steigung einer linearen Gleichung. +7. Löse eine quadratische Gleichung (`solve_quadratic_eqn`). +8. `print_list`: Gibt jedes Element einer Liste aus. +9. `reverse_list`: Gibt eine Liste umgekehrt zurück (nutze Schleifen). +10. `capitalize_list_items`: Schreibt alle Elemente einer Liste groß. +11. `add_item` / `remove_item`: Fügt ein Element am Ende hinzu bzw. entfernt es. +12. Summiere alle Zahlen in einem Bereich (`sum_of_numbers`). + +### Level 2 +1. `evens_and_odds`: Zählt die Anzahl der geraden und ungeraden Zahlen in einem Bereich. +2. Berechne die Fakultät (`factorial`) einer Zahl. +3. `is_empty`: Prüft, ob ein Parameter leer ist. +4. Berechne statistische Werte für eine Liste: Durchschnitt (Mean), Median, Modus, Varianz, Standardabweichung. +5. `greet`: Begrüßt einen Nutzer oder einen "Gast" als Standard. + +### Level 3 +1. `is_prime`: Prüft, ob eine Zahl eine Primzahl ist. +2. Prüfe, ob alle Elemente einer Liste einzigartig sind. +3. Prüfe, ob alle Elemente einer Liste denselben Datentyp haben. +4. Finde die meistgesprochenen Sprachen und bevölkerungsreichsten Länder aus der `countries-data.py`. + +🎉 HERZLICEN GLÜCKWUNSCH! 🎉 + +[<< Tag 10](./10_loops_de.md) | [Tag 12 >>](./12_modules_de.md) diff --git a/German/12_modules_de.md b/German/12_modules_de.md new file mode 100644 index 000000000..2c34d78d8 --- /dev/null +++ b/German/12_modules_de.md @@ -0,0 +1,137 @@ +
+

30 Tage Python: Tag 12 - Module (Modules)

+ + + + + Twitter Follow + + +Autor: +Asabeneh Yetayeh
+ Zweite Edition: Juli 2021 + + +
+ +[<< Tag 11](./11_functions_de.md) | [Tag 13 >>](./13_list_comprehension_de.md) + +![30DaysOfPython](../images/30DaysOfPython_banner3@2x.png) + +- [📘 Tag 12](#-tag-12) + - [Module](#module) + - [Was ist ein Module](#was-ist-ein-module) + - [Ein Modul erstellen](#ein-modul-erstellen) + - [Ein Modul importieren](#ein-modul-importieren) + - [Funktionen gezielt importieren](#funktionen-gezielt-importieren) + - [Importieren und Umbenennen (As)](#importieren-und-umbenennen-as) + - [Eingebaute Module](#eingebaute-module) + - [OS Modul](#os-modul) + - [Sys Modul](#sys-modul) + - [Statistics Modul](#statistics-modul) + - [Math Modul](#math-modul) + - [String Modul](#string-modul) + - [Random Modul](#random-modul) + - [💻 Übungen - Tag 12](#-übungen---tag-12) + +# 📘 Tag 12 + +## Module + +### Was ist ein Modul + +Ein Modul ist eine Datei, die Code oder Funktionen enthält, die in eine Anwendung eingebunden werden können. Ein Modul kann eine einzelne Variable, eine Funktion oder eine große Codebasis sein. + +### Ein Modul erstellen + +Um ein Modul zu erstellen, schreiben wir unseren Code in ein Python-Skript und speichern es als `.py` Datei (z. B. `mymodule.py`). + +```python +# mymodule.py +def generate_full_name(firstname, lastname): + return firstname + ' ' + lastname +``` + +### Ein Modul importieren + +Wir nutzen das Schlüsselwort `import`, gefolgt vom Dateinamen (ohne .py). + +```python +# main.py +import mymodule +print(mymodule.generate_full_name('Asabeneh', 'Yetayeh')) +``` + +### Funktionen gezielt importieren + +Man kann auch nur bestimmte Teile eines Moduls importieren: +```python +from mymodule import generate_full_name, person +``` + +### Importieren und Umbenennen (As) + +Um Namenskollisionen zu vermeiden oder Schreibarbeit zu sparen: +```python +import mymodule as mm +from math import pi as PI +``` + +## Eingebaute Module + +Python wird mit einer "Batteries Included"-Philosophie ausgeliefert, was bedeutet, dass viele nützliche Module bereits eingebaut sind. + +### OS Modul +Ermöglicht Interaktionen mit dem Betriebssystem (Ordner erstellen, Verzeichnisse wechseln, etc.). +```python +import os +os.mkdir('neuer_ordner') +print(os.getcwd()) # Aktuelles Verzeichnis +``` + +### Sys Modul +Bietet Funktionen und Variablen, um das Python-Laufzeitsystem zu manipulieren (z. B. Kommandozeilenargumente abrufen). +```python +import sys +print(sys.argv) # Liste der Argumente +``` + +### Statistics Modul +Mathematische Statistik für numerische Daten (`mean`, `median`, `mode`, `stdev`). + +### Math Modul +Enthält mathematische Konstanten und Funktionen (`pi`, `sqrt`, `pow`, `floor`, `ceil`). +```python +import math +print(math.sqrt(16)) # 4.0 +``` + +### Random Modul +Erzeugt Zufallszahlen. +```python +from random import random, randint +print(random()) # Zufallszahl zwischen 0 und 1 +print(randint(5, 20)) # Zufällige Ganzzahl zwischen 5 und 20 +``` + +--- + +## 💻 Übungen - Tag 12 + +### Level 1 +1. Schreibe eine Funktion, die eine zufällige 6-stellige `user_id` generiert (z. B. '1ee33d'). +2. Erstelle eine Funktion `user_id_gen_by_user`, die via `input()` nach der Anzahl der Zeichen und der Anzahl der zu generierenden IDs fragt. +3. Schreibe `rgb_color_gen`, die eine zufällige RGB-Farbe im Format `rgb(125,244,255)` generiert. + +### Level 2 +1. Erstelle eine Funktion `list_of_hexa_colors`, die eine Liste von Hexadezimal-Farben zurückgibt (z. B. #a3e12f). +2. Erstelle `list_of_rgb_colors` für RGB-Listen. +3. Schreibe `generate_colors(type, n)`, die entweder Hex- oder RGB-Farben in der gewünschten Anzahl generiert. + +### Level 3 +1. Erstelle `shuffle_list`, die eine Liste zufällig durchmischt. +2. Schreibe eine Funktion, die 7 einzigartige Zufallszahlen im Bereich 0-9 zurückgibt. + +🎉 HERZLICEN GLÜCKWUNSCH! 🎉 + +[<< Tag 11](./11_functions_de.md) | [Tag 13 >>](./13_list_comprehension_de.md) diff --git a/German/13_list_comprehension_de.md b/German/13_list_comprehension_de.md new file mode 100644 index 000000000..570d42802 --- /dev/null +++ b/German/13_list_comprehension_de.md @@ -0,0 +1,116 @@ +
+

30 Tage Python: Tag 13 - List Comprehension & Lambda-Funktionen

+ + + + + Twitter Follow + + +Autor: +Asabeneh Yetayeh
+ Zweite Edition: Juli 2021 + + +
+ +[<< Tag 12](./12_modules_de.md) | [Tag 14 >>](./14_higher_order_functions_de.md) + +![30DaysOfPython](../images/30DaysOfPython_banner3@2x.png) + +- [📘 Tag 13](#-tag-13) + - [List Comprehension (Listen-Abstraktion)](#list-comprehension-listen-abstraktion) + - [Lambda-Funktionen (Anonyme Funktionen)](#lambda-funktionen-anonyme-funktionen) + - [Eine Lambda-Funktion erstellen](#eine-lambda-funktion-erstellen) + - [Lambda innerhalb anderer Funktionen](#lambda-innerhalb-anderer-funktionen) + - [💻 Übungen - Tag 13](#-übungen---tag-13) + +# 📘 Tag 13 + +## List Comprehension (Listen-Abstraktion) + +List Comprehension ist ein kompakter Weg, um in Python eine neue Liste aus einer bestehenden Sequenz zu erstellen. Es ist kürzer und oft deutlich schneller als eine herkömmliche `for`-Schleife. + +```python +# Syntax +[ausdruck for element in iterierbar if bedingung] +``` + +**Beispiel 1: String in eine Liste von Zeichen umwandeln** +```python +language = 'Python' +# Der klassische Weg: +lst = list(language) +# Mit List Comprehension: +lst = [i for i in language] +print(lst) # ['P', 'y', 't', 'h', 'o', 'n'] +``` + +**Beispiel 2: Zahlen und mathematische Operationen** +```python +# Zahlen von 0 bis 10 generieren +numbers = [i for i in range(11)] +# Quadrate berechnen +squares = [i * i for i in range(11)] # [0, 1, 4, 9, 16, ...] +# Liste von Tupeln erstellen (Zahl, Quadrat) +num_tuples = [(i, i * i) for i in range(11)] +``` + +**Beispiel 3: Mit Bedingungen (if)** +```python +# Nur gerade Zahlen filtern +evens = [i for i in range(21) if i % 2 == 0] +``` + +## Lambda-Funktionen (Anonyme Funktionen) + +Eine Lambda-Funktion ist eine kleine, anonyme Funktion ohne Namen. Sie kann beliebig viele Argumente haben, aber nur **einen Ausdruck**. Sie ähnelt den anonymen Funktionen (Arrow Functions) in JavaScript. + +### Eine Lambda-Funktion erstellen + +Wir nutzen das Schlüsselwort `lambda`, gefolgt von Parametern, einem Doppelpunkt und dem Ausdruck. + +```python +# Syntax +x = lambda param1, param2: param1 + param2 +print(x(5, 3)) # 8 +``` + +**Beispiel:** +```python +# Normale Funktion +def add(a, b): return a + b + +# Als Lambda +add_lambda = lambda a, b: a + b +print(add_lambda(2, 3)) # 5 +``` + +### Lambda innerhalb anderer Funktionen + +Lambdas sind besonders nützlich, wenn sie von einer anderen Funktion zurückgegeben werden. + +```python +def power(x): + return lambda n : x ** n + +cube = power(2)(3) # 2 hoch 3 = 8 +``` + +--- + +## 💻 Übungen - Tag 13 + +1. Filtere nur negative Zahlen und die Null aus einer Liste mit List Comprehension: + `numbers = [-4, -3, -2, -1, 0, 2, 4, 6]` +2. "Flache" eine verschachtelte Liste (`list of lists`) in eine eindimensionale Liste ab: + `list_of_lists = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]` -> `[1, 2, 3, 4, 5, 6, 7, 8, 9]` +3. Erstelle mit List Comprehension eine Liste von Tupeln (Zahl, 1, Zahl, Quadrat, Kubik, etc.) – siehe Original-Tabelle. +4. Wandle eine Liste von Ländern (mit Hauptstädten) in ein neues Format um (Land, Kürzel, Stadt in Großbuchstaben). +5. Wandle eine Liste von Ländern in eine Liste von Dictionaries um (Keys: 'country', 'city'). +6. Verbinde Vornamen und Nachnamen aus einer Liste von Listen zu einer Liste von kompletten Namen (Strings). +7. Schreibe eine Lambda-Funktion, die die Steigung oder den y-Achsenabschnitt einer linearen Funktion berechnet. + +🎉 HERZLICEN GLÜCKWUNSCH! 🎉 + +[<< Tag 12](./12_modules_de.md) | [Tag 14 >>](./14_higher_order_functions_de.md) diff --git a/German/14_higher_order_functions_de.md b/German/14_higher_order_functions_de.md new file mode 100644 index 000000000..fc60de82d --- /dev/null +++ b/German/14_higher_order_functions_de.md @@ -0,0 +1,157 @@ +
+

30 Tage Python: Tag 14 - Funktionen höherer Ordnung

+ + + + + Twitter Follow + + +Autor: +Asabeneh Yetayeh
+ Zweite Edition: Juli 2021 + + +
+ +[<< Tag 13](./13_list_comprehension_de.md) | [Tag 15 >>](./15_python_type_errors_de.md) + +![30DaysOfPython](../images/30DaysOfPython_banner3@2x.png) + +- [📘 Tag 14](#-tag-14) + - [Funktionen höherer Ordnung](#funktionen-höherer-ordnung) + - [Funktion als Parameter](#funktion-als-parameter) + - [Funktion als Rückgabewert](#funktion-als-rückgabewert) + - [Python Closures (Abschlüsse)](#python-closures-abschlüsse) + - [Python Decorators (Dekoratoren)](#python-decorators-dekoratoren) + - [Eingebaute Funktionen höherer Ordnung](#eingebaute-funktionen-höherer-ordnung) + - [Map-Funktion](#map-funktion) + - [Filter-Funktion](#filter-funktion) + - [Reduce-Funktion](#reduce-funktion) + - [💻 Übungen - Tag 14](#-übungen---tag-14) + +# 📘 Tag 14 + +## Funktionen höherer Ordnung + +In Python werden Funktionen als "First Class Citizens" behandelt. Das bedeutet: +- Eine Funktion kann eine oder mehrere Funktionen als Parameter annehmen. +- Eine Funktion kann eine Funktion als Ergebnis zurückgeben. +- Eine Funktion kann modifiziert oder einer Variablen zugewiesen werden. + +### Funktion als Parameter + +```python +def sum_numbers(nums): + return sum(nums) + +def higher_order_function(f, lst): + return f(lst) + +result = higher_order_function(sum_numbers, [1, 2, 3, 4, 5]) +print(result) # 15 +``` + +### Funktion als Rückgabewert + +```python +def square(x): return x ** 2 +def cube(x): return x ** 3 + +def higher_order_function(type): + if type == 'square': + return square + elif type == 'cube': + return cube + +result = higher_order_function('square') +print(result(3)) # 9 +``` + +## Python Closures (Abschlüsse) + +Ein Closure erlaubt es einer inneren Funktion, auf den Gültigkeitsbereich (Scope) der äußeren Funktion zuzugreifen, selbst wenn die äußere Funktion bereits fertig ausgeführt wurde. + +```python +def add_ten(): + ten = 10 + def add(num): + return num + ten + return add + +closure_result = add_ten() +print(closure_result(5)) # 15 +``` + +## Python Decorators (Dekoratoren) + +Ein Decorator ist ein Design-Pattern, das es ermöglicht, die Funktionalität eines Objekts zu erweitern, ohne dessen Struktur zu verändern. Man nutzt dafür das `@`-Symbol. + +```python +def uppercase_decorator(function): + def wrapper(): + func = function() + return func.upper() + return wrapper + +@uppercase_decorator +def greeting(): + return 'Willkommen zu Python' + +print(greeting()) # WILLKOMMEN ZU PYTHON +``` + +## Eingebaute Funktionen höherer Ordnung + +### Map-Funktion +Wendet eine Funktion auf jedes Element einer Sequenz an. +```python +numbers = [1, 2, 3, 4] +squared = map(lambda x: x**2, numbers) +print(list(squared)) # [1, 4, 9, 16] +``` + +### Filter-Funktion +Filtert Elemente heraus, die eine bestimmte Bedingung (True/False) erfüllen. +```python +numbers = [1, 2, 3, 4, 5] +evens = filter(lambda x: x % 2 == 0, numbers) +print(list(evens)) # [2, 4] +``` + +### Reduce-Funktion +Reduziert eine Sequenz auf einen einzigen Wert (muss aus `functools` importiert werden). +```python +from functools import reduce +numbers = [1, 2, 3, 4, 5] +total = reduce(lambda x, y: x + y, numbers) +print(total) # 15 +``` + +--- + +## 💻 Übungen - Tag 14 + +### Level 1 +1. Erkläre den Unterschied zwischen `map`, `filter` und `reduce`. +2. Erkläre den Unterschied zwischen Higher Order Function, Closure und Decorator. +3. Gib alle Länder, Namen und Zahlen aus den gegebenen Listen mit einer Schleife aus. + +### Level 2 +1. Nutze `map`, um alle Länder in der Liste in Großbuchstaben umzuwandeln. +2. Nutze `map`, um alle Zahlen zu quadrieren. +3. Nutze `filter`, um Länder zu filtern, die das Wort "land" enthalten. +4. Nutze `filter`, um Länder mit genau 6 Zeichen zu finden. +5. Schreibe eine Funktion `get_string_lists`, die nur die String-Elemente aus einer gemischten Liste filtert. +6. Nutze `reduce`, um alle Zahlen zu summieren. +7. Nutze `reduce`, um alle Länder zu einem Satz zu verbinden. + +### Level 3 +1. Nutze die `countries_data.py`: + - Sortiere Länder nach Name, Hauptstadt und Bevölkerung. + - Finde die 10 am häufigsten gesprochenen Sprachen. + - Finde die 10 bevölkerungsreichsten Länder. + +🎉 HERZLICEN GLÜCKWUNSCH! 🎉 + +[<< Tag 13](./13_list_comprehension_de.md) | [Tag 15 >>](./15_python_type_errors_de.md) diff --git a/German/15_python_type_errors_de.md b/German/15_python_type_errors_de.md new file mode 100644 index 000000000..3e3b8888f --- /dev/null +++ b/German/15_python_type_errors_de.md @@ -0,0 +1,121 @@ +
+

30 Tage Python: Tag 15 - Python Fehlertypen

+ + + + + Twitter Follow + + +Autor: +Asabeneh Yetayeh
+ Zweite Edition: Juli 2021 + + +
+ +[<< Tag 14](./14_higher_order_functions_de.md) | [Tag 16 >>](./16_python_datetime_de.md) + +![30DaysOfPython](../images/30DaysOfPython_banner3@2x.png) + +- [📘 Tag 15](#-tag-15) + - [Python Fehlertypen](#python-fehlertypen) + - [SyntaxError](#syntaxerror) + - [NameError](#nameerror) + - [IndexError](#indexerror) + - [ModuleNotFoundError](#modulenotfounderror) + - [AttributeError](#attributeerror) + - [KeyError](#keyerror) + - [TypeError](#typeerror) + - [ImportError](#importerror) + - [ValueError](#valueerror) + - [ZeroDivisionError](#zerodivisionerror) + - [💻 Übungen - Tag 15](#-übungen---tag-15) + +# 📘 Tag 15 + +## Python Fehlertypen + +Beim Programmieren ist es völlig normal, Fehler zu machen – sei es ein Tippfehler oder ein logischer Fehler. Wenn dein Code nicht läuft, zeigt Python eine Fehlermeldung an. Diese enthält Informationen darüber, wo das Problem aufgetreten ist und um welche Art von Fehler es sich handelt. Das Verständnis dieser Fehlermeldungen hilft dir, deinen Code schnell zu "debuggen" (Fehler zu beheben). + +### SyntaxError +Tritt auf, wenn Python den Code aufgrund falscher Grammatik nicht lesen kann (z. B. fehlende Klammern). +```python +# Fehler +print 'Hallo Welt' # SyntaxError: Missing parentheses +# Lösung +print('Hallo Welt') +``` + +### NameError +Tritt auf, wenn du eine Variable verwendest, die noch nicht definiert wurde. +```python +# Fehler +print(alter) # NameError: name 'age' is not defined +# Lösung +alter = 25 +print(alter) +``` + +### IndexError +Tritt auf, wenn du auf einen Index in einer Liste zugreifst, der nicht existiert. +```python +lst = [1, 2, 3] +print(lst[5]) # IndexError: list index out of range +``` + +### ModuleNotFoundError +Tritt auf, wenn du ein Modul importieren möchtest, das nicht installiert oder falsch geschrieben ist. +```python +import maths # ModuleNotFoundError: No module named 'maths' (es heißt 'math') +``` + +### AttributeError +Tritt auf, wenn du auf eine Eigenschaft oder Methode eines Objekts zugreifst, die dieses nicht besitzt. +```python +import math +math.PI # AttributeError: module 'math' has no attribute 'PI' (es heißt 'pi') +``` + +### KeyError +Tritt auf, wenn du in einem Dictionary auf einen Schlüssel zugreifst, der nicht existiert. +```python +user = {'name': 'Asab'} +print(user['alter']) # KeyError: 'alter' +``` + +### TypeError +Tritt auf, wenn eine Operation auf einen Datentyp angewendet wird, der dafür nicht geeignet ist (z. B. Zahl + String). +```python +print(4 + '3') # TypeError: unsupported operand type(s) for +: 'int' and 'str' +``` + +### ImportError +Tritt auf, wenn ein Import fehlschlägt, z. B. weil die Funktion im Modul nicht existiert. +```python +from math import power # ImportError: cannot import name 'power' (es heißt 'pow') +``` + +### ValueError +Tritt auf, wenn eine Funktion ein Argument mit dem richtigen Typ, aber einem ungültigen Wert erhält. +```python +int('12a') # ValueError: invalid literal for int() +``` + +### ZeroDivisionError +Tritt auf, wenn du versuchst, eine Zahl durch Null zu teilen. +```python +print(1/0) # ZeroDivisionError: division by zero +``` + +Das Verständnis dieser Fehler macht dich zu einem effizienteren Programmierer. Nutze die Fehlermeldungen als Wegweiser zur Lösung! + +--- + +## 💻 Übungen - Tag 15 + +1. Öffne die interaktive Python-Shell und provoziere absichtlich jeden der oben genannten Fehler, um die Meldungen selbst zu sehen. Fixe sie anschließend. + +🎉 HERZLICEN GLÜCKWUNSCH! 🎉 + +[<< Tag 14](./14_higher_order_functions_de.md) | [Tag 16 >>](./16_python_datetime_de.md) diff --git a/German/16_python_datetime_de.md b/German/16_python_datetime_de.md new file mode 100644 index 000000000..7c4be47df --- /dev/null +++ b/German/16_python_datetime_de.md @@ -0,0 +1,126 @@ +
+

30 Tage Python: Tag 16 - Python Datum und Zeit

+ + + + + Twitter Follow + + +Autor: +Asabeneh Yetayeh
+ Zweite Edition: Juli 2021 + + +
+ +[<< Tag 15](./15_python_type_errors_de.md) | [Tag 17 >>](./17_exception_handling_de.md) + +![30DaysOfPython](../images/30DaysOfPython_banner3@2x.png) + +- [📘 Tag 16](#-tag-16) + - [Python datetime](#python-datetime) + - [Aktuelle Zeit abrufen](#aktuelle-zeit-abrufen) + - [Datum formatieren mit strftime](#datum-formatieren-mit-strftime) + - [Strings in Zeit umwandeln mit strptime](#strings-in-zeit-umwandeln-mit-strptime) + - [Datumsobjekte (date)](#datumsobjekte-date) + - [Zeitobjekte (time)](#zeitobjekte-time) + - [Zeitdifferenzen (Timedelta)](#zeitdifferenzen-timedelta) + - [💻 Übungen - Tag 16](#-übungen---tag-16) + +# 📘 Tag 16 + +## Python datetime + +Python nutzt das Modul `datetime`, um mit Datum und Uhrzeit zu arbeiten. + +```python +import datetime +print(dir(datetime)) # Listet alle verfügbaren Funktionen auf +``` + +Wir konzentrieren uns auf die wichtigsten Klassen: `date`, `datetime`, `time` und `timedelta`. + +### Aktuelle Zeit abrufen + +```python +from datetime import datetime +now = datetime.now() +print(now) # 2021-07-08 07:34:46.549883 +day = now.day +month = now.month +year = now.year +timestamp = now.timestamp() # Unix-Zeitstempel (Sekunden seit 1.1.1970) +``` + +### Datum formatieren mit strftime + +Mit `strftime` kannst du bestimmen, wie ein Datum als Text dargestellt wird. Die Symbole (wie `%d`, `%m`, `%Y`) findest du auf [strftime.org](https://strftime.org/). + +```python +from datetime import datetime +now = datetime.now() +formatted = now.strftime("%d.%m.%Y, %H:%M:%S") +print(formatted) # 08.07.2021, 07:34:46 +``` + +### Strings in Zeit umwandeln mit strptime + +Wenn du ein Datum als Text hast, kannst du es in ein Python-Objekt umwandeln: +```python +from datetime import datetime +date_string = "5 December, 2019" +date_obj = datetime.strptime(date_string, "%d %B, %Y") +print(date_obj) # 2019-12-05 00:00:00 +``` + +### Datumsobjekte (date) + +Wenn du nur das Datum ohne Uhrzeit brauchst: +```python +from datetime import date +today = date.today() +print(today.year, today.month, today.day) +``` + +### Zeitobjekte (time) + +Wenn du nur die Uhrzeit brauchst: +```python +from datetime import time +t = time(10, 30, 50) +print(t) # 10:30:50 +``` + +### Zeitdifferenzen (Timedelta) + +Du kannst Zeiträume addieren oder subtrahieren: +```python +from datetime import datetime, timedelta +now = datetime.now() +in_one_week = now + timedelta(weeks=1) +print(in_one_week) +``` + +Berechnung der Differenz zwischen zwei Zeitpunkten: +```python +t1 = datetime(2020, 1, 1) +t2 = datetime.now() +diff = t2 - t1 +print(f"Seit Neujahr 2020 sind {diff.days} Tage vergangen.") +``` + +--- + +## 💻 Übungen - Tag 16 + +1. Rufe den aktuellen Tag, Monat, Jahr, Stunde, Minute und den Zeitstempel ab. +2. Formatiere das aktuelle Datum im Format: `"%m/%d/%Y, %H:%M:%S"`. +3. Wandle den String "5 December, 2019" in ein Zeitobjekt um. +4. Berechne die verbleibende Zeit bis zum nächsten Neujahr. +5. Berechne die Differenz zwischen dem 1. Januar 1970 und dem heutigen Tag. +6. Überlege: Wofür braucht man das `datetime` Modul im echten Leben? (Beispiele: Blog-Posts, Logs, Zeitreihenanalyse). + +🎉 HERZLICEN GLÜCKWUNSCH! 🎉 + +[<< Tag 15](./15_python_type_errors_de.md) | [Tag 17 >>](./17_exception_handling_de.md) diff --git a/German/17_exception_handling_de.md b/German/17_exception_handling_de.md new file mode 100644 index 000000000..eea7a6480 --- /dev/null +++ b/German/17_exception_handling_de.md @@ -0,0 +1,118 @@ +
+

30 Tage Python: Tag 17 - Ausnahmebehandlung & Packing/Unpacking

+ + + + + Twitter Follow + + +Autor: +Asabeneh Yetayeh
+ Zweite Edition: Juli 2021 + + +
+ +[<< Tag 16](./16_python_datetime_de.md) | [Tag 18 >>](./18_regular_expressions_de.md) + +![30DaysOfPython](../images/30DaysOfPython_banner3@2x.png) + +- [📘 Tag 17](#-tag-17) + - [Ausnahmebehandlung (Exception Handling)](#ausnahmebehandlung-exception-handling) + - [Packing und Unpacking von Argumenten](#packing-und-unpacking-von-argumenten) + - [Unpacking (Entpacken)](#unpacking-entpacken) + - [Packing (Verpacken)](#packing-verpacken) + - [Enumerate](#enumerate) + - [Zip](#zip) + - [💻 Übungen - Tag 17](#-übungen---tag-17) + +# 📘 Tag 17 + +## Ausnahmebehandlung (Exception Handling) + +Python nutzt `try` und `except`, um Fehler elegant abzufangen. Ein Programm sollte bei einem Fehler nicht einfach abstürzen ("crash"), sondern kontrolliert reagieren ("graceful exit"). Das macht Anwendungen robuster gegen falsche Benutzereingaben oder externe Probleme (z. B. fehlende Dateien). + +```python +# Syntax +try: + code_der_einen_fehler_verursachen_koennte +except: + code_der_ausgefuehrt_wird_wenn_ein_fehler_auftritt +``` + +**Beispiel mit spezifischen Fehlern:** +```python +try: + name = input('Name: ') + year = int(input('Geburtsjahr: ')) + age = 2021 - year + print(f'Hallo {name}, du bist {age} Jahre alt.') +except ValueError: + print('Bitte gib eine gültige Zahl für das Jahr ein!') +except Exception as e: + print(f'Ein unerwarteter Fehler ist aufgetreten: {e}') +finally: + print('Dieser Teil wird IMMER ausgeführt (z.B. zum Aufräumen).') +``` + +## Packing und Unpacking von Argumenten + +In Python nutzen wir Symbole, um Sammlungen in einzelne Argumente zu zerlegen oder umgekehrt. + +- `*` wird für **Listen/Tupel** verwendet. +- `**` wird für **Dictionaries** verwendet. + +### Unpacking (Entpacken) + +Wenn eine Funktion einzelne Werte erwartet, du aber eine Liste hast: +```python +def add(a, b, c): + return a + b + c + +nums = [1, 2, 3] +# print(add(nums)) # Fehler! +print(add(*nums)) # Funktioniert: 6 +``` + +### Packing (Verpacken) + +Wenn du nicht weißt, wie viele Argumente übergeben werden, kannst du sie "einpacken": +```python +def sum_all(*args): + return sum(args) + +print(sum_all(1, 2, 3, 4, 5)) # 15 +``` + +## Enumerate + +Wenn du beim Iterieren durch eine Liste auch den **Index** (die Position) wissen möchtest: +```python +countries = ['Finnland', 'Schweden', 'Norwegen'] +for index, country in enumerate(countries): + print(f'{index}. {country}') +# 0. Finnland, 1. Schweden, ... +``` + +## Zip + +Mit `zip` kannst du mehrere Listen gleichzeitig in einer Schleife durchlaufen: +```python +fruits = ['Banane', 'Orange'] +prices = [1.2, 0.8] + +for fruit, price in zip(fruits, prices): + print(f'{fruit} kostet {price}€') +``` + +--- + +## 💻 Übungen - Tag 17 + +1. Gegeben ist die Liste: `names = ['Finland', 'Sweden', 'Norway', 'Denmark', 'Iceland', 'Estonia', 'Russia']`. + Entpacke die ersten fünf Länder in eine Variable `nordic_countries`. Speichere 'Estonia' in `es` und 'Russia' in `ru`. + +🎉 HERZLICEN GLÜCKWUNSCH! 🎉 + +[<< Tag 16](./16_python_datetime_de.md) | [Tag 18 >>](./18_regular_expressions_de.md) diff --git a/German/18_regular_expressions_de.md b/German/18_regular_expressions_de.md new file mode 100644 index 000000000..6861236df --- /dev/null +++ b/German/18_regular_expressions_de.md @@ -0,0 +1,118 @@ +
+

30 Tage Python: Tag 18 - Reguläre Ausdrücke (Regular Expressions)

+ + + + + Twitter Follow + + +Autor: +Asabeneh Yetayeh
+ Zweite Edition: Juli 2021 + + +
+ +[<< Tag 17](./17_exception_handling_de.md) | [Tag 19 >>](./19_file_handling_de.md) + +![30DaysOfPython](../images/30DaysOfPython_banner3@2x.png) + +- [📘 Tag 18](#-tag-18) + - [Reguläre Ausdrücke](#reguläre-ausdrücke) + - [Das re-Modul](#das-re-modul) + - [Methoden im re-Modul](#methoden-im-re-modul) + - [Match](#match) + - [Search](#search) + - [Findall](#findall) + - [Sub (Ersetzen)](#sub-ersetzen) + - [Split](#split) + - [Regex-Muster schreiben](#regex-muster-schreiben) + - [💻 Übungen - Tag 18](#-übungen---tag-18) + +# 📘 Tag 18 + +## Reguläre Ausdrücke + +Ein regulärer Ausdruck (Regular Expression oder kurz **RegEx**) ist eine spezielle Zeichenfolge, die hilft, Muster in Texten zu finden. RegEx wird verwendet, um Daten zu validieren, zu suchen oder zu ersetzen. In Python nutzen wir dafür das eingebaute Modul `re`. + +### Das re-Modul + +Zuerst müssen wir das Modul importieren: +```python +import re +``` + +### Methoden im re-Modul + +- `re.match()`: Sucht **nur am Anfang** der ersten Zeile. +- `re.search()`: Sucht im **gesamten String** nach dem ersten Vorkommen. +- `re.findall()`: Gibt eine **Liste aller Treffer** zurück. +- `re.split()`: Teilt den String an den Stellen, an denen das Muster passt. +- `re.sub()`: Ersetzt einen oder mehrere Treffer durch einen neuen Text. + +#### Match +```python +import re +txt = 'Ich liebe es, Python zu lernen' +match = re.match('Ich liebe', txt, re.I) # re.I ignoriert Groß/Kleinschreibung +print(match) # +``` + +#### Search +```python +match = re.search('Python', txt, re.I) +print(match.span()) # (14, 20) - Start- und Endposition +``` + +#### Findall +```python +txt = 'Python ist toll. Ich mag Python.' +matches = re.findall('Python', txt) +print(matches) # ['Python', 'Python'] +``` + +#### Sub (Ersetzen) +```python +txt = 'Ich liebe %Python% und %Java%.' +clean_txt = re.sub('%', '', txt) +print(clean_txt) # Ich liebe Python und Java. +``` + +### Regex-Muster schreiben + +Um ein Regex-Muster zu definieren, nutzen wir in Python "Raw Strings" mit einem vorangestellten `r`, z. B. `r'apple'`. + +**Wichtige Meta-Charaktere:** +- `[]`: Ein Zeichensatz (z. B. `[a-z]` für alle Kleinbuchstaben). +- `\`: Maskiert Sonderzeichen (z. B. `\d` für Ziffern, `\D` für Nicht-Ziffern). +- `.`: Jedes Zeichen außer Zeilenumbruch. +- `^`: Beginnt mit (z. B. `^Hallo`). +- `$`: Endet mit (z. B. `Welt$`). +- `*`: Null oder mehr Male. +- `+`: Ein oder mehr Male. +- `?`: Null oder ein Mal (optional). +- `{n}`: Genau n Mal. +- `|`: Entweder oder (z. B. `Apfel|Birne`). +- `()`: Gruppierung. + +--- + +## 💻 Übungen - Tag 18 + +### Level 1 +1. Was ist das häufigste Wort im folgenden Absatz? (Nutze Regex zur Reinigung). + `paragraph = 'I love teaching. If you do not love teaching what else can you love...'` +2. Extrahiere alle Zahlen aus folgendem Text und berechne die Distanz zwischen den beiden am weitesten entfernten Punkten auf einer x-Achse: + `'Die Positionen der Teilchen sind -12, -4, -3, -1, 0, 4 und 8.'` + +### Level 2 +1. Schreibe ein Muster, das prüft, ob ein String ein gültiger Python-Variablenname ist (keine Zahlen am Anfang, nur Alphanumerik und Unterstriche). + +### Level 3 +1. Reinige den folgenden Text von Sonderzeichen (`%`, `$`, `@`, `&`, `#`) und finde danach die drei häufigsten Wörter: + `sentence = '''%I $am@% a %tea@cher%, &and& I lo%#ve %tea@ching%;...'''` + +🎉 HERZLICEN GLÜCKWUNSCH! 🎉 + +[<< Tag 17](./17_exception_handling_de.md) | [Tag 19 >>](./19_file_handling_de.md) diff --git a/German/19_file_handling_de.md b/German/19_file_handling_de.md new file mode 100644 index 000000000..eb547854c --- /dev/null +++ b/German/19_file_handling_de.md @@ -0,0 +1,119 @@ +
+

30 Tage Python: Tag 19 - Dateiverarbeitung (File Handling)

+ + + + + Twitter Follow + + +Autor: +Asabeneh Yetayeh
+ Zweite Edition: Juli 2021 + + +
+ +[<< Tag 18](./18_regular_expressions_de.md) | [Tag 20 >>](./20_python_package_manager_de.md) + +![30DaysOfPython](../images/30DaysOfPython_banner3@2x.png) + +- [📘 Tag 19](#-tag-19) + - [Dateiverarbeitung](#dateiverarbeitung) + - [Dateien zum Lesen öffnen](#dateien-zum-lesen-öffnen) + - [Dateien zum Schreiben und Aktualisieren öffnen](#dateien-zum-schreiben-und-aktualisieren-öffnen) + - [Dateien löschen](#dateien-löschen) + - [Dateitypen](#dateitypen) + - [TXT-Dateien](#txt-dateien) + - [JSON-Dateien](#json-dateien) + - [CSV-Dateien](#csv-dateien) + - [XML-Dateien](#xml-dateien) + - [💻 Übungen - Tag 19](#-übungen---tag-19) + +# 📘 Tag 19 + +## Dateiverarbeitung + +Bisher haben wir Daten nur im Arbeitsspeicher gehalten. Um Daten dauerhaft zu speichern, nutzen wir Dateien. Python bietet die eingebaute Funktion `open()`, um Dateien zu erstellen, zu lesen, zu aktualisieren und zu löschen. + +```python +# Syntax +open('dateiname', modus) +``` + +**Die verschiedenen Modi:** +- `"r"` (Read): Standardwert. Öffnet zum Lesen. Fehler, wenn Datei fehlt. +- `"a"` (Append): Fügt am Ende hinzu. Erstellt Datei, falls nötig. +- `"w"` (Write): Überschreibt den Inhalt. Erstellt Datei, falls nötig. +- `"x"` (Create): Erstellt neue Datei. Fehler, wenn Datei bereits existiert. +- `"t"` (Text): Standardwert (Textmodus). +- `"b"` (Binary): Binärmodus (z. B. für Bilder). + +### Dateien zum Lesen öffnen + +Es wird empfohlen, das `with`-Statement zu nutzen, da es die Datei automatisch schließt. + +```python +with open('./files/beispiel.txt') as f: + inhalt = f.read() + print(inhalt) +``` + +**Methoden zum Lesen:** +- `read()`: Liest die gesamte Datei als String. +- `readline()`: Liest nur die erste Zeile. +- `readlines()`: Liest alle Zeilen und gibt eine Liste zurück. + +### Dateien zum Schreiben und Aktualisieren öffnen + +```python +# Hinzufügen (Append) +with open('./files/beispiel.txt', 'a') as f: + f.write('\nDieser Text wird hinten angehängt.') + +# Überschreiben (Write) +with open('./files/neu.txt', 'w') as f: + f.write('Dies ist eine neue Datei.') +``` + +### Dateien löschen + +Hierfür nutzen wir das `os`-Modul: +```python +import os +if os.path.exists('test.txt'): + os.remove('test.txt') +``` + +## Dateitypen + +### JSON-Dateien +JSON (JavaScript Object Notation) ist das Standardformat für den Datenaustausch im Web. In Python entspricht es fast exakt einem Dictionary. + +- `json.loads(json_string)`: Wandelt JSON in ein Python-Dictionary um. +- `json.dumps(dictionary)`: Wandelt ein Dictionary in einen JSON-String um. +- `json.dump(data, file)`: Speichert Daten direkt in eine JSON-Datei. + +### CSV-Dateien +CSV (Comma Separated Values) speichert tabellarische Daten. Python hat dafür das `csv`-Modul. + +### XML-Dateien +XML ist ein strukturiertes Format (ähnlich wie HTML). Wir nutzen `xml.etree.ElementTree`, um XML zu verarbeiten. + +--- + +## 💻 Übungen - Tag 19 + +### Level 1 +1. Schreibe eine Funktion, die Zeilen und Wörter in einem Text zählt. Teste sie mit den Reden von Obama, Michelle Obama, Donald Trump und Melina Trump (Dateien im `data`-Ordner). +2. Finde die 10 am häufigsten gesprochenen Sprachen aus der `countries_data.json`. +3. Finde die 10 bevölkerungsreichsten Länder aus der `countries_data.json`. + +### Level 2 +1. Extrahiere alle E-Mail-Adressen aus der Datei `email_exchange_big.txt` als Liste. +2. Finde die häufigsten Wörter in der englischen Sprache basierend auf einer Textdatei. +3. Vergleiche die Reden von Michelle Obama und Melina Trump auf Ähnlichkeit. (Tipp: Berechne die Worthäufigkeiten und vergleiche sie). + +🎉 HERZLICEN GLÜCKWUNSCH! 🎉 + +[<< Tag 18](./18_regular_expressions_de.md) | [Tag 20 >>](./20_python_package_manager_de.md) diff --git a/German/20_python_package_manager_de.md b/German/20_python_package_manager_de.md new file mode 100644 index 000000000..8fcdf2667 --- /dev/null +++ b/German/20_python_package_manager_de.md @@ -0,0 +1,110 @@ +
+

30 Tage Python: Tag 20 - PIP & Paket-Manager

+ + + + + Twitter Follow + + +Autor: +Asabeneh Yetayeh
+ Zweite Edition: Juli 2021 + + +
+ +[<< Tag 19](./19_file_handling_de.md) | [Tag 21 >>](./21_classes_and_objects_de.md) + +![30DaysOfPython](../images/30DaysOfPython_banner3@2x.png) + +- [📘 Tag 20](#-tag-20) + - [Python PIP - Der Paket-Manager](#python-pip---der-paket-manager) + - [Was ist PIP?](#was-ist-pip) + - [Pakete installieren](#pakete-installieren) + - [Pakete deinstallieren und auflisten](#pakete-deinstallieren-und-auflisten) + - [PIP Freeze & requirements.txt](#pip-freeze--requirementstxt) + - [Lesen von URLs (Requests)](#lesen-von-urls-requests) + - [Ein eigenes Paket erstellen](#ein-eigenes-paket-erstellen) + - [Beliebte Python Pakete](#beliebte-python-pakete) + - [💻 Übungen - Tag 20](#-übungen---tag-20) + +# 📘 Tag 20 + +## Python PIP - Der Paket-Manager + +### Was ist PIP? +PIP steht für "Preferred Installer Program". Wir nutzen `pip`, um zusätzliche Python-Pakete zu installieren. Ein **Paket** ist eine Sammlung von Modulen. In der Programmierung müssen wir das Rad nicht neu erfinden – wir nutzen Pakete, die andere bereits für uns geschrieben haben. + +### Pakete installieren + +Um ein Paket (z. B. `numpy` für Mathematik oder `requests` für das Web) zu installieren, nutzt du dein Terminal: +```shell +pip install numpy +pip install requests +``` + +### Pakete deinstallieren und auflisten + +- Deinstallieren: `pip uninstall paketname` +- Auflisten: `pip list` +- Details anzeigen: `pip show paketname` + +### PIP Freeze & requirements.txt + +Wenn du ein Projekt veröffentlichst, möchtest du anderen mitteilen, welche Pakete sie brauchen. +```shell +pip freeze > requirements.txt +``` +Die Datei `requirements.txt` enthält alle installierten Pakete und deren Versionen. + +### Lesen von URLs (Requests) + +Um Daten aus dem Internet oder von einer API zu laden, nutzen wir das Paket `requests`. + +```python +import requests +url = 'https://www.w3.org/TR/PNG/iso_8859-1.txt' +response = requests.get(url) +print(response.status_code) # 200 bedeutet Erfolg +print(response.text) # Zeigt den Text der Webseite an +``` + +### Ein eigenes Paket erstellen + +Ein Paket ist einfach ein Ordner, der eine spezielle Datei namens `__init__.py` enthält. Diese Datei sagt Python: "Dieser Ordner ist ein Paket". + +Struktur: +``` +mypackage/ + ├── __init__.py + ├── arithmetic.py + └── greet.py +``` + +## Beliebte Python Pakete + +- **Datenanalyse:** `numpy`, `pandas`, `matplotlib` +- **Web-Entwicklung:** `Django`, `Flask` +- **Web Scraping:** `BeautifulSoup`, `requests` +- **Machine Learning:** `TensorFlow`, `scikit-learn`, `PyTorch` +- **Datenbanken:** `SQLAlchemy` + +--- + +## 💻 Übungen - Tag 20 + +1. Lies eine Textdatei von einer URL (z. B. Romeo & Julia von Projekt Gutenberg) und finde die 10 häufigsten Wörter. +2. Nutze die [Cats API](https://api.thecatapi.com/v1/breeds): + - Berechne Minimum, Maximum und Durchschnittsgewicht der Katzenrassen. + - Berechne die durchschnittliche Lebenserwartung. + - Erstelle eine Tabelle, welche Rassen aus welchen Ländern kommen. +3. Nutze die [Countries API](https://restcountries.com/v2/all) (Hinweis: URL kann variieren): + - Finde die 10 größten Länder. + - Finde die 10 meistgesprochenen Sprachen. + - Zähle die Gesamtzahl aller Sprachen. +4. Versuche, die UCI Machine Learning Repository Webseite mit `BeautifulSoup` zu analysieren (Bonusaufgabe). + +🎉 HERZLICEN GLÜCKWUNSCH! 🎉 + +[<< Tag 19](./19_file_handling_de.md) | [Tag 21 >>](./21_classes_and_objects_de.md) diff --git a/German/21_classes_and_objects_de.md b/German/21_classes_and_objects_de.md new file mode 100644 index 000000000..5daf7c894 --- /dev/null +++ b/German/21_classes_and_objects_de.md @@ -0,0 +1,119 @@ +
+

30 Tage Python: Tag 21 - Klassen und Objekte (OOP)

+ + + + + Twitter Follow + + +Autor: +Asabeneh Yetayeh
+ Zweite Edition: Juli 2021 + + +
+ +[<< Tag 20](./20_python_package_manager_de.md) | [Tag 22 >>](./22_web_scraping_de.md) + +![30DaysOfPython](../images/30DaysOfPython_banner3@2x.png) + +- [📘 Tag 21](#-tag-21) + - [Klassen und Objekte](#klassen-und-objekte) + - [Eine Klasse erstellen](#eine-klasse-erstellen) + - [Ein Objekt erstellen](#ein-objekt-erstellen) + - [Der Klassen-Konstruktor (__init__)](#der-klassen-konstruktor-init) + - [Methoden eines Objekts](#methoden-eines-objekts) + - [Standardwerte in Konstruktoren](#standardwerte-in-konstruktoren) + - [Vererbung (Inheritance)](#vererbung-inheritance) + - [Methoden überschreiben (Overriding)](#methoden-überschreiben-overriding) + - [💻 Übungen - Tag 21](#-übungen---tag-21) + +# 📘 Tag 21 + +## Klassen und Objekte + +Python ist eine objektorientierte Programmiersprache (OOP). Alles in Python ist ein Objekt mit seinen Eigenschaften (Attributen) und Methoden. Eine Klasse ist wie ein "Bauplan" oder eine Konstruktionszeichnung zur Erstellung von Objekten. Wir instanziieren eine Klasse, um ein Objekt zu erzeugen. + +### Eine Klasse erstellen + +Wir nutzen das Schlüsselwort `class`. Klassennamen werden üblicherweise in **CamelCase** geschrieben. + +```python +# Syntax +class ClassName: + # Code hier +``` + +### Ein Objekt erstellen + +```python +class Person: + pass + +p = Person() # Erstellt eine Instanz der Klasse Person +``` + +### Der Klassen-Konstruktor (__init__) + +Die `__init__`-Methode ist eine spezielle Funktion, die automatisch aufgerufen wird, wenn ein neues Objekt erstellt wird. Sie initialisiert die Attribute des Objekts. Der Parameter `self` bezieht sich auf die aktuelle Instanz der Klasse. + +```python +class Person: + def __init__(self, firstname, lastname): + self.firstname = firstname + self.lastname = lastname + +p = Person('Asabeneh', 'Yetayeh') +print(p.firstname) # Asabeneh +``` + +### Methoden eines Objekts + +Methoden sind Funktionen, die innerhalb einer Klasse definiert sind und auf das Objekt angewendet werden können. + +```python +class Person: + def __init__(self, firstname, lastname, age): + self.firstname = firstname + self.lastname = lastname + self.age = age + + def info(self): + return f'{self.firstname} ist {self.age} Jahre alt.' + +p = Person('Asabeneh', 'Yetayeh', 250) +print(p.info()) +``` + +### Vererbung (Inheritance) + +Vererbung erlaubt es uns, eine Klasse zu definieren, die alle Methoden und Eigenschaften einer anderen Klasse (Elternklasse) übernimmt. + +```python +class Student(Person): # Student erbt von Person + def __init__(self, firstname, lastname, age, student_id): + super().__init__(firstname, lastname, age) # Ruft den Konstruktor der Elternklasse auf + self.student_id = student_id + +s = Student('Eyob', 'Yetayeh', 30, 'S12345') +print(s.info()) # Nutzt die Methode von Person +``` + +--- + +## 💻 Übungen - Tag 21 + +### Level 1 +1. Erstelle eine Klasse namens `Statistics`. Sie soll eine Liste von Zahlen entgegennehmen und Methoden für folgende statistische Berechnungen enthalten: + - `count()`, `sum()`, `min()`, `max()`, `range()`, `mean()`, `median()`, `mode()`, `std()` (Standardabweichung), `var()` (Varianz). + - Die Methode `describe()` soll eine Zusammenfassung aller Werte ausgeben. + +### Level 2 +1. Erstelle eine Klasse `PersonAccount`. + - Eigenschaften: `firstname`, `lastname`, `incomes` (Menge aus Einkommen & Beschreibung), `expenses` (Menge aus Ausgaben & Beschreibung). + - Methoden: `total_income()`, `total_expense()`, `account_info()`, `add_income()`, `add_expense()`, `account_balance()`. + +🎉 HERZLICEN GLÜCKWUNSCH! 🎉 + +[<< Tag 20](./20_python_package_manager_de.md) | [Tag 22 >>](./22_web_scraping_de.md) diff --git a/German/22_web_scraping_de.md b/German/22_web_scraping_de.md new file mode 100644 index 000000000..eb7c3e12d --- /dev/null +++ b/German/22_web_scraping_de.md @@ -0,0 +1,79 @@ +
+

30 Tage Python: Tag 22 - Web Scraping

+ + + + + Twitter Follow + + +Autor: +Asabeneh Yetayeh
+ Zweite Edition: Juli 2021 + + +
+ +[<< Tag 21](./21_classes_and_objects_de.md) | [Tag 23 >>](./23_virtual_environment_de.md) + +![30DaysOfPython](../images/30DaysOfPython_banner3@2x.png) + +- [📘 Tag 22](#-tag-22) + - [Python Web Scraping](#python-web-scraping) + - [Was ist Web Scraping?](#was-ist-web-scraping) + - [Werkzeuge: BeautifulSoup und Requests](#werkzeuge-beautifulsoup-und-requests) + - [💻 Übungen - Tag 22](#-übungen---tag-22) + +# 📘 Tag 22 + +## Python Web Scraping + +### Was ist Web Scraping? + +Das Internet ist voll von riesigen Datenmengen, die für verschiedene Zwecke genutzt werden können. Um diese Daten automatisiert zu sammeln, nutzen wir Web Scraping. **Web Scraping** ist der Prozess, bei dem Daten von Webseiten extrahiert, gesammelt und auf dem lokalen Computer oder in einer Datenbank gespeichert werden. + +### Werkzeuge: BeautifulSoup und Requests + +Um mit dem Scraping zu beginnen, benötigen wir zwei Pakete: +1. **Requests:** Um die Webseite herunterzuladen. +2. **BeautifulSoup4:** Um den HTML-Code der Seite zu analysieren und die gewünschten Informationen zu finden. + +```shell +pip install requests +pip install beautifulsoup4 +``` + +Um erfolgreich zu scrapen, ist ein Grundverständnis von HTML-Tags (wie ``, ``, `
`, ``) und CSS-Selektoren (Klassen und IDs) hilfreich. + +**Beispiel:** +```python +import requests +from bs4 import BeautifulSoup + +url = 'https://archive.ics.uci.edu/ml/datasets.php' +response = requests.get(url) +content = response.content # HTML-Inhalt der Seite + +soup = BeautifulSoup(content, 'html.parser') +print(soup.title.get_text()) # Gibt den Titel der Webseite aus + +# Tabellen finden +tables = soup.find_all('table', {'cellpadding': '3'}) +table = tables[0] +for tr in table.find_all('tr'): + tds = tr.find_all('td') + for td in tds: + print(td.text) +``` + +--- + +## 💻 Übungen - Tag 22 + +1. Scrape die folgende Webseite und speichere die Daten als JSON-Datei: `http://www.bu.edu/president/boston-university-facts-stats/`. +2. Extrahiere die Tabelle aus dieser URL: `https://archive.ics.uci.edu/ml/datasets.php` und wandle sie in eine JSON-Datei um. +3. Scrape die Tabelle der US-Präsidenten von Wikipedia und speichere sie als JSON: `https://en.wikipedia.org/wiki/List_of_presidents_of_the_United_States`. (Hinweis: Dies ist eine fortgeschrittene Aufgabe, da Wikipedia-Tabellen oft komplex strukturiert sind). + +🎉 HERZLICEN GLÜCKWUNSCH! 🎉 + +[<< Tag 21](./21_classes_and_objects_de.md) | [Tag 23 >>](./23_virtual_environment_de.md) diff --git a/German/23_virtual_environment_de.md b/German/23_virtual_environment_de.md new file mode 100644 index 000000000..4bb966076 --- /dev/null +++ b/German/23_virtual_environment_de.md @@ -0,0 +1,76 @@ + + +[<< Tag 22](./22_web_scraping_de.md) | [Tag 24 >>](./24_statistics_de.md) + +![30DaysOfPython](../images/30DaysOfPython_banner3@2x.png) + +- [📘 Tag 23](#-tag-23) + - [Virtuelle Umgebungen einrichten](#virtuelle-umgebungen-einrichten) + - [Warum eine virtuelle Umgebung?](#warum-eine-virtuelle-umgebung) + - [Erstellung und Aktivierung](#erstellung-und-aktivierung) + - [💻 Übungen - Tag 23](#-übungen---tag-23) + +# 📘 Tag 23 + +## Virtuelle Umgebungen einrichten + +Bevor du mit einem neuen Projekt beginnst, ist es ratsam, eine **virtuelle Umgebung (Virtual Environment)** zu erstellen. Diese hilft dir dabei, ein isoliertes System für jedes Projekt zu schaffen. Ohne virtuelle Umgebung würden sich die Pakete verschiedener Projekte gegenseitig stören oder Konflikte verursachen. + +### Warum eine virtuelle Umgebung? +Wenn du `pip freeze` in deinem normalen Terminal eingibst, siehst du alle Pakete, die global auf deinem Computer installiert sind. In einer virtuellen Umgebung siehst du nur die Pakete, die du **explizit für dieses eine Projekt** installiert hast. + +### Erstellung und Aktivierung + +1. **Erstellen:** + Gehe in deinen Projektordner und gib folgenden Befehl ein: + + - **Windows:** `python -m venv venv` + - **Mac/Linux:** `python3 -m venv venv` + +2. **Aktivieren:** + Nach der Erstellung musst du die Umgebung aktivieren: + + - **Windows (PowerShell):** `.\venv\Scripts\Activate.ps1` + - **Windows (Git Bash/CMD):** `source venv/Scripts/activate` + - **Mac/Linux:** `source venv/bin/activate` + +Sobald die Umgebung aktiviert ist, erscheint ein `(venv)` vor deiner Eingabeaufforderung im Terminal. + +**Beispiel:** +```shell +(venv) user@computer:~/mein_projekt$ pip install Flask +``` +Jetzt ist `Flask` nur in diesem Projekt verfügbar. + +3. **Deaktivieren:** + Wenn du fertig bist, kannst du die Umgebung mit dem Befehl `deactivate` verlassen. + +**Wichtig:** Du solltest den Ordner `venv/` niemals in dein GitHub-Repository hochladen. Füge ihn stattdessen zu deiner `.gitignore` Datei hinzu. + +--- + +## 💻 Übungen - Tag 23 + +1. Erstelle einen neuen Ordner für ein Projekt (z. B. `mein_test_projekt`). +2. Erstelle darin eine virtuelle Umgebung. +3. Aktiviere sie und installiere ein beliebiges Paket (z. B. `requests`). +4. Prüfe mit `pip freeze`, ob das Paket installiert ist. +5. Deaktiviere die Umgebung wieder. + +🎉 HERZLICEN GLÜCKWUNSCH! 🎉 + +[<< Tag 22](./22_web_scraping_de.md) | [Tag 24 >>](./24_statistics_de.md) diff --git a/German/24_statistics_de.md b/German/24_statistics_de.md new file mode 100644 index 000000000..8e466f1ec --- /dev/null +++ b/German/24_statistics_de.md @@ -0,0 +1,118 @@ +
+

30 Tage Python: Tag 24 - Statistik & NumPy

+ + + + + Twitter Follow + + +Autor: +Asabeneh Yetayeh
+ Zweite Edition: Juli 2021 + + +
+ +[<< Tag 23](./23_virtual_environment_de.md) | [Tag 25 >>](./25_pandas_de.md) + +![30DaysOfPython](../images/30DaysOfPython_banner3@2x.png) + +- [📘 Tag 24](#-tag-24) + - [Statistik in Python](#statistik-in-python) + - [NumPy (Numerical Python)](#numpy-numerical-python) + - [Einführung in NumPy](#einführung-in-numpy) + - [NumPy Arrays erstellen](#numpy-arrays-erstellen) + - [Mathematische Operationen mit NumPy](#mathematische-operationen-mit-numpy) + - [Mehrdimensionale Arrays](#mehrdimensionale-arrays) + - [Zufallszahlen generieren](#zufallszahlen-generieren) + - [Zusammenfassung](#zusammenfassung) + - [💻 Übungen - Tag 24](#-übungen---tag-24) + +# 📘 Tag 24 + +## Statistik in Python + +Statistik ist die Disziplin, die sich mit der Sammlung, Organisation, Analyse und Präsentation von Daten befasst. Für Data Science und Machine Learning ist ein Grundverständnis der Statistik unerlässlich. + +## NumPy (Numerical Python) + +Während Python-Listen flexibel sind, sind sie für große mathematische Berechnungen langsam. **NumPy** ist die Kernbibliothek für wissenschaftliches Rechnen in Python. Sie bietet leistungsstarke mehrdimensionale Arrays und Werkzeuge, um effizient damit zu arbeiten. + +### Einführung in NumPy + +Installation: +```shell +pip install numpy +``` + +Importieren: +```python +import numpy as np +print(np.__version__) +``` + +### NumPy Arrays erstellen + +NumPy Arrays (ndarrays) sind schneller und speichereffizienter als normale Listen. + +- **Aus einer Liste:** +```python +lst = [1, 2, 3, 4, 5] +np_arr = np.array(lst) +``` + +- **Mit Datentyp (Float):** +```python +np_float = np.array([1, 2, 3], dtype=float) # [1., 2., 3.] +``` + +### Mathematische Operationen mit NumPy + +Einer der größten Vorteile von NumPy ist die **Vektorisierung**. Du kannst mathematische Operationen auf das gesamte Array anwenden, ohne eine Schleife zu schreiben. + +```python +nums = np.array([1, 2, 3, 4]) +print(nums + 10) # [11, 12, 13, 14] +print(nums * 2) # [2, 4, 6, 8] +print(nums ** 2) # [1, 4, 9, 16] +``` + +### Mehrdimensionale Arrays + +```python +matrix = np.array([[1, 2], [3, 4], [5, 6]]) +print(matrix.shape) # (3, 2) - 3 Zeilen, 2 Spalten +``` + +### Zufallszahlen generieren + +```python +# Zufällige Zahl zwischen 0 und 1 +rand = np.random.random() + +# 5 Zufallszahlen +rand_arr = np.random.random(5) + +# Zufällige Ganzzahlen zwischen 0 und 10 +rand_int = np.random.randint(0, 11) +``` + +## Zusammenfassung + +Unterschiede zu normalen Listen: +1. Arrays unterstützen **vektorisierte Operationen**. +2. Die Größe eines Arrays ist nach der Erstellung **fest**. +3. Alle Elemente in einem Array müssen den **gleichen Datentyp** haben. +4. NumPy Arrays verbrauchen deutlich **weniger Speicher**. + +--- + +## 💻 Übungen - Tag 24 + +1. Wiederhole alle Code-Beispiele aus diesem Kapitel in deiner eigenen Entwicklungsumgebung (oder im Jupyter Notebook). +2. Erstelle ein 3x3 Array mit Zufallswerten und berechne den Mittelwert jeder Spalte. + +🎉 HERZLICEN GLÜCKWUNSCH! 🎉 + +[<< Tag 23](./23_virtual_environment_de.md) | [Tag 25 >>](./25_pandas_de.md) diff --git a/German/25_pandas_de.md b/German/25_pandas_de.md new file mode 100644 index 000000000..0fc09775d --- /dev/null +++ b/German/25_pandas_de.md @@ -0,0 +1,118 @@ +
+

30 Tage Python: Tag 25 - Pandas

+ + + + + Twitter Follow + + +Autor: +Asabeneh Yetayeh
+ Zweite Edition: Juli 2021 + + +
+ +[<< Tag 24](./24_statistics_de.md) | [Tag 26 >>](./26_python_web_de.md) + +![30DaysOfPython](../images/30DaysOfPython_banner3@2x.png) + +- [📘 Tag 25](#-tag-25) + - [Pandas](#pandas) + - [Installation und Import](#installation-und-import) + - [Pandas Series](#pandas-series) + - [Pandas DataFrames](#pandas-dataframes) + - [Datenexploration](#datenexploration) + - [DataFrames modifizieren](#dataframes-modifizieren) + - [Spalten hinzufügen](#spalten-hinzufügen) + - [Werte berechnen](#werte-berechnen) + - [Filtern (Boolean Indexing)](#filtern-boolean-indexing) + - [💻 Übungen - Tag 25](#-übungen---tag-25) + +# 📘 Tag 25 + +## Pandas + +Pandas ist eine Open-Source-Bibliothek für Python, die leistungsstarke, einfach zu bedienende Datenstrukturen und Analysewerkzeuge bietet. Es ist das Standardwerkzeug für die Arbeit mit tabellarischen Daten (ähnlich wie Excel oder SQL-Tabellen). + +### Installation und Import + +```shell +pip install pandas +``` + +```python +import pandas as pd +import numpy as np +``` + +### Pandas Series + +Eine **Series** ist eine einzelne Spalte von Daten. Sie kann aus einer Liste, einem Dictionary oder einem NumPy-Array erstellt werden. + +```python +nums = [1, 2, 3, 4, 5] +s = pd.Series(nums) +print(s) +``` + +### Pandas DataFrames + +Ein **DataFrame** ist eine zweidimensionale Tabelle (eine Sammlung von Series). Er ist das Herzstück von Pandas. + +```python +data = { + 'Name': ['Asabeneh', 'David', 'John'], + 'Land': ['Finnland', 'UK', 'Schweden'], + 'Stadt': ['Helsinki', 'London', 'Stockholm'] +} +df = pd.DataFrame(data) +``` + +## Datenexploration + +Wenn du einen großen Datensatz hast (z. B. eine CSV-Datei), helfen dir diese Methoden: + +- `df.head()`: Zeigt die ersten 5 Zeilen. +- `df.tail()`: Zeigt die letzten 5 Zeilen. +- `df.shape`: Zeigt die Anzahl der Zeilen und Spalten (Tupel). +- `df.info()`: Zeigt Datentypen und fehlende Werte. +- `df.describe()`: Berechnet statistische Kennzahlen (Mittelwert, Min, Max etc.). + +## DataFrames modifizieren + +### Spalten hinzufügen +```python +df['Gewicht'] = [74, 78, 69] +``` + +### Werte berechnen +Du kannst Spalten direkt miteinander verrechnen: +```python +# BMI berechnen (Gewicht / Größe in m^2) +df['BMI'] = df['Gewicht'] / (df['Größe'] ** 2) +``` + +### Filtern (Boolean Indexing) +Du kannst Daten basierend auf Bedingungen filtern: +```python +# Nur Personen über 30 Jahre anzeigen +print(df[df['Alter'] > 30]) +``` + +--- + +## 💻 Übungen - Tag 25 + +1. Lies die Datei `hacker_news.csv` aus dem `data`-Ordner ein. +2. Zeige die ersten und letzten 5 Zeilen an. +3. Extrahiere die Spalte "title" als Series. +4. Zähle die Anzahl der Zeilen und Spalten. +5. Filtere alle Titel, die das Wort "python" enthalten. +6. Filtere alle Titel, die das Wort "JavaScript" enthalten. +7. Vergleiche, über welche Sprache öfter geschrieben wurde. + +🎉 HERZLICEN GLÜCKWUNSCH! 🎉 + +[<< Tag 24](./24_statistics_de.md) | [Tag 26 >>](./26_python_web_de.md) diff --git a/German/26_python_web_de.md b/German/26_python_web_de.md new file mode 100644 index 000000000..8c8af9199 --- /dev/null +++ b/German/26_python_web_de.md @@ -0,0 +1,124 @@ +
+

30 Tage Python: Tag 26 - Python im Web (Flask)

+ + + + + Twitter Follow + + +Autor: +Asabeneh Yetayeh
+ Zweite Edition: Juli 2021 + + +
+ +[<< Tag 25](./25_pandas_de.md) | [Tag 27 >>](./27_python_with_mongodb_de.md) + +![30DaysOfPython](../images/30DaysOfPython_banner3@2x.png) + +- [📘 Tag 26](#-tag-26) + - [Python für das Web](#python-für-das-web) + - [Flask Framework](#flask-framework) + - [Projektstruktur](#projektstruktur) + - [Routen erstellen](#routen-erstellen) + - [Templates verwenden](#templates-verwenden) + - [Layouts und Vererbung](#layouts-und-vererbung) + - [Statische Dateien (CSS)](#statische-dateien-css) + - [Deployment (Veröffentlichung)](#deployment-veröffentlichung) + - [💻 Übungen - Tag 26](#-übungen---tag-26) + +# 📘 Tag 26 + +## Python für das Web + +Python ist eine vielseitige Sprache, die auch in der Web-Entwicklung eine große Rolle spielt. Die beiden populärsten Frameworks sind **Django** (umfangreich) und **Flask** (leichtgewichtig). In diesem Kapitel lernen wir, wie man Flask verwendet. + +### Flask Framework + +Flask ist ein Micro-Web-Framework. Es ist einfach zu erlernen und bietet dennoch alle Werkzeuge, um moderne Webanwendungen zu bauen. Flask nutzt die **Jinja2** Template-Engine, um dynamische HTML-Seiten zu erzeugen. + +### Projektstruktur + +Ein typisches Flask-Projekt sieht so aus: +``` +├── app.py # Die Hauptanwendung +├── static/ # Bilder, CSS, JavaScript +│ └── css/ +│ └── main.css +└── templates/ # HTML-Dateien + ├── home.html + └── layout.html +``` + +### Routen erstellen + +Eine "Route" bestimmt, was passiert, wenn ein Nutzer eine bestimmte URL aufruft. + +```python +from flask import Flask, render_template +import os + +app = Flask(__name__) + +@app.route('/') # Die Startseite +def home(): + return '

Willkommen auf der Startseite!

' + +@app.route('/about') # Die Über-uns-Seite +def about(): + return '

Über uns

' + +if __name__ == '__main__': + app.run(debug=True) +``` + +### Templates verwenden + +Anstatt Text direkt im Python-Code zu schreiben, nutzen wir HTML-Dateien im Ordner `templates/`. + +```python +@app.route('/') +def home(): + return render_template('home.html', title='Startseite') +``` + +### Layouts und Vererbung + +Um Code-Wiederholungen zu vermeiden (z. B. Navigation auf jeder Seite), nutzen wir ein Basis-Layout (`layout.html`), das von anderen Seiten erweitert wird. + +**layout.html:** +```html + + {{ title }} + + + {% block content %}{% endblock %} + + +``` + +**home.html:** +```html +{% extends 'layout.html' %} +{% block content %} +

Willkommen!

+{% endblock %} +``` + +### Deployment (Veröffentlichung) + +Damit deine Seite für alle erreichbar ist, musst du sie auf einem Server veröffentlichen. Beliebte Dienste sind Heroku, PythonAnywhere oder digitale Ozeane (DigitalOcean). Dafür brauchst du eine `requirements.txt` und oft ein `Procfile`. + +--- + +## 💻 Übungen - Tag 26 + +1. Erstelle eine kleine Flask-Anwendung mit mindestens drei Seiten (Home, Über uns, Kontakt). +2. Nutze ein gemeinsames Layout für alle Seiten. +3. Erstelle eine Seite "Text-Analysator", die einen Text entgegennimmt (Formular) und die Anzahl der Wörter zählt. + +🎉 HERZLICEN GLÜCKWUNSCH! 🎉 + +[<< Tag 25](./25_pandas_de.md) | [Tag 27 >>](./27_python_with_mongodb_de.md) diff --git a/German/27_python_with_mongodb_de.md b/German/27_python_with_mongodb_de.md new file mode 100644 index 000000000..aad32cc1f --- /dev/null +++ b/German/27_python_with_mongodb_de.md @@ -0,0 +1,123 @@ +
+

30 Tage Python: Tag 27 - Python mit MongoDB

+ + + + + Twitter Follow + + +Autor: +Asabeneh Yetayeh
+ Zweite Edition: Juli 2021 + + +
+ +[<< Tag 26](./26_python_web_de.md) | [Tag 28 >>](./28_API_de.md) + +![30DaysOfPython](../images/30DaysOfPython_banner3@2x.png) + +- [📘 Tag 27](#-tag-27) + - [Python mit MongoDB](#python-mit-mongodb) + - [SQL vs. NoSQL](#sql-vs-nosql) + - [MongoDB Einrichtung](#mongodb-einrichtung) + - [Verbindung mit PyMongo](#verbindung-mit-pymongo) + - [Datenbank und Kollektion erstellen](#datenbank-und-kollektion-erstellen) + - [CRUD-Operationen](#crud-operationen) + - [Einfügen (Create)](#einfügen-create) + - [Finden (Read)](#finden-read) + - [Aktualisieren (Update)](#aktualisieren-update) + - [Löschen (Delete)](#löschen-delete) + - [💻 Übungen - Tag 27](#-übungen---tag-27) + +# 📘 Tag 27 + +## Python mit MongoDB + +Python wird oft als Backend-Technologie eingesetzt und kann mit verschiedenen Datenbanksystemen verbunden werden (SQL und NoSQL). In diesem Kapitel verbinden wir Python mit **MongoDB**, einer beliebten NoSQL-Datenbank. + +### SQL vs. NoSQL + +Während SQL-Datenbanken (wie MySQL oder PostgreSQL) Tabellen mit festen Schemata nutzen, speichert MongoDB Daten in Dokumenten (JSON-ähnlich). Dies macht MongoDB sehr flexibel und skalierbar. + +### MongoDB Einrichtung + +Wir nutzen **MongoDB Atlas**, die Cloud-Lösung von MongoDB. +1. Registriere dich auf [mongodb.com](https://www.mongodb.com/). +2. Erstelle einen kostenlosen Cluster (Shared Sandbox). +3. Erstelle einen Datenbank-Nutzer (Name & Passwort). +4. Erlaube den Zugriff von deiner IP-Adresse. +5. Kopiere den "Connection String" (URI). + +### Verbindung mit PyMongo + +Um MongoDB in Python zu nutzen, benötigen wir den Treiber `pymongo`. + +```shell +pip install pymongo dnspython +``` + +**Verbindung herstellen:** +```python +import pymongo + +# Ersetze durch dein Passwort +uri = "mongodb+srv://user:@cluster.mongodb.net/test?retryWrites=true&w=majority" +client = pymongo.MongoClient(uri) + +# Datenbank und Kollektion auswählen +db = client.python_kurs +collection = db.studenten +``` + +### CRUD-Operationen + +#### Einfügen (Create) +```python +student = {'name': 'Asabeneh', 'land': 'Finnland', 'alter': 250} +collection.insert_one(student) # Ein Dokument einfügen +``` + +#### Finden (Read) +```python +# Das erste Dokument finden +result = collection.find_one() + +# Alle Dokumente finden +for s in collection.find(): + print(s) + +# Mit Filter (z. B. alle aus Finnland) +for s in collection.find({'land': 'Finnland'}): + print(s) +``` + +#### Aktualisieren (Update) +```python +query = {'name': 'Asabeneh'} +neue_werte = {'$set': {'alter': 38}} +collection.update_one(query, neue_werte) +``` + +#### Löschen (Delete) +```python +collection.delete_one({'name': 'Asabeneh'}) +# collection.drop() # Löscht die gesamte Kollektion +``` + +--- + +## 💻 Übungen - Tag 27 + +1. Erstelle einen MongoDB Atlas Account und einen kostenlosen Cluster. +2. Verbinde dein Python-Skript mit der Cloud-Datenbank. +3. Erstelle eine Datenbank `schulverwaltung` und eine Kollektion `lehrer`. +4. Füge 5 Lehrer-Dokumente mit Name, Fach und Erfahrung (Jahre) ein. +5. Finde alle Lehrer, die mehr als 10 Jahre Erfahrung haben. +6. Aktualisiere das Fach eines Lehrers. +7. Lösche einen Lehrer aus der Datenbank. + +🎉 HERZLICEN GLÜCKWUNSCH! 🎉 + +[<< Tag 26](./26_python_web_de.md) | [Tag 28 >>](./28_API_de.md) diff --git a/German/28_API_de.md b/German/28_API_de.md new file mode 100644 index 000000000..aa7cc9120 --- /dev/null +++ b/German/28_API_de.md @@ -0,0 +1,81 @@ +
+

30 Tage Python: Tag 28 - API (Schnittstellen)

+ + + + + Twitter Follow + + +Autor: +Asabeneh Yetayeh
+ Zweite Edition: Juli 2021 + + +
+ +[<< Tag 27](./27_python_with_mongodb_de.md) | [Tag 29 >>](./29_building_API_de.md) + +![30DaysOfPython](../images/30DaysOfPython_banner3@2x.png) + +- [📘 Tag 28](#-tag-28) + - [Application Programming Interface (API)](#application-programming-interface-api) + - [Was ist eine API?](#was-ist-eine-api) + - [HTTP-Protokoll](#http-protokoll) + - [Struktur von HTTP](#struktur-von-http) + - [HTTP-Methoden](#http-methoden) + - [Status-Codes](#status-codes) + - [💻 Übungen - Tag 28](#-übungen---tag-28) + +# 📘 Tag 28 + +## Application Programming Interface (API) + +### Was ist eine API? + +API steht für **Application Programming Interface** (Programmierschnittstelle). Eine Web-API ist eine definierte Schnittstelle, über die verschiedene Anwendungen miteinander kommunizieren können. Im Web-Kontext ist eine API oft eine Sammlung von Spezifikationen für HTTP-Anfragen, deren Antworten meist im **JSON**- oder XML-Format geliefert werden. + +REST (Representational State Transfer) ist der heute am weitesten verbreitete Stil für Web-APIs. + +### HTTP-Protokoll + +HTTP (Hypertext Transfer Protocol) ist das Kommunikationsprotokoll zwischen einem **Client** (z. B. dein Browser) und einem **Server** (wo die Daten liegen). + +### Struktur von HTTP + +Jede Kommunikation folgt dem **Request-Response-Zyklus**: +1. Der Client sendet eine Anfrage (Request). +2. Der Server verarbeitet diese und sendet eine Antwort (Response). + +Eine Nachricht besteht aus: +- Einer Startzeile (Methode/Pfad/Version). +- Header-Feldern (Metadaten wie `Content-Type`). +- Einem optionalen Body (die eigentlichen Daten, z. B. JSON). + +### HTTP-Methoden + +Um CRUD-Operationen (Erstellen, Lesen, Aktualisieren, Löschen) über eine API durchzuführen, nutzen wir: +1. **GET:** Daten abrufen/lesen. +2. **POST:** Neue Daten erstellen/senden. +3. **PUT:** Bestehende Daten aktualisieren/ersetzen. +4. **DELETE:** Daten löschen. + +### Status-Codes + +Der Server gibt immer einen Code zurück, der über den Erfolg informiert: +- **200 OK:** Alles hat geklappt. +- **201 Created:** Erfolgreich erstellt. +- **400 Bad Request:** Fehler in der Anfrage. +- **404 Not Found:** Ressource nicht gefunden. +- **500 Server Error:** Fehler auf dem Server. + +--- + +## 💻 Übungen - Tag 28 + +1. Recherchiere und lies mehr über das HTTP-Protokoll und REST-APIs. +2. Suche nach drei öffentlichen APIs im Internet (z. B. Wetter, News, Pokémon) und schaue dir deren Dokumentation an. + +🎉 HERZLICEN GLÜCKWUNSCH! 🎉 + +[<< Tag 27](./27_python_with_mongodb_de.md) | [Tag 29 >>](./29_building_API_de.md) diff --git a/German/29_building_API_de.md b/German/29_building_API_de.md new file mode 100644 index 000000000..30e843bb2 --- /dev/null +++ b/German/29_building_API_de.md @@ -0,0 +1,101 @@ +
+

30 Tage Python: Tag 29 - API Erstellen (Building API)

+ + + + + Twitter Follow + + +Autor: +Asabeneh Yetayeh
+ Zweite Edition: Juli 2021 + + +
+ +[<< Tag 28](./28_API_de.md) | [Tag 30 >>](./30_conclusions_de.md) + +![30DaysOfPython](../images/30DaysOfPython_banner3@2x.png) + +- [📘 Tag 29](#-tag-29) + - [API Erstellen](#api-erstellen) + - [Struktur einer API](#struktur-einer-api) + - [Daten abrufen (GET)](#daten-abrufen-get) + - [Daten per ID finden](#daten-per-id-finden) + - [Daten erstellen (POST)](#daten-erstellen-post) + - [Daten aktualisieren (PUT)](#daten-aktualisieren-put) + - [Daten löschen (DELETE)](#daten-löschen-delete) + - [💻 Übungen - Tag 29](#-übungen---tag-29) + +# 📘 Tag 29 + +## API Erstellen + +In diesem Abschnitt bauen wir eine echte **RESTful API**, die alle HTTP-Methoden (GET, POST, PUT, DELETE) nutzt, um Daten zu verarbeiten. Wir kombinieren dafür unser Wissen über Python, Flask und MongoDB. + +Da ein Browser standardmäßig nur GET-Anfragen einfach darstellen kann, benötigen wir ein Werkzeug wie **Postman** oder **Insomnia**, um unsere API-Endpunkte professionell zu testen. + +### Struktur einer API + +Ein API-Endpunkt ist eine URL, über die eine Ressource erreicht wird. +Beispiel: `http://localhost:5000/api/v1.0/students` + +### Daten abrufen (GET) + +Zuerst erstellen wir einen Endpunkt, der uns eine Liste von Studenten als JSON zurückgibt. + +```python +from flask import Flask, Response +import json + +app = Flask(__name__) + +@app.route('/api/v1.0/students', methods=['GET']) +def get_students(): + student_list = [ + {'name': 'Asabeneh', 'country': 'Finland'}, + {'name': 'David', 'country': 'UK'} + ] + return Response(json.dumps(student_list), mimetype='application/json') +``` + +### Daten erstellen (POST) + +Mit der POST-Methode können wir neue Daten an den Server senden und in der Datenbank speichern. + +```python +@app.route('/api/v1.0/students', methods=['POST']) +def create_student(): + name = request.form['name'] + country = request.form['country'] + # Logik zum Speichern in MongoDB... + return Response(json.dumps({'result': 'Erfolgreich erstellt'}), mimetype='application/json') +``` + +### Daten aktualisieren (PUT) + +PUT wird verwendet, um einen bestehenden Datensatz komplett zu ersetzen oder zu aktualisieren. Wir identifizieren den Datensatz meist über eine eindeutige ID. + +### Daten löschen (DELETE) + +Der DELETE-Endpunkt entfernt eine Ressource aus der Datenbank. + +```python +@app.route('/api/v1.0/students/', methods=['DELETE']) +def delete_student(id): + db.students.delete_one({'_id': ObjectId(id)}) + return Response(json.dumps({'result': 'Gelöscht'}), mimetype='application/json') +``` + +--- + +## 💻 Übungen - Tag 29 + +1. Implementiere das Beispiel aus diesem Kapitel und erstelle eine voll funktionsfähige API für eine Studentenverwaltung. +2. Teste alle Endpunkte (GET, POST, PUT, DELETE) mit Postman. +3. (Bonus): Füge Validierungen hinzu, sodass ein Student nicht ohne Namen gespeichert werden kann. + +🎉 HERZLICEN GLÜCKWUNSCH! 🎉 + +[<< Tag 28](./28_API_de.md) | [Tag 30 >>](./30_conclusions_de.md) diff --git a/German/30_conclusions_de.md b/German/30_conclusions_de.md new file mode 100644 index 000000000..098a343c5 --- /dev/null +++ b/German/30_conclusions_de.md @@ -0,0 +1,42 @@ +
+

30 Tage Python: Tag 30 - Fazit (Conclusions)

+ + + + + Twitter Follow + + +Autor: +Asabeneh Yetayeh
+ Zweite Edition: Juli 2021 + + +
+ +[<< Tag 29](./29_building_API_de.md) + +![30DaysOfPython](../images/30DaysOfPython_banner3@2x.png) + +- [📘 Tag 30](#-tag-30) + - [Fazit](#fazit) + - [Erfahrungsberichte (Testimonials)](#erfahrungsberichte-testimonials) + +# 📘 Tag 30 + +## Fazit + +Während der Erstellung dieses Materials habe ich selbst sehr viel gelernt, und dein Fortschritt hat mich dazu inspiriert, noch mehr zu tun. **Herzlichen Glückwunsch!** Du hast es bis zum Ende geschafft. Wenn du alle Übungen und Projekte abgeschlossen hast, bist du nun bereit, tiefer in die Bereiche Datenanalyse, Data Science, Machine Learning oder Web-Entwicklung einzusteigen. Python ist das perfekte Fundament für deine weitere Karriere. + +Wenn dir dieser Kurs gefallen hat, kannst du den [Autor unterstützen](https://www.paypal.com/paypalme/asabeneh), um mehr freie Bildungsmaterialien zu ermöglichen. + +## Erfahrungsberichte (Testimonials) + +Jetzt ist es an der Zeit, deine Gedanken über den Kurs und den Autor zu teilen. Du kannst dein Feedback unter diesem [Link](https://www.asabeneh.com/testimonials) hinterlassen. + +**FEEDBACK GEBEN:** +http://thirtydayofpython-api.herokuapp.com/feedback + +🎉 HERZLICEN GLÜCKWUNSCH! 🎉 + +[<< Tag 29](./29_building_API_de.md) diff --git a/German/README.md b/German/README.md new file mode 100644 index 000000000..fec0ce2a9 --- /dev/null +++ b/German/README.md @@ -0,0 +1,324 @@ +# 🐍 30 Tage Python (30 Days Of Python) + +|# Tag | Themen | +|------|:---------------------------------------------------------:| +| 01 | [Einführung](./readme.md)| +| 02 | [Variablen, Eingebaute Funktionen](./02_variables_builtin_functions_de.md)| +| 03 | [Operatoren](./03_operators_de.md)| +| 04 | [Strings](./04_strings_de.md)| +| 05 | [Listen (Lists)](./05_lists_de.md)| +| 06 | [Tupel (Tuples)](./06_tuples_de.md)| +| 07 | [Mengen (Sets)](./07_sets_de.md)| +| 08 | [Dictionaries (Wörterbücher)](./08_dictionaries_de.md)| +| 09 | [Bedingungen (Conditionals)](./09_conditionals_de.md)| +| 10 | [Schleifen (Loops)](./10_loops_de.md)| +| 11 | [Funktionen (Functions)](./11_functions_de.md)| +| 12 | [Module](./12_modules_de.md)| +| 13 | [List Comprehension](./13_list_comprehension_de.md)| +| 14 | [Funktionen höherer Ordnung](./14_higher_order_functions_de.md)| +| 15 | [Python Typ-Fehler](./15_python_type_errors_de.md)| +| 16 | [Python Datum und Zeit](./16_python_datetime_de.md) | +| 17 | [Fehlerbehandlung (Exception Handling)](./17_exception_handling_de.md)| +| 18 | [Reguläre Ausdrücke (Regular Expressions)](./18_regular_expressions_de.md)| +| 19 | [Dateiverarbeitung (File Handling)](./19_file_handling_de.md)| +| 20 | [Python Paket-Manager](./20_python_package_manager_de.md)| +| 21 | [Klassen und Objekte](./21_classes_and_objects_de.md)| +| 22 | [Web Scraping](./22_web_scraping_de.md)| +| 23 | [Virtuelle Umgebung](./23_virtual_environment_de.md)| +| 24 | [Statistik](./24_statistics_de.md)| +| 25 | [Pandas](./25_pandas_de.md)| +| 26 | [Python im Web](./26_python_web_de.md)| +| 27 | [Python mit MongoDB](./27_python_with_mongodb_de.md)| +| 28 | [API](./28_API_de.md)| +| 29 | [API Erstellen](./29_building_API_de.md)| +| 30 | [Fazit & Ausblick](./30_conclusions_de.md)| + +🧡🧡🧡 HAPPY CODING 🧡🧡🧡 + +--- +
+

💖 Sponsoren

+ +

Vielen Dank an unsere fantastischen Sponsoren für die Unterstützung meines Open-Source-Beitrags und der 30 Tage Herausforderung Serie!

+ +

Aktuelle Sponsoren

+
+ +
+ + +--- + +### 🙌 Sponsor werden + +Du kannst dieses Projekt unterstützen, indem du Sponsor auf **[GitHub Sponsors](https://github.com/sponsors/asabeneh)** wirst oder über [PayPal](https://www.paypal.me/asabeneh) spendest. + +Jeder Beitrag, egal wie klein, macht einen großen Unterschied. Vielen Dank für deine Unterstützung! 🌟 + +--- + +
+

30 Tage Python: Tag 1 - Einführung

+ + + + + Twitter Follow + + + Autor: + Asabeneh Yetayeh
+ Zweite Edition: Juli 2021 + +
+ +🇧🇷 [Portugiesisch](../Portuguese/README.md) +🇨🇳 [Chinesisch](../Chinese/README.md) +🇪🇸 [Spanisch](../Spanish/readme.md) + +[Tag 2 >>](./02_variables_builtin_functions_de.md) + +![30DaysOfPython](../images/30DaysOfPython_banner3@2x.png) + +- [🐍 30 Tage Python](#-30-tage-python) + - [🙌 Sponsor werden](#-sponsor-werden) +- [📘 Tag 1](#-tag-1) + - [Willkommen](#willkommen) + - [Einführung](#einführung) + - [Warum Python?](#warum-python) + - [Einrichten der Umgebung](#einrichten-der-umgebung) + - [Python installieren](#python-installieren) + - [Python-Shell](#python-shell) + - [Installation von Visual Studio Code](#installation-von-visual-studio-code) + - [Verwendung von Visual Studio Code](#verwendung-von-visual-studio-code) + - [Grundlagen Python](#grundlagen-python) + - [Python-Syntax](#python-syntax) + - [Einrückung in Python (Indentation)](#einrückung-in-python-indentation) + - [Kommentare](#kommentare) + - [Datentypen](#datentypen) + - [Zahlen (Number)](#zahlen-number) + - [Zeichenketten (String)](#zeichenketten-string) + - [Booleans (Wahrheitswerte)](#booleans-wahrheitswerte) + - [Listen (List)](#listen-list) + - [Dictionaries (Wörterbücher)](#dictionaries-wörterbücher) + - [Tupel (Tuple)](#tupel-tuple) + - [Mengen (Set)](#mengen-set) + - [Datentypen prüfen](#datentypen-prüfen) + - [Python-Datei](#python-datei) + - [💻 Übungen - Tag 1](#-übungen---tag-1) + - [Übung: Level 1](#übung-level-1) + - [Übung: Level 2](#übung-level-2) + - [Übung: Level 3](#übung-level-3) + +# 📘 Tag 1 + +## Willkommen + +**Herzlichen Glückwunsch** zu deiner Entscheidung, an der *30 Tage Python*-Herausforderung teilzunehmen. In dieser Challenge wirst du alles lernen, was du brauchst, um ein Python-Programmierer zu werden, und das gesamte Konzept der Programmierung verstehen. Am Ende der Herausforderung erhältst du ein *30DaysOfPython*-Zertifikat. + +Wenn du dich aktiv an der Herausforderung beteiligen möchtest, kannst du der [30DaysOfPython-Challenge Telegram-Gruppe](https://t.me/ThirtyDaysOfPython) beitreten. + +## Einführung + +Python ist eine High-Level-Programmiersprache für allgemeine Programmierzwecke. Es ist eine Open-Source-, interpretierte und objektorientierte Programmiersprache. Python wurde von dem niederländischen Programmierer Guido van Rossum entwickelt. Der Name der Sprache leitet sich von der britischen Comedy-Serie *Monty Python’s Flying Circus* ab. Die erste Version wurde am 20. Februar 1991 veröffentlicht. Diese 30-tägige Herausforderung hilft dir, die neueste Version von Python, Python 3, Schritt für Schritt zu erlernen. Die Themen sind in 30 Tage unterteilt, wobei jeder Tag mehrere Unterthemen mit leicht verständlichen Erklärungen, Beispielen aus der Praxis und vielen praktischen Übungen und Projekten enthält. + +Diese Herausforderung ist sowohl für Anfänger als auch für Profis konzipiert, die die Programmiersprache Python erlernen möchten. Es kann 30 bis 100 Tage dauern, um die Herausforderung abzuschließen. Menschen, die aktiv in der Telegram-Gruppe teilnehmen, haben eine hohe Wahrscheinlichkeit, die Herausforderung erfolgreich zu beenden. + +Dieser Kurs ist leicht zu lesen, in einem konversationellen Ton geschrieben, fesselnd, motivierend und gleichzeitig sehr fordernd. Du musst viel Zeit einplanen, um diese Herausforderung abzuschließen. Wenn du ein visueller Lerntyp bist, findest du Video-Lektionen auf dem YouTube-Kanal Washera. Du kannst mit dem [Python für absolute Anfänger Video](https://youtu.be/OCCWZheOesI) beginnen. Abonniere den Kanal, kommentiere und stelle Fragen zu den Videos – der Autor wird dich schließlich bemerken. + +Der Autor freut sich über deine Meinung zur Challenge. Teile deine Gedanken über die 30DaysOfPython-Herausforderung mit dem Autor. Du kannst dein Feedback unter diesem [Link](https://www.asabeneh.com/testimonials) hinterlassen. + +## Warum Python? + +Python ist eine Programmiersprache, die der menschlichen Sprache sehr nahe kommt und daher leicht zu erlernen und zu verwenden ist. Python wird von verschiedenen Branchen und Unternehmen (einschließlich Google) verwendet. Es wurde zur Entwicklung von Webanwendungen, Desktop-Anwendungen, zur Systemadministration und für Machine-Learning-Bibliotheken eingesetzt. Python ist eine in der Data-Science- und Machine-Learning-Community sehr geschätzte Sprache. Ich hoffe, das reicht aus, um dich davon zu überzeugen, Python zu lernen. Python erobert die Welt, und du solltest es beherrschen, bevor es dich "frisst". + +## Einrichten der Umgebung + +### Python installieren + +Um ein Python-Skript auszuführen, musst du Python installieren. Lass uns Python [herunterladen](https://www.python.org/). +Wenn du Windows-Benutzer bist, klicke auf die rot eingekreiste Schaltfläche. + +[![Installation unter Windows](../images/installing_on_windows.png)](https://www.python.org/) + +Wenn du macOS-Benutzer bist, klicke auf die rot eingekreiste Schaltfläche. + +[![Installation unter macOS](../images/installing_on_macOS.png)](https://www.python.org/) + +Um zu prüfen, ob Python installiert ist, gib den folgenden Befehl in dein Terminal ein: + +```shell +python3 --version +``` + +![Python Version](../images/python_versio.png) + +Wie du im Terminal sehen kannst, verwende ich momentan die Version *Python 3.7.5*. Deine Version kann abweichen, sollte aber 3.6 oder höher sein. Wenn du die Version siehst, gut gemacht! Python wurde auf deinem Computer installiert. Weiter zum nächsten Abschnitt. + +### Python-Shell + +Python ist eine interpretierte Skriptsprache, muss also nicht kompiliert werden. Das bedeutet, der Code wird Zeile für Zeile ausgeführt. Python wird mit einer *Python-Shell (Python Interactive Shell)* geliefert. Diese wird verwendet, um einen einzelnen Python-Befehl auszuführen und das Ergebnis sofort zu erhalten. + +Die Python-Shell wartet auf Python-Code vom Benutzer. Wenn du Code eingibst, wird dieser interpretiert und das Ergebnis in der nächsten Zeile angezeigt. +Öffne dein Terminal oder die Eingabeaufforderung (cmd) und schreibe: + +```shell +python +``` + +![Python Scripting Shell](../images/opening_python_shell.png) + +Die interaktive Shell ist geöffnet und wartet darauf, dass du Python-Code schreibst. Du schreibst dein Skript hinter das Symbol >>> und drückst Enter. +Lass uns unser erstes Skript in der Shell schreiben: + +![Python Skript in der Shell](../images/adding_on_python_shell.png) + +Gut gemacht, du hast dein erstes Python-Skript geschrieben! Wie schließen wir die interaktive Shell? +Gib hinter dem Symbol >>> den Befehl **exit()** ein und drücke Enter. + +![Beenden der Shell](../images/exit_from_shell.png) + +Jetzt weißt du, wie man die Shell öffnet und wieder schließt. + +Python liefert Ergebnisse, wenn du Skripte schreibst, die Python versteht. Wenn nicht, gibt es Fehler zurück. Lass uns absichtlich einen Fehler machen. + +![Syntaxfehler](../images/invalid_syntax_error.png) + +Wie du sehen kannst, ist Python schlau genug, um zu wissen, welchen Fehler wir gemacht haben: *Syntax Error: invalid syntax*. Die Verwendung von 'x' als Multiplikationszeichen ist in Python ein Syntaxfehler. Stattdessen nutzen wir das Sternchen (*) für die Multiplikation. Der Fehler zeigt deutlich, was zu beheben ist. + +Der Prozess des Identifizierens und Entfernens von Fehlern aus einem Programm wird *Debugging* genannt. Lass uns debuggen, indem wir das * anstelle von x einsetzen. + +![Syntaxfehler beheben](../images/fixing_syntax_error.png) + +Der Fehler wurde behoben, der Code lief und wir erhielten das erwartete Ergebnis. Als Programmierer wirst du täglich mit solchen Fehlern konfrontiert. Es ist wichtig zu wissen, wie man debuggt. Um gut im Debugging zu sein, solltest du die verschiedenen Fehlertypen verstehen (z.B. *SyntaxError*, *IndexError*, *NameError*, *KeyError*, etc.). Wir werden später mehr dazu lernen. + +Üben wir weiter in der Shell: + +![Mathe in der Shell](../images/maths_on_python_shell.png) + +Bevor wir weitermachen, hier die wichtigsten mathematischen Operationen in Python: +- 2 + 3 = 5 (Addition) +- 3 - 2 = 1 (Subtraktion) +- 3 * 2 = 6 (Multiplikation) +- 3 / 2 = 1.5 (Division) +- 3 ** 2 = 9 (Potenzierung: 3 hoch 2) +- 3 % 2 = 1 (Modulo: Rest der Division) +- 3 // 2 = 1 (Ganzzahl-Division: Rest wird verworfen) + +### Kommentare +Ein *Kommentar* wird nicht von Python ausgeführt. Er macht den Code lesbarer. In Python beginnen Kommentare mit einer Raute (#). + +```python + # Ein Kommentar beginnt mit einer Raute + # Dies ist ein Python-Kommentar +``` + +### Installation von Visual Studio Code + +Die interaktive Shell ist gut für kleine Tests, aber nicht für große Projekte. Wir verwenden Visual Studio Code (VS Code), einen sehr beliebten Open-Source-Texteditor. [Lade VS Code hier herunter](https://code.visualstudio.com/). + +[![Visual Studio Code](../images/vscode.png)](https://code.visualstudio.com/) + +#### Verwendung von Visual Studio Code +Erstelle einen Ordner namens `30DaysOfPython` auf deinem Desktop und öffne ihn in VS Code. Erstelle darin eine Datei namens `helloworld.py`. + +![Erstellen einer Python-Datei](../images/helloworld.png) + +Um die Datei auszuführen, klicke auf den grünen "Run"-Button oder gib `python helloworld.py` im Terminal ein. + +## Grundlagen Python + +### Datentypen (Kurzübersicht) + +#### Zahlen (Number) +- Integer: Ganze Zahlen (... -2, -1, 0, 1, 2 ...) +- Float: Dezimalzahlen (... -1.0, 0.0, 1.1 ...) +- Complex: Komplexe Zahlen (1 + j) + +#### Zeichenketten (String) +Text in einfachen (') oder doppelten (") Anführungszeichen. +`'Python ist toll'` + +#### Booleans +Wahrheitswerte: `True` oder `False`. + +#### Listen (List) +Geordnete Sammlung: `[1, 2, 3, 'Banane']` + +#### Dictionaries +Schlüssel-Wert-Paare: `{'name': 'Asabeneh', 'land': 'Finnland'}` + +#### Tupel (Tuple) +Wie Listen, aber nach Erstellung nicht mehr veränderbar: `(1, 2, 3)` + +#### Mengen (Set) +Ungeordnete Sammlung eindeutiger Werte: `{1, 2, 3}` + +--- + +## 💻 Übungen - Tag 1 + +### Übung: Level 1 +1. Prüfe deine Python-Version. +2. Führe in der Shell Operationen mit 3 und 4 durch (+, -, *, %, /, **, //). +3. Schreibe deinen Namen, dein Land und "Ich genieße 30 Tage Python" als Strings in der Shell. +4. Prüfe die Datentypen von: 10, 9.8, 3.14, 4-4j, ['Asabeneh', 'Python', 'Finnland'], deinem Namen und deinem Land. + +### Übung: Level 2 +Erstelle einen Ordner `tag_1` und eine Datei `helloworld.py`. Wiederhole die Aufgaben von Level 1 dort mit der `print()` Funktion. + +### Übung: Level 3 +1. Schreibe ein Beispiel für jeden Datentyp (Integer, Float, Complex, String, Boolean, List, Tuple, Set, Dictionary). +2. Berechne den [Euklidischen Abstand](https://de.wikipedia.org/wiki/Euklidischer_Abstand) zwischen (2, 3) und (10, 8). + +🎉 HERZLICHEN GLÜCKWUNSCH! 🎉 + +[Tag 2 >>](./02_variables_builtin_functions_de.md) From 671bfb3660a87224f46488b4df92019caace1a9d Mon Sep 17 00:00:00 2001 From: KatCat2 <166694207+KatCat2@users.noreply.github.com> Date: Sat, 28 Mar 2026 10:54:33 +0100 Subject: [PATCH 3/3] Delete German/test.md --- German/test.md | 1 - 1 file changed, 1 deletion(-) delete mode 100644 German/test.md diff --git a/German/test.md b/German/test.md deleted file mode 100644 index 8b1378917..000000000 --- a/German/test.md +++ /dev/null @@ -1 +0,0 @@ -