Initial push.
This commit is contained in:
@@ -0,0 +1,607 @@
|
||||
{
|
||||
"cells": [
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {
|
||||
"slideshow": {
|
||||
"slide_type": "slide"
|
||||
}
|
||||
},
|
||||
"source": [
|
||||
"# Software Entwicklung \n",
|
||||
"\n",
|
||||
"## Kapitel 3: Listen und Tupel\n",
|
||||
"\n",
|
||||
"Die bisher betrachteten Datentypen umfassen stets genau einen Wert. Möchte man mehrere Werte \n",
|
||||
"mit den bekannten Datentypen verwalten, müsste für jeden Wert eine Variable verwendet werden.\n",
|
||||
"Man erkennt schnell, dass dies nicht praktikabel ist, da oft sehr viele Werte verarbeitet werden\n",
|
||||
"müssen und gelegentlich die genaue Anzahl vorab nicht bekannt ist."
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {
|
||||
"slideshow": {
|
||||
"slide_type": "slide"
|
||||
}
|
||||
},
|
||||
"source": [
|
||||
"### 3.1 Liste \n",
|
||||
"Python bietet mit *Listen* einen Datentyp, der\n",
|
||||
"* mehrere Werte\n",
|
||||
"* auch unterschiedlichen Typs\n",
|
||||
"* in einer festen Reihenfolge\n",
|
||||
"\n",
|
||||
"beinhalten kann. Listen können zudem entstehen, dynamisch wachsen, schrumpfen und aufgelöst werden, \n",
|
||||
"ohne dass explizit Speicherplatz angefordert oder freigegeben werden müsste. Die Speicherverwaltung übernimmt \n",
|
||||
"vollständig der Python-Interpreter. Listen-Literale werden in Python mit eckigen Klammern begrenzt\n",
|
||||
"und die Elemente mit Kommas getrennt."
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {
|
||||
"pycharm": {
|
||||
"is_executing": false,
|
||||
"name": "#%%\n"
|
||||
},
|
||||
"slideshow": {
|
||||
"slide_type": "slide"
|
||||
}
|
||||
},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"[3, \"Hallo\", True, None]"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"Natürlich können Listen - wie jeder andere Datentyp - auch Variablen zugewiesen und Funktionen\n",
|
||||
"übergeben werden."
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {
|
||||
"pycharm": {
|
||||
"is_executing": false,
|
||||
"name": "#%%\n"
|
||||
}
|
||||
},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"a = [4, 5, 6]\n",
|
||||
"print(a)"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {
|
||||
"slideshow": {
|
||||
"slide_type": "slide"
|
||||
}
|
||||
},
|
||||
"source": [
|
||||
"Listen-Literale werden im Code häufig erweitert, verkürzt oder hinsichtlich der Reihenfolge verändert. Um dies \n",
|
||||
"möglichst einfach zu gestalten, können die Listeneinträge über mehrere Zeilen verteilt werden. \n",
|
||||
"Ein Komma <code>,</code> nach dem letzten Eintrag ist optional erlaubt, so dass bei Anpassung nicht Syntaxfehler\n",
|
||||
"durch fehlende oder überzählige Kommata entstehen."
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {
|
||||
"pycharm": {
|
||||
"is_executing": false,
|
||||
"name": "#%%\n"
|
||||
}
|
||||
},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"a = [ \"Erster Eintrag\",\n",
|
||||
" \"Zweiter Eintrag\",\n",
|
||||
" # \"Letzter (?) Eintrag\",\n",
|
||||
" # \"Noch einer\",\n",
|
||||
" ]\n",
|
||||
"print(a)"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {
|
||||
"pycharm": {
|
||||
"name": "#%% md\n"
|
||||
},
|
||||
"slideshow": {
|
||||
"slide_type": "slide"
|
||||
}
|
||||
},
|
||||
"source": [
|
||||
"### 3.2 Operationen \n",
|
||||
"\n",
|
||||
"Auf die einzelnen Elemente einer Liste kann mithilfe eines Index zugegriffen werden. Dabei \n",
|
||||
"besitzt das erste Element der Liste den Index <code>0</code>."
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {
|
||||
"pycharm": {
|
||||
"is_executing": false,
|
||||
"name": "#%%\n"
|
||||
}
|
||||
},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"liste = [1, 2, 3]\n",
|
||||
"print(liste[2])"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"Der Zugriff funktioniert nicht nur lesend, sondern auch schreibend."
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {
|
||||
"pycharm": {
|
||||
"is_executing": false,
|
||||
"name": "#%%\n"
|
||||
}
|
||||
},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"liste = [1, 2, 3]\n",
|
||||
"liste[1] = 5\n",
|
||||
"print(liste)"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {
|
||||
"slideshow": {
|
||||
"slide_type": "slide"
|
||||
}
|
||||
},
|
||||
"source": [
|
||||
"Erwartungsgemäß führt der Zugriff mit einem zu großen Index zu einem Laufzeitfehler."
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {
|
||||
"pycharm": {
|
||||
"is_executing": false,
|
||||
"name": "#%%\n"
|
||||
}
|
||||
},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"liste = [1, 2, 3]\n",
|
||||
"print(liste[10])"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {
|
||||
"slideshow": {
|
||||
"slide_type": "slide"
|
||||
}
|
||||
},
|
||||
"source": [
|
||||
"Negative Zahlen werden als Zugriffsindex vom Ende der Liste interpretiert, d.h. <code>-1</code> greift auf \n",
|
||||
"das letzte Listenelement zu, <code>-2</code> auf das vorletzte usw."
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {
|
||||
"pycharm": {
|
||||
"is_executing": false,
|
||||
"name": "#%%\n"
|
||||
}
|
||||
},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"liste = [1, 2, 3]\n",
|
||||
"print(liste[-1])\n",
|
||||
"print(liste[-2])"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {
|
||||
"slideshow": {
|
||||
"slide_type": "-"
|
||||
}
|
||||
},
|
||||
"source": [
|
||||
"Für das Aneinanderhängen zweier Listen kann die Infix-Operator <code>+</code> verwendet werden."
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {
|
||||
"pycharm": {
|
||||
"is_executing": false,
|
||||
"name": "#%%\n"
|
||||
}
|
||||
},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"[1, 2] + [3, 4]"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {
|
||||
"slideshow": {
|
||||
"slide_type": "slide"
|
||||
}
|
||||
},
|
||||
"source": [
|
||||
"Dabei werden vorhandene Elemente nicht abgeglichen, d.h. ggf. sind gleiche Elemente mehrfach enthalten."
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {
|
||||
"pycharm": {
|
||||
"is_executing": false,
|
||||
"name": "#%%\n"
|
||||
}
|
||||
},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"[1, 2] + [2]\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {
|
||||
"slideshow": {
|
||||
"slide_type": "-"
|
||||
}
|
||||
},
|
||||
"source": [
|
||||
"Für das Anhängen einzelner *Elemente* an eine Liste steht die <code>append</code> in Dot-Notation zur Verfügung."
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {
|
||||
"pycharm": {
|
||||
"is_executing": false,
|
||||
"name": "#%%\n"
|
||||
}
|
||||
},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"liste = [1, 2]\n",
|
||||
"liste.append(\"Wert\")\n",
|
||||
"print(liste)\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {
|
||||
"slideshow": {
|
||||
"slide_type": "slide"
|
||||
}
|
||||
},
|
||||
"source": [
|
||||
"Mittels <code>remove</code> kann ein Element auch wieder aus einer Liste entfernt werden.\n",
|
||||
"Die nachfolgenden Elemente rücken auf, d.h. es verbleibt keine Lücke in der Liste."
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {
|
||||
"pycharm": {
|
||||
"is_executing": false,
|
||||
"name": "#%%\n"
|
||||
}
|
||||
},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"liste = [1, \"Zwei\", 3, \"Zwei\"]\n",
|
||||
"liste.remove(\"Zwei\")\n",
|
||||
"print(liste)\n",
|
||||
"liste.remove(\"Zwei\")\n",
|
||||
"print(liste)"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {
|
||||
"slideshow": {
|
||||
"slide_type": "slide"
|
||||
}
|
||||
},
|
||||
"source": [
|
||||
"Ist das zu löschende Element mehrfach enthalten, wird nur das erste Auftreten entfernt."
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {
|
||||
"pycharm": {
|
||||
"is_executing": false,
|
||||
"name": "#%%\n"
|
||||
}
|
||||
},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"liste = [1, 2, 3, 2, 4]\n",
|
||||
"liste.remove(2)\n",
|
||||
"print(liste)"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {
|
||||
"slideshow": {
|
||||
"slide_type": "-"
|
||||
}
|
||||
},
|
||||
"source": [
|
||||
"Möchte man ein Element an einer bestimmten Stelle einer Liste einfügen, so leistet dies <code>insert</code>. \n",
|
||||
"Der erste Parameter ist dabei der Index, an dem das Element eingefügt werden soll, der zweite Parameter\n",
|
||||
"das einzufügende Element."
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {
|
||||
"pycharm": {
|
||||
"is_executing": false,
|
||||
"name": "#%%\n"
|
||||
}
|
||||
},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"liste = ['A', 'C']\n",
|
||||
"liste.insert(1, 'B')\n",
|
||||
"print(liste)"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {
|
||||
"slideshow": {
|
||||
"slide_type": "slide"
|
||||
}
|
||||
},
|
||||
"source": [
|
||||
"Die Anzahl des Auftretens eines bestimmten Elements kann mittels <code>count</code> ermittelt werden."
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {
|
||||
"pycharm": {
|
||||
"is_executing": false,
|
||||
"name": "#%%\n"
|
||||
}
|
||||
},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"liste = ['A', 'C', 'A', 'B']\n",
|
||||
"liste.count('Z')"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {
|
||||
"slideshow": {
|
||||
"slide_type": "-"
|
||||
}
|
||||
},
|
||||
"source": [
|
||||
"Die Position eines Elements in einer Liste liefert <code>index</code>."
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {
|
||||
"pycharm": {
|
||||
"is_executing": false,
|
||||
"name": "#%%\n"
|
||||
}
|
||||
},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"liste = ['A', 'C', 'A', 'B']\n",
|
||||
"liste.index('B')"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {
|
||||
"slideshow": {
|
||||
"slide_type": "slide"
|
||||
}
|
||||
},
|
||||
"source": [
|
||||
"Ob ein Element überhaupt in einer Liste enthalten ist, kann mit dem Infix-Operator <code>in</code>\n",
|
||||
"festgestellt werden."
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {
|
||||
"pycharm": {
|
||||
"is_executing": false,
|
||||
"name": "#%%\n"
|
||||
}
|
||||
},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"liste = ['A', 'C', 'A', 'B']\n",
|
||||
"'P' in liste"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {
|
||||
"slideshow": {
|
||||
"slide_type": "slide"
|
||||
}
|
||||
},
|
||||
"source": [
|
||||
"### 3.3 Built-In-Funktionen und Listen\n",
|
||||
"\n",
|
||||
"Wird der Built-In-Funktion <code>len</code> eine Liste als Parameter übergeben, so ist das \n",
|
||||
"Ergebnis die Anzahl der in der Liste enthaltenen Elemente."
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {
|
||||
"pycharm": {
|
||||
"is_executing": false,
|
||||
"name": "#%%\n"
|
||||
}
|
||||
},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"liste = ['A', 'B', 'C']\n",
|
||||
"len(liste)"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {
|
||||
"slideshow": {
|
||||
"slide_type": "slide"
|
||||
}
|
||||
},
|
||||
"source": [
|
||||
"Die Built-In-Funktionen <code>min</code> und <code>max</code> ergeben das Minimum bzw. das Maximum der Liste."
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {
|
||||
"pycharm": {
|
||||
"is_executing": false,
|
||||
"name": "#%%\n"
|
||||
}
|
||||
},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"liste = ['AA', 'B', 'a']\n",
|
||||
"print(min(liste))\n",
|
||||
"print(max(liste))"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {
|
||||
"slideshow": {
|
||||
"slide_type": "slide"
|
||||
}
|
||||
},
|
||||
"source": [
|
||||
"Natürlich müssen dazu die Elemente der Liste vergleichbar sein, d.h. eine Ordnungsrelation definiert sein."
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {
|
||||
"pycharm": {
|
||||
"is_executing": false,
|
||||
"name": "#%%\n"
|
||||
}
|
||||
},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"liste = ['A', 2, 'C']\n",
|
||||
"print(min(liste))"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {
|
||||
"slideshow": {
|
||||
"slide_type": "slide"
|
||||
}
|
||||
},
|
||||
"source": [
|
||||
"Und schließlich: mit der Built-In Funktion <code>del</code> können Elemente einer Liste \n",
|
||||
"mit Angabe ihrer Position gelöscht werden."
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {
|
||||
"pycharm": {
|
||||
"is_executing": false,
|
||||
"name": "#%%\n"
|
||||
}
|
||||
},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"liste = ['A', 2, 'C', 2]\n",
|
||||
"del(liste[1], liste[2])\n",
|
||||
"print(liste)\n"
|
||||
]
|
||||
}
|
||||
],
|
||||
"metadata": {
|
||||
"celltoolbar": "Slideshow",
|
||||
"kernelspec": {
|
||||
"display_name": "Python 3 (ipykernel)",
|
||||
"language": "python",
|
||||
"name": "python3"
|
||||
},
|
||||
"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.9.9"
|
||||
},
|
||||
"pycharm": {
|
||||
"stem_cell": {
|
||||
"cell_type": "raw",
|
||||
"metadata": {
|
||||
"collapsed": false
|
||||
},
|
||||
"source": []
|
||||
}
|
||||
}
|
||||
},
|
||||
"nbformat": 4,
|
||||
"nbformat_minor": 1
|
||||
}
|
||||
@@ -0,0 +1,289 @@
|
||||
{
|
||||
"cells": [
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {
|
||||
"slideshow": {
|
||||
"slide_type": "slide"
|
||||
}
|
||||
},
|
||||
"source": [
|
||||
"# Software Entwicklung \n",
|
||||
"\n",
|
||||
"## Kapitel 3: Listen und Tupel"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {
|
||||
"slideshow": {
|
||||
"slide_type": "slide"
|
||||
}
|
||||
},
|
||||
"source": [
|
||||
"### 3.4 Traversieren \n",
|
||||
"\n",
|
||||
"Häufig müssen Listen von vorne bis hinten durchlaufen werden, um mit den Elementen der Liste Berechnungen \n",
|
||||
"durchzuführen oder Aktionen auszuführen. Dieses Traversieren der Liste kann bereits mit den bekannten \n",
|
||||
"Sprachmitteln erledigt werden:"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {
|
||||
"pycharm": {
|
||||
"is_executing": false,
|
||||
"name": "#%%\n"
|
||||
}
|
||||
},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"liste = [3, 7, 4, 9]\n",
|
||||
"index = 0\n",
|
||||
"while index < len(liste):\n",
|
||||
" print(liste[index])\n",
|
||||
" index = index + 1"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {
|
||||
"slideshow": {
|
||||
"slide_type": "slide"
|
||||
}
|
||||
},
|
||||
"source": [
|
||||
"Allerdings bietet Python eine eigene Schleifenkonstruktion für das Traversieren einer Sequenz (wie z.B. einer Liste).\n",
|
||||
"Dabei ist nach dem Schlüsselwort <code>for</code> eine Variable anzugeben (hier <code>element</code> genannt),\n",
|
||||
"die sukzessive alle Werte annimmt, die in der Liste enthalten sind. Eine Variable für den Index ist nicht mehr nötig.\n",
|
||||
" "
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {
|
||||
"pycharm": {
|
||||
"is_executing": false,
|
||||
"name": "#%%\n"
|
||||
}
|
||||
},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"liste = [3, 7, 4, 9]\n",
|
||||
"for element in liste:\n",
|
||||
" print(element)"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {
|
||||
"slideshow": {
|
||||
"slide_type": "slide"
|
||||
}
|
||||
},
|
||||
"source": [
|
||||
"Neben Listen können z.B. auch Strings mit Hilfe von <code>for</code> durchlaufen werden."
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {
|
||||
"pycharm": {
|
||||
"is_executing": false,
|
||||
"name": "#%%\n"
|
||||
}
|
||||
},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"s = \"Hello!\"\n",
|
||||
"for char in s:\n",
|
||||
" print(char)"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {
|
||||
"slideshow": {
|
||||
"slide_type": "slide"
|
||||
}
|
||||
},
|
||||
"source": [
|
||||
"Die bekannten Schlüsselworte <code>break</code> und <code>continue</code> können auch bei einer \n",
|
||||
"<code>for</code>-Schleife verwendet werden."
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {
|
||||
"pycharm": {
|
||||
"is_executing": false,
|
||||
"name": "#%%\n"
|
||||
}
|
||||
},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"text = input(\"Text:\")\n",
|
||||
"vokale = ['A', 'E', 'O', 'U', 'I', 'a', 'e', 'o', 'u', 'i']\n",
|
||||
"ergebnis = \"\"\n",
|
||||
"\n",
|
||||
"for char in text:\n",
|
||||
" if char in vokale:\n",
|
||||
" continue\n",
|
||||
" ergebnis = ergebnis + char\n",
|
||||
"\n",
|
||||
"print(ergebnis)\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {
|
||||
"slideshow": {
|
||||
"slide_type": "slide"
|
||||
}
|
||||
},
|
||||
"source": [
|
||||
"### 3.5 Range\n",
|
||||
"\n",
|
||||
"Möchte man mit einer <code>for</code>-Schleife über einen Zahlenbereich iterieren,\n",
|
||||
"so kann mit Hilfe der Built-In-Funktion <code>range</code> eine passende Sequenz \n",
|
||||
"erzeugt werden. Der Zahlenbereich startet - sofern nichts anderes angegeben wurde - bei 0\n",
|
||||
"und endet so, dass die übergebene Grenze gerade nicht erreicht wird."
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {
|
||||
"pycharm": {
|
||||
"is_executing": false,
|
||||
"name": "#%%\n"
|
||||
}
|
||||
},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"bereich = range(1000)\n",
|
||||
"print(bereich)"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {
|
||||
"slideshow": {
|
||||
"slide_type": "slide"
|
||||
}
|
||||
},
|
||||
"source": [
|
||||
"Ein *Range* ist keine Liste, da man sich den Speicherplatz für viele einzelne \n",
|
||||
"Elemente sparen kann, wenn man die Unter- und Obergrenze kennt. Möchte man eine\n",
|
||||
"Sequenz wie *Range* doch in eine Liste umwandeln, so kann die Built-In-Funktion \n",
|
||||
"<code>list</code> verwendet werden."
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {
|
||||
"pycharm": {
|
||||
"is_executing": false,
|
||||
"name": "#%%\n"
|
||||
}
|
||||
},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"bereich = range(50)\n",
|
||||
"print(list(bereich))"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {
|
||||
"slideshow": {
|
||||
"slide_type": "slide"
|
||||
}
|
||||
},
|
||||
"source": [
|
||||
"Ein *Range* kann auch mit Angabe der Untergrenze, der Obergrenze und der Sprungweite angelegt werden."
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {
|
||||
"pycharm": {
|
||||
"is_executing": false,
|
||||
"name": "#%%\n"
|
||||
}
|
||||
},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"unten = 10\n",
|
||||
"oben = 20\n",
|
||||
"sprung = 2\n",
|
||||
"bereich = range(unten, oben, sprung)\n",
|
||||
"print(list(bereich))"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {
|
||||
"slideshow": {
|
||||
"slide_type": "slide"
|
||||
}
|
||||
},
|
||||
"source": [
|
||||
"Ein *Range* kann von einer <code>for</code>-Schleife durchlaufen werden, ohne dass er zuvor in eine \n",
|
||||
"Liste umgewandelt wird."
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {
|
||||
"pycharm": {
|
||||
"is_executing": false,
|
||||
"name": "#%%\n"
|
||||
}
|
||||
},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"for index in range(5):\n",
|
||||
" print(index)"
|
||||
]
|
||||
}
|
||||
],
|
||||
"metadata": {
|
||||
"celltoolbar": "Slideshow",
|
||||
"kernelspec": {
|
||||
"display_name": "Python 3 (ipykernel)",
|
||||
"language": "python",
|
||||
"name": "python3"
|
||||
},
|
||||
"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.9.9"
|
||||
},
|
||||
"pycharm": {
|
||||
"stem_cell": {
|
||||
"cell_type": "raw",
|
||||
"metadata": {
|
||||
"collapsed": false
|
||||
},
|
||||
"source": []
|
||||
}
|
||||
}
|
||||
},
|
||||
"nbformat": 4,
|
||||
"nbformat_minor": 1
|
||||
}
|
||||
@@ -0,0 +1,304 @@
|
||||
{
|
||||
"cells": [
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {
|
||||
"slideshow": {
|
||||
"slide_type": "slide"
|
||||
}
|
||||
},
|
||||
"source": [
|
||||
"# Software Entwicklung \n",
|
||||
"\n",
|
||||
"## Kapitel 3: Listen und Tupel"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {
|
||||
"slideshow": {
|
||||
"slide_type": "slide"
|
||||
}
|
||||
},
|
||||
"source": [
|
||||
"### 3.6 Tupel\n",
|
||||
"\n",
|
||||
"*Tupel* sind wie Listen ein Datentyp, mit dem *mehrere Werte* verwaltet werden können. Aber anders als Listen\n",
|
||||
"kann ein einmal erzeugtes Tupel nicht verändert werden, d.h.\n",
|
||||
"\n",
|
||||
"* es können keine weiteren Werte hinzugefügt werden\n",
|
||||
"* es können keine Werte aus dem Tupel entfernt werden\n",
|
||||
"* es kann kein Wert innerhalb des Tupels verändert werden\n",
|
||||
"\n",
|
||||
"Aufgrund dieser Einschränkungen werden Tupel i.d.R. schneller verarbeitet als Listen.\n",
|
||||
"\n",
|
||||
"Tupel werden durch runde Klammern begrenzt."
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {
|
||||
"pycharm": {
|
||||
"is_executing": false,
|
||||
"name": "#%%\n"
|
||||
}
|
||||
},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"tupel = (3, 7, 4, 9)\n",
|
||||
"print(len(tupel))"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {
|
||||
"slideshow": {
|
||||
"slide_type": "slide"
|
||||
}
|
||||
},
|
||||
"source": [
|
||||
"Lesender Zugriff ist wiederum mit einem Index möglich."
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {
|
||||
"pycharm": {
|
||||
"is_executing": false,
|
||||
"name": "#%%\n"
|
||||
}
|
||||
},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"tupel = (3, 7, 4, 9)\n",
|
||||
"print(tupel[2])"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {
|
||||
"slideshow": {
|
||||
"slide_type": "slide"
|
||||
}
|
||||
},
|
||||
"source": [
|
||||
"Schreibender Zugriff wird aufgrund des Read-Only-Charakters von Tupeln verwehrt. "
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {
|
||||
"pycharm": {
|
||||
"is_executing": false,
|
||||
"name": "#%%\n"
|
||||
}
|
||||
},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"tupel = (3, 7, 4, 9)\n",
|
||||
"tupel[2] = 3"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {
|
||||
"slideshow": {
|
||||
"slide_type": "slide"
|
||||
}
|
||||
},
|
||||
"source": [
|
||||
"Die Elemente eines Tupels können mit einem einzigen Befehl separaten Variablen zugewiesen werden. Die Anzahl der\n",
|
||||
"aufnehmenden Variablen muss aber exakt der Länge des Tupels entsprechen."
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {
|
||||
"pycharm": {
|
||||
"is_executing": false,
|
||||
"name": "#%%\n"
|
||||
}
|
||||
},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"tupel = (3, 7, 4, 9)\n",
|
||||
"e1, e2, e3, e4 = tupel\n",
|
||||
"print(e4)"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {
|
||||
"slideshow": {
|
||||
"slide_type": "slide"
|
||||
}
|
||||
},
|
||||
"source": [
|
||||
"Wie die Liste ist auch ein Tupel eine Sequenz, die mit Hilfe der <code>for</code>-Schleife\n",
|
||||
"durchlaufen werden kann."
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {
|
||||
"pycharm": {
|
||||
"is_executing": false,
|
||||
"name": "#%%\n"
|
||||
}
|
||||
},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"for zahl in (3, 7, 4, 9):\n",
|
||||
" print(zahl)"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {
|
||||
"pycharm": {
|
||||
"name": "#%% md\n"
|
||||
},
|
||||
"slideshow": {
|
||||
"slide_type": "slide"
|
||||
}
|
||||
},
|
||||
"source": [
|
||||
"Listen und Tupel können verschachtelt werden, d.h. eine Liste kann wiederum Listen und/oder Tupel enthalten bzw. \n",
|
||||
"die Elemenente eines Tupels können auch Listen oder Tupel sein."
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {
|
||||
"pycharm": {
|
||||
"is_executing": false,
|
||||
"name": "#%%\n"
|
||||
}
|
||||
},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"tupel = ((3, 7), (4, 9))\n",
|
||||
"print(len(tupel))\n",
|
||||
"print(tupel[1][0])"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {
|
||||
"pycharm": {
|
||||
"is_executing": false,
|
||||
"name": "#%%\n"
|
||||
}
|
||||
},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"ergebnis = []\n",
|
||||
"for zeilennummer in range(1, 6):\n",
|
||||
" neue_zeile = []\n",
|
||||
" for index in range(zeilennummer):\n",
|
||||
" neue_zeile.append(zeilennummer)\n",
|
||||
" ergebnis.append(neue_zeile)\n",
|
||||
"print(ergebnis)"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {
|
||||
"slideshow": {
|
||||
"slide_type": "slide"
|
||||
}
|
||||
},
|
||||
"source": [
|
||||
"Gelegentlich möchte man eine Liste \"durchnummerieren\", d.h. neben den eigentlichen Listenelementen\n",
|
||||
"auch den Index des Listenelements ausweisen:\n",
|
||||
"\n",
|
||||
"<code>['A', 'B', 'C']</code> -> <code>[(0, 'A'), (1, 'B'), (2, 'C')]</code>\n",
|
||||
"\n",
|
||||
"Genau dieses leistet die Built-In-Funktion <code>enumerate</code>, die aus einer Liste eine Sequenz \n",
|
||||
"von derartigen Tupeln generiert. Und wie bei <code>range</code> muss das Ergebnis erst noch in eine Liste\n",
|
||||
"umgewandelt werden, um wirklich das obige Verhalten nachzubilden."
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {
|
||||
"pycharm": {
|
||||
"is_executing": false,
|
||||
"name": "#%%\n"
|
||||
}
|
||||
},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"print(list(enumerate(['A', 'B', 'C'])))"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {
|
||||
"slideshow": {
|
||||
"slide_type": "slide"
|
||||
}
|
||||
},
|
||||
"source": [
|
||||
"Ein häufiger Anwendungsfall einer <code>enumerate</code>-Sequenz ist die Verwendung in einer \n",
|
||||
"<code>for</code>-Schleife. Die entstehenden Tupel können unmittelbar in zwei einzelne Variablen \n",
|
||||
"übernommen werden."
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {
|
||||
"pycharm": {
|
||||
"is_executing": false,
|
||||
"name": "#%%\n"
|
||||
}
|
||||
},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"liste = [3, 7, 4, 9]\n",
|
||||
"for index, zahl in enumerate(liste):\n",
|
||||
" print(f\"{index+1}. Zahl ist {zahl}\")"
|
||||
]
|
||||
}
|
||||
],
|
||||
"metadata": {
|
||||
"celltoolbar": "Slideshow",
|
||||
"kernelspec": {
|
||||
"display_name": "Python 3 (ipykernel)",
|
||||
"language": "python",
|
||||
"name": "python3"
|
||||
},
|
||||
"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.9.9"
|
||||
},
|
||||
"pycharm": {
|
||||
"stem_cell": {
|
||||
"cell_type": "raw",
|
||||
"metadata": {
|
||||
"collapsed": false
|
||||
},
|
||||
"source": []
|
||||
}
|
||||
}
|
||||
},
|
||||
"nbformat": 4,
|
||||
"nbformat_minor": 1
|
||||
}
|
||||
@@ -0,0 +1,360 @@
|
||||
{
|
||||
"cells": [
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {
|
||||
"slideshow": {
|
||||
"slide_type": "slide"
|
||||
}
|
||||
},
|
||||
"source": [
|
||||
"# Software Entwicklung \n",
|
||||
"\n",
|
||||
"## Kapitel 3: Listen und Tupel\n",
|
||||
"\n",
|
||||
"### 3.7 List Comprehensions\n",
|
||||
"\n",
|
||||
"Mit Hilfe von *List Comprehensions* können Listen basierend auf bestehenden Listen oder Sequenzen erzeugt werden. \n",
|
||||
"Dazu wird die bestehende Sequenz mit einer <code>for</code>-Schleife durchlaufen und die einzelnen Elemente zu einer\n",
|
||||
"neuen Liste zusammengefasst. Die Syntax dazu sieht so aus:\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {
|
||||
"pycharm": {
|
||||
"is_executing": false,
|
||||
"name": "#%%\n"
|
||||
}
|
||||
},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"alte_liste = [1, 2, 3]\n",
|
||||
"neue_liste = [x for x in alte_liste]\n",
|
||||
"print(neue_liste)"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {
|
||||
"slideshow": {
|
||||
"slide_type": "slide"
|
||||
}
|
||||
},
|
||||
"source": [
|
||||
"Natürlich sind auch Funktionsaufrufe möglich."
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {
|
||||
"pycharm": {
|
||||
"is_executing": false,
|
||||
"name": "#%%\n"
|
||||
}
|
||||
},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"alte_liste = ['Hello', 'World!']\n",
|
||||
"neue_liste = [len(word) for word in alte_liste]\n",
|
||||
"print(neue_liste)"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {
|
||||
"slideshow": {
|
||||
"slide_type": "slide"
|
||||
}
|
||||
},
|
||||
"source": [
|
||||
"Durch das Ergänzen eines <code>if</code> können Elemente der ursprünglichen Liste bzw. Sequenz \n",
|
||||
"ausgelassen werden."
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {
|
||||
"pycharm": {
|
||||
"is_executing": false,
|
||||
"name": "#%%\n"
|
||||
}
|
||||
},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"neue_liste = [x for x in range(20) if x%2 == 0 ]\n",
|
||||
"print(neue_liste)"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {
|
||||
"slideshow": {
|
||||
"slide_type": "slide"
|
||||
}
|
||||
},
|
||||
"source": [
|
||||
"### 3.8 Listen und Strings\n",
|
||||
"\n",
|
||||
"Gelegentlich möchte man einen String in einzelne Wörter zerlegen und diese als\n",
|
||||
"Liste zurückgeliefert bekommen. Hierzu dient die Operation <code>split</code>, die \n",
|
||||
"in Dot-Notation im Datentyp String enthalten ist."
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {
|
||||
"pycharm": {
|
||||
"is_executing": false,
|
||||
"name": "#%%\n"
|
||||
}
|
||||
},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"text =\"Software Entwicklung macht Spaß\"\n",
|
||||
"liste = text.split()\n",
|
||||
"print(liste)"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {
|
||||
"slideshow": {
|
||||
"slide_type": "slide"
|
||||
}
|
||||
},
|
||||
"source": [
|
||||
"Normalerweise verwendet <code>split</code> ein *Whitespace*-Zeichen (d.h. Leerzeichen, Tabulator, neue Zeile,...)\n",
|
||||
"als Trennzeichen für die Zerlegung. Es kann jedoch auch eine andere Zeichenkette festgelegt werden. "
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {
|
||||
"pycharm": {
|
||||
"is_executing": false,
|
||||
"name": "#%%\n"
|
||||
}
|
||||
},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"text = \"der, die, das, wieso, weshalb, warum\"\n",
|
||||
"liste = text.split(\", \")\n",
|
||||
"print(liste)"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"Hinweis: Mehrere unterschiedliche Trennzeichen sind mit der Standard-<code>split</code>-Funktion nicht realisierbar. \n",
|
||||
"Dazu benötigt man *reguläre Ausdrücke*, die zu einem späteren Zeitpunkt eingeführt werden."
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {
|
||||
"slideshow": {
|
||||
"slide_type": "slide"
|
||||
}
|
||||
},
|
||||
"source": [
|
||||
"Soll umgekehrt aus einer Liste von einzelnen Wörtern ein String zusammengesetzt werden, kann die \n",
|
||||
"Funktion <code>join</code> genutzt werden. Sie wird in der Dot-Notation mit einem String verwendet,\n",
|
||||
"der die einzufügenden Trennzeichen enthält."
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {
|
||||
"pycharm": {
|
||||
"is_executing": false,
|
||||
"name": "#%%\n"
|
||||
}
|
||||
},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"liste = [\"das\", \"ist\", \"das\", \"Haus\", \"vom\", \"Nikolaus\"]\n",
|
||||
"text = \"\".join(liste)\n",
|
||||
"print(text)"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {
|
||||
"slideshow": {
|
||||
"slide_type": "slide"
|
||||
}
|
||||
},
|
||||
"source": [
|
||||
"### 3.9 Slicing\n",
|
||||
"\n",
|
||||
"Viele Sequenztypen in Python (bisher bekannt: Listen, Tupel, Strings, Ranges) können mittels *Slicing* \n",
|
||||
"zurechtgeschnitten werden. Dazu werden der Index des ersten zu berücksichtigenden Elements und der\n",
|
||||
"Index des ersten nicht mehr zu berücksichtigenden Elements getrennt durch einen Doppelpunkt angegeben."
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {
|
||||
"pycharm": {
|
||||
"is_executing": false,
|
||||
"name": "#%%\n"
|
||||
}
|
||||
},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"liste = ['A', 'B', 'C', 'D', 'E']\n",
|
||||
"middle = liste[1:4]\n",
|
||||
"print(middle)"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {
|
||||
"pycharm": {
|
||||
"name": "#%% md\n"
|
||||
},
|
||||
"slideshow": {
|
||||
"slide_type": "slide"
|
||||
}
|
||||
},
|
||||
"source": [
|
||||
"Wird einer der Indexwerte weggelassen, so bedeutet dies, dass der Ausschnitt am Anfang beginnt bzw. bis\n",
|
||||
"zum Ende reicht."
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {
|
||||
"pycharm": {
|
||||
"is_executing": false,
|
||||
"name": "#%%\n"
|
||||
}
|
||||
},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"liste = ['A', 'B', 'C', 'D', 'E']\n",
|
||||
"anfang = liste[:3]\n",
|
||||
"print(anfang)\n",
|
||||
"ende = liste[2:]\n",
|
||||
"print(ende)"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {
|
||||
"slideshow": {
|
||||
"slide_type": "slide"
|
||||
}
|
||||
},
|
||||
"source": [
|
||||
"Natürlich funktionieren auch negative Indizes."
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {
|
||||
"pycharm": {
|
||||
"is_executing": false,
|
||||
"name": "#%%\n"
|
||||
}
|
||||
},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"liste = ['A', 'B', 'C', 'D', 'E']\n",
|
||||
"middle = liste[1:-1]\n",
|
||||
"print(middle)"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {
|
||||
"slideshow": {
|
||||
"slide_type": "slide"
|
||||
}
|
||||
},
|
||||
"source": [
|
||||
"Und schließlich kann durch Angabe eines dritten Parameters eine Schrittweite vorgegeben werden. "
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {
|
||||
"pycharm": {
|
||||
"is_executing": false,
|
||||
"name": "#%%\n"
|
||||
}
|
||||
},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"sequenz = range(20)\n",
|
||||
"gerade = sequenz[0::2]\n",
|
||||
"print(list(gerade))"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"Auch negative Schrittweiten sind zulässig. Die Sequenz wird dann von hinten durchlaufen."
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {
|
||||
"pycharm": {
|
||||
"is_executing": false,
|
||||
"name": "#%%\n"
|
||||
}
|
||||
},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"text = \"TH Nürnberg\"\n",
|
||||
"print(text[::-1])\n"
|
||||
]
|
||||
}
|
||||
],
|
||||
"metadata": {
|
||||
"celltoolbar": "Slideshow",
|
||||
"kernelspec": {
|
||||
"display_name": "Python 3 (ipykernel)",
|
||||
"language": "python",
|
||||
"name": "python3"
|
||||
},
|
||||
"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.9.9"
|
||||
},
|
||||
"pycharm": {
|
||||
"stem_cell": {
|
||||
"cell_type": "raw",
|
||||
"metadata": {
|
||||
"collapsed": false
|
||||
},
|
||||
"source": []
|
||||
}
|
||||
}
|
||||
},
|
||||
"nbformat": 4,
|
||||
"nbformat_minor": 1
|
||||
}
|
||||
@@ -0,0 +1,152 @@
|
||||
{
|
||||
"cells": [
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {
|
||||
"collapsed": true,
|
||||
"pycharm": {
|
||||
"name": "#%% md\n"
|
||||
},
|
||||
"slideshow": {
|
||||
"slide_type": "slide"
|
||||
}
|
||||
},
|
||||
"source": [
|
||||
"_Aufgabe 1_\n",
|
||||
"\n",
|
||||
"Schreiben Sie ein Python-Programm, das einen Text von der Tastatur einliest und anschließend\n",
|
||||
"die Anfangsbuchstaben aller Wörter im Text ausgibt. Dabei soll jeder Buchstabe nur einmal vorkommen."
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": []
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {
|
||||
"pycharm": {
|
||||
"name": "#%%\n"
|
||||
},
|
||||
"slideshow": {
|
||||
"slide_type": "slide"
|
||||
}
|
||||
},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"text = input(\"Text:\")\n",
|
||||
"\n",
|
||||
"worte = text.split()\n",
|
||||
"startchars = [wort[0] for wort in worte ]\n",
|
||||
"\n",
|
||||
"for index, current in enumerate(startchars):\n",
|
||||
" if current not in startchars[:index]:\n",
|
||||
" print(current)"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {
|
||||
"pycharm": {
|
||||
"name": "#%% md\n"
|
||||
},
|
||||
"slideshow": {
|
||||
"slide_type": "slide"
|
||||
}
|
||||
},
|
||||
"source": [
|
||||
"_Aufgabe 2_\n",
|
||||
"\n",
|
||||
"Gegeben sind zwei Listen gleicher Länge mit Artikeln und zugehörgen Preisen, z.B.:\n",
|
||||
"\n",
|
||||
"<code>artikel = [ \"Klopapier\", \"Maske\", \"Desinfektionsmittel\" ]</code>\n",
|
||||
"\n",
|
||||
"<code>preis = [ 3.5, 2.25, 7.4 ]</code>\n",
|
||||
"\n",
|
||||
"Schreiben Sie ein Python-Programm, das eine Ergebnisliste berechnet, in der Artikel und Preis zu Tupeln \n",
|
||||
"zusammengefasst sind:\n",
|
||||
"\n",
|
||||
"<code>ergebnis = [('Klopapier', 3.5), ('Maske', 2.25), ('Desinfektionsmittel', 7.4)] </code>"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {
|
||||
"slideshow": {
|
||||
"slide_type": "subslide"
|
||||
}
|
||||
},
|
||||
"outputs": [],
|
||||
"source": []
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {
|
||||
"pycharm": {
|
||||
"is_executing": false,
|
||||
"name": "#%%\n"
|
||||
},
|
||||
"slideshow": {
|
||||
"slide_type": "slide"
|
||||
}
|
||||
},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"artikel = [ \"Klopapier\", \"Maske\", \"Desinfektionsmittel\" ]\n",
|
||||
"preis = [ 3.50, 2.25, 7.4 ]\n",
|
||||
"\n",
|
||||
"ergebnis = [(a, preis[index]) for index, a in enumerate(artikel)]\n",
|
||||
"print(ergebnis)\n",
|
||||
"\n",
|
||||
"########\n",
|
||||
"ergebnis2 = list(zip(artikel, preis))\n",
|
||||
"print(ergebnis2)\n",
|
||||
"\n",
|
||||
"########\n",
|
||||
"index = 0\n",
|
||||
"ergebnis3 = []\n",
|
||||
"while index < len(artikel):\n",
|
||||
" ergebnis3.append((artikel[index], preis[index]))\n",
|
||||
" index = index + 1\n",
|
||||
"print(ergebnis3)"
|
||||
]
|
||||
}
|
||||
],
|
||||
"metadata": {
|
||||
"celltoolbar": "Slideshow",
|
||||
"kernelspec": {
|
||||
"display_name": "Python 3 (ipykernel)",
|
||||
"language": "python",
|
||||
"name": "python3"
|
||||
},
|
||||
"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.9.9"
|
||||
},
|
||||
"pycharm": {
|
||||
"stem_cell": {
|
||||
"cell_type": "raw",
|
||||
"metadata": {
|
||||
"collapsed": false
|
||||
},
|
||||
"source": []
|
||||
}
|
||||
}
|
||||
},
|
||||
"nbformat": 4,
|
||||
"nbformat_minor": 1
|
||||
}
|
||||
@@ -0,0 +1,22 @@
|
||||
body.rise-enabled div.inner_cell>div.input_area {
|
||||
font-size: 150%;
|
||||
}
|
||||
|
||||
body.rise-enabled div.output_subarea.output_text.output_result {
|
||||
font-size: 150%;
|
||||
}
|
||||
body.rise-enabled div.output_subarea.output_text.output_stream.output_stdout {
|
||||
font-size: 150%;
|
||||
}
|
||||
|
||||
body.rise-enabled div.output_subarea.output_html.rendered_html.output_result {
|
||||
font-size: 150%;
|
||||
}
|
||||
|
||||
body.rise-enabled td {
|
||||
font-size: 120%;
|
||||
}
|
||||
|
||||
body.rise-enabled th {
|
||||
font-size: 120%;
|
||||
}
|
||||
Reference in New Issue
Block a user