Initial push.
This commit is contained in:
@@ -0,0 +1,419 @@
|
||||
{
|
||||
"cells": [
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {
|
||||
"slideshow": {
|
||||
"slide_type": "slide"
|
||||
}
|
||||
},
|
||||
"source": [
|
||||
"# Software Entwicklung \n",
|
||||
"\n",
|
||||
"## Kapitel 4: Funktionen\n",
|
||||
"\n",
|
||||
"Bislang wurden lediglich Operationen verwendet, die bereits im Sprachumfang von Python enthalten sind, wie \n",
|
||||
"z.B. Built-In Funktionen, Infix-Operatoren oder Funktionen eines gegebenen Datentyps in Dot-Notation. \n",
|
||||
"In diesem Kapitel wird vorgestellt, wie eigene Funktionen definiert und genutzt werden können."
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {
|
||||
"slideshow": {
|
||||
"slide_type": "slide"
|
||||
}
|
||||
},
|
||||
"source": [
|
||||
"### 4.1 Funktionsdefinition und -aufruf\n",
|
||||
"Die Definition einer Funktion wird eingeleitet durch das Schlüsselwort <code>def</code> gefolgt vom \n",
|
||||
"Namen der Funktion, einer Parameterliste und einem Doppelpunkt. Danach werden die Befehle der Funktion, \n",
|
||||
"auch *Funktionsrumpf* genannt, eingerückt angegeben."
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {
|
||||
"pycharm": {
|
||||
"is_executing": false,
|
||||
"name": "#%%\n"
|
||||
}
|
||||
},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"def name_der_funktion():\n",
|
||||
" print(1)\n",
|
||||
" print(2)"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {
|
||||
"slideshow": {
|
||||
"slide_type": "slide"
|
||||
}
|
||||
},
|
||||
"source": [
|
||||
"Allein durch die Definition der Funktion wird noch kein Code aus dem Funktionsrumpf ausgeführt. Dies geschieht \n",
|
||||
"erst, indem die Funktion aufgerufen wird. "
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {
|
||||
"pycharm": {
|
||||
"is_executing": false,
|
||||
"name": "#%%\n"
|
||||
}
|
||||
},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"print(name_der_funktion())"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {
|
||||
"slideshow": {
|
||||
"slide_type": "-"
|
||||
}
|
||||
},
|
||||
"source": [
|
||||
"Man sieht in diesem Beispiel auch, dass die Zellen eines Jupyter-Notebooks nicht voneinander unabhängig sind,\n",
|
||||
"sondern sich einen Namensraum teilen. Die in der ersten Zelle definierte Funktion ist nach ihrer Ausführung \n",
|
||||
"anschließend in der zweiten Zelle bekannt. Das gilt für alle Vereinbarungen wie z.B. auch Variablen."
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {
|
||||
"slideshow": {
|
||||
"slide_type": "slide"
|
||||
}
|
||||
},
|
||||
"source": [
|
||||
"### 4.2 Rückgabewerte\n",
|
||||
"\n",
|
||||
"Wie schon früher einmal ausgeführt liefert jede Operation in Python einen Wert zurück. Bei der oben defnierten\n",
|
||||
"Funktion ist dies <code>None</code>, weil keine anderen Anweisungen gegeben wurden. "
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {
|
||||
"pycharm": {
|
||||
"is_executing": false,
|
||||
"name": "#%%\n"
|
||||
}
|
||||
},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"print(name_der_funktion())"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {
|
||||
"slideshow": {
|
||||
"slide_type": "slide"
|
||||
}
|
||||
},
|
||||
"source": [
|
||||
"Soll die Funktion einen Rückgabewert besitzen, so ist dieser mit dem Schlüsselwort <code>return</code> \n",
|
||||
"anzugeben."
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {
|
||||
"pycharm": {
|
||||
"is_executing": false,
|
||||
"name": "#%%\n"
|
||||
}
|
||||
},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"def immer_drei():\n",
|
||||
" return 3\n",
|
||||
"\n",
|
||||
"print(immer_drei())"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {
|
||||
"slideshow": {
|
||||
"slide_type": "slide"
|
||||
}
|
||||
},
|
||||
"source": [
|
||||
"Die Ausführung des Funktionsrumpfs wird mit einer <code>return</code>-Anweisung beendet. Sollte der Rumpf\n",
|
||||
"danach weitere Anweisungen beitzen, werden diese nicht ausgeführt."
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {
|
||||
"pycharm": {
|
||||
"is_executing": false,
|
||||
"name": "#%%\n"
|
||||
}
|
||||
},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"def immer_drei():\n",
|
||||
" if 3 < 4:\n",
|
||||
" return 3\n",
|
||||
" if 4 < 3:\n",
|
||||
" return \"Hallo\"\n",
|
||||
" print(\"Noch in der Funktion\")\n",
|
||||
"\n",
|
||||
"print(immer_drei())"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {
|
||||
"slideshow": {
|
||||
"slide_type": "slide"
|
||||
}
|
||||
},
|
||||
"source": [
|
||||
"Anders als in anderen Programmiersprachen ist der Datentyp des Rückgabewertes in Python nicht \n",
|
||||
"festgelegt. Es kann also durchaus vorkommen, dass ein Kontrollflusszweig im Methodenrumpf einen\n",
|
||||
"*String* zurückgibt, ein anderer einen *Integer*-Wert und wieder ein anderer nichts bzw. <code>None</code>."
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {
|
||||
"slideshow": {
|
||||
"slide_type": "slide"
|
||||
}
|
||||
},
|
||||
"source": [
|
||||
"Natürlich sind auch komplexere Rückgabetypen wie Listen oder Tupel zulässig. Tupel sind eine verbreitete\n",
|
||||
"Möglichkeit, mehr als einen Wert zurückzugeben, was in anderen Programmiersprachen oft schwieriger \n",
|
||||
"zu realisieren ist."
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {
|
||||
"pycharm": {
|
||||
"is_executing": false,
|
||||
"name": "#%%\n"
|
||||
}
|
||||
},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"def immer_drei_ohne_fehler():\n",
|
||||
" return (3, False)\n",
|
||||
" \n",
|
||||
" \n",
|
||||
"ergebnis, fehler = immer_drei_ohne_fehler()\n",
|
||||
"print(ergebnis)\n",
|
||||
"print(fehler)"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {
|
||||
"slideshow": {
|
||||
"slide_type": "slide"
|
||||
}
|
||||
},
|
||||
"source": [
|
||||
"### 4.3 Gültigkeitsbereich von Variablen\n",
|
||||
"\n",
|
||||
"Variablen \"entstehen\" in Python durch die Zuweisung eines Wertes. Findet diese Zuweisung \n",
|
||||
"in einer Funktion statt, so entsteht eine *lokale Variable*, die nur in dieser Funktion bekannt ist.\n",
|
||||
"Erfolgt die Zuweisung außerhalb einer Funktion, so ist es eine *globale Variable*, die in \n",
|
||||
"allen Funktionen der jeweiligen Programmdatei bekannt ist. "
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {
|
||||
"pycharm": {
|
||||
"is_executing": false,
|
||||
"name": "#%%\n"
|
||||
},
|
||||
"slideshow": {
|
||||
"slide_type": "subslide"
|
||||
}
|
||||
},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"def test_variablen():\n",
|
||||
" lokale_varibale = 1\n",
|
||||
" print(lokale_varibale)\n",
|
||||
" print(globale_variable)\n",
|
||||
"\n",
|
||||
"globale_variable = 2\n",
|
||||
"test_variablen()\n",
|
||||
"print(globale_variable)\n",
|
||||
"print(lokale_varibale)"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {
|
||||
"slideshow": {
|
||||
"slide_type": "slide"
|
||||
}
|
||||
},
|
||||
"source": [
|
||||
"Wird in einer Funktion einer Variablen ein Wert zugewiesen, die bereits als globale Variable \n",
|
||||
"initialisiert ist, so entsteht eine zusätzliche lokale Variable, die die globale Variable verdeckt. "
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {
|
||||
"pycharm": {
|
||||
"is_executing": false,
|
||||
"name": "#%%\n"
|
||||
}
|
||||
},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"def verdeckte_variablen():\n",
|
||||
" a = 2\n",
|
||||
" print(a)\n",
|
||||
"\n",
|
||||
"a = 1\n",
|
||||
"verdeckte_variablen()\n",
|
||||
"print(a)"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {
|
||||
"slideshow": {
|
||||
"slide_type": "slide"
|
||||
}
|
||||
},
|
||||
"source": [
|
||||
"Eine Variable kann nicht \"verzögert\" zu einer lokalen Variable werden."
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {
|
||||
"pycharm": {
|
||||
"is_executing": false,
|
||||
"name": "#%%\n"
|
||||
}
|
||||
},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"def keine_verzoegerte_lokale_variablen():\n",
|
||||
" print(b)\n",
|
||||
" b = 2\n",
|
||||
" print(b)\n",
|
||||
"\n",
|
||||
"b = 1\n",
|
||||
"keine_verzoegerte_lokale_variablen()\n",
|
||||
"print(b)"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {
|
||||
"slideshow": {
|
||||
"slide_type": "slide"
|
||||
}
|
||||
},
|
||||
"source": [
|
||||
"Soll das Verdecken einer globalen Variable verhindert werden, d.h. die Zuweisung eines\n",
|
||||
"Wertes an eine globale Variable erlaubt werden, so muss diese Variable mit dem \n",
|
||||
"Schlüsselwort <code>global</code> ausgewiesen werden."
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {
|
||||
"pycharm": {
|
||||
"is_executing": false,
|
||||
"name": "#%%\n"
|
||||
}
|
||||
},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"def keine_verdeckte_variable():\n",
|
||||
" global c\n",
|
||||
" c = 2\n",
|
||||
" print(c)\n",
|
||||
"\n",
|
||||
"c = 1\n",
|
||||
"keine_verdeckte_variable()\n",
|
||||
"print(c)\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {
|
||||
"slideshow": {
|
||||
"slide_type": "slide"
|
||||
}
|
||||
},
|
||||
"source": [
|
||||
"Sollte die mit <code>global</code> ausgewiesene Variable erstmals in der Funktion mit\n",
|
||||
"einem Wert versorgt werden, so wird sie als *globale Variable* angelegt."
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {
|
||||
"pycharm": {
|
||||
"is_executing": false,
|
||||
"name": "#%%\n"
|
||||
}
|
||||
},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"def keine_verdeckte_variable():\n",
|
||||
" global d\n",
|
||||
" d = 2\n",
|
||||
" print(d)\n",
|
||||
"\n",
|
||||
"keine_verdeckte_variable()\n",
|
||||
"print(d)"
|
||||
]
|
||||
}
|
||||
],
|
||||
"metadata": {
|
||||
"celltoolbar": "Slideshow",
|
||||
"kernelspec": {
|
||||
"display_name": "Python 3 (ipykernel)",
|
||||
"language": "python",
|
||||
"name": "python3"
|
||||
},
|
||||
"language_info": {
|
||||
"codemirror_mode": {
|
||||
"name": "ipython",
|
||||
"version": 3
|
||||
},
|
||||
"file_extension": ".py",
|
||||
"mimetype": "text/x-python",
|
||||
"name": "python",
|
||||
"nbconvert_exporter": "python",
|
||||
"pygments_lexer": "ipython3",
|
||||
"version": "3.9.9"
|
||||
}
|
||||
},
|
||||
"nbformat": 4,
|
||||
"nbformat_minor": 1
|
||||
}
|
||||
@@ -0,0 +1,696 @@
|
||||
{
|
||||
"cells": [
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {
|
||||
"slideshow": {
|
||||
"slide_type": "slide"
|
||||
}
|
||||
},
|
||||
"source": [
|
||||
"# Software Entwicklung \n",
|
||||
"\n",
|
||||
"## Kapitel 4: Funktionen\n",
|
||||
"\n",
|
||||
"### 4.4 Funktionsparameter \n",
|
||||
"\n",
|
||||
"Globale Variablen sind keine gute Idee, um Werte in Funktionen verfügbar zu machen, da schnell der\n",
|
||||
"Überblick verloren geht, welche Variable in welcher Funktion gelesen oder sogar geändert wird.\n",
|
||||
"Auch würde ein solches Vorgehen erfordern, dass man funktionsübergreifend Variablennamen im \n",
|
||||
"Blick behält, was ebenfalls bei komplexeren Aufgaben ein schwieriges Unterfangen ist."
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {
|
||||
"slideshow": {
|
||||
"slide_type": "slide"
|
||||
}
|
||||
},
|
||||
"source": [
|
||||
"Daher verwendet man besser *Funktionsparameter*, um Werte von der aufrufenden Programmstelle \n",
|
||||
"in eine Funktion zu übergeben. Die erwarteten Parameter werden bei der Funktionsdefinition\n",
|
||||
"und beim Funktionsaufruf zwischen den runden Klammern aufgeführt. "
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {
|
||||
"pycharm": {
|
||||
"is_executing": false,
|
||||
"name": "#%%\n"
|
||||
}
|
||||
},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"def drucke_addition(a, b):\n",
|
||||
" print(a+b)\n",
|
||||
"\n",
|
||||
"drucke_addition(4, 7)"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {
|
||||
"slideshow": {
|
||||
"slide_type": "slide"
|
||||
}
|
||||
},
|
||||
"source": [
|
||||
"Natürlich können auch Werte aus Variablen beim Funktionsaufruf übergeben werden. \n",
|
||||
"Dabei sind die Variablen- und Parameternamen völlig unabhängig. "
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {
|
||||
"pycharm": {
|
||||
"is_executing": false,
|
||||
"name": "#%%\n"
|
||||
}
|
||||
},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"def drucke_addition(a, b):\n",
|
||||
" print(a+b)\n",
|
||||
"\n",
|
||||
"x=1\n",
|
||||
"y=2\n",
|
||||
"drucke_addition(x, y)"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {
|
||||
"slideshow": {
|
||||
"slide_type": "slide"
|
||||
}
|
||||
},
|
||||
"source": [
|
||||
"Um berechnete Werte aus einer Funktion an die Außenwelt unter Vermeidung von\n",
|
||||
"globalen Variablen zurückzugeben, sollten Rückgabewerte benutzt werden."
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {
|
||||
"pycharm": {
|
||||
"is_executing": false,
|
||||
"name": "#%%\n"
|
||||
}
|
||||
},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"def tausche(a, b):\n",
|
||||
" return (b, a)\n",
|
||||
"\n",
|
||||
"x=\"Erster\"\n",
|
||||
"y=\"Zweiter\"\n",
|
||||
"x, y = tausche(x, y) \n",
|
||||
"print(x, y)"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {
|
||||
"slideshow": {
|
||||
"slide_type": "slide"
|
||||
}
|
||||
},
|
||||
"source": [
|
||||
"### 4.5 Identität vs. Gleichheit\n",
|
||||
"\n",
|
||||
"In der Informatik wird zwischen *Identität* und *Gleichheit* unterschieden. Zwei \n",
|
||||
"Variablen sind gleich, wenn sie den gleichen Wert enthalten. Dies wird typischerweise\n",
|
||||
"durch das Doppel-Gleichheitszeichen <code>==</code> überprüft."
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {
|
||||
"pycharm": {
|
||||
"name": "#%%\n"
|
||||
}
|
||||
},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"x=5\n",
|
||||
"y=5\n",
|
||||
"if x == y:\n",
|
||||
" print(\"Gleich!\")"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {
|
||||
"slideshow": {
|
||||
"slide_type": "slide"
|
||||
}
|
||||
},
|
||||
"source": [
|
||||
"Die Identität von zwei Variablen ist dann gegeben, wenn sie auf das gleiche Objekt im\n",
|
||||
"Speicher verweisen. Überprüft wird dies in Python durch den Infix-Operator <code>is</code>. "
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {
|
||||
"pycharm": {
|
||||
"is_executing": false,
|
||||
"name": "#%%\n"
|
||||
}
|
||||
},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"x=5\n",
|
||||
"y=5\n",
|
||||
"if x is y:\n",
|
||||
" print(\"Identisch!\")"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {
|
||||
"slideshow": {
|
||||
"slide_type": "slide"
|
||||
}
|
||||
},
|
||||
"source": [
|
||||
"Außerdem kann mit der Built-In Funktion <code>id</code> eine Art *Speicheradresse* eines Werts \n",
|
||||
"ermittelt werden, der bei identischen Werten gleich ist. "
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {
|
||||
"pycharm": {
|
||||
"is_executing": false,
|
||||
"name": "#%%\n"
|
||||
}
|
||||
},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"x=\"Hello\"\n",
|
||||
"y=\"Hello\"\n",
|
||||
"\n",
|
||||
"print(id(x))\n",
|
||||
"print(id(y))"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {
|
||||
"slideshow": {
|
||||
"slide_type": "slide"
|
||||
}
|
||||
},
|
||||
"source": [
|
||||
"Bei Datentypen, deren Werte unveränderlich sind, können Identität und Gleichheit synonym verwendet werden. \n",
|
||||
"In Python sind dies\n",
|
||||
"\n",
|
||||
"* Zahlen\n",
|
||||
"* Strings\n",
|
||||
"* <code>True</code> und <code>False</code>\n",
|
||||
"* Tupel"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {
|
||||
"slideshow": {
|
||||
"slide_type": "slide"
|
||||
}
|
||||
},
|
||||
"source": [
|
||||
"Variablen, die diese Art von Datentypen enthalten, ändern somit automatisch ihre Identität, wenn\n",
|
||||
"sich ihr Wert ändert."
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {
|
||||
"pycharm": {
|
||||
"is_executing": false,
|
||||
"name": "#%%\n"
|
||||
}
|
||||
},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"x=17\n",
|
||||
"print(id(x))\n",
|
||||
"x = x + 1\n",
|
||||
"print(id(x))"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {
|
||||
"slideshow": {
|
||||
"slide_type": "slide"
|
||||
}
|
||||
},
|
||||
"source": [
|
||||
"Bei veränderlichen Datentypen wie Listen ist es aber möglich, dass \n",
|
||||
"sich ihr Wert ändert, ohne dass sie ihre Identität verlieren. "
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {
|
||||
"pycharm": {
|
||||
"is_executing": false,
|
||||
"name": "#%%\n"
|
||||
}
|
||||
},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"liste = [1, 2, 3]\n",
|
||||
"print(id(liste))\n",
|
||||
"liste.append(4)\n",
|
||||
"print(id(liste))\n",
|
||||
"print(liste)"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {
|
||||
"slideshow": {
|
||||
"slide_type": "slide"
|
||||
}
|
||||
},
|
||||
"source": [
|
||||
"Werden Variablen an eine Funktion übergeben, so behalten sie im aufrufenden Kontext \n",
|
||||
"in jedem Fall ihre Identität, auch wenn in der Funktion der Wert des zugeordneten Parameters\n",
|
||||
"geändert wird.\n",
|
||||
"\n",
|
||||
"Bei unveränderlichen Datentypen, bei denen eine Wertänderung unweigerlich auch zu einer\n",
|
||||
"neuen Identität führt, sind diese Parameter somit wie lokale Variable zu betrachten,\n",
|
||||
"die vollständig vom aufrufenden Code entkoppelt sind."
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {
|
||||
"pycharm": {
|
||||
"is_executing": false,
|
||||
"name": "#%%\n"
|
||||
},
|
||||
"slideshow": {
|
||||
"slide_type": "subslide"
|
||||
}
|
||||
},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"def tue_was(a):\n",
|
||||
" print(f\"ID von a vor Änderung: {id(a)}\")\n",
|
||||
" a = a + 1\n",
|
||||
" print(a)\n",
|
||||
" print(f\"ID von a nach Änderung: {id(a)}\")\n",
|
||||
"\n",
|
||||
"x=1\n",
|
||||
"print(f\"ID von x vor Aufruf: {id(x)}\")\n",
|
||||
"tue_was(x)\n",
|
||||
"print(x)\n",
|
||||
"print(f\"ID von x nach Aufruf: {id(x)}\")"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {
|
||||
"slideshow": {
|
||||
"slide_type": "slide"
|
||||
}
|
||||
},
|
||||
"source": [
|
||||
"Bei veränderlichen Datentypen wie Listen können \n",
|
||||
"Wertänderungen nach außen durchschlagen, weil \n",
|
||||
"die Identität durch die Wertänderung nicht verändert wird."
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {
|
||||
"pycharm": {
|
||||
"is_executing": false,
|
||||
"name": "#%%\n"
|
||||
}
|
||||
},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"def tue_was_mit_liste(a):\n",
|
||||
" print(f\"ID von a vor Änderung: {id(a)}\")\n",
|
||||
" a.append(3)\n",
|
||||
" print(a)\n",
|
||||
" print(f\"ID von a nach Änderung: {id(a)}\")\n",
|
||||
"\n",
|
||||
"x=[1, 2]\n",
|
||||
"print(f\"ID von x vor Aufruf: {id(x)}\")\n",
|
||||
"tue_was_mit_liste(x)\n",
|
||||
"print(x)\n",
|
||||
"print(f\"ID von x nach Aufruf: {id(x)}\")"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {
|
||||
"slideshow": {
|
||||
"slide_type": "slide"
|
||||
}
|
||||
},
|
||||
"source": [
|
||||
"Daher liefern die Operatoren <code>==</code> und <code>is</code> bei Listen \n",
|
||||
"ggf. auch abweichende Ergebnisse."
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {
|
||||
"pycharm": {
|
||||
"is_executing": false,
|
||||
"name": "#%%\n"
|
||||
}
|
||||
},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"liste1 = [1, 2, 3]\n",
|
||||
"liste2 = [1, 2, 3]\n",
|
||||
"\n",
|
||||
"if liste1 == liste2:\n",
|
||||
" print(\"Gleich!\")\n",
|
||||
" \n",
|
||||
"if liste1 is liste2:\n",
|
||||
" print(\"Identisch!\")"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {
|
||||
"slideshow": {
|
||||
"slide_type": "slide"
|
||||
}
|
||||
},
|
||||
"source": [
|
||||
"**Aber:** Zuweisungen und Parameterübergaben erhalten bei allen Datentypen (auch bei Listen) die Identität."
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {
|
||||
"pycharm": {
|
||||
"is_executing": false,
|
||||
"name": "#%%\n"
|
||||
}
|
||||
},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"liste1 = ['A', 'B', 'C']\n",
|
||||
"liste2 = liste1\n",
|
||||
"\n",
|
||||
"print(id(liste1))\n",
|
||||
"print(id(liste2))\n",
|
||||
"\n",
|
||||
"if liste1 == liste2:\n",
|
||||
" print(\"Gleich!\")\n",
|
||||
" \n",
|
||||
"if liste1 is liste2:\n",
|
||||
" print(\"Identisch!\")"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {
|
||||
"slideshow": {
|
||||
"slide_type": "slide"
|
||||
}
|
||||
},
|
||||
"source": [
|
||||
"Soll bei einer Zuweisung oder Parameterübergabe einer Liste die empfangende Seite eine eigene \n",
|
||||
"Identität erhalten, so muss eine Kopie der Liste verwendet werden."
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {
|
||||
"pycharm": {
|
||||
"is_executing": false,
|
||||
"name": "#%%\n"
|
||||
}
|
||||
},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"liste1 = ['A', 'B', 'C']\n",
|
||||
"liste2 = liste1.copy()\n",
|
||||
"\n",
|
||||
"print(id(liste1))\n",
|
||||
"print(id(liste2))\n",
|
||||
"\n",
|
||||
"if liste1 == liste2:\n",
|
||||
" print(\"Gleich!\")\n",
|
||||
"\n",
|
||||
"if liste1 is liste2:\n",
|
||||
" print(\"Identisch!\")"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {
|
||||
"pycharm": {
|
||||
"name": "#%% md\n"
|
||||
},
|
||||
"slideshow": {
|
||||
"slide_type": "slide"
|
||||
}
|
||||
},
|
||||
"source": [
|
||||
"### 4.6 Benannte Parameter\n",
|
||||
"\n",
|
||||
"Normalerweise erfolgt das Mapping der Parameter beim Aufruf einer Funktion \n",
|
||||
"aufgrund der Reihenfolge der Parameter. Die Variablennamen bzw. Parameternamen \n",
|
||||
"haben keinen Einfluss."
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {
|
||||
"pycharm": {
|
||||
"name": "#%%\n"
|
||||
}
|
||||
},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"a = \"1\"\n",
|
||||
"b = \"2\"\n",
|
||||
"\n",
|
||||
"def ausgabe(a, b):\n",
|
||||
" print(a)\n",
|
||||
" print(b)\n",
|
||||
" \n",
|
||||
"ausgabe(b, a) # Reihenfolge vertauscht"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {
|
||||
"slideshow": {
|
||||
"slide_type": "slide"
|
||||
}
|
||||
},
|
||||
"source": [
|
||||
"Möchte man beim Aufruf die Reihenfolge der Parameter ändern, so können auch die\n",
|
||||
"Parameternamen explizit aufgeführt werden."
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {
|
||||
"pycharm": {
|
||||
"is_executing": false,
|
||||
"name": "#%%\n"
|
||||
}
|
||||
},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"a = \"1\"\n",
|
||||
"b = \"2\"\n",
|
||||
"\n",
|
||||
"def ausgabe(parm1, parm2):\n",
|
||||
" print(parm1)\n",
|
||||
" print(parm2)\n",
|
||||
" \n",
|
||||
"ausgabe(parm2=b, parm1=a) "
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {
|
||||
"slideshow": {
|
||||
"slide_type": "slide"
|
||||
}
|
||||
},
|
||||
"source": [
|
||||
"Bei einem Funktionsaufruf können benannte und unbenannte Parameter gemischt werden,\n",
|
||||
"jedoch dürfen nach einem benannten Parameter keine unbenannten mehr folgen."
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {
|
||||
"pycharm": {
|
||||
"is_executing": false,
|
||||
"name": "#%%\n"
|
||||
}
|
||||
},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"def viele_parameter(a, b, c, d, e, f):\n",
|
||||
" print(a, b, c, d, e, f)\n",
|
||||
"\n",
|
||||
"viele_parameter(1, 2, 3, f=7, e=3, d=5)"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {
|
||||
"slideshow": {
|
||||
"slide_type": "slide"
|
||||
}
|
||||
},
|
||||
"source": [
|
||||
"### 4.7 Funktionen mit variabler Parameterzahl\n",
|
||||
"\n",
|
||||
"Normalerweise müssen bei einem Funktionsaufruf alle Parameter angegeben werden. \n",
|
||||
"Werden bei der Funktionsdefinition Parameter jedoch mit *Default-Werten* versehen,\n",
|
||||
"so können diese beim Aufruf ausgelassen werden. In der Funktion steht dann \n",
|
||||
"der Default-Wert zur Verfügung."
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {
|
||||
"pycharm": {
|
||||
"is_executing": false,
|
||||
"name": "#%%\n"
|
||||
}
|
||||
},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"def default_parameter(a, b=1, c=True):\n",
|
||||
" return a+b if c else a*b\n",
|
||||
"\n",
|
||||
"print(default_parameter(5))\n",
|
||||
"print(default_parameter(5, c=False))\n",
|
||||
"print(default_parameter(5, 2))\n",
|
||||
"print(default_parameter(4, 4, False))"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {
|
||||
"slideshow": {
|
||||
"slide_type": "slide"
|
||||
}
|
||||
},
|
||||
"source": [
|
||||
"Noch flexibler ist die Verwendung eines <code>*</code> vor den Parameternamen. Dadurch werden \n",
|
||||
"beliebig viele Parameter als Tupel an die Funktion übergeben. "
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {
|
||||
"pycharm": {
|
||||
"is_executing": false,
|
||||
"name": "#%%\n"
|
||||
}
|
||||
},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"def ausgabe_tupel(*args):\n",
|
||||
" for parm in args:\n",
|
||||
" print(parm)\n",
|
||||
" \n",
|
||||
"ausgabe_tupel(1, 'A', 3.14) "
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {
|
||||
"slideshow": {
|
||||
"slide_type": "slide"
|
||||
}
|
||||
},
|
||||
"source": [
|
||||
"Dieser besondere Parameter kann mit weiteren Parametern kombiniert werden, muss aber als \n",
|
||||
"letzter (unbenannter) Parameter in der Liste stehen."
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {
|
||||
"pycharm": {
|
||||
"name": "#%%\n"
|
||||
}
|
||||
},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"def ausgabe_parms_und_tupel(a, b, *args):\n",
|
||||
" if a > b:\n",
|
||||
" print(\"Größer!\")\n",
|
||||
" for parm in args:\n",
|
||||
" print(parm)\n",
|
||||
" \n",
|
||||
"ausgabe_parms_und_tupel(4, 3, 1, 'A', 3.14) "
|
||||
]
|
||||
}
|
||||
],
|
||||
"metadata": {
|
||||
"celltoolbar": "Slideshow",
|
||||
"kernelspec": {
|
||||
"display_name": "Python 3 (ipykernel)",
|
||||
"language": "python",
|
||||
"name": "python3"
|
||||
},
|
||||
"language_info": {
|
||||
"codemirror_mode": {
|
||||
"name": "ipython",
|
||||
"version": 3
|
||||
},
|
||||
"file_extension": ".py",
|
||||
"mimetype": "text/x-python",
|
||||
"name": "python",
|
||||
"nbconvert_exporter": "python",
|
||||
"pygments_lexer": "ipython3",
|
||||
"version": "3.9.9"
|
||||
},
|
||||
"pycharm": {
|
||||
"stem_cell": {
|
||||
"cell_type": "raw",
|
||||
"metadata": {
|
||||
"collapsed": false
|
||||
},
|
||||
"source": []
|
||||
}
|
||||
}
|
||||
},
|
||||
"nbformat": 4,
|
||||
"nbformat_minor": 1
|
||||
}
|
||||
@@ -0,0 +1,153 @@
|
||||
{
|
||||
"cells": [
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {
|
||||
"collapsed": true,
|
||||
"pycharm": {
|
||||
"name": "#%% md\n"
|
||||
},
|
||||
"slideshow": {
|
||||
"slide_type": "slide"
|
||||
}
|
||||
},
|
||||
"source": [
|
||||
"_Aufgabe 1_\n",
|
||||
"\n",
|
||||
"Schreiben Sie eine Funktion <code>schnittmenge</code>, die zwei Listen als Parameter erwartet\n",
|
||||
"und eine Liste zurückgibt, die nur die Elemente beinhaltet, die in beiden übergebenen Listen enthalten waren."
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"# Todo: Hier die Funktion anlegen\n",
|
||||
"print(schnittmenge([1, 2, 3, 10], [3, 4, 1]))"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {
|
||||
"pycharm": {
|
||||
"is_executing": false,
|
||||
"name": "#%%\n"
|
||||
},
|
||||
"slideshow": {
|
||||
"slide_type": "slide"
|
||||
}
|
||||
},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"def schnittmenge(liste1, liste2):\n",
|
||||
" ergebnis = []\n",
|
||||
" for element in liste2:\n",
|
||||
" if element in liste1:\n",
|
||||
" ergebnis.append(element)\n",
|
||||
" return ergebnis\n",
|
||||
"\n",
|
||||
"print(schnittmenge([1, 2, 3, 10], [3, 4, 1]))"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {
|
||||
"slideshow": {
|
||||
"slide_type": "slide"
|
||||
}
|
||||
},
|
||||
"source": [
|
||||
"_Aufgabe 2_\n",
|
||||
"\n",
|
||||
"Schreiben Sie eine Funktion <code>pascal</code>, der eine Liste <code>z</code> von Integer-Zahlen \n",
|
||||
"übergeben wird. Sei <code>n</code> die Länge dieser Liste. \n",
|
||||
"Das Ergebnis soll eine neue Liste sein mit folgenden Einträgen\n",
|
||||
"\n",
|
||||
"Falls <code>n == 0</code>:\n",
|
||||
"\n",
|
||||
" <code>[ 1 ]</code>\n",
|
||||
"\n",
|
||||
"Falls <code>n == 1</code>:\n",
|
||||
"\n",
|
||||
" <code>[ 1 , 1 ]</code>\n",
|
||||
"\n",
|
||||
"Sonst:\n",
|
||||
"\n",
|
||||
" <code>[ 1 , z[0]+z[1] , z[1]+z[2] , ... , z[n-2]+z[n-1] , 1 ]</code>"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {
|
||||
"slideshow": {
|
||||
"slide_type": "slide"
|
||||
}
|
||||
},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"# Todo: Hier die Funktion anlegen\n",
|
||||
"\n",
|
||||
"print(pascal([]))\n",
|
||||
"print(pascal([5]))\n",
|
||||
"print(pascal([5, 2, 7, 3]))"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {
|
||||
"slideshow": {
|
||||
"slide_type": "subslide"
|
||||
}
|
||||
},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"def pascal(z):\n",
|
||||
" erg = [1]\n",
|
||||
" erg.extend([a+b for a, b in zip(z[:-1], z[1:])])\n",
|
||||
" if len(z) > 0:\n",
|
||||
" erg.append(1)\n",
|
||||
" return erg\n",
|
||||
"\n",
|
||||
"print(pascal([]))\n",
|
||||
"print(pascal([5]))\n",
|
||||
"print(pascal([5, 2, 7, 3]))"
|
||||
]
|
||||
}
|
||||
],
|
||||
"metadata": {
|
||||
"celltoolbar": "Slideshow",
|
||||
"kernelspec": {
|
||||
"display_name": "Python 3 (ipykernel)",
|
||||
"language": "python",
|
||||
"name": "python3"
|
||||
},
|
||||
"language_info": {
|
||||
"codemirror_mode": {
|
||||
"name": "ipython",
|
||||
"version": 3
|
||||
},
|
||||
"file_extension": ".py",
|
||||
"mimetype": "text/x-python",
|
||||
"name": "python",
|
||||
"nbconvert_exporter": "python",
|
||||
"pygments_lexer": "ipython3",
|
||||
"version": "3.9.9"
|
||||
},
|
||||
"pycharm": {
|
||||
"stem_cell": {
|
||||
"cell_type": "raw",
|
||||
"metadata": {
|
||||
"collapsed": false
|
||||
},
|
||||
"source": []
|
||||
}
|
||||
}
|
||||
},
|
||||
"nbformat": 4,
|
||||
"nbformat_minor": 1
|
||||
}
|
||||
@@ -0,0 +1,217 @@
|
||||
{
|
||||
"cells": [
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {
|
||||
"slideshow": {
|
||||
"slide_type": "slide"
|
||||
}
|
||||
},
|
||||
"source": [
|
||||
"# Software Entwicklung \n",
|
||||
"\n",
|
||||
"## Kapitel 4: Funktionen"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {
|
||||
"slideshow": {
|
||||
"slide_type": "slide"
|
||||
}
|
||||
},
|
||||
"source": [
|
||||
"### 4.8 Funktionen als Datentyp \n",
|
||||
"\n",
|
||||
"In Python werden Funktionen als *first class object* behandelt, d.h. sie sind ein\n",
|
||||
"vollwertiger Datentyp, dessen Werte Variablen zugewiesen oder als Parameter übergeben\n",
|
||||
"werden können. "
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {
|
||||
"pycharm": {
|
||||
"name": "#%%\n"
|
||||
}
|
||||
},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"def quadrat(x):\n",
|
||||
" return x*x\n",
|
||||
"\n",
|
||||
"variable = quadrat\n",
|
||||
"print(type(variable))"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {
|
||||
"slideshow": {
|
||||
"slide_type": "slide"
|
||||
}
|
||||
},
|
||||
"source": [
|
||||
"Mit einer Variablen, die als Wert eine Funktion enthält, verfügt man quasi über einen\n",
|
||||
"zweiten Alias-Namen für die Funktion. Der Aufruf der Funktion ist auch mittels dieses Alias möglich."
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {
|
||||
"pycharm": {
|
||||
"name": "#%%\n"
|
||||
}
|
||||
},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"def quadrat(x):\n",
|
||||
" return x*x\n",
|
||||
"\n",
|
||||
"zweiter_name = quadrat\n",
|
||||
"print(zweiter_name(5))"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {
|
||||
"slideshow": {
|
||||
"slide_type": "slide"
|
||||
}
|
||||
},
|
||||
"source": [
|
||||
"Eine interessante Anwendung ist die Übergabe von Funktionen als Parameter an andere Funktionen."
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {
|
||||
"pycharm": {
|
||||
"name": "#%%\n"
|
||||
}
|
||||
},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"def drucke_1():\n",
|
||||
" print(\"1\")\n",
|
||||
"\n",
|
||||
"def drucke_2():\n",
|
||||
" print(\"2\")\n",
|
||||
"\n",
|
||||
"def tue_das_eine_und_x_mal_das_andere(f1, x, f2):\n",
|
||||
" f1()\n",
|
||||
" for _ in range(x):\n",
|
||||
" f2()\n",
|
||||
" \n",
|
||||
"tue_das_eine_und_x_mal_das_andere(drucke_1, 4, drucke_2)"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {
|
||||
"slideshow": {
|
||||
"slide_type": "slide"
|
||||
}
|
||||
},
|
||||
"source": [
|
||||
"### 4.9 Lambda-Funktionen\n",
|
||||
"\n",
|
||||
"Kurze Funktionen können als sog. *Lambda-Funktionen* ohne Funktionsnamen\n",
|
||||
"definiert werden. *Lambda-Funktionen* bestehen nur aus einer einzigen Operation, deren Ergebnis ohne\n",
|
||||
"<code>return</code> zurückgegeben wird. Die Parameterliste wird nicht eingeklammert; der aus\n",
|
||||
"nur einem Befehl bestehende Funktionsrumpf folgt unmittelbar nach einem Doppelpunkt.\n",
|
||||
"\n",
|
||||
"<code>lambda < Parameterliste > : < Befehl > </code>\n",
|
||||
"\n",
|
||||
"anstelle von\n",
|
||||
"\n",
|
||||
"<code>def < Funktionsname > ( < Parameterliste > ) : <br>\n",
|
||||
" return < Befehl > </code>"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {
|
||||
"pycharm": {
|
||||
"name": "#%%\n"
|
||||
},
|
||||
"slideshow": {
|
||||
"slide_type": "subslide"
|
||||
}
|
||||
},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"quadrat = lambda x : x*x\n",
|
||||
"\n",
|
||||
"print(quadrat(3))"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {
|
||||
"slideshow": {
|
||||
"slide_type": "slide"
|
||||
}
|
||||
},
|
||||
"source": [
|
||||
"Diese kompakte Form der Funktionsdefinition ist insbesondere bei der Übergabe der\n",
|
||||
"Funktion als Parameter beliebt."
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {
|
||||
"pycharm": {
|
||||
"is_executing": false,
|
||||
"name": "#%%\n"
|
||||
}
|
||||
},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"def foreach(f, *args):\n",
|
||||
" result = []\n",
|
||||
" for element in args:\n",
|
||||
" result.append(f(element))\n",
|
||||
" return result\n",
|
||||
"\n",
|
||||
"foreach(lambda x: x*x+1, 1, 2, 3)"
|
||||
]
|
||||
}
|
||||
],
|
||||
"metadata": {
|
||||
"celltoolbar": "Slideshow",
|
||||
"kernelspec": {
|
||||
"display_name": "Python 3 (ipykernel)",
|
||||
"language": "python",
|
||||
"name": "python3"
|
||||
},
|
||||
"language_info": {
|
||||
"codemirror_mode": {
|
||||
"name": "ipython",
|
||||
"version": 3
|
||||
},
|
||||
"file_extension": ".py",
|
||||
"mimetype": "text/x-python",
|
||||
"name": "python",
|
||||
"nbconvert_exporter": "python",
|
||||
"pygments_lexer": "ipython3",
|
||||
"version": "3.9.9"
|
||||
},
|
||||
"pycharm": {
|
||||
"stem_cell": {
|
||||
"cell_type": "raw",
|
||||
"metadata": {
|
||||
"collapsed": false
|
||||
},
|
||||
"source": []
|
||||
}
|
||||
}
|
||||
},
|
||||
"nbformat": 4,
|
||||
"nbformat_minor": 1
|
||||
}
|
||||
@@ -0,0 +1,22 @@
|
||||
body.rise-enabled div.inner_cell>div.input_area {
|
||||
font-size: 150%;
|
||||
}
|
||||
|
||||
body.rise-enabled div.output_subarea.output_text.output_result {
|
||||
font-size: 150%;
|
||||
}
|
||||
body.rise-enabled div.output_subarea.output_text.output_stream.output_stdout {
|
||||
font-size: 150%;
|
||||
}
|
||||
|
||||
body.rise-enabled div.output_subarea.output_html.rendered_html.output_result {
|
||||
font-size: 150%;
|
||||
}
|
||||
|
||||
body.rise-enabled td {
|
||||
font-size: 120%;
|
||||
}
|
||||
|
||||
body.rise-enabled th {
|
||||
font-size: 120%;
|
||||
}
|
||||
Reference in New Issue
Block a user