weiterfuehrende.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Weiterführende Elemente der Programmierung"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Schleifen\n",
    "\n",
    "Eins der wichtigsten Konstrukte für die Programmierung ist die Schleife. Schleifen erlauben es uns, einen Teil des Programms mehrmals unter (leicht) veränderten Bedingungen auszuführen.\n",
    "\n",
    "Wir unterscheiden dabei zwei Arten von Schleifen: \n",
    "\n",
    "* `for`-Schleife: Iteration über eine gegebene Sequenz von Objekten\n",
    "* `while`-Schleife: Iterationen solange eine boolsche Abbruchbedingung nicht erfüllt ist"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### for-Schleife\n",
    "\n",
    "Die `for`-Schleife iteriert über eine vorgegebene Sequenz von Objekten, wobei die Art der Objekte sehr unterschiedlich sein kann. Jede Iteration beinhaltet dann das Objekt, das gerade \"dran\" ist."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in [1, 2, 3, 4]:\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for t in ['Mareike', 'Julius', 'Peter']:\n",
    "    print('Hallo ' + t)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for x in [3, 'Daniel', True, 5.7]:\n",
    "    print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### while-Schleife\n",
    "\n",
    "Für die `while`-Schleife deklarieren wir keine feste Sequenz, sondern eine Abbruchbedingung. Vor jeder Iteration wird geprüft, wie der Status der Abbruchbedingung ist. Ist die Abbruchbedingung `False`, führt die Schleife eine weitere Iteration durch. Ist die Abbruchbedingung `True`, wird keine weitere Iteration mehr durchgeführt."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "i = 0\n",
    "while i < 5:\n",
    "    print(i)\n",
    "    i += 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Nützliche Konstrukte für Schleifen\n",
    "\n",
    "Die Funktion `range()` erzeugt eine Sequenz mit Zahlen: https://docs.python.org/3.8/library/functions.html#func-range"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for x in range(5):\n",
    "    print(x)\n",
    "\n",
    "print('----')\n",
    "\n",
    "for x in range(3, 6):\n",
    "    print(x)\n",
    "\n",
    "print('----')\n",
    "\n",
    "for x in range(3, 16, 5):\n",
    "    print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Die Funktion `enumerate()` iteriert über einzelne Elemente eines Objekts (z.B. einem String). Spannend an dieser Funktion ist, dass sie uns nicht nur das Element zurückgibt, das sie gerade betrachtet, sondern auch dessen Position.  \n",
    "https://docs.python.org/3.8/library/functions.html#enumerate"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for index, elem in enumerate(['Mareike', 'Julius', 'Peter']):\n",
    "    print(index, ': ' + elem, sep='')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Übungsaufgabe\n",
    "\n",
    "Gegeben ist ein etwas merkwürdiger Text `text = 'E4dcitrzosm_ tS4ulmdmweürc lS-cfhhosoglä'`, mit dem offenbar etwas schief gelaufen ist. Bitte schreibt ein Programm, das immer nur den zweiten Buchstaben des Texts ausgibt."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Bitte schreibt ein Programm, das Zeichen für Zeichen durch\n",
    "# den Text iteriert und jedes zweite Zeichen ausgibt.\n",
    "# Hinweise: enumerate(), modulo und print()\n",
    "\n",
    "# Wir prüfen für jedes Zeichen, ob die Position des Zeichens gerade oder ungerade ist\n",
    "# und geben nur die Zeichen aus, die an gerader Position stehen\n",
    "\n",
    "text = 'E4dcitrzosm_ tS4ulmdmweürc lS-cfhhosoglä'\n",
    "\n",
    "for index, char in enumerate(text):\n",
    "    if index % 2 == 0:\n",
    "        print(char, end='')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Datenstrukturen\n",
    "\n",
    "### Tuples\n",
    "\n",
    "Tuples sind einfache Listen in Python, die nicht mehr veränderbar sind, wenn sie einmal deklariert wurden."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "beispiel_tuple = ('Mareike', 'Julius', 'Peter', 3, 7.5, 'Julius', 'Daniel')\n",
    "\n",
    "for elem in beispiel_tuple:\n",
    "    print(elem,  ' (Datentyp = ', type(elem), ')', sep='')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(beispiel_tuple[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(beispiel_tuple[4])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(beispiel_tuple[-3])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "beispiel_tuple.count('Julius')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "beispiel_tuple.index(3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Lists\n",
    "\n",
    "Listen sind wie Tuples eine Sequenz von Objekten. Listen können aber zur Laufzeit verändert werden. Es können sowohl die Werte in einer Liste verändert werden als auch die Anzahl der Elemente veringert oder vergrößert werden."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "beispiel_list = ['Mareike', 'Julius', 'Peter', 3, 7.5, 'Julius', 'Daniel']\n",
    "\n",
    "beispiel_list.remove('Julius')\n",
    "\n",
    "for index, elem in enumerate(beispiel_list):\n",
    "    print(str(index) + ': ' + str(elem))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(beispiel_list[1])\n",
    "print(beispiel_list[2:4])\n",
    "print(beispiel_list[:2])\n",
    "print(beispiel_list[4:])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(beispiel_list)\n",
    "beispiel_list[1] = 'Dennis'\n",
    "beispiel_list[4] = 'Fiona'\n",
    "print(beispiel_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "if 'Daniel' in beispiel_list:\n",
    "    print('Ja, Daniel ist in der Liste')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(len(beispiel_list))\n",
    "beispiel_list.append('Anastasia')\n",
    "print(len(beispiel_list))\n",
    "\n",
    "print(beispiel_list)\n",
    "beispiel_list.insert(1, 'Johannes')\n",
    "\n",
    "print(beispiel_list)\n",
    "beispiel_list.pop()\n",
    "\n",
    "print(beispiel_list)\n",
    "beispiel_list.remove('Fiona')\n",
    "\n",
    "print(beispiel_list)\n",
    "del beispiel_list[2]\n",
    "\n",
    "print(beispiel_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Eine Liste der Funktionen, die wir auf Listen ausführen können, findet ihr hier: https://www.w3schools.com/python/python_lists.asp"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Sets\n",
    "\n",
    "Sets sind Sammlungen von Werten. Die Werte dürfen alle nur einmal vorkommen. Eine feste Reihenfolge haben Sets nicht. Die Funktionen, die wir auf Sets ausführen können, findet ihr hier: https://www.w3schools.com/python/python_sets.asp"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "beispiel_set = {'Daniel', 'Anastasia', 'Peter'}\n",
    "\n",
    "for elem in beispiel_set:\n",
    "    print(elem)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Dictionaries\n",
    "\n",
    "Dictionaries sind Sammlungen von Werten, die wie bei Sets unsortiert sind. Im Gegensatz zu Sets besitzen die Einträge in einem Dictionary immer einen `Key` und einen `Value`. Werte in einem Dictionary sind somit adressierbar."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "beispiel_dictionary = {\n",
    "    'work': 'Der Freischütz',\n",
    "    'composer': 'Carl Maria von Weber',\n",
    "    'date': 1821\n",
    "}\n",
    "\n",
    "print(beispiel_dictionary['work'])\n",
    "print(beispiel_dictionary.get('composer'))\n",
    "\n",
    "beispiel_dictionary['date'] = 1820 # Entschuldigt, ich habe mich vertan ;-)\n",
    "\n",
    "print(beispiel_dictionary)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for key, value in beispiel_dictionary.items():\n",
    "    print(key, value)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Die Funktionen, die wir im Zusammenhang mit Dictionaries benutzen können, findet ihr hier: https://www.w3schools.com/python/python_dictionaries.asp"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Übungsaufgabe\n",
    "\n",
    "Erfrage bei deinem Nutzer seinen Vornamen, den Nachnamen und das Geburtsjahr. Speichere diese Werte in einem Dictionary. Lies aus dem Datensatz den Vornamen aus und berechne das Alter anhand des Geburtsjahres. Gib einen Satz aus, in dem du den Nutzer mit seinem Vornamen ansprichst und ihm sein Alter nennst."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Übungsaufgabe zu Dictionaries\n",
    "\n",
    "vorname = input(\"Bitte gib deinen Vornamen ein: \")\n",
    "nachname = input(\"Bitte gib deinen Nachnamen ein: \")\n",
    "geburtsjahr = int(input(\"Bitte gib dein Geburtsjahr ein: \"))\n",
    "\n",
    "person = {\n",
    "    'vorname': vorname,\n",
    "    'nachname': nachname,\n",
    "    'geburtsjahr': geburtsjahr\n",
    "}\n",
    "\n",
    "print(person)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "person = {}\n",
    "\n",
    "person['vorname'] = input(\"Bitte gib deinen Vornamen ein: \")\n",
    "person['nachname'] = input(\"Bitte gib deinen Nachnamen ein: \")\n",
    "person['geburtsjahr'] = int(input(\"Bitte gib dein Geburtsjahr ein: \"))\n",
    "\n",
    "print(person)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Funktionen\n",
    "\n",
    "Für wiederkehrende Aufgaben schreiben wir uns Funktionen, damit wir den Programmabschnitt nicht öfter schreiben müssen. Funktionen werden im Programm einmal definiert und können dann beliebig oft aufgerufen werden."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def hello_world():\n",
    "    print(\"Hello World\")\n",
    "\n",
    "hello_world()\n",
    "hello_world()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"\"\"\n",
    "Berechnet das Alter einer Person im Jahr 2020.\n",
    "\"\"\"\n",
    "def berechne_alter(person):\n",
    "    AKTUELLES_JAHR = 2020\n",
    "    geburtsjahr = person['geburtsjahr']\n",
    "    return AKTUELLES_JAHR - geburtsjahr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Ändert das oben stehende Programm zu dem Dictionary so, dass es die neue Funktion nutzt\n",
    "\n",
    "person = {\n",
    "    'vorname': 'Daniel',\n",
    "    'geburtsjahr': 1980\n",
    "}\n",
    "\n",
    "alter = berechne_alter(person)\n",
    "print(alter)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Funktionen können, wie wir ja auch schon gesehen haben, mehrere Parameter haben. \n",
    "def funktion1(*args):\n",
    "    print(args)\n",
    "\n",
    "funktion1('Dennis')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Argumente können auch mit dem Parametername an eine Funktion übergeben werden\n",
    "def funktion2(arg1, arg2):\n",
    "    print(f\"arg1 {arg1} und arg2 {arg2}\")\n",
    "\n",
    "funktion2('steht vorn', 'steht hinten')\n",
    "funktion2(arg2='steht hinten', arg1='steht vorne')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Und es können Default-Werte angegeben werden\n",
    "def funktion3(arg1='Wenn nichts da ist, nehme ich diesen Wert'):\n",
    "    print(arg1)\n",
    "    \n",
    "funktion3()\n",
    "funktion3('Hier kommt aber doch etwas')"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.8.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}