{
 "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
}
