kap_grundlagen.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Zahlen"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`begin calculator`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "101"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Kommentare beginnen mit # und werden vom Interpreter ignoriert\n",
    "# Grundrechenarten funktionieren wie erwartet\n",
    "100 + 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "14"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Punkt geht vor Strichrechnung\n",
    "2+3*4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "20"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(2+3)*4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.5"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Mit Division verlassen wir die natürlichen Zahlen\n",
    "3/2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2.0"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "4/2  # Division liefert immer eine Gleitkommazahl"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1024"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Potenzen mit **\n",
    "2**10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1024.0"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1.024e3  # Kurzschreibweise für Zehnerpotenzen"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`end`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`begin number_types`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "int"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(32)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "float"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(32.5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`end`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`begin assignment`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7.142857142857143"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = 7 # Variable anlegen und zuweisen mit =\n",
    "1/x + x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x += 1  # entspricht x = x + 1\n",
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "16"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x *= 2  # x = x * 2\n",
    "x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`end`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`begin unlimited`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "114813069527425452423283320117768198402231770208869520047764273682576626139237031385665948631650626991844596463898746277344711896086305533142593135616665318539129989145312280000688779148240044871428926990063486244781615463646388363947317026040466353970904996558162398808944629605623311649536164221970332681344168908984458505602379484807914058900934776500429002716706625830522008132236281291761267883317206598995396418127021779858404042159853183251540889433902091920554957783589672039160081957216630582755380425583726015528348786419432054508915275783882625175435528800822842770817965453762184851149029376"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2**2000"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "OverflowError: (34, 'Result too large')\n"
     ]
    }
   ],
   "source": [
    "#!2.0**2000\n",
    "print(\"OverflowError: (34, 'Result too large')\")#!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`end`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Booleans"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`begin bool_literal`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "bool"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a_bool = True\n",
    "another_bool = False\n",
    "type(a_bool)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`end`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`begin bool_comparisons`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "3.14 < 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "-1/12 >= 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "6 * 69 == 420  # Gleich"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "0.33333333333333 != 1/3  # Ungleich"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = 12\n",
    "# Vergleichsoperatoren können verkettet werden\n",
    "10 <= x < 20"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n"
     ]
    }
   ],
   "source": [
    "# Achtung: Unterschied Zuweisung = und Vergleich ==\n",
    "is_eight = x == 8\n",
    "print(is_eight)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`end`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`begin bool_operations`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "# Einige Annahmen über Sie\n",
    "is_engineer = True\n",
    "needs_to_program = False\n",
    "wants_to_program = True\n",
    "afraid_of_snakes = False\n",
    "# Könnte Sie dieses Buch interessieren?\n",
    "potential_reader = is_engineer and (needs_to_program or wants_to_program) and not afraid_of_snakes\n",
    "print(potential_reader)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Wahrheitsverknüpfungen haben die allerniedrigste Präzedenz,\n",
    "# d. h. was links und rechts steht wird zuerst ausgewertet\n",
    "# --> spart Klammern\n",
    "x = 42\n",
    "x > 10 or x < -10"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`end`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Typen"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`begin number_constructor`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "42"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "int(42)  # Erstellt ein int mit Wert 42"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "42"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "int(42.5) # Konvertiert float zu int"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "42.0"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "float(42)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bool(1)  # 0 entspricht False, alles andere True"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`end`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`begin datetime_constructor`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Kalenderfunktionen liegen in separatem \"Modul\" und\n",
    "# müssen importiert werden\n",
    "from datetime import datetime\n",
    "sw = datetime(1977, 5, 25, 19, 0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`end`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`begin datetime_attributes`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1977"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sw.year"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "19"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sw.hour"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`end`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`begin datetime_methods`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sw.weekday()  # Berechne Wochentag (Mittwoch)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Wednesday, 05. May 1977, 19:00'"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Gib datetime als Text in spezifiziertem Format aus\n",
    "sw.strftime(\"%A, %m. %B %Y, %H:%M\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`end`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`begin obj_eq`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "date2 = datetime(1977, 5, 25, 19, 0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sw == date2  # Objekte sind inhaltlich gleich"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sw is date2  # Identitäten (Speicherstellen) sind unterschiedlich"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`end`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Listen"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`begin list_def`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Listenelemente in [] schreiben und mit Kommata trennen\n",
    "numbers = [1, 2, 789, 4]\n",
    "# Listen können beliebige Typen enthalten\n",
    "booleans = [True, False, False, True]\n",
    "# Auch gemischt und geschachtelt\n",
    "# Achtung: Davon ist meistens abzuraten\n",
    "chaos = [3.14, True, 4, [1, 2, 3], False]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`end list_def`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`begin list_read`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "789"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "numbers[2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "chaos[3][1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Negative Indizes zählen von hinten\n",
    "numbers[-1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "IndexError: list index out of range\n"
     ]
    }
   ],
   "source": [
    "# Listenindizes werden auf Intervall geprüft\n",
    "# Fehler, denn numbers hat nur 4 Elemente (Indizes 0 bis 3)\n",
    "#!numbers[4]\n",
    "print(\"IndexError: list index out of range\")#!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`end`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`begin list_write`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 4]"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "numbers[2] = 3\n",
    "numbers"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`end`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`begin list_trap`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[7, 2, 3]"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = [1, 2, 3]\n",
    "# b verweist auf die gleiche Liste wie a\n",
    "b = a\n",
    "# Ändere ersten Eintrag\n",
    "b[0] = 7\n",
    "b # ist erwartungsgemäß anders"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[7, 2, 3]"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a # ist die gleiche Listeninstanz und damit auch verändert"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`end`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`begin list_copy`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[7, 2, 99]"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Funktion list(...) mit Liste als Argument kopiert diese\n",
    "c = list(a)\n",
    "c[2] = 99  # Ändere letztes Argument\n",
    "c"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[7, 2, 3]"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a  # ist unverändert"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`end`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`begin list_slices`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 1, 1, 2]"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fib = [0, 1, 1, 2, 3, 5, 8, 13]\n",
    "# Teilliste von 0 (inkl.) bis 4 (exkl.)!\n",
    "# Indizes sind also 0, 1, 2, 3\n",
    "fib[0:4]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 1, 1, 2]"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Obere und untere Grenze kann ausgelassen werden\n",
    "fib[:4]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[3, 5, 8, 13]"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fib[4:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 1, 2, 3, 5, 8]"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Alles, außer erstes und letztes Element\n",
    "fib[1:-1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 1, 3, 8]"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Schrittweite angeben mit [start:stop:step]\n",
    "fib[0:7:2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[13, 8, 5, 3, 2, 1, 1, 0]"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Auslassen geht natürlich immer noch\n",
    "fib[::-1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 1, 1, 2, 0, 1, 1, 2]"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Slicing funktioniert auch auf linker Seite einer Zuweisung\n",
    "fib[4:] = fib[:4]\n",
    "fib"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`end`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`begin list_more`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[5, 6, 7, 8, 9, 10, 11, 12]"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = [5, 6, 7, 8, 9]\n",
    "a + [10, 11, 12]  # Zwei Listen aneinanderfügen"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(a)  # Länge einer Liste"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "7 in a  # Ist Element in Liste enthalten?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[5, 6, 7, 9]"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "del a[3]  # Element mit Index entfernen (kann auch Slices)\n",
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a.pop(2)  # Element mit Index entfernen und zurückgeben"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[5, 6, 9]"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[6, 9]"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a.remove(5)  # Element mit bestimmtem Wert entfernen\n",
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[6, 9, 10]"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a.append(10)  # Element an Ende anhängen\n",
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[6, 7, 9, 10]"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a.insert(1, 7)  # Element an Index einfügen\n",
    "a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`end`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`begin str_def_old`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [],
   "source": [
    "doppelt = \"Ich bin ein String.\"\n",
    "einfach = 'Ich auch!'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Strings sind mit UTF-8 codiert und unterstützen Unicode\n",
    "titel = \"🐍 für 🛠\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`end`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`begin str_def`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [],
   "source": [
    "doppelt = \"Ich bin ein String.\"\n",
    "einfach = 'Ich auch!'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`end`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`begin str_ops`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Ich bin ein String. Ich auch!'"
      ]
     },
     "execution_count": 65,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "doppelt + \" \" + einfach  # Zusammenfügen mit +"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'I'"
      ]
     },
     "execution_count": 66,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "einfach[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'!hcua hcI'"
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "einfach[::-1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`end`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`begin print`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hallo Python!\n"
     ]
    }
   ],
   "source": [
    "print(\"Hallo Python!\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Wie darf ich Sie nennen?\n",
      "Daniel Düsentrieb\n",
      "Herzlich Willkommen, Daniel Düsentrieb!\n"
     ]
    }
   ],
   "source": [
    "print(\"Wie darf ich Sie nennen?\")\n",
    "#!name = input()\n",
    "#!print(\"Herzlich Willkommen, \" + name + \"!\")\n",
    "print(\"Daniel Düsentrieb\") #!\n",
    "print(\"Herzlich Willkommen, Daniel Düsentrieb!\") #!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`end`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`begin fstrings`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 118,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Sie haben 905 ungelesene E-Mails!'"
      ]
     },
     "execution_count": 118,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = 905\n",
    "f\"Sie haben {x} ungelesene E-Mails!\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`end`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tuple"
      ]
     },
     "execution_count": 70,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type((1, 2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`begin tuple_def`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [],
   "source": [
    "size = (1920, 1080)  # Tupel mit zwei Einträgen"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Tupel mit Elementen unterschiedlichen Typs sind sehr üblich,\n",
    "# per Konvention legt man fest, was wo zu erwarten ist\n",
    "var_x = ('x', 'm/s', [3, 3.1, 3.4, 3.2])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'m/s'"
      ]
     },
     "execution_count": 73,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Indexierung wie bei Listen\n",
    "var_x[1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 74,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Einige Listenfunktionen gehen auch, solange sie die\n",
    "# Größe und den Inhalt nicht verändern\n",
    "len(var_x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`end`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`begin tuple_destruct`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [],
   "source": [
    "var_name, var_unit, var_values = var_x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'m/s'"
      ]
     },
     "execution_count": 76,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "var_unit"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`end`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`begin tuple_special`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [],
   "source": [
    "empty_tuple = ()  # Das leere Tupel"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [],
   "source": [
    "one_tuple = (4,)  # Tupel mit einem Eintrag"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 79,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "four, = one_tuple  # 1-Tupel \"zerlegen\"\n",
    "four"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`end`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`begin dict_def`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'m/s'"
      ]
     },
     "execution_count": 80,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Definition in geschweiften Klammern nach dem Schema \"key: value\"\n",
    "dict_x = {'name': 'x', 'unit': 'm/s', 'values': [3, 3.1, 3.4, 3.2]}\n",
    "# Lesen und Schreiben jetzt über die Schlüssel\n",
    "dict_x['unit']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'name': 'x', 'unit': 'm/s', 'values': [3, 3.1, 3.4, 3.2, 3.3]}"
      ]
     },
     "execution_count": 81,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dict_x['values'].append(3.3)\n",
    "dict_x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Als Schlüssel können beliebige Konstanten dienen\n",
    "wavelengths = {450: 'blau', 520: 'grün', 590: 'gelb', 620: 'orange', 650: 'rot'}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`end`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`begin dict_more`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{450: 'blau',\n",
       " 520: 'grün',\n",
       " 590: 'gelb',\n",
       " 620: 'orange',\n",
       " 650: 'rot',\n",
       " 400: 'violett'}"
      ]
     },
     "execution_count": 83,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Neue Elemente können jederzeit hinzugefügt werden\n",
    "wavelengths[400] = 'violett'\n",
    "wavelengths"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{450: 'blau', 520: 'grün', 590: 'gelb', 650: 'rot', 400: 'violett'}"
      ]
     },
     "execution_count": 84,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Löschen wie bei Listen\n",
    "del wavelengths[620]\n",
    "wavelengths"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 85,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Existenz von Schlüsseln prüfen\n",
    "'name' in dict_x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 86,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(dict_x)  # Anzahl von Einträgen"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dict_keys(['name', 'unit', 'values'])"
      ]
     },
     "execution_count": 87,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dict_x.keys()  # Alle Schlüssel"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dict_values(['x', 'm/s', [3, 3.1, 3.4, 3.2, 3.3]])"
      ]
     },
     "execution_count": 88,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dict_x.values()  # Alle Werte"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dict_items([('name', 'x'), ('unit', 'm/s'), ('values', [3, 3.1, 3.4, 3.2, 3.3])])"
      ]
     },
     "execution_count": 89,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dict_x.items()  # Einträge als Tupel von Schlüssel und Wert"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`end`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`begin if_def`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "outputs": [],
   "source": [
    "#!if bedingung:\n",
    "    # Führe aus, wenn bedingung wahr\n",
    "#!elif alternativ_bedingung_1:\n",
    "    # Führe aus, wenn vorherige Bedingung nicht zutrifft\n",
    "    # und alternativ_bedingung_1 wahr\n",
    "#!elif alternativ_bedingung_2:\n",
    "    # Führe aus, wenn vorherige Bedingungen nicht zutreffen\n",
    "    # und alternativ_bedingung_2 wahr\n",
    "#!else:\n",
    "    # Führe aus, wenn keine der vorherigen Bedingungen zutreffen"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`end`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`begin if_temp`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Temperatur im Nominalbereich\n"
     ]
    }
   ],
   "source": [
    "temperatur = 20\n",
    "\n",
    "if temperatur < 15:\n",
    "    print('Zu kalt, heizen...')\n",
    "elif temperatur < 25:\n",
    "    print('Temperatur im Nominalbereich')\n",
    "else:\n",
    "    print('Zu heiß, abkühlen...')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`end`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`begin line_continuation`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Variante 1: Impliziter Umbruch in Klammern\n",
    "#!if (eine_sehr_lange_bedingung and\n",
    "#!    noch_eine_sehr_lange_bedingung):\n",
    "#!    ...\n",
    "#_\n",
    "# Variante 2: Expliziter Umbruch mit Backslash\n",
    "#!if eine_sehr_lange_bedingung and \\\n",
    "#!   noch_eine_sehr_lange_bedingung:\n",
    "#!    ..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`end`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`begin truthy_list`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {},
   "outputs": [],
   "source": [
    "#!if meine_liste:  # anstelle len(meine_liste) > 0\n",
    "#!    print('Liste ist nicht leer.')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`end`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`begin while_ex`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "summe 1: 8\n",
      "summe 2: 7\n"
     ]
    }
   ],
   "source": [
    "commands = [1, 4, 3, \"summe 1\", 6, 1, \"summe 2\", \"exit\", 7, 8, 9]\n",
    "current_sum = 0\n",
    "\n",
    "while commands:  # Solange commands noch Elemente enthält\n",
    "    c = commands.pop(0)\n",
    "    \n",
    "    if c == \"exit\":\n",
    "        break  # Verlasse Schleife\n",
    "    elif isinstance(c, str):\n",
    "        print(c + \": \" + str(current_sum))\n",
    "        current_sum = 0\n",
    "        continue  # Springe zum Schleifenanfang\n",
    "    \n",
    "    current_sum += c"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`end`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`begin for_in`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2.4\n",
      "1.7\n",
      "0.8\n",
      "1.1\n"
     ]
    }
   ],
   "source": [
    "measurements = [2.4, 1.7, 0.8, 1.1]\n",
    "for length in measurements:\n",
    "    print(length)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`end`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`begin for_unit`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0: 0.7315200000000001 m\n",
      "1: 0.017 m\n",
      "2: 0.8 m\n",
      "3: 0.33528 m\n"
     ]
    }
   ],
   "source": [
    "measurements = [2.4, 1.7, 0.8, 1.1]\n",
    "units = ['ft', 'cm', 'm', 'ft']\n",
    "unit_scales = {'m': 1, 'cm': 0.01, 'ft': 0.3048}\n",
    "for i, length in enumerate(measurements):\n",
    "    print(str(i) + ': ' + str(length * unit_scales[units[i]]) + ' m')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.7315200000000001\n",
      "0.017\n",
      "0.8\n",
      "0.33528\n"
     ]
    }
   ],
   "source": [
    "#_\n",
    "# Alternative: zip(a, b) gibt eine Sequenz von Tupeln, mit den\n",
    "# Einträgen aus a und b paarweise kombiniert\n",
    "for length, unit in zip(measurements, units):\n",
    "    print(length * unit_scales[unit])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`end`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`begin for_range`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "4\n",
      "9\n"
     ]
    }
   ],
   "source": [
    "for n in range(4):  # Iteriere von 0 (inkl.) bis 4 (exkl.)\n",
    "    print(n**2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "100\n",
      "121\n",
      "144\n",
      "169\n",
      "196\n"
     ]
    }
   ],
   "source": [
    "for n in range(10, 15):  # Start und Stoppwert angegeben\n",
    "    print(n**2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`end`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Funktionen"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`begin fun_convert`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.6096"
      ]
     },
     "execution_count": 100,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def convert_length(amount, from_unit):\n",
    "    units = {'m': 1, 'cm': 1e-2, 'km': 1e3,\n",
    "             'ft': 0.3048, 'in': 0.0254, 'mi': 1609.34}\n",
    "    return amount * units[from_unit]\n",
    "\n",
    "convert_length(2, 'ft')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`end`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`begin fun_optional`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.6096"
      ]
     },
     "execution_count": 101,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def convert_length(amount, from_unit='m', to_unit='m'):\n",
    "    units = {'m': 1, 'cm': 1e-2, 'km': 1e3,\n",
    "             'ft': 0.3048, 'in': 0.0254, 'mi': 1609.34}\n",
    "    if from_unit not in units or to_unit not in units:\n",
    "        return None  # Frühzeitiger Abbruch\n",
    "    \n",
    "    return amount * units[from_unit] / units[to_unit]\n",
    "\n",
    "convert_length(2, 'ft')  # 2 ft in m?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "60.96"
      ]
     },
     "execution_count": 102,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "convert_length(2, 'ft', 'cm')  # 2 ft in cm?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6.561679790026246"
      ]
     },
     "execution_count": 103,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# from_unit hat Standardwert 'm', to_unit wird mit seinem Namen übergeben\n",
    "convert_length(2, to_unit='ft')  # 2 m in ft?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3.21868"
      ]
     },
     "execution_count": 104,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "convert_length(2, from_unit='mi', to_unit='km')  # 2 mi in km?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3.21868"
      ]
     },
     "execution_count": 105,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Bei benannten Argumenten ist die Reihenfolge egal\n",
    "convert_length(from_unit='mi', to_unit='km', amount=2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`end`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`begin fun_pass`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "metadata": {},
   "outputs": [],
   "source": [
    "def design_perpetuum_mobile():\n",
    "    pass"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`end`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`begin fun_scoping`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7"
      ]
     },
     "execution_count": 107,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y = 3\n",
    "def add_y(x):\n",
    "    # greift lesend auf äußere Variable y zu\n",
    "    # definiert funktionsinterne Variable z\n",
    "    z = x + y\n",
    "    return z\n",
    "#_\n",
    "add_y(4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8"
      ]
     },
     "execution_count": 108,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y = 4\n",
    "# Ändert sich y, ändert sich auch das Verhalten der Funktion\n",
    "add_y(4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "NameError: name 'z' is not defined\n"
     ]
    }
   ],
   "source": [
    "# z ist außerhalb der Funktion nicht zugänglich\n",
    "#!z\n",
    "print(\"NameError: name 'z' is not defined\")#!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`end`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Imports"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`begin import_math`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 110,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.9999998001333682"
      ]
     },
     "execution_count": 110,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import math\n",
    "math.sin(22/14) # 22/7 ist eine erstaunlich gute Näherung für Pi"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`end`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`begin import_as`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.999997271884531"
      ]
     },
     "execution_count": 111,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import math as m\n",
    "m.sin((m.sqrt(2) + m.sqrt(3))/2) # π ≈ √2 + √3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`end`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`begin import_from`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.0"
      ]
     },
     "execution_count": 112,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from math import sin, pi as PI\n",
    "sin(PI/2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`end`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`begin import_all`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.0"
      ]
     },
     "execution_count": 113,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from math import *\n",
    "sin(pi/2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`end`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Fehler"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`begin error_colon`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 114,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "  File \"example.py\", line 2\n",
      "    if x != 0\n",
      "             ^\n",
      "SyntaxError: invalid syntax\n"
     ]
    }
   ],
   "source": [
    "#!x = 7\n",
    "#!if x != 0\n",
    "#!    y = 1/x\n",
    "#!     print(y)\n",
    "print('  File \"example.py\", line 2\\n    if x != 0\\n             ^\\nSyntaxError: invalid syntax') #!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`end`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`begin error_indent`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "  File \"example.py\", line 4\n",
      "    print(y)\n",
      "    ^\n",
      "IndentationError: unexpected indent\n"
     ]
    }
   ],
   "source": [
    "#!x = 7\n",
    "#!if x != 0:\n",
    "#!    y = 1/x\n",
    "#!     print(y)\n",
    "print('  File \"example.py\", line 4\\n    print(y)\\n    ^\\nIndentationError: unexpected indent') #!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`end`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`begin error_def_sum`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "metadata": {},
   "outputs": [],
   "source": [
    "def sum(xs):\n",
    "    sum_result = 0\n",
    "    for x in xs:\n",
    "        sum_result += x\n",
    "    return sum_result\n",
    "\n",
    "def mean(xs):\n",
    "    factor = 1/len(xs)  # Skalierungsfaktor 1/n\n",
    "    return factor * sum(xs)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`end`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`begin error_mean`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 117,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "---------------------------------------------------------------------------\n",
      "ZeroDivisionError                         Traceback (most recent call last)\n",
      "\"app.py\" in <module>\n",
      "----> 1 mean([])\n",
      "\"definitions.py\" in mean(xs)\n",
      "      6 \n",
      "      7 def mean(xs):\n",
      "----> 8     factor = 1/len(xs)\n",
      "      9     return factor * sum(xs)\n",
      "\n",
      "ZeroDivisionError: division by zero\n"
     ]
    }
   ],
   "source": [
    "#!mean([])\n",
    "print('---------------------------------------------------------------------------\\nZeroDivisionError                         Traceback (most recent call last)\\n\"app.py\" in <module>\\n----> 1 mean([])\\n\"definitions.py\" in mean(xs)\\n      6 \\n      7 def mean(xs):\\n----> 8     factor = 1/len(xs)\\n      9     return factor * sum(xs)\\n\\nZeroDivisionError: division by zero')#!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`end`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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
}