Compare commits
4 Commits
c102ea465e
...
fb0fed2247
| Author | SHA1 | Date |
|---|---|---|
 Christopher Arndt
|
fb0fed2247 | |
|
Christopher Arndt
|
d59ec6069b | |
|
Christopher Arndt
|
2fec50720d | |
|
Christopher Arndt
|
bbfee09be4 |
|
|
@ -0,0 +1,154 @@
|
|||
# Programmieren mit Python: Kursgliederung
|
||||
|
||||
|
||||
## Tag 1 (Montag) Vormittag (9:00 - 12:30 Uhr)
|
||||
|
||||
### Vorstellung & Organisatorisches (15-20 min)
|
||||
|
||||
* Vorstellung SoftEd, Trainer, Seminarbegleitung
|
||||
* Ausblick auf die Seminarinhalte
|
||||
* Vorstellungsrunde Teilnehmer, Präsens und Online
|
||||
* Ablauf, Pausen, Mittagessen etc.
|
||||
|
||||
### Einführung in die Programmiersprache Python (45-60 min)
|
||||
|
||||
* Einführung in die Arbeitsumgebung für den Kurs
|
||||
* Verwendung des Interpreters (Interactive Modus)
|
||||
* Aufruf
|
||||
* Interaktives Testen von Code
|
||||
* Python als Taschenrechner
|
||||
* Erweiterte interaktive Umgebungen (IPython, Jupyter)
|
||||
* Genereller Aufbau eines Programms
|
||||
* Hallo, Welt!
|
||||
* Ein kurzes, aber komplettes Kommandozeilenprogramm
|
||||
* Syntaxelemente von Python (Ausdrücke, Anweisungen, Operatoren, Trennzeichen, Einrückung usw.)
|
||||
* Grundlegende Datentypen und Operationen
|
||||
* Integer und mathematische Operatoren
|
||||
* Fließkommazahlen (Floats)
|
||||
* Strings
|
||||
* Kontrollstrukturen und Vergleichsoperatoren
|
||||
* Branching (Verzweigung): `if` / `elif` / `else` und `match`
|
||||
* Loops (Schleifen): `for` und `while`
|
||||
* Funktionen: `def` und `return`
|
||||
|
||||
### Warum Python? (15 min)
|
||||
|
||||
#### Was macht Python besonders und unterscheidet es von anderen Programmiersprachen?
|
||||
|
||||
#### Anwendungsbereiche von Python
|
||||
|
||||
* als "Skriptsprache"
|
||||
* für Desktop- und Webanwendungen
|
||||
* für Scientific Computing und Data Science
|
||||
* für Machine Learning
|
||||
* als Bindeglied zwischen Komponenten und Bibliotheken in anderen Sprachen
|
||||
* Für Embedded Programming (MicroPython)
|
||||
|
||||
## Kaffee/Teepause (20 min)
|
||||
|
||||
### Erweiterte Grundlagen in Python
|
||||
|
||||
#### Erweiterte Datentypen: Container (45 min)
|
||||
|
||||
* Listen
|
||||
* Tupel
|
||||
* Dictionary
|
||||
* Sets
|
||||
|
||||
**Übungsaufgaben**
|
||||
|
||||
|
||||
#### String-Operation und String-Formatierung und Ausgabe (45 min)
|
||||
|
||||
* Escape-Sequenzen, Single-, Double- und Triple-Quotes und Klammerung
|
||||
* Stringvergleiche und Testen auf Substrings
|
||||
* Strings zusammenfügen, auftrennen und slicen
|
||||
* Uppercase, Lowercase, Capitalization, Stripping, usw.
|
||||
* String-Formatierung und Formatstrings
|
||||
|
||||
**Übungsaufgaben**
|
||||
|
||||
|
||||
## Mittagspause (12:30 - 13:30 Uhr)
|
||||
|
||||
## Tag 1 (Montag) Nachmittag (13:30 Uhr - 17:00 Uhr)
|
||||
|
||||
### Zugriff auf Dateisystem (Teil 1) (20 min)
|
||||
|
||||
* Öffnen und Lesen von Dateien
|
||||
* Ganzen Dateiinhalt einlesen
|
||||
* Textdateien zeilenweise einlesen
|
||||
* Textzeilen in Datenfelder zerlegen
|
||||
|
||||
### Fehlerbehandlung in Python (45-60 min)
|
||||
|
||||
* Was sind Exceptions?
|
||||
* Abfangen von Fehlern
|
||||
* Eigene Fehler erzeugen
|
||||
* Eigene Exceptions definieren und benutzen
|
||||
|
||||
**Übungsaufgaben**
|
||||
|
||||
### Objektorientierung in Python (45-60 min)
|
||||
|
||||
* Allgemeiner Einblick in die Objektstruktur in Python
|
||||
* Definieren von Klassen
|
||||
* Erzeugen von Objekten
|
||||
* Vererbung
|
||||
* Spezialmethoden von Objekten ("Dunder methods")
|
||||
|
||||
### Kaffee-/Teepause (20 min)
|
||||
|
||||
**Übungsaufgaben**
|
||||
|
||||
### Tipps und Tricks im täglichen Umgang mit Python (10-20 min)
|
||||
|
||||
### Zusammenfassung, Fragen, Lösungen usw.
|
||||
|
||||
|
||||
## Tag 2 (Dienstag) Vormittag (9:00 - 12:30 Uhr)
|
||||
|
||||
### Rekapitulierung der Inhalte vom Vortag und Fragen (20-30 min)
|
||||
|
||||
### Module in Python (45-60 min)
|
||||
|
||||
* Importieren, verwenden von Modulen
|
||||
* Allgemeiner Umgang mit dem Packet Manager PIP
|
||||
* Eigene Module definieren
|
||||
* Module und Pakete (`Packages')
|
||||
* Der Standardmodulsuchpfad (`sys.path`)
|
||||
* Relative Importe
|
||||
|
||||
## Kaffee-/Teepause (20 min)
|
||||
|
||||
### Zugriff auf das Dateisystem (Teil 2)
|
||||
|
||||
* Öffnen, Lesen und Schreiben von Dateien
|
||||
* Text- und Binärdaten
|
||||
* Text-Encodings
|
||||
* Lesen und Schreiben von Daten im JSON Format
|
||||
* Fehlerbehandlung und Context Manager (`with`-Statement)
|
||||
* Dateiordner auflisten und durchsuchen
|
||||
|
||||
**Übungsaufgaben**
|
||||
|
||||
### Datenbankzugriff mit Sqlite3
|
||||
|
||||
**Übungsaufgaben**
|
||||
|
||||
|
||||
## Mittagspause (12:30 - 13:30 Uhr)
|
||||
|
||||
|
||||
## Tag 2 (Dienstag) Nachmittag (13:30 Uhr - 17:00 Uhr)
|
||||
|
||||
### Entwicklung eines HTML-Crawlers (60-90 min)
|
||||
|
||||
## Kaffee-/Teepause (20 min)
|
||||
|
||||
### Zusammenfassung, Fragen, Lösungen usw. (30 min)
|
||||
|
||||
### Best Practices (30 min)
|
||||
|
||||
* Code Style
|
||||
* Verwendung von Dekoratoren (falls Zeit)
|
||||
Binary file not shown.
|
|
@ -0,0 +1,53 @@
|
|||
# Programmieren mit Python: Seminarinhalt
|
||||
|
||||
## Einführung in die Programmiersprache Python
|
||||
|
||||
* Verwendung des Interpreters (Interactive Modus)
|
||||
* Genereller Aufbau eines Programms
|
||||
* Grundlegende Datentypen und Operationen
|
||||
* Kontrollstrukturen
|
||||
|
||||
## Erweiterte Grundlagen in Python
|
||||
|
||||
* Erweiterte Datentypen: Listen, Tupel, Dictionary, Set
|
||||
* String Formatierung
|
||||
|
||||
## Funktionen in Python
|
||||
|
||||
* Definition und Aufruf von Funktionen
|
||||
* Generatoren
|
||||
* Rekursion
|
||||
|
||||
## Objektorientierung in Python
|
||||
|
||||
* Allgemeiner Einblick in die Objektstruktur in Python
|
||||
* Definieren von Klassen
|
||||
* Erzeugen von Objekten
|
||||
* Vererbung
|
||||
|
||||
## Fehlerbehandlung in Python
|
||||
|
||||
* Abfangen von Fehlern
|
||||
* Eigene Fehler erzeugen
|
||||
|
||||
## Module in Python
|
||||
|
||||
* Importieren, Verwenden von Modulen
|
||||
* Allgemeiner Umgang mit dem Packet Manager PIP
|
||||
|
||||
## Zugriff auf das Dateisystem
|
||||
|
||||
* Lesen und Schreiben von Daten im JSON Format
|
||||
|
||||
## Datenbankzugriff mit Sqlite3
|
||||
|
||||
## Entwicklung eines HTML-Crawlers
|
||||
|
||||
## Best Practices
|
||||
|
||||
* Code Style
|
||||
* Verwendung von Dekoratoren
|
||||
|
||||
|
||||
|
||||
|
||||
Binary file not shown.
|
|
@ -0,0 +1,8 @@
|
|||
#!/bin/bash
|
||||
|
||||
for md in *.md; do
|
||||
if [[ "$md" = "README.md" ]]; then
|
||||
continue
|
||||
fi
|
||||
pandoc --from=gfm --to=pdf -o "${md%.*}.pdf" "$md"
|
||||
done
|
||||
|
|
@ -0,0 +1,420 @@
|
|||
{
|
||||
"cells": [
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"# Grundlegende Datentypen und Operationen"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"## Numerische Typen"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 3,
|
||||
"metadata": {},
|
||||
"outputs": [
|
||||
{
|
||||
"name": "stdout",
|
||||
"output_type": "stream",
|
||||
"text": [
|
||||
"42\n",
|
||||
"23\n",
|
||||
"65\n"
|
||||
]
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"# Ganzzahlen (Integers)\n",
|
||||
"\n",
|
||||
"a = 42\n",
|
||||
"b = 23\n",
|
||||
"print(a)\n",
|
||||
"print(b)\n",
|
||||
"print(a + b)"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 4,
|
||||
"metadata": {},
|
||||
"outputs": [
|
||||
{
|
||||
"name": "stdout",
|
||||
"output_type": "stream",
|
||||
"text": [
|
||||
"3.14159\n",
|
||||
"2.71828\n",
|
||||
"8.539721265199999\n"
|
||||
]
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"# Fließkommazahlen (Floats)\n",
|
||||
"\n",
|
||||
"pi = 3.14159\n",
|
||||
"e = 2.71828\n",
|
||||
"print(pi)\n",
|
||||
"print(type(pi))\n",
|
||||
"print(e)\n",
|
||||
"print(pi * e)"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 1,
|
||||
"metadata": {},
|
||||
"outputs": [
|
||||
{
|
||||
"name": "stdout",
|
||||
"output_type": "stream",
|
||||
"text": [
|
||||
"3 1.5 4.5\n",
|
||||
"<class 'float'>\n",
|
||||
"0.16666666666666666\n"
|
||||
]
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"# Implizite Umwandlung von numerischen Typen\n",
|
||||
"\n",
|
||||
"i = 3\n",
|
||||
"f = 1.5\n",
|
||||
"summe = a + f\n",
|
||||
"print(i, f, summe)\n",
|
||||
"print(type(e))\n",
|
||||
"z = 1\n",
|
||||
"n = 6\n",
|
||||
"print(z / n)"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 3,
|
||||
"metadata": {},
|
||||
"outputs": [
|
||||
{
|
||||
"name": "stdout",
|
||||
"output_type": "stream",
|
||||
"text": [
|
||||
"2\n",
|
||||
"999\n",
|
||||
"144\n",
|
||||
"8.0\n",
|
||||
"3.8\n",
|
||||
"1.0\n",
|
||||
"23.799999999999997\n",
|
||||
"0.3333333333333333\n"
|
||||
]
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"# Grundrechenarten\n",
|
||||
"\n",
|
||||
"# Integer\n",
|
||||
"print(1 + 1)\n",
|
||||
"print(1_000 - 1)\n",
|
||||
"print(12 * 12) # Vorsicht: Asterisk (\"Sternchen\"), nicht x)\n",
|
||||
"print(64 / 8)\n",
|
||||
"\n",
|
||||
"# Floats\n",
|
||||
"print(0.5 + 3.3)\n",
|
||||
"print(1.99 - 0.99)\n",
|
||||
"print(20.0 * 1.19)\n",
|
||||
"print(1.0 / 3.0)"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 6,
|
||||
"metadata": {},
|
||||
"outputs": [
|
||||
{
|
||||
"name": "stdout",
|
||||
"output_type": "stream",
|
||||
"text": [
|
||||
"64\n",
|
||||
"512\n",
|
||||
"512\n",
|
||||
"11585.237502960395\n"
|
||||
]
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"# X hoch Y\n",
|
||||
"\n",
|
||||
"x = 8\n",
|
||||
"x2 = x ** 2\n",
|
||||
"print(x2)\n",
|
||||
"print(x ** 3)\n",
|
||||
"print(pow(x, 3))\n",
|
||||
"\n",
|
||||
"print(x ** e)\n",
|
||||
"print(pow(x, e)) # pow akzeptiert integer und floats"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 9,
|
||||
"metadata": {},
|
||||
"outputs": [
|
||||
{
|
||||
"name": "stdout",
|
||||
"output_type": "stream",
|
||||
"text": [
|
||||
"1\n",
|
||||
"<class 'int'>\n"
|
||||
]
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"# Modulo\n",
|
||||
"\n",
|
||||
"x = 10\n",
|
||||
"y = 3\n",
|
||||
"rest = x % 3\n",
|
||||
"print(rest)\n",
|
||||
"print(type(rest))"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"# Strings"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 18,
|
||||
"metadata": {},
|
||||
"outputs": [
|
||||
{
|
||||
"name": "stdout",
|
||||
"output_type": "stream",
|
||||
"text": [
|
||||
"Dies ist ein String!\n",
|
||||
"Man kann einfache oder doppelte Anführungszeichen verwenden.\n",
|
||||
"Innerhalb der Anführungszeichen kann man den jeweils \"anderen Typ\" verwenden\n",
|
||||
"Oder 'andersherum'.\n",
|
||||
"Alternativ kann man eine Backslash als \"Escape\"-Zeichen verwenden\n",
|
||||
"String-Literale, die direkt hintereinander, durch Leerzeichen getrennt, stehenwerden zusammengefügt.\n",
|
||||
"Mit Klammerung klapt das auch über mehrere Zeilen hinweg\n"
|
||||
]
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"s = \"Dies ist ein String!\"\n",
|
||||
"print(s)\n",
|
||||
"s2 = 'Man kann einfache oder doppelte Anführungszeichen verwenden.'\n",
|
||||
"print(s2)\n",
|
||||
"s3a = 'Innerhalb der Anführungszeichen kann man den jeweils \"anderen Typ\" verwenden'\n",
|
||||
"print(s3a)\n",
|
||||
"s3b = \"Oder 'andersherum'.\"\n",
|
||||
"print(s3b)\n",
|
||||
"s4 = \"Alternativ kann man eine Backslash als \\\"Escape\\\"-Zeichen verwenden\"\n",
|
||||
"print(s4)\n",
|
||||
"s5 = \"String-Literale\" \", die direkt hintereinander\" \", durch Leerzeichen getrennt, stehen\" \"werden zusammengefügt.\"\n",
|
||||
"print(s5)\n",
|
||||
"s6 = (\"Mit Klammerung klappt das auch \"\n",
|
||||
" \"über mehrere Zeilen \"\n",
|
||||
" \"hinweg\")\n",
|
||||
"print(s6)"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 11,
|
||||
"metadata": {},
|
||||
"outputs": [
|
||||
{
|
||||
"name": "stdout",
|
||||
"output_type": "stream",
|
||||
"text": [
|
||||
"Dies ist ein langer String (\"triple quoted string\").\n",
|
||||
"Er kann Zeilenumbrüche enthalten.\n",
|
||||
"\n",
|
||||
"Und Leerzeilen.\n",
|
||||
"\n",
|
||||
"Und auch 'einfache' oder \"doppelte\" Anführungszeichen.\n",
|
||||
"\n",
|
||||
"Er endet mit drei weiteren Anführungszeichen des gleichen Typs.\n",
|
||||
"\n",
|
||||
"'Dies ist ein langer String (\"triple quoted string\").\\nEr kann Zeilenumbrüche enthalten.\\n\\nUnd Leerzeilen.\\n\\nUnd auch \\'einfache\\' oder \"doppelte\" Anführungszeichen.\\n\\nEr endet mit drei weiteren Anführungszeichen des gleichen Typs.\\n'\n"
|
||||
]
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"# Längere Strings\n",
|
||||
"\n",
|
||||
"long_string = \"\"\"Dies ist ein langer String (\"triple quoted string\").\n",
|
||||
"Er kann Zeilenumbrüche enthalten.\n",
|
||||
"\n",
|
||||
"Und Leerzeilen.\n",
|
||||
"\n",
|
||||
"Und auch 'einfache' oder \"doppelte\" Anführungszeichen.\n",
|
||||
"\n",
|
||||
"Er endet mit drei weiteren Anführungszeichen des gleichen Typs.\n",
|
||||
"\"\"\"\n",
|
||||
"print(long_string)\n",
|
||||
"print(repr(long_string))"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 15,
|
||||
"metadata": {},
|
||||
"outputs": [
|
||||
{
|
||||
"name": "stdout",
|
||||
"output_type": "stream",
|
||||
"text": [
|
||||
"Erste Zeile\n",
|
||||
"Zweite Zeile\n",
|
||||
"Eine Zeile\n",
|
||||
"Noch eine Zeile\n",
|
||||
"Eins\tZwei\tDrei\n",
|
||||
"1\t2\t3\n",
|
||||
"'Dieser String enthält ein\\x00Null-Zeichen'\n",
|
||||
"Hexadezimal-Codes können wir druckbare (e.g. '@') und nicht druckbare Zeichen (e.g. ) verwendet werden.\n",
|
||||
"❤\n"
|
||||
]
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"# Escape Sequenzen\n",
|
||||
"\n",
|
||||
"# Zeilenumbrüche und Tabs\n",
|
||||
"print(\"Erste Zeile\\r\\nZweite Zeile\") # Zeilenumbruch nach Windows-Art \n",
|
||||
"print(\"Eine Zeile\\nNoch eine Zeile\") # Rest der Welt ;-)\n",
|
||||
"print(\"Eins\\tZwei\\tDrei\")\n",
|
||||
"print(\"1\\t2\\t3\")\n",
|
||||
"\n",
|
||||
"# Null und Hexadezimal- und Unicode-Sequenzen\n",
|
||||
"print(repr(\"Dieser String enthält ein\\0Null-Zeichen\"))\n",
|
||||
"print(\"Hexadezimal-Codes können wir druckbare (e.g. '\\x40') und nicht druckbare Zeichen (e.g. \\x7F) verwendet werden.\")\n",
|
||||
"print('\\u2764') # Unicode"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 19,
|
||||
"metadata": {},
|
||||
"outputs": [
|
||||
{
|
||||
"name": "stdout",
|
||||
"output_type": "stream",
|
||||
"text": [
|
||||
"Dies ist der erste String.Und dies der zweite.\n",
|
||||
"Ich habe es dir schon dreimal gesagt!Ich habe es dir schon dreimal gesagt!Ich habe es dir schon dreimal gesagt!\n"
|
||||
]
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"# String-Operationen\n",
|
||||
"\n",
|
||||
"s1 = \"Dies ist der erste String.\"\n",
|
||||
"s2 = \"Und dies der zweite.\"\n",
|
||||
"s3 = s1 + s2\n",
|
||||
"print(s3)\n",
|
||||
"s4 = \"Ich habe es dir schon dreimal gesagt! \"\n",
|
||||
"print(s4 * 3)"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 21,
|
||||
"metadata": {},
|
||||
"outputs": [
|
||||
{
|
||||
"name": "stdout",
|
||||
"output_type": "stream",
|
||||
"text": [
|
||||
"SCHREI NICHT SO LAUT!\n",
|
||||
"True\n",
|
||||
"True\n",
|
||||
"True\n"
|
||||
]
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"klein = \"schrei nicht so laut!\"\n",
|
||||
"print(klein.upper())\n",
|
||||
"print(\"hallo\" == \"HALLO\".lower())\n",
|
||||
"print(\"hallo\" == \"Hallo\".lower())\n",
|
||||
"print(\"straße\".upper() == \"STRASSE\")\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 23,
|
||||
"metadata": {},
|
||||
"outputs": [
|
||||
{
|
||||
"name": "stdout",
|
||||
"output_type": "stream",
|
||||
"text": [
|
||||
"Hallo\n",
|
||||
"a\n",
|
||||
"Hello\n"
|
||||
]
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"hallo = \"Hallo\"\n",
|
||||
"print(hallo)\n",
|
||||
"print(hallo[1])\n",
|
||||
"print(hallo[0] + 'e' + hallo[2:])"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 24,
|
||||
"metadata": {},
|
||||
"outputs": [
|
||||
{
|
||||
"ename": "TypeError",
|
||||
"evalue": "'str' object does not support item assignment",
|
||||
"output_type": "error",
|
||||
"traceback": [
|
||||
"\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
|
||||
"\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)",
|
||||
"\u001b[1;32m/home/chris/work/python-kurs-softed/notebooks/basictypes.ipynb Cell 16\u001b[0m line \u001b[0;36m3\n\u001b[1;32m <a href='vscode-notebook-cell:/home/chris/work/python-kurs-softed/notebooks/basictypes.ipynb#X23sZmlsZQ%3D%3D?line=0'>1</a>\u001b[0m \u001b[39m# Aber das geht nicht:\u001b[39;00m\n\u001b[0;32m----> <a href='vscode-notebook-cell:/home/chris/work/python-kurs-softed/notebooks/basictypes.ipynb#X23sZmlsZQ%3D%3D?line=2'>3</a>\u001b[0m hallo[\u001b[39m1\u001b[39;49m] \u001b[39m=\u001b[39m \u001b[39m'\u001b[39m\u001b[39me\u001b[39m\u001b[39m'\u001b[39m\n",
|
||||
"\u001b[0;31mTypeError\u001b[0m: 'str' object does not support item assignment"
|
||||
]
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"# Aber das geht nicht!:\n",
|
||||
"\n",
|
||||
"hallo[1] = 'e'"
|
||||
]
|
||||
}
|
||||
],
|
||||
"metadata": {
|
||||
"kernelspec": {
|
||||
"display_name": "softed",
|
||||
"language": "python",
|
||||
"name": "softed"
|
||||
},
|
||||
"language_info": {
|
||||
"codemirror_mode": {
|
||||
"name": "ipython",
|
||||
"version": 3
|
||||
},
|
||||
"file_extension": ".py",
|
||||
"mimetype": "text/x-python",
|
||||
"name": "python",
|
||||
"nbconvert_exporter": "python",
|
||||
"pygments_lexer": "ipython3",
|
||||
"version": "3.11.8"
|
||||
}
|
||||
},
|
||||
"nbformat": 4,
|
||||
"nbformat_minor": 2
|
||||
}
|
||||
|
|
@ -0,0 +1,121 @@
|
|||
{
|
||||
"cells": [
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"# Erweiterte Datentypen: Container"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"# Listen und Tupel"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 4,
|
||||
"metadata": {},
|
||||
"outputs": [
|
||||
{
|
||||
"name": "stdout",
|
||||
"output_type": "stream",
|
||||
"text": [
|
||||
"[5, 10, 20, 30, 50]\n",
|
||||
"[0.5, 0.6, 0.8, 1.0, 1.2]\n",
|
||||
"['Joe', 'Alice', 'Bob', 'Charly']\n",
|
||||
"[1, 'Joe', 1.4, 'Alice', 100]\n",
|
||||
"['one'] [] []\n"
|
||||
]
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"# Listenliterale\n",
|
||||
"\n",
|
||||
"values = [5, 10, 20, 30, 50]\n",
|
||||
"print(values)\n",
|
||||
"fractions = [0.5, 0.6, 0.8, 1.0, 1.2]\n",
|
||||
"print(fractions)\n",
|
||||
"names = [\"Joe\", \"Alice\", \"Bob\", \"Charly\"]\n",
|
||||
"print(names)\n",
|
||||
"heap = [1, \"Joe\", 1.4, \"Alice\", 100]\n",
|
||||
"print(heap)\n",
|
||||
"single = [\"one\"]\n",
|
||||
"leer = []\n",
|
||||
"auch_leer = list()\n",
|
||||
"print(single, leer, auch_leer)"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 8,
|
||||
"metadata": {},
|
||||
"outputs": [
|
||||
{
|
||||
"name": "stdout",
|
||||
"output_type": "stream",
|
||||
"text": [
|
||||
"(5, 10, 20, 30, 50)\n",
|
||||
"(0.5, 0.6, 0.8, 1.0, 1.2)\n",
|
||||
"('Joe', 'Alice', 'Bob', 'Charly')\n",
|
||||
"(1, 'Joe', 1.4, 'Alice', 100)\n",
|
||||
"('one',) ('one',) ()\n"
|
||||
]
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"# Tuplelliterale\n",
|
||||
"values = (5, 10, 20, 30, 50)\n",
|
||||
"print(values)\n",
|
||||
"fractions = (0.5, 0.6, 0.8, 1.0, 1.2)\n",
|
||||
"print(fractions)\n",
|
||||
"names = (\"Joe\", \"Alice\", \"Bob\", \"Charly\")\n",
|
||||
"print(names)\n",
|
||||
"heap = (1, \"Joe\", 1.4, \"Alice\", 100)\n",
|
||||
"print(heap)\n",
|
||||
"t_single = (\"one\",)\n",
|
||||
"t_auch_single = \"one\",\n",
|
||||
"t_leer = ()\n",
|
||||
"print(t_single, t_auch_single, t_leer)\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"# Umwandlung\n",
|
||||
"\n",
|
||||
"l = [1, 2, 3, 4, 5]\n",
|
||||
"t= tuple(t)\n",
|
||||
"print(l, t)\n",
|
||||
"l = [10, 20, 30, 40, 50]\n",
|
||||
"print(l, t)\n"
|
||||
]
|
||||
}
|
||||
],
|
||||
"metadata": {
|
||||
"kernelspec": {
|
||||
"display_name": "softed",
|
||||
"language": "python",
|
||||
"name": "softed"
|
||||
},
|
||||
"language_info": {
|
||||
"codemirror_mode": {
|
||||
"name": "ipython",
|
||||
"version": 3
|
||||
},
|
||||
"file_extension": ".py",
|
||||
"mimetype": "text/x-python",
|
||||
"name": "python",
|
||||
"nbconvert_exporter": "python",
|
||||
"pygments_lexer": "ipython3",
|
||||
"version": "3.11.8"
|
||||
}
|
||||
},
|
||||
"nbformat": 4,
|
||||
"nbformat_minor": 2
|
||||
}
|
||||
|
|
@ -0,0 +1,585 @@
|
|||
{
|
||||
"cells": [
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"# Kontrollstrukturen und Vergleichsoperatoren"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"## Verzweigung (Branching)"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 4,
|
||||
"metadata": {},
|
||||
"outputs": [
|
||||
{
|
||||
"name": "stdout",
|
||||
"output_type": "stream",
|
||||
"text": [
|
||||
"Hmm, ob das so stimmt?\n"
|
||||
]
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"# if / else / elif\n",
|
||||
"\n",
|
||||
"alter = -1\n",
|
||||
"\n",
|
||||
"if alter >= 16:\n",
|
||||
" print(\"Nicht vergessen: am 9.6.2024 ist Europa-Wahl!\")\n",
|
||||
"elif alter > 0:\n",
|
||||
" print(\"Schön, dass du geboren bist!\")\n",
|
||||
"else:\n",
|
||||
" print(\"Hmm, ob das so stimmt?\")"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 7,
|
||||
"metadata": {},
|
||||
"outputs": [
|
||||
{
|
||||
"name": "stdout",
|
||||
"output_type": "stream",
|
||||
"text": [
|
||||
"Nach Süden, nach Süden!\n"
|
||||
]
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"richtung = \"s\"\n",
|
||||
"\n",
|
||||
"if richtung == \"n\":\n",
|
||||
" print(\"Auf in den hohen Norden!\")\n",
|
||||
"elif richtung == \"s\":\n",
|
||||
" print(\"Nach Süden, nach Süden!\")\n",
|
||||
"elif richtung == \"w\":\n",
|
||||
" print(\"Go west!\")\n",
|
||||
"elif richtung == \"o\":\n",
|
||||
" print(\"Bin schon da.\")\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 15,
|
||||
"metadata": {},
|
||||
"outputs": [
|
||||
{
|
||||
"name": "stdout",
|
||||
"output_type": "stream",
|
||||
"text": [
|
||||
"Auf in den hohen Norden!\n"
|
||||
]
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"# match\n",
|
||||
"\n",
|
||||
"# richtung = input(\"Wo soll's denn lang gehen? \")\n",
|
||||
"richtung = \"n\"\n",
|
||||
"\n",
|
||||
"match richtung:\n",
|
||||
" case \"n\" | \"norden\":\n",
|
||||
" print(\"Auf in den hohen Norden!\")\n",
|
||||
" case \"s\" | \"süden\":\n",
|
||||
" print(\"Nach Süden, nach Süden!\")\n",
|
||||
" case \"w\" | \"westen\":\n",
|
||||
" print(\"Go west!\")\n",
|
||||
" case \"o\" | \"osten\":\n",
|
||||
" print(\"Bin schon da.\")\n",
|
||||
" case _:\n",
|
||||
" print(\"Das Glück liegt manchmal abseits des direkten Wegs!\")"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"## Schleifen"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 16,
|
||||
"metadata": {},
|
||||
"outputs": [
|
||||
{
|
||||
"name": "stdout",
|
||||
"output_type": "stream",
|
||||
"text": [
|
||||
"Schleifendurchlauf Nr. 0\n",
|
||||
"Schleifendurchlauf Nr. 1\n",
|
||||
"Schleifendurchlauf Nr. 2\n",
|
||||
"Schleifendurchlauf Nr. 3\n",
|
||||
"Schleifendurchlauf Nr. 4\n"
|
||||
]
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"# for\n",
|
||||
"\n",
|
||||
"for i in range(5):\n",
|
||||
" print(\"Schleifendurchlauf Nr. \", i)\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 17,
|
||||
"metadata": {},
|
||||
"outputs": [
|
||||
{
|
||||
"name": "stdout",
|
||||
"output_type": "stream",
|
||||
"text": [
|
||||
"Summer der Zahlen 1-10: 55\n"
|
||||
]
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"result = 0\n",
|
||||
"for i in range(1, 11):\n",
|
||||
" result += i\n",
|
||||
"print(\"Summe der Zahlen 1-10:\", result)"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 18,
|
||||
"metadata": {},
|
||||
"outputs": [
|
||||
{
|
||||
"name": "stdout",
|
||||
"output_type": "stream",
|
||||
"text": [
|
||||
"9 passt in die Reihe\n"
|
||||
]
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"for i in (2, 4, 6, 8, 9, 10):\n",
|
||||
" if i % 2:\n",
|
||||
" print(i, \"passt nicht in die Reihe\")"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 1,
|
||||
"metadata": {},
|
||||
"outputs": [
|
||||
{
|
||||
"name": "stdout",
|
||||
"output_type": "stream",
|
||||
"text": [
|
||||
"10 ... 9 ... 8 ... 7 ... 6 ... 5 ... 4 ... 3 ... 2 ... 1 ... Lift off!\n"
|
||||
]
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"# while\n",
|
||||
"\n",
|
||||
"i = 10\n",
|
||||
"while i > 0: # or: while True:\n",
|
||||
" print(i, \"... \", end=\"\")\n",
|
||||
" i -= 1\n",
|
||||
"print(\"Lift off!\")"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 2,
|
||||
"metadata": {},
|
||||
"outputs": [
|
||||
{
|
||||
"name": "stdout",
|
||||
"output_type": "stream",
|
||||
"text": [
|
||||
"10\n",
|
||||
"11\n",
|
||||
"12\n",
|
||||
"14\n",
|
||||
"15\n",
|
||||
"16\n",
|
||||
"17\n",
|
||||
"18\n",
|
||||
"19\n"
|
||||
]
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"# continue\n",
|
||||
"\n",
|
||||
"for i in range(10, 20):\n",
|
||||
" if i == 13:\n",
|
||||
" continue\n",
|
||||
" print(i)"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 3,
|
||||
"metadata": {},
|
||||
"outputs": [
|
||||
{
|
||||
"name": "stdout",
|
||||
"output_type": "stream",
|
||||
"text": [
|
||||
"Iteration: 142\n"
|
||||
]
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"# break\n",
|
||||
"\n",
|
||||
"i = 0\n",
|
||||
"result = 0\n",
|
||||
"maximum = 10_000\n",
|
||||
"\n",
|
||||
"while True:\n",
|
||||
" result += i\n",
|
||||
"\n",
|
||||
" if result >= maximum:\n",
|
||||
" print(\"Iteration: \", i+1)\n",
|
||||
" break\n",
|
||||
"\n",
|
||||
" i += 1\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 10,
|
||||
"metadata": {},
|
||||
"outputs": [
|
||||
{
|
||||
"name": "stdout",
|
||||
"output_type": "stream",
|
||||
"text": [
|
||||
"q ist Buchstabe Nr. 17 des dt. Alphabets.\n"
|
||||
]
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"alphabet = \"abcdefghifklmnopqrstuvwxyz\"\n",
|
||||
"buchstabe = \"q\"\n",
|
||||
"i = 0\n",
|
||||
"for char in alphabet:\n",
|
||||
" i += 1\n",
|
||||
" if char == buchstabe:\n",
|
||||
" print(buchstabe, \"ist Buchstabe Nr.\", i, \"des dt. Alphabets.\")\n",
|
||||
" break\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 11,
|
||||
"metadata": {},
|
||||
"outputs": [
|
||||
{
|
||||
"name": "stdout",
|
||||
"output_type": "stream",
|
||||
"text": [
|
||||
"q ist Buchstabe Nr. 17 des dt. Alphabets.\n"
|
||||
]
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"# einfacher:\n",
|
||||
"\n",
|
||||
"for i, char in enumerate(alphabet):\n",
|
||||
" if char == buchstabe:\n",
|
||||
" print(buchstabe, \"ist Buchstabe Nr.\", i + 1, \"des dt. Alphabets.\")\n",
|
||||
" break"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"# Funktionen"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 14,
|
||||
"metadata": {},
|
||||
"outputs": [
|
||||
{
|
||||
"name": "stdout",
|
||||
"output_type": "stream",
|
||||
"text": [
|
||||
"256 256 100\n"
|
||||
]
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"# Aufruf eingebauter Funktionen\n",
|
||||
"\n",
|
||||
"x = pow(2, 8)\n",
|
||||
"y = max(x, 100)\n",
|
||||
"z = min(max(0, x), 100)\n",
|
||||
"print(x, y, z)"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 15,
|
||||
"metadata": {},
|
||||
"outputs": [
|
||||
{
|
||||
"name": "stdout",
|
||||
"output_type": "stream",
|
||||
"text": [
|
||||
"\n",
|
||||
"\n"
|
||||
]
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"# optionale Parameter\n",
|
||||
"\n",
|
||||
"print()\n",
|
||||
"print(\"\")"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 16,
|
||||
"metadata": {},
|
||||
"outputs": [
|
||||
{
|
||||
"name": "stdout",
|
||||
"output_type": "stream",
|
||||
"text": [
|
||||
"5\n"
|
||||
]
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"# eigene Funktionen\n",
|
||||
"\n",
|
||||
"def add(a, b):\n",
|
||||
" return a + b\n",
|
||||
"\n",
|
||||
"print(add(2, 3))"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 20,
|
||||
"metadata": {},
|
||||
"outputs": [
|
||||
{
|
||||
"name": "stdout",
|
||||
"output_type": "stream",
|
||||
"text": [
|
||||
"15\n",
|
||||
"24\n"
|
||||
]
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"# Keyword arguments\n",
|
||||
"\n",
|
||||
"print(add(a=5, b=10))\n",
|
||||
"print(add(4, b=20))"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 21,
|
||||
"metadata": {},
|
||||
"outputs": [
|
||||
{
|
||||
"ename": "SyntaxError",
|
||||
"evalue": "positional argument follows keyword argument (1525390589.py, line 2)",
|
||||
"output_type": "error",
|
||||
"traceback": [
|
||||
"\u001b[0;36m Cell \u001b[0;32mIn[21], line 2\u001b[0;36m\u001b[0m\n\u001b[0;31m print(add(a=6, 10))\u001b[0m\n\u001b[0m ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m positional argument follows keyword argument\n"
|
||||
]
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"# Das geht nicht:\n",
|
||||
"print(add(a=6, 10))"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"# Vergleichsausdrücke"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 23,
|
||||
"metadata": {},
|
||||
"outputs": [
|
||||
{
|
||||
"name": "stdout",
|
||||
"output_type": "stream",
|
||||
"text": [
|
||||
"False\n",
|
||||
"True\n",
|
||||
"False\n",
|
||||
"True\n",
|
||||
"True\n",
|
||||
"False\n",
|
||||
"True\n",
|
||||
"True\n"
|
||||
]
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"a = 10\n",
|
||||
"b = 50\n",
|
||||
"c = 2\n",
|
||||
"d = 5 * a\n",
|
||||
"\n",
|
||||
"print(a == b)\n",
|
||||
"print(a != d)\n",
|
||||
"print(a > b)\n",
|
||||
"print(a > c)\n",
|
||||
"print(a >= c)\n",
|
||||
"print(c > a)\n",
|
||||
"print(c < b)\n",
|
||||
"print(c >= 2)"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 32,
|
||||
"metadata": {},
|
||||
"outputs": [
|
||||
{
|
||||
"name": "stdout",
|
||||
"output_type": "stream",
|
||||
"text": [
|
||||
"True\n",
|
||||
"True\n",
|
||||
"True\n",
|
||||
"False\n"
|
||||
]
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"# Negation\n",
|
||||
"\n",
|
||||
"print(not c > a)\n",
|
||||
"print(not a == b) # klarer: a != b\n",
|
||||
"print(not b != d) # klarer: b == d\n",
|
||||
"print(not a > c)"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 31,
|
||||
"metadata": {},
|
||||
"outputs": [
|
||||
{
|
||||
"name": "stdout",
|
||||
"output_type": "stream",
|
||||
"text": [
|
||||
"True\n",
|
||||
"True\n",
|
||||
"True\n"
|
||||
]
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"# logische Kombination\n",
|
||||
"\n",
|
||||
"print(b > a and a > c)\n",
|
||||
"print(a > b or a > c)\n",
|
||||
"print(not a < c and b >= d)"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 41,
|
||||
"metadata": {},
|
||||
"outputs": [
|
||||
{
|
||||
"name": "stdout",
|
||||
"output_type": "stream",
|
||||
"text": [
|
||||
"True\n",
|
||||
"True\n",
|
||||
"True\n",
|
||||
"False\n"
|
||||
]
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"# Bool'scher (True/False) Wert von Integers, Floats und Strings \n",
|
||||
"print(a > c)\n",
|
||||
"print(bool(a > c)) ## redundant, da Vergleichsausdrücke immer einen bool'schen Wert haben\n",
|
||||
"# Aber:\n",
|
||||
"print(bool(a))\n",
|
||||
"print(not a) # auch ein bool'scher Ausdruck\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 45,
|
||||
"metadata": {},
|
||||
"outputs": [
|
||||
{
|
||||
"name": "stdout",
|
||||
"output_type": "stream",
|
||||
"text": [
|
||||
"False\n",
|
||||
"True\n",
|
||||
"True\n",
|
||||
"False\n",
|
||||
"True\n",
|
||||
"True\n",
|
||||
"True\n",
|
||||
"True\n",
|
||||
"False\n",
|
||||
"True\n"
|
||||
]
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"print(bool(0))\n",
|
||||
"print(bool(1))\n",
|
||||
"print(bool(-1))\n",
|
||||
"print(bool(0.0))\n",
|
||||
"print(bool(0.1))\n",
|
||||
"print(bool(-0.1))\n",
|
||||
"print(bool(\"True\"))\n",
|
||||
"print(bool(\"False\")) # !!!\n",
|
||||
"print(bool(\"\"))\n",
|
||||
"print(bool(\"\\0\"))\n"
|
||||
]
|
||||
}
|
||||
],
|
||||
"metadata": {
|
||||
"kernelspec": {
|
||||
"display_name": "softed",
|
||||
"language": "python",
|
||||
"name": "softed"
|
||||
},
|
||||
"language_info": {
|
||||
"codemirror_mode": {
|
||||
"name": "ipython",
|
||||
"version": 3
|
||||
},
|
||||
"file_extension": ".py",
|
||||
"mimetype": "text/x-python",
|
||||
"name": "python",
|
||||
"nbconvert_exporter": "python",
|
||||
"pygments_lexer": "ipython3",
|
||||
"version": "3.11.8"
|
||||
}
|
||||
},
|
||||
"nbformat": 4,
|
||||
"nbformat_minor": 2
|
||||
}
|
||||
|
|
@ -0,0 +1,147 @@
|
|||
# Übungen zu Dateine (Teil 1)
|
||||
|
||||
|
||||
## Ausgangslage
|
||||
|
||||
Im Ordner `uebungen` sind folgende Textdateien mit Mitarbeiter- und
|
||||
Planstellendaten vorhanden:
|
||||
|
||||
* `employee_skills.txt`
|
||||
* `job_skills.txt`
|
||||
* `salaries.txt`
|
||||
* `salaries-errors.txt`
|
||||
|
||||
Jede dieser Dateien enthält einen Datensatz pro Zeile. Jede Zeile ist
|
||||
nach folgendem Schema aufgebaut:
|
||||
|
||||
* Name
|
||||
* Doppelpunkt
|
||||
* Whitespace (ein oder mehrere Leerzeichen)
|
||||
* Daten
|
||||
|
||||
Das Format des Datenfelds unterscheidet sich je nach Datei.
|
||||
|
||||
|
||||
Aufgabe 1:
|
||||
|
||||
Öffnen Sie die Datei `employee_skills.txt` zum Lesen und lesen Sie die gesamte
|
||||
Datei in einen String ein.
|
||||
|
||||
Wieviele Bytes ist der Dateihalt lang?
|
||||
|
||||
|
||||
Aufgabe 3:
|
||||
|
||||
Öffnen Sie die Datei `employee_skills.txt` zum Lesen und lesen Sie die Datei
|
||||
zeilenweise ein.
|
||||
|
||||
Wieviele Zeilen mit Daten enhält die Datei? Zeilen, die *nur* Whitespace
|
||||
(Leerzeichen, CR, LF, Tabs, etc.) enthalten, werden nicht gezählt.
|
||||
|
||||
|
||||
Aufgabe 3:
|
||||
|
||||
Öffnen Sie die Datei `employee_skills.txt` zum Lesen und lesen Sie die Datei
|
||||
zeilenweise ein. Parsen Sie den Namen des Mitarbeiters aus jeder Datenzeile und
|
||||
fügen Sie ihn zu einer Liste hinzu.
|
||||
|
||||
Geben Sie die Liste der Namen der Mitarbeiter alphabetisch sortiert, ein Name
|
||||
pro Zeile, aus.
|
||||
|
||||
|
||||
Tipp: verwenden Sie die String-Methode `split()` zum Parsen jeder Zeile.
|
||||
|
||||
|
||||
Aufgabe 4:
|
||||
|
||||
Öffnen Sie die Datei `salaries.txt` zum Lesen und lesen Sie die Datei
|
||||
zeilenweise ein. Parsen Sie den Namen des Mitarbeiters sowie das Gehalt aus
|
||||
jeder Datenzeile und speichern die Daten in einem Dictionary mit dem Namen
|
||||
des Mitarbeiters als Key und dem Gehalt als Wert. Der Gehaltswert sollte
|
||||
jeweils in einen Integerwert umgewandelt werden.
|
||||
|
||||
Geben Sie das höchste, sowie das niedrigste Gehalt aus.
|
||||
|
||||
|
||||
Tipp 1: verwenden Sie die String-Methode `split()` zum Parsen jeder Zeile und
|
||||
die Funktion `int()` zum Umwandeln des Gehaltwerts.
|
||||
|
||||
Tipp 2: verwenden Sie die `min()` und `max()` Funktionen und wenden sie jeweils
|
||||
auf alle Werte des Dictionaries auf einmal an.
|
||||
|
||||
|
||||
Aufgabe 5:
|
||||
|
||||
Öffnen Sie die Datei `employee_skills.txt` zum Lesen und lesen Sie die Datei
|
||||
zeilenweise ein. Parsen Sie den Namen des Mitarbeiters sowie die Liste der
|
||||
Skills aus jeder Datenzeile und speichern die Daten in einem Dictionary mit dem
|
||||
Namen des Mitarbeiters als Key und der Liste der Skills als Wert. Die Liste der
|
||||
Skills für jeden Mitarbeiter sollte jeweils in eine Liste von Strings (ein
|
||||
Element pro Skill) umgewandelt werden.
|
||||
|
||||
Tipp 1: verwenden Sie die String-Methode `split()` zum Parsen jeder Zeile und
|
||||
nochmals zum Parsen der Liste der Skills. Dabei müssen jeweils unterschiedliche
|
||||
Trennzeichen verwendet werden.
|
||||
|
||||
|
||||
Aufgabe 6:
|
||||
|
||||
Kombinieren Sie die Programme aus Aufgabe 4 und 5 und kombinieren Sie die
|
||||
beiden Dictionaries, die Sie aus den Daten erstellt haben.
|
||||
|
||||
Speichern Sie dabei das Gehalt und die Skills jedes Mitarbeiters jeweils
|
||||
zusammen in einem Dictionary mit folgendem Format:
|
||||
|
||||
```py
|
||||
employee_data = {
|
||||
"salary": ..., # integer
|
||||
"skills": [...], # list of strings
|
||||
}
|
||||
```
|
||||
|
||||
Speichern Sie alle Daten in einem Dictionary mit dem Namen des Mitarbeiters
|
||||
als Key und dem `employee_data` Dictionary als Wert. Dadurch ergibt sich
|
||||
folgende geschachtelte Datenstruktur:
|
||||
|
||||
```py
|
||||
employees = {
|
||||
"name 1": {
|
||||
"salary": ...,
|
||||
"skills": [...],
|
||||
},
|
||||
"name 2": {
|
||||
"salary": ...,
|
||||
"skills": [...],
|
||||
},
|
||||
...
|
||||
}
|
||||
```
|
||||
|
||||
|
||||
Aufgabe 7:
|
||||
|
||||
Diese Aufgabe ist ähnlich wie Aufgabe 4, die einzulesende Datei enthält jedoch
|
||||
mehrere Fehler, die Sie abfangen und behandeln müssen.
|
||||
|
||||
Öffnen Sie die Datei `salaries-errors.txt` zum Lesen und lesen Sie die Datei
|
||||
zeilenweise ein. Parsen Sie den Namen des Mitarbeiters sowie das Gehalt aus
|
||||
jeder Datenzeile und speichern die Daten in einem Dictionary mit dem Namen
|
||||
des Mitarbeiters als Key und dem Gehalt als Wert. Der Gehaltswert sollte
|
||||
jeweils in einen Integerwert umgewandelt werden.
|
||||
|
||||
Die Datei enthält folgende Fehler:
|
||||
|
||||
* Manche Zeilen sind auskommentiert (d.h. sie starten mit einem Hash (`#`).
|
||||
dise Zeilen sollen ignoriert werden, d.h. sie werden nicht in den Daten
|
||||
gespeichert.
|
||||
* Bei manchen Zeilen fehlt der trennende Doppelpunkt zwischen dem Namen und
|
||||
dem Gehalt. Fangen Sie diesen Fehler beim Parsen der Zeile ab und
|
||||
ignorieren Sie entweder die Zeile oder versuchen Sie sie erneut mit einer
|
||||
anderen Methode zu parsen.
|
||||
* Bei manchen Mitarbeitern ist das Gehalt mit einem Währungssymbol angegeben.
|
||||
Fangen Sie den Fehler beim Umwandeln des Gehaltwerts in einen Integer ab und
|
||||
ignorieren Sie entweder die Zeile oder entfernen Sie das Währungssymbol vor
|
||||
dem Parsen.
|
||||
|
||||
|
||||
Geben Sie das höchste, sowie das niedrigste Gehalt aus.
|
||||
|
|
@ -0,0 +1,93 @@
|
|||
# Übungen zu Dictionaries
|
||||
|
||||
|
||||
## Ausgangslage
|
||||
|
||||
Sie haben zwei Tabellen mit Personallisten jeweils mit Namen und Monatsgehältern
|
||||
als ein Python-Dictionary. Die Keys sind die Namen der Angestellten (strings),
|
||||
die Werte das jeweilige Monatsgehalt (integer):
|
||||
|
||||
```py
|
||||
salaries_1 = {'Anna': 2000, 'Mark': 3000, 'Judith': 3500, 'Thomas': 2500}
|
||||
salaries_2 = {'Barbara': 3000, 'Elke': 3300, 'Michael': 2800, 'Johann': 2000}
|
||||
```
|
||||
|
||||
|
||||
## Aufgabe 1:
|
||||
|
||||
Schreiben Sie ein Programm, das die beiden Dictionaries in einem neuen
|
||||
Dictionary (`salaries_all`) zusammenführt und die Namen aller Mitarbeiter
|
||||
als Liste ausgibt.
|
||||
|
||||
Tipp: Machen Sie zunächst eine Kopie des ersten Dictionaries (`dict.copy()`)
|
||||
und fügen Sie dann die Einträge des zweiten Dictionaries der Kopie hinzu
|
||||
(`dict.update()`).
|
||||
|
||||
|
||||
## Aufgabe 2:
|
||||
|
||||
Schreiben Sie ein Programm, das den Namen und das Gehalt des Mitarbeiters mit
|
||||
dem höchsten Gehalt aus den gesamten Daten ermittelt und diese ausgibt (mit
|
||||
`print`).
|
||||
|
||||
|
||||
## Aufgabe 3:
|
||||
|
||||
Schreiben Sie ein Programm, das die Gesamtsumme aller monatlichen Gehälter
|
||||
ermittelt und diese ausgibt.
|
||||
|
||||
|
||||
## Aufgabe 4:
|
||||
|
||||
Schreiben Sie ein Programm, das das Gehalt aller Mitarbeiter um 10% erhöht und
|
||||
diese Daten in einem *neuen* Dictionary mit der selben Struktur speichert. Das
|
||||
ursprüngliche Dictionary soll nicht verändert werden.
|
||||
|
||||
|
||||
## Aufgabe 5:
|
||||
|
||||
Lassen Sie das Program dieses neue Dictionary in folgendem Format ausgeben:
|
||||
|
||||
```
|
||||
Name Gehalt
|
||||
--------------
|
||||
Anna ???
|
||||
Mark ???
|
||||
...
|
||||
```
|
||||
|
||||
Tipp: verwenden Sie die Escape-Sequenz für Tabulatoren `\t`.
|
||||
|
||||
|
||||
## Aufgabe 6:
|
||||
|
||||
|
||||
Lassen Sie das Programm die alten Gehälter in der gleichen Form ausgeben,
|
||||
um zu zeigen, dass das ursprüngliche Dictionary nicht verändert wurde.
|
||||
|
||||
|
||||
## Bonusaufgaben:
|
||||
|
||||
1. Sortieren Sie die Liste nach Höhe des Gehalts (absteigend).
|
||||
|
||||
Tipp: verwenden Sie die Funktion `sorted()` zum Sortieren.
|
||||
|
||||
2. Nummerieren Sie die Listeneinträge in der Ausgabe, startend mit 1.
|
||||
|
||||
3. Ermitteln Sie das durchschnittliche Gehalt nach der Erhöhung.
|
||||
|
||||
4. Berechnen Sie, wieviel Prozent des durchschnitlichen Gehalts jeder Mitarbeiter
|
||||
verdient und geben diese Prozentzahl in einer zusätzlichen Spalte aus.
|
||||
|
||||
Tipp: Sie können die Prozentzahlen in einem neuen, zusätzlichen Dictionary
|
||||
speichern oder, anstatt nur dem Gehalt, für jeden Mitarbeiter das Gehalt und
|
||||
die Prozent des Durchschnittsverdienstes als Tuple mit zwei Elementen als
|
||||
Wert im Dictionary ablegen.
|
||||
|
||||
|
||||
## Ressourcen
|
||||
|
||||
Hilfe zu Dictionaries:
|
||||
|
||||
* <https://docs.python.org/3/library/stdtypes.html#mapping-types-dict>
|
||||
* <https://www.data-science-architect.de/dictionaries-python/>
|
||||
|
|
@ -0,0 +1,8 @@
|
|||
Anna: buchhaltung,management,marketing
|
||||
Mark: management,marketing
|
||||
Judith: management,buchhaltung,human resources
|
||||
Thomas: software development,it support
|
||||
Barbara: software development,management
|
||||
Elke: management,buchhaltung,it support
|
||||
Michael: software development,buchhaltung
|
||||
Johann: it support,software development
|
||||
|
|
@ -0,0 +1,5 @@
|
|||
office manager: management,buchhaltung
|
||||
ceo: management,human resources
|
||||
developer: software development
|
||||
cto: software development,system design,human resources
|
||||
support desk: it support
|
||||
|
|
@ -0,0 +1,10 @@
|
|||
Anna: 2000
|
||||
Mark: 3000$
|
||||
# Gekündigt:
|
||||
# Margrit: 4000
|
||||
Judith: 3500€
|
||||
Thomas 2500
|
||||
Barbara: 3000€
|
||||
Elke: 3300
|
||||
Michael: 2800€
|
||||
Johann: 2000
|
||||
|
|
@ -0,0 +1,8 @@
|
|||
Anna: 2000
|
||||
Mark: 3000
|
||||
Judith: 3500
|
||||
Thomas: 2500
|
||||
Barbara: 3000
|
||||
Elke: 3300
|
||||
Michael: 2800
|
||||
Johann: 2000
|
||||
|
|
@ -0,0 +1,83 @@
|
|||
# Übungen zu Sets
|
||||
|
||||
|
||||
## Ausgangslage
|
||||
|
||||
Sie haben eine Liste mit Mitarbeitern und ihren Skills sowie eine Liste
|
||||
von Planstellen im Betrieb mit erforderlichen Skills:
|
||||
|
||||
```py
|
||||
employee_skills = {
|
||||
'Anna': ("buchhaltung", "management", "marketing"),
|
||||
'Mark': ("management", "marketing"),
|
||||
'Judith': ("management", "buchhaltung", "human resources"),
|
||||
'Thomas': ("software development", "it support"),
|
||||
'Barbara': ("software development", "management"),
|
||||
'Elke': ("management", "buchhaltung", "it support"),
|
||||
'Michael': ("software development", "buchhaltung"),
|
||||
'Johann': ("it support", "software development"),
|
||||
}
|
||||
|
||||
job_skills = {
|
||||
"office manager": ("management", "buchhaltung"),
|
||||
"ceo": ("management", "human resources"),
|
||||
"developer": ("software development",),
|
||||
"cto": ("software development", "system design", "human resources"),
|
||||
"support desk": ("it support",),
|
||||
}
|
||||
```
|
||||
|
||||
|
||||
## Aufgabe 1:
|
||||
|
||||
Schreiben Sie ein Programm, das ermittelt, welche Menge an Skills bei den
|
||||
Mitarbeitern insgesamt vorhanden sind. Jeder Skill wird nur einmal
|
||||
berücksichtigt.
|
||||
|
||||
Verwenden Sie zum Speichern ein Set und geben Sie den Inhalt diese Sets aus.
|
||||
Wieviele unterschiedliche Skills sind vorhanden?
|
||||
|
||||
|
||||
## Aufgabe 2:
|
||||
|
||||
Schreiben Sie ein Programm, das ermittelt, welche Menge an Skills benötigt
|
||||
werden, um die Anforderungen für alle Planstellen zu erfüllen.
|
||||
|
||||
Verwenden Sie zum Speichern ein Set und geben Sie den Inhalt diese Sets aus.
|
||||
Wieviele unterschiedliche Skills werden insgesamt benötigt?
|
||||
|
||||
|
||||
## Aufgabe 3:
|
||||
|
||||
Schreiben Sie ein Programm, das die beiden Sets aus Aufgabe 1 und 2 vergleicht
|
||||
und feststellt, welche Skills im Mitabeiterstamm fehlen.
|
||||
|
||||
|
||||
## Aufgabe 3:
|
||||
|
||||
Schreiben Sie ein Programm, das die beiden Sets aus Aufgabe 1 und 2 vergleicht
|
||||
und feststellt, welche vorhandene Skills der Mitarbeiter von keiner Planstelle
|
||||
abgedeckt werden.
|
||||
|
||||
|
||||
## Aufgabe 4:
|
||||
|
||||
Schreiben Sie ein Programm, das für jede Planstelle herausfindet, welche
|
||||
Mitarbeiter die notwendigen Skills für die Stelle besitzen.
|
||||
|
||||
Speichern Sie das Ergebnis in einem Dictionary der Form:
|
||||
|
||||
```py
|
||||
candidates = {
|
||||
"job 1": ("name 1", "name 2", ...),
|
||||
"job 2: ("name 1", "name 3", ...),
|
||||
...
|
||||
}
|
||||
```
|
||||
|
||||
|
||||
## Ressourcen
|
||||
|
||||
Hilfe zu Dictionaries:
|
||||
|
||||
* <https://docs.python.org/3/library/stdtypes.html#set-types-set-frozenset>
|
||||
Loading…
Reference in New Issue