8_Funktionen.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Funktionen in Python**\n",
    "\n",
    "**Funktionskopf** \n",
    "\n",
    "*def myName(myInput):*\n",
    "\n",
    "besteht aus \n",
    "\n",
    "- dem Signalwort für eine Funktion  *def*\n",
    "- dem  Funktionsnamen, den Sie selbst wählen können; der Funktionsname darf keine Sonderzeichen wie / der \\% oder Leerzeichen enthalten\n",
    "- den Eingabeparameter, die in runden Klammern direkt auf den Funktiosnamen folgen\n",
    "- einem Doppelpunkt (nicht vergessen!)\n",
    "\n",
    "**Funktionsrumpf**\n",
    "- folgt eingerückt auf den Funktionskopf (Einrücken nicht vergessen!)\n",
    "- der Rückgabewert wird über das Signalwort *return* definiert.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Teil 1**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "def summe(start,end):                #Funktionskopf mit Schlüsselwort def, Name, Eingabeparametern, Doppelpunkt\n",
    "    wert=0                           #Start Funktionsrumpf\n",
    "    for i in range(start,end+1):\n",
    "        wert=wert+i\n",
    "    return(wert)                     #Ende Funktionsrumpf mit Rückgabewert"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Die so von Ihnen definierte Funktion können Sie dann durch ihren Namen und konkrete Werte für die Eingabeparameter aufrufen. Dem Rückgabewert können Sie dann wieder einen Namen Ihrer Wahl geben."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "ergebnis=summe(7,3)\n",
    "print(ergebnis)\n",
    "summe(5,12)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Beispiele für Funktionen**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Isolierter Aufruf"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "def ausgabeString(s):\n",
    "    print(\"Der Name lautet\", str(s))\n",
    "\n",
    "a=ausgabeString(4)\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Aufruf mit einer Zuweisung"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def flaecheRechteck(a, b):\n",
    "    return a * b\n",
    "\n",
    "A=flaecheRechteck(10.3, 4.4)\n",
    "print(\"Flaeche: %.2f \"%A)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Aufruf in einem Ausdruck"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "from math import sqrt \n",
    "\n",
    "def dist(xa,ya,xb,yb): \n",
    "    \"\"\"dist - Berechnet den Abstand zweier Punkte. \n",
    "    Übergabeparameter sind \n",
    "    xa,ya (erster Punkt) und xb,yb (zweiter Punkt)\"\"\"\n",
    "    abstand = sqrt((xa-xb)**2+(ya-yb)**2) \n",
    "    return abstand\n",
    "# Punkt 1 \n",
    "x1 = 1.0; y1 = 0.0\n",
    "# Punkt 2\n",
    "x2 = 0.5; y2 = 0.5\n",
    "\n",
    "if (dist(x1,y1,x2,y2)<1):\n",
    "    print('Die Punkte haben einen Abstand kleiner als 1.')\n",
    "\n",
    "        "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Eingabeparameter einer Funktion**\n",
    "\n",
    "Besitzt eine Funktion keinen Übergabeparameter, so wird an den Funktionsnamen\n",
    "ein Paar runde Klammern angehängt: *funktionsname()*\n",
    "\n",
    "Sie können beliebig viele Parameter an die Funktion übergeben.  Beim Aufruf einer Funktion mit Parametern finden Zuweisungen statt, d.h. die Variablennamen in der Definition der Funktion erhalten die Werte die beim Aufruf der Funktion entweder als Zahlen oder über Variablen angegeben werden."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "def ohneInput():\n",
    "    print('Hallo, wie heißt Du?')\n",
    "    \n",
    "ohneInput()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "def summe(a, b, c=0, d=0):\n",
    "    return a + b + c + d\n",
    "#Aufruf mit 2,3, oder 4 Eingabeparametern\n",
    "print(summe(1,2))\n",
    "print(summe(1,2,3))\n",
    "print(summe(1,2,3,4))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Eine beliebige Anzahl von Parametern wird durch einen Parameter mit einem\n",
    "Stern vor dem Namen gekennzeichnet. Es darf nur ein einziger\n",
    "$*$ - Parameter am Ende der Parameterliste der Funktion vorkommen."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "#beliebige Anzahl von Eingabeparametern\n",
    "def summe(a, *b):\n",
    "    return a + sum(b)\n",
    "\n",
    "#Aufruf\n",
    "print(summe(2))\n",
    "print(summe(1,2,3))\n",
    "print(summe(1,2,3,4))\n",
    "print(summe(1,2,3,4,5,6,7,8,9))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Aufgabe**\n",
    "\n",
    "Schreiben Sie eine Funktion, die den Mittelwert von beliebig vielen Zahlen berechnet. Verwenden Sie diese Funktion mit einer Zuweisung."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Teil 2**\n",
    "\n",
    "**Rückgabewerte einer Funktion**\n",
    "\n",
    "Die optionale Anweisung *return* gibt den Wert oder die Werte hinter diesem Schlüsselwort\n",
    "an den Aufrufer der Funktion zurück. Das Programm kehrt dann zum Funktionsaufruf\n",
    "zurück und arbeitet anschließend die nächste Anweisung ab.\n",
    "\n",
    "\n",
    "(1) Mehrere Rückgabewerte können durch eine Liste zurückgegeben werden."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "from numpy import abs\n",
    "from numpy import max\n",
    "from math import sqrt \n",
    "\n",
    "\n",
    "\n",
    "def dist3(xa,ya,xb,yb): \n",
    "    \"\"\"dist - Berechnet den Abstand zweier Punkte. \n",
    "    Eingabeparameter sind xa,ya (erster Punkt) \n",
    "    und xb,yb (zweiter Punkt)\"\"\"\n",
    "    abstandE = sqrt((xa-xb)**2+(ya-yb)**2)     # euklidischer Abstand\n",
    "    abstandM = abs(xa-xb)+abs(ya-yb)           # Manhattan Abstand\n",
    "    abstandMax = max([abs(xa-xb),abs(ya-yb)])  # Maximum-Abstand\n",
    "    return [abstandE, abstandM, abstandMax]\n",
    "\n",
    "# Punkt 1 \n",
    "x1 = 0.0; y1 = 0.0\n",
    "# Punkt 2\n",
    "x2 = 0.5; y2 = 1\n",
    "a=dist3(x1,y1,x2,y2)\n",
    "a[0]\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "(2) Funktionen ohne Rückgabewerte beinhalten in der Regel Konsolenausgaben (*print*) oder Graphiken.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "def Rechteck(a, b):\n",
    "    F= a * b\n",
    "    U=2*(a+b)\n",
    "    print(\"Das Rechteck hat Fläche %.3f und Umfang %.3f.\\n\"%(F,U))\n",
    "    \n",
    "Rechteck(3,5)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Globale und lokale Variable**\n",
    "\n",
    " Variablen, die innerhalb von Funktionen definiert sind, heißen **lokale Variable**.\n",
    "Für lokale Variable gilt:\n",
    "\n",
    "- Lokale Variable sind nur in der Funktion verfügbar, in der sie definiert wurden. Dadurch können in verschiedenen Funktionen immer wieder Variablen gleichen Namens verwendet werden, ohne dass Konflikte auftreten. \n",
    "- Sie werden  generiert, zu dem Zeitpunkt, zu dem die Funktion aufgerufen wird. Bei Beendigung der Funktion wird der für sie verwendete Speicherplatz wieder frei gegeben. \n",
    "\n",
    "\n",
    "Grundsätzlich heißen Variable, die außerhalb einer Funktion im Skript definiert werden, **globale Variable**. Das Verwenden von globalen Variablen  in Funktionen gilt als schlechter Programmierstil. Daher unterstützt Python nicht die Verwendung globaler Variable, insbesondere kennen Funktionen nicht globale Variable.\n",
    "\n",
    "Durch die Deklaration als *global* können Sie innerhalb einer Funktion eine globale Variable verwenden.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 2\n",
    "\n",
    "#Beispiel: x ist globale Variable\n",
    "def Wurzel2():\n",
    "    global x\n",
    "    x = sqrt(x)\n",
    "    print(x)\n",
    " \n",
    "#Beispiel: x ist lokale Variable\n",
    "def Wurzel2_a(x):\n",
    "    x = sqrt(x)\n",
    "    print(x)\n",
    "\n",
    "Wurzel2_a(x)\n",
    "print(x)\n",
    "Wurzel2()\n",
    "print(x)\n",
    "Wurzel2_a(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Call by reference**\n",
    "\n",
    "Bei der Übergabe als Referenzparameter bleibt jede Veränderung auch nach Verlassen der Funktion erhalten, da keine Kopien des Parameters für die Funktion erzeugt werden. Der Nachteil hierbei besteht darin, dass eine ungewollte Beeinflussung von Hauptprogrammvariablen durch eine Funkton möglich ist.\n",
    "\n",
    "\n",
    "In Python kann nur bei Arrays der Fall  des Call by reference auftreten: Falls Sie Arrayelemente in der Funktion verändern, wirkt sich\n",
    "diese Änderung auch auf das entsprechende Array in dem Programm aus, in dem die Funktion aufgerufen wird."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "def beispielCbR(a,index):\n",
    "    b=a\n",
    "    b[index]=-1\n",
    "    print('Funktion CbR - Eingabe',a)\n",
    "    print('Funktion CbR - Ausgabe',b)\n",
    "    return(b)\n",
    "    \n",
    "\n",
    "meinArray=[1,2,3,4,5]\n",
    "print('Mein Array ist', meinArray)\n",
    "beispielCbR(meinArray,0)\n",
    "print('Mein Array ist', meinArray)\n",
    "beispielCbR(meinArray,3)\n",
    "print('Mein Array ist', meinArray)\n",
    "    \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Soll ein Array *a* als **Wertparameter (call by value)** in einer Funktion genutzt werden, so kann der Array durch *a[:]* als Kopie an die Funktion übergeben werden."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "def beispielCbV(a,index):\n",
    "    b=a[:]\n",
    "    b[index]=-1\n",
    "    print('Funktion CbV - Eingabe',a)\n",
    "    print('Funktion CbV - Ausgabe',b)\n",
    "    return(b)\n",
    "    \n",
    "meinArray=[1,2,3,4,5]\n",
    "print('Mein Array ist', meinArray)\n",
    "beispielCbV(meinArray,0)\n",
    "print('Mein Array ist', meinArray)\n",
    "beispielCbV(meinArray[:],3)\n",
    "print('Mein Array ist', meinArray)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Aufgabe**\n",
    "\n",
    "Schreiben Sie eine Funktion *nimm2* mit einer Liste als Eingabeparameter, die eine neue Liste erzeugt, die sich von der Eingabeliste dadurch unterscheidet, dass jedes Element doppelt vorkommt."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Aufgabe**\n",
    "\n",
    "Schreiben Sie eine Funktion *ausfuehren*, die eine Buchstabenfolge *s* (z.B. *hallo*) als Eingabeparameter erhält und die eine eingabeparamterfreie Python-Funktion mit Namen *s* (z.B. *hallo*) ausführt."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "    "
   ]
  }
 ],
 "metadata": {
  "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.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}