Python_3_Lambda_Ausdrücke.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 5,
  "metadata": {
    "celltoolbar": "Slideshow",
    "interpreter": {
      "hash": "b73d1a4536618e175e90ff685b834bc4473c0d15eefc412f5790ee72ebe09a54"
    },
    "kernelspec": {
      "display_name": "Python 3.7.11 64-bit ('thesis': conda)",
      "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.7.11"
    },
    "colab": {
      "name": "Python_3_Lambda_Ausdrücke.ipynb",
      "provenance": [],
      "include_colab_link": true
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/ChristophRaab/Smart-VHB-Python-3/blob/main/Python_3_Lambda_Ausdru%CC%88cke.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "86S77Nz3zMD2"
      },
      "source": [
        "# Python 3 Lambda Ausdrücke"
      ],
      "id": "86S77Nz3zMD2"
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "YZbjRb1FzMD5"
      },
      "source": [
        "Diese Präsentation ist ein Jupyter Notebook. Mit Jupyter-Notebooks können gewöhnliche Präsentation-Slides und Code kombiniert dargestellt werden. Eine Code-Slide erkennen Sie an ```In [Zahl]:``` und ```Out[Zahl]:```. Dabei bezeichnet ```In``` den verwendeten Code und ```Out``` die Ausgabe dessen. Achten Sie auf ```#``` Symbole für weitere Informationen.\n"
      ],
      "id": "YZbjRb1FzMD5"
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qU7Y60bnzMD5"
      },
      "source": [
        "## Lernziele \n",
        "- Lambda Ausdrücke können erkannt und implementiert werden.\n",
        "- Die Abgrenzung zwischen Lambda Ausdrücken und Python-Funktionen kann definiert werden.\n",
        "- Sogenannte High-Order Functions können erkannt und implementiert werden.\n",
        "- Anwendung der Built-In High-Order Functions von Python.\n",
        "- Coding Guidelines für Lambda Ausdrücke können benannt werden.   "
      ],
      "id": "qU7Y60bnzMD5"
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "K3IupbGQzMD6"
      },
      "source": [
        "## Vorkenntnisse \n",
        "- Grundlagen in Mathematik \n",
        "- Python 3 Kenntnisse in\n",
        "    - Variablen und Operatoren\n",
        "    - Kontrollstrukturen\n",
        "    - Erweiterte Variablentypen (Datenstrukturen)"
      ],
      "id": "K3IupbGQzMD6"
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "s5xiVTmdzMD6"
      },
      "source": [
        "## Zielgruppe\n",
        "- Studierende in naturwissenschaftlichen Studiengängen\n",
        "- Studierende in Ingenieurstudiengängen \n",
        "- Studierende mit anderweitigem naturwissenschaftlichen/technischen Hintergrund\n",
        "- Studierende mit ersten Erfahrungen in anderen Programmiersprachen"
      ],
      "id": "s5xiVTmdzMD6"
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "HsTJt4R1zMD6"
      },
      "source": [
        "## Aufbau\n",
        "- Lambda Expressions (Ausdrücke) vs. Funktionen\n",
        "- Programmabläufe in Lambda Expressions\n",
        "- Named Lambda Expressions\n",
        "- High-Order Functions\n",
        "- Coding Guidelines"
      ],
      "id": "HsTJt4R1zMD6"
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "5WCWyGUQzMD7"
      },
      "source": [
        "## Lambda Expresssion (Ausdrücke) und  Funktionen\n",
        "## Ein Vergleich\n"
      ],
      "id": "5WCWyGUQzMD7"
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Txpb5F8gzMD7",
        "outputId": "864c0978-6901-4af1-bac5-c85cc71bb8a1"
      },
      "source": [
        "# Die Identity-Funktion gibt einfach das Funktionsargument x zurück.\n",
        "def identity(x):\n",
        "    return x \n",
        "\n",
        "identity(5) # Integer 5 in\n",
        "# Integer 5 out"
      ],
      "id": "Txpb5F8gzMD7",
      "execution_count": null,
      "outputs": [
        {
          "data": {
            "text/plain": [
              "5"
            ]
          },
          "execution_count": 15,
          "metadata": {
            "slideshow": {
              "slide_type": "slide"
            }
          },
          "output_type": "execute_result"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ZERM26_QzMD8"
      },
      "source": [
        "## Syntax \n",
        "Die Syntax von Lambda Expressions ist vergleichbar mit der Syntax von Funktionen:</br>\n",
        "`lambda <Funktionsargument> : <Code>`\n",
        "\n",
        "Dabei ist `lambda` ein reserviertes Keyword von Python selbst. `<Funktionsargument>` und `<Code>` werden vom Entwickler festgelegt. Allerdings darf `<Code>` nicht länger als eine Programmzeile sein.</br>\n",
        "\n",
        "Wenn die Definition, Argumentübergabe und Ausführung von Lambda alles in einer Zeile definiert wird, müssen Klammern verwendet werden:</br>\n",
        "`(lambda <Funktionsargument> : <Code>) (<Funktionsargument>)`</br>\n",
        "Dies wird als \"Immediately Invoked Function Expression\" (IIFE) bezeichnet."
      ],
      "id": "ZERM26_QzMD8"
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "KuK-lJ76zMD9",
        "outputId": "fd86e24f-de3a-4e19-ddd6-770b7abb4b9d"
      },
      "source": [
        "# Lambda-Aquivalent zu der Identity Funktions \n",
        "(lambda x : x)(5)\n",
        "# Erste Klammer definiert die Lambda Funktion.\n",
        "# Zweite Klammer definiert den Input der Lambda Funktion. "
      ],
      "id": "KuK-lJ76zMD9",
      "execution_count": null,
      "outputs": [
        {
          "data": {
            "text/plain": [
              "5"
            ]
          },
          "execution_count": 16,
          "metadata": {
            "slideshow": {
              "slide_type": "slide"
            }
          },
          "output_type": "execute_result"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "GQ2gzRaKzMD9"
      },
      "source": [
        "Lambda Ausdrücke oder auch Expressions genannt sind so genannte anonyme Funktionen. Anonyme deshalb, da sie auch ohne Bezeichner definiert und ausgeführt werden dürfen."
      ],
      "id": "GQ2gzRaKzMD9"
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "dxIYTi-kzMD-"
      },
      "source": [
        "## Logik in Lambda Expressions\n",
        "- Lambda Expressions können Logik, Abläufe oder Berechnungen kapseln.\n",
        "- Innerhalb von Lambda Expressions können Funktionen geschachtelt werden"
      ],
      "id": "dxIYTi-kzMD-"
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Iib16FQtzMD-",
        "outputId": "4b65a653-9606-4f82-a432-7bc09a6d0302"
      },
      "source": [
        "def mul_two(x):\n",
        "    return print(x*2)\n",
        "\n",
        "mul_two(3)\n",
        "(lambda x : print(x * 2))(3)"
      ],
      "id": "Iib16FQtzMD-",
      "execution_count": null,
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "6\n",
            "6\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "T99QCzpwzMD-"
      },
      "source": [
        "## Named Lambda Expression\n",
        "Lambda Expressions können auch wie Funkionen benannt werden. Dadurch können sie wiederverwendet werden. Named Lambda Expressions werden vom Python-Compiler als Funktion interpretiert"
      ],
      "id": "T99QCzpwzMD-"
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ZBA1_AjqzMD_",
        "outputId": "685ad4e3-b32d-4788-ba1d-1b533639297f"
      },
      "source": [
        "# Funktion mit einer geschachtelten Funktion\n",
        "def add_one_print(x):\n",
        "    print(x*2) # Berechnung und \n",
        "               # Funktionsaufruf in der Funktion \n",
        "\n",
        "# Lambda Äquivalent\n",
        "add_one_lambda = lambda x : print(x*2)\n",
        "\n",
        "print(type(add_one_lambda)) # Gib den Typ hinter Bezeichner add_one_lambda aus\n",
        "add_one_print(3) # Funktionsaufruf\n",
        "add_one_lambda(3) # Named Lambda Expression Aufruf"
      ],
      "id": "ZBA1_AjqzMD_",
      "execution_count": null,
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "<class 'function'>\n",
            "6\n",
            "6\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "pVKuXFRizMD_"
      },
      "source": [
        "## Lambda Expressions mit mehreren Parametern\n",
        "Die Syntax mit mehreren Parametern ist wieder vergleichbar zu Funktionen:\n",
        "\n",
        "`lambda <Funktionsargument1>,<Funktionsargument2> : <Code>`"
      ],
      "id": "pVKuXFRizMD_"
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "0wbyV-vfzMD_",
        "outputId": "910d9efa-b9f1-41f3-ecbf-f8b7a84ba78c"
      },
      "source": [
        "# Beispiel n-the Potenz mit Standardwert 2. \n",
        "# Wenn nichts weiter übergeben, wird der Wert 2 verwendet.\n",
        "nthpower = lambda x,n=2 : x**n\n",
        "\n",
        "\n",
        "print(nthpower(4)) # Ausgabe von 4^2\n",
        "print(nthpower(4,3)) # Ausgabe von 4^3"
      ],
      "id": "0wbyV-vfzMD_",
      "execution_count": null,
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "16\n",
            "64\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "r_MmQeCZzMD_",
        "outputId": "3f790675-80e5-4c34-d8e2-98f2b28a0aa3"
      },
      "source": [
        "# Weitere Beispiele von Lambda Expressions\n",
        "\n",
        "# Lambda Expression mit sogenanntem Named Argument \n",
        "# für die Variable x,y,z und einem Default-Wert für z = 3.\n",
        "print((lambda x,y,z : x + y+ z) (x=1,y=2,z=3))\n",
        "\n",
        "# Lambda Expression welches *args erwarten.\n",
        "# *args ist ein Iterator und erwartet \n",
        "# beliebig viele Funktionsargumente\n",
        "print((lambda *args : sum(args)) (1,2,3))\n",
        "print((lambda *args : sum(args)) (1,2,3,4))"
      ],
      "id": "r_MmQeCZzMD_",
      "execution_count": null,
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "6\n",
            "6\n",
            "10\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "XcjeDOVFzMD_"
      },
      "source": [
        "## Synonyme zu Lambda Expression\n",
        "In der Python-Community haben sich für die Lambda Expressions verschiedene Synonyme etabliert. So werden die folgenden Begriffe synonym behandelt:\n",
        "- Lambda Functions \n",
        "- Lambda Expressions\n",
        "- Lambda Abstractions\n",
        "- Lambda Forms"
      ],
      "id": "XcjeDOVFzMD_"
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "RL1BFrnazMEA"
      },
      "source": [
        "## High Order Functions\n",
        "Eine sogenannte \"Higher Order Function\" ist eine Funktion die entweder eine oder mehrere Funktionen als Funktionsargument erwartet oder eine oder mehrere Funktionen zurück gibt. "
      ],
      "id": "RL1BFrnazMEA"
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "BkYo_BDfzMEA",
        "outputId": "08853b51-3e97-4237-d417-6403eb60577f"
      },
      "source": [
        "# Beispiel\n",
        "\n",
        "ho_func = lambda x, function : x + function(x)\n",
        "# Zweites Funktionsargument ist eine Funktion.\n",
        "# Daher erwartet ho_func entweder eine Funkion \n",
        "# oder eine andere Lambda Expression.\n",
        "def secpow(x): return x * x # Funktion\n",
        "secpow_lambda = lambda x : x*x  # Lambda Expression\n",
        "print(ho_func(2 , secpow ))\n",
        "print(ho_func(2,secpow_lambda))\n",
        "# Funktionen werden ohne Klammern übergeben."
      ],
      "id": "BkYo_BDfzMEA",
      "execution_count": null,
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "6\n",
            "6\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "wIVnpvuczMEA"
      },
      "source": [
        "# Standard Higher Order Functions\n",
        "Die Python Programmiersprache bietet standardmäßig sogenannte \"built-in\" Higher Order Functions an. Beispielsweise \n",
        "- map() => Wendet übergebene Funktion auf übergebe Variable an\n",
        "- filter() => Filter übergebene Variable via übergebene Funktion\n",
        "- sort() => Sortiert eine Liste\n",
        "- all() = > Gibt True zurück, wenn alle Elemente übergebenen Argumente True sind sonst False.\n",
        "- min() => Gibt kleinste Zahl einer Liste zurück\n",
        "- max() => Gibt größte Zahl einer Liste zurück"
      ],
      "id": "wIVnpvuczMEA"
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "CPZR-qfzzMEA",
        "outputId": "5be9e551-fcfa-4613-d4a7-7f191e2d8ab5"
      },
      "source": [
        "# Beispiel Map\n",
        "numbs = [2,4,6]\n",
        "square = lambda x : x *x \n",
        "squared = map(square,numbs)\n",
        "print(squared) # Gibt Map Iterator zurück\n",
        "\n",
        "# Konvertiert Iterator zu Liste.\n",
        "print(list(squared)) \n",
        "# Wichtig: Map wird erst zu dieser Zeit ausgeführt!"
      ],
      "id": "CPZR-qfzzMEA",
      "execution_count": null,
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "<map object at 0x7f8d704a3350>\n",
            "[4, 16, 36]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "wPawk1wXzMEA",
        "outputId": "73121b22-043b-47d8-c8a3-d63f4bedecc1"
      },
      "source": [
        "# Beispiel Filter \n",
        "numbs = [1 ,2 ,3 ,4 ,5 ,6 ,7 ,8 ]\n",
        "def check_even(x):  \n",
        "    if x % 2 == 0:return True\n",
        "    else: return False\n",
        "\n",
        "print(list(filter(check_even,numbs)))\n",
        "# Alle Schritte in einer Zeile zusammengefasst.\n",
        "# Filter, Iterator, Konvertierung zur Liste und Ausgabe."
      ],
      "id": "wPawk1wXzMEA",
      "execution_count": null,
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[2, 4, 6, 8]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "IAyvZVRzzMEA",
        "outputId": "739e374b-6e84-4968-d071-736b1ca89e8b"
      },
      "source": [
        "# Beispiel für das Filtern mit If-Else Kontrollstruktur\n",
        "# Dabei ist die Syntax der If-Else Abfrage gleich zur \n",
        "# Syntax bei der Erstellung der einer Variablen.\n",
        "list(map(lambda x: 'a' if x<5 else 'b',[0,1,2,3,7,8]))"
      ],
      "id": "IAyvZVRzzMEA",
      "execution_count": null,
      "outputs": [
        {
          "data": {
            "text/plain": [
              "['a', 'a', 'a', 'a', 'b', 'b']"
            ]
          },
          "execution_count": 24,
          "metadata": {
            "slideshow": {
              "slide_type": "slide"
            }
          },
          "output_type": "execute_result"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "cjgSI7P-zMEB"
      },
      "source": [
        "## Coding Guidelines \n",
        "- Zwar können Lambda Expressions vielfältig eingesetzt werden, allerdings gibt es einiges zu beachten, da sonst das nachträgliche Verstehen und das Debugging schwierig wird. \n",
        "- Daher sollten Lambda Expressions nur gezielt eingesetzt werden\n",
        "\n",
        "Nachfolgend einige Beispiele die es zu vermeiden gilt."
      ],
      "id": "cjgSI7P-zMEB"
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "lctPMG78zMEB"
      },
      "source": [
        "## Guideline Documentation\n",
        "- Lambda Expressions können nicht wie üblich Dokumentiert werden.\n",
        "- D.h. das Docstring Element fehlt und daher kann Beispielsweise eine IDE keine Dokumentation von Lambda Expression aufrufen. \n",
        "- Des Weiteren fehlt jedem Dritten die Information über die Funktionalität.\n",
        "- Daher sollte die Lambda Expression selbsterklärend sein."
      ],
      "id": "lctPMG78zMEB"
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "0R19sMXRzMEB"
      },
      "source": [
        "## Guideline Exception\n",
        "- Da Lambda Expressions nicht gut debuggt werden können, sollten sie daher nicht zum werfen eine Expection verwendet werden. \n",
        "- Dritte werden Probleme haben, die Fehlermeldung korrekt nachzuvollziehen und einen möglichen Fehler zu beheben.\n",
        "- Beispielsweise sollte folgendes vermieden werden:</br>\n",
        "`def throw(ex): raise ex`</br>\n",
        "`(lambda: throw(Exception('Something bad happened')))()` \n"
      ],
      "id": "0R19sMXRzMEB"
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "a3FpG4n-zMEB"
      },
      "source": [
        "## Guideline Kryptische Funktion\n",
        "- Da Lambda Expressions nicht dokumentiert werden können muss klar sein:\n",
        "    - Usecase\n",
        "    - und  Funktionalität\n",
        "- Komplizierte Berechnungen oder Programmlogik sollten daher in eine Funktion geschrieben werden.  "
      ],
      "id": "a3FpG4n-zMEB"
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "oNpbeilPzMEB",
        "outputId": "dc580310-278d-47fa-ccc4-b82ff9f739d4"
      },
      "source": [
        "# Beispiel Kryptische Lambda Expression\n",
        "# Das Underscore (_) ermöglicht das Verwenden einer Variablen ohne Namen.\n",
        "# Dies erschwert Nachvollziehbarkeit.\n",
        "print((lambda _: list(map(lambda _: _ // 2, _)))\n",
        "    ([1,2,3,4,5,6,7,8,9,10]))\n"
      ],
      "id": "oNpbeilPzMEB",
      "execution_count": null,
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[0, 1, 1, 2, 2, 3, 3, 4, 4, 5]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "DDPdZ4DBzMEC",
        "outputId": "d62875b9-b389-489b-d8cb-69b280fe464f"
      },
      "source": [
        "# Komplizierte Rechnungen sollten in eine Funktion, da sonst nicht richtig Dokumentiert. \n",
        "# Demonstriert im folgendem Beispiel zur Berechnung eines Gaussian Kernels mit der Zahl 2.\n",
        "import math\n",
        "print((lambda _: list(map(lambda _: math.exp( (_ - 2) / 1.5**2), _)))([1,2,3,4,5,6,7,8,9,10]))"
      ],
      "id": "DDPdZ4DBzMEC",
      "execution_count": null,
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[0.6411803884299546, 1.0, 1.5596234976067807, 2.4324254542872077, 3.7936678946831774, 5.916693590664329, 9.227814352139525, 14.391916095149892, 22.445970517581, 35.00726304580835]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "9r-zfxBjzMEC",
        "outputId": "400d8140-f497-4094-9b25-84270d7466ae"
      },
      "source": [
        "%%html\n",
        "<script>var code_show=!1;function code_toggle(){var e,d;code_show?(null!=(e=document.getElementsByClassName(\"jp-CodeMirrorEditor jp-Editor jp-InputArea-editor\")[12])&&(e.style.display=\"\"),null!=(d=document.querySelector(\"div.cell.code_cell.rendered.selected div.input\"))&&(d.style.display=\"\")):(null!=(e=document.getElementsByClassName(\"jp-CodeMirrorEditor jp-Editor jp-InputArea-editor\")[12])&&(e.style.display=\"none\"),null!=(d=document.querySelector(\"div.cell.code_cell.rendered.selected div.input\"))&&(d.style.display=\"none\"));code_show=!code_show}code_toggle();</script>Zum Anzeigen des verwendeten Javascript klicken Sie <a onClick=\"code_toggle(); return false;\" >hier</a>.<center><h1>Single Choice Fragen</h1></center><p><form name=\"quiz\"><p><b>Frage 1.<br>Welche der folgenden Aussagen stimmt über Lambda Expressions?<br></b><blockquote><input type=\"radio\" name=\"q1\" value=\"first\">Sind immer selbsterklärend.<br><input type=\"radio\" name=\"q1\" value=\"second\">High Order Functions können mit ihnen kombiniert werden.<br><input type=\"radio\" name=\"q1\" value=\"third\">Lambda Expressions eignen sich für Exceptions.<br></blockquote><p><b><hr>Frage 2.<br>Welche der folgenden Codezeilen stimmt?<br></b><blockquote><input type=\"radio\" name=\"q2\" value=\"first\">(lambda x,y : x * y)(x=2,3)<br><input type=\"radio\" name=\"q2\" value=\"second\">(lambda x,y : x * y)(2,y=3)<br><input type=\"radio\" name=\"q2\" value=\"thrid\">(lambda x,y : x * y)(2)<br></blockquote><p><b><hr><input type=\"button\"value=\"Einreichen\"onClick=\"getScore(this.form);\"><input type=\"reset\" value=\"Auswahl löschen\"><p>Von 2 Fragen sind richtig: <input type=text size 15 name=\"mark\"> Genauigkeit=<input type=text size=15 name=\"percentage\"><br></form><p><form method=\"post\" name=\"Form\" onsubmit=\"\" action=\"\"></form></body><script>var numQues=2;var numChoi=3;var answers=new Array(numQues);answers[0]=\"second\";answers[1]=\"second\";function getScore(form){var score=0;var currElt;var currSelection;for (i=0; i<numQues; i++){currElt=i*numChoi;answered=false;for (j=0; j<numChoi; j++){currSelection=form.elements[currElt + j];if (currSelection.checked){answered=true;if (currSelection.value==answers[i]){score++;break;}}}if (answered===false){alert(\"Bitte alle Fragen beantworten!\") ;return false;}}var scoreper=Math.round(score/numQues*100);form.percentage.value=scoreper + \"%\";form.mark.value=score;}</script>"
      ],
      "id": "9r-zfxBjzMEC",
      "execution_count": null,
      "outputs": [
        {
          "data": {
            "text/html": [
              "<script>var code_show=!1;function code_toggle(){var e,d;code_show?(null!=(e=document.getElementsByClassName(\"jp-CodeMirrorEditor jp-Editor jp-InputArea-editor\")[12])&&(e.style.display=\"\"),null!=(d=document.querySelector(\"div.cell.code_cell.rendered.selected div.input\"))&&(d.style.display=\"\")):(null!=(e=document.getElementsByClassName(\"jp-CodeMirrorEditor jp-Editor jp-InputArea-editor\")[12])&&(e.style.display=\"none\"),null!=(d=document.querySelector(\"div.cell.code_cell.rendered.selected div.input\"))&&(d.style.display=\"none\"));code_show=!code_show}code_toggle();</script>Zum Anzeigen des verwendeten Javascript klicken Sie <a onClick=\"code_toggle(); return false;\" >hier</a>.<center><h1>Single Choice Fragen</h1></center><p><form name=\"quiz\"><p><b>Frage 1.<br>Welche der folgenden Aussagen stimmt über Lambda Expressions?<br></b><blockquote><input type=\"radio\" name=\"q1\" value=\"first\">Sind immer selbsterklärend.<br><input type=\"radio\" name=\"q1\" value=\"second\">High Order Functions können mit ihnen kombiniert werden.<br><input type=\"radio\" name=\"q1\" value=\"third\">Lambda Expressions eignen sich für Exceptions.<br></blockquote><p><b><hr>Frage 2.<br>Welche der folgenden Codezeilen stimmt?<br></b><blockquote><input type=\"radio\" name=\"q2\" value=\"first\">(lambda x,y : x * y)(x=2,3)<br><input type=\"radio\" name=\"q2\" value=\"second\">(lambda x,y : x * y)(2,y=3)<br><input type=\"radio\" name=\"q2\" value=\"thrid\">(lambda x,y : x * y)(2)<br></blockquote><p><b><hr><input type=\"button\"value=\"Einreichen\"onClick=\"getScore(this.form);\"><input type=\"reset\" value=\"Auswahl löschen\"><p>Von 2 Fragen sind richtig: <input type=text size 15 name=\"mark\"> Genauigkeit=<input type=text size=15 name=\"percentage\"><br></form><p><form method=\"post\" name=\"Form\" onsubmit=\"\" action=\"\"></form></body><script>var numQues=2;var numChoi=3;var answers=new Array(numQues);answers[0]=\"second\";answers[1]=\"second\";function getScore(form){var score=0;var currElt;var currSelection;for (i=0; i<numQues; i++){currElt=i*numChoi;answered=false;for (j=0; j<numChoi; j++){currSelection=form.elements[currElt + j];if (currSelection.checked){answered=true;if (currSelection.value==answers[i]){score++;break;}}}if (answered===false){alert(\"Bitte alle Fragen beantworten!\") ;return false;}}var scoreper=Math.round(score/numQues*100);form.percentage.value=scoreper + \"%\";form.mark.value=score;}</script>\n"
            ],
            "text/plain": [
              "<IPython.core.display.HTML object>"
            ]
          },
          "metadata": {
            "slideshow": {
              "slide_type": "slide"
            }
          },
          "output_type": "display_data"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "IuUhjYYZzMEC"
      },
      "source": [
        "\n",
        "# Zusammenfassung \n",
        "- Lambda Expressions kapseln Programmlogik ohne dafür eine Funktion definieren zu müssen.\n",
        "    - Sind daher Funktionen in Syntax und Funktionsweise sehr ähnlich.\n",
        "- Mit Built-In Funktionen wie map oder filter können dadurch sehr klar und schnell, große Funktionsabläufe programmiert werden.\n",
        "- Allerdings muss darauf geachtet werden, dass die Lambda Expression gut dokumentiert oder selbsterklärend ist. \n",
        "- Wenn der Programmablauf nicht in eine Codezeile des Editors passt, sollte eine eigene Funktion implementiert werden. \n",
        "- Abschließend sollten Lambdas nicht für Exceptions verwendet werden, da sie schwer zu Debuggen sind.  "
      ],
      "id": "IuUhjYYZzMEC"
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "a8EIKjY2zMEC"
      },
      "source": [
        "## Quellen und Weiterführendes\n",
        "- https://realpython.com/python-lambda\n",
        "- https://www.programiz.com/python-programming/methods/built-in/map \n",
        "- https://www.programiz.com/python-programming/methods/built-in/filter "
      ],
      "id": "a8EIKjY2zMEC"
    }
  ]
}