functions2.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Funktioner\n",
    "\n",
    "Funktioner i python kan ses som standardrutiner, ett eget litet program i programmet; en låda som gör en speciell sak och sedan skickar tillbaka resultatet till där man anropade funktionen. En funktion, en s.k. 'def', ses som en avgränsad låda som gör en specifik uppgift. Man skickar data till den och den skickar data tillbaka. Ibland kallas de också för subrutiner.\n",
    "\n",
    "\n",
    "'Funktion' betyder i python inte bara funktion som du är van vid att möta den i matematiken utan är ett utvidgat funktionsbegrepp som mer liknar 'en sammanhållen grupp av beräkningar'. En python-funktion anges med det inledande ordet 'def'. 'def' är ett så kallat reserverat ord. Du bör inte använda det ordet till något annat i dina program.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Definition\n",
    "\n",
    "Vi **definierar** funktionen $f(x)=2x+1$ i python genom att skriva just `def`. Funktionen börjar med `def` och slutar med att indraget upphör."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "7\n"
     ]
    }
   ],
   "source": [
    "# Definiera en funktion\n",
    "def f(x):\n",
    "    y = 2*x + 1\n",
    "    return(y)\n",
    "\n",
    "print(f(3))  # Anropet till funktionen är f(3)\n",
    "             # f(3) har erhållit värdet hos y med hjälp av return(y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Funktionens definierande kommando är\n",
    "\n",
    "```\n",
    "def f(x):\n",
    "    ett\n",
    "    antal\n",
    "    indragna \n",
    "    satser\n",
    "    return()\n",
    "```\n",
    "Funktionens namn är `f`. Parenteserna efter f omger *parametrar* som funktionen har. I detta fall har funktionen f parametern x.\n",
    "\n",
    "\n",
    "Därefter ett kolon för att det kommer indragna satser, ett kod-block(svit).\n",
    "\n",
    "\n",
    "`return()` för att skicka tillbaka något till anropet (ej nödvändigt). Det som skickas tillbaka är i exemplet värdet på `y` som i sin tur är resultatet av beräkningen `2*x + 1`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Anropet till funktionen finns i `print(f(3))`. Anropet är `f(3)`. Värdet hos `f(3)` är värdet som beräknats och lagrats i `y` och skickas ut från def med hjälp av `return`; i just detta fall talet 7. Man kan säga att `f(3)` blir en variabel som tilldelas värdet av `y` genom `return(y)`.\n",
    "\n",
    "Funktionen `f(x)` anropas med _argumentet_ 3. Det är själva anropet som gör att funktionens kod körs; till skillnad från deklarationen. Att skriva själva def-en är en deklaration av den, men den körs inte då. Den körs då den anropas.\n",
    "\n",
    "`x` i definitionen kallas för _parameter_.\n",
    "\n",
    "Håll isär termerna argument och parameter annars orsakas missförstånd."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python läser kod rad för rad. En def ska stå tidigt i kod, i regel direkt efter importerna. \n",
    "\n",
    "Även om def-satser ska stå i början av koden så körs de **inte före** den egentliga koden; de deklareras först och körs sedan när någon sats **anropar** dem. Python bara läser def när den börjar läsa ditt program från rad 1, men def körs inte förrän den anropas.\n",
    "\n",
    "Kör följande cell och den ger inget ut. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Definierar en funktion; den körs inte när du klickar på symbolen för 'run',\n",
    "# ger inget ut även om det står en print-sats.\n",
    "def f(x):\n",
    "    print(\"Hej\")\n",
    "    return(2*x + 1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "I och med att def är en deklaration så är det inte effektivt att ha den t.ex. i en loop; python behöver bara ha funktionen deklarerad 1 gång, då i början av programmet. I en loop deklareras den flera gånger, vilket är resurskrävande."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Antalet argument måste stämma med antalet parametrar annars ges felmeddelande (vi ska se strax hur man kommer förbi detta).\n",
    "\n",
    "Vi börjar med för många argument."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "f() takes 1 positional argument but 2 were given",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "Cell \u001b[0;32mIn[6], line 5\u001b[0m\n\u001b[1;32m      2\u001b[0m     y \u001b[38;5;241m=\u001b[39m \u001b[38;5;241m2\u001b[39m\u001b[38;5;241m*\u001b[39mx \u001b[38;5;241m+\u001b[39m \u001b[38;5;241m1\u001b[39m\n\u001b[1;32m      3\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m(y)\n\u001b[0;32m----> 5\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[43mf\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m3\u001b[39;49m\u001b[43m,\u001b[49m\u001b[38;5;241;43m2\u001b[39;49m\u001b[43m)\u001b[49m)\n",
      "\u001b[0;31mTypeError\u001b[0m: f() takes 1 positional argument but 2 were given"
     ]
    }
   ],
   "source": [
    "def f(x):\n",
    "    y = 2*x + 1\n",
    "    return(y)\n",
    "\n",
    "print(f(3,2)) # Vi skickar 2 argument men det finns bara en parameter  \n",
    "             "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Vi skickar 1 argument men det finns 2 parametrar."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "f() missing 1 required positional argument: 'y'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "Cell \u001b[0;32mIn[7], line 5\u001b[0m\n\u001b[1;32m      2\u001b[0m     z \u001b[38;5;241m=\u001b[39m \u001b[38;5;241m2\u001b[39m\u001b[38;5;241m*\u001b[39mx \u001b[38;5;241m+\u001b[39m y\n\u001b[1;32m      3\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m(z)\n\u001b[0;32m----> 5\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[43mf\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m3\u001b[39;49m\u001b[43m)\u001b[49m)\n",
      "\u001b[0;31mTypeError\u001b[0m: f() missing 1 required positional argument: 'y'"
     ]
    }
   ],
   "source": [
    "def f(x,y):\n",
    "    z = 2*x + y\n",
    "    return(z)\n",
    "\n",
    "print(f(3)) # Vi skickar 1 argument men det finns 2 parametrar  \n",
    "             "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exempel"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Kuben av ett tal\n",
    "\n",
    "Vi definierar en funktion som beräknar kuben av ett tal och använder den i en loop för att beräkna summan av kuber. (Inte mycket lönt, men av didaktiska orsaker)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "i   summa\n",
      "1     1\n",
      "2     9\n",
      "3     36\n",
      "4     100\n",
      "5     225\n",
      "6     441\n",
      "7     784\n",
      "8     1296\n",
      "9     2025\n",
      "10     3025\n",
      "11     4356\n",
      "12     6084\n",
      "13     8281\n",
      "14     11025\n",
      "15     14400\n",
      "16     18496\n",
      "17     23409\n",
      "18     29241\n",
      "19     36100\n",
      "20     44100\n"
     ]
    }
   ],
   "source": [
    "# Definierar en funktion för kuben av ett tal; inget utförs\n",
    "def kub(n):\n",
    "  return(n**3)\n",
    "\n",
    "summakub = 0  # Initiering av variabel\n",
    "print(\"i   summa\")  # Rubrik för tabell\n",
    "\n",
    "for i in range(1,21,1):  # Från 1 till 20\n",
    "  summakub = kub(i) + summakub  # Anrop av funktionen kub(); nu utförs den\n",
    "  print(i, \"   \",summakub)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Produkten av två tal\n",
    "\n",
    "En funktion som beräknar produkten av två tal som matas in i programmet.\n",
    "Skickar nu 2 tal till en funktion, inte bara 1 som tidigare."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Beräknar produkten av två tal\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Ange det första talet  4\n",
      "Ange det andra talet  6\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Produkten är  24.0\n"
     ]
    }
   ],
   "source": [
    "print(\"Beräknar produkten av två tal\")\n",
    "\n",
    "def prod(x,y):  # Funktionen definieras, den ska ha 2 tal\n",
    "  return(x*y)\n",
    "\n",
    "\n",
    "\n",
    "a = float(input(\"Ange det första talet \"))\n",
    "b = float(input(\"Ange det andra talet \"))\n",
    "print(\"Produkten är \", prod(a,b))  # Anrop\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Räta linjen\n",
    "\n",
    "Programmet skickar 2 tal tillbaka, inte bara 1.\n",
    "När 2 tal, eller fler, skickas tillbaka med return så kan värdena tas fram enskilt genom att som vid listor ange index.\n",
    "\n",
    "Vi använder $y=kx+m$.\n",
    "Och med $y_1=kx_1+m$ och $y_2=kx_2+m$ för två punkter på linjen.\n",
    "Vi erhåller för riktningskoefficienten\n",
    "$$k=\\frac{y_1-y_2}{x_1-x_2}$$\n",
    "\n",
    "och interceptet\n",
    "$$m=y_2-k\\cdot x_2$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "k = 4.0 m = -1.0\n"
     ]
    }
   ],
   "source": [
    "\"\"\"\n",
    "Programmet bestämmer riktningskoefficient och \n",
    "intercept för en rät linje genom två angivna punkter.\n",
    "(på detta sätt kan man skriva övergripande kommentarer)\n",
    "\"\"\"\n",
    "\n",
    "# Första punkten\n",
    "L1 = [1.0,3.0]  # (x1,y1)\n",
    "# Andra punkten\n",
    "L2 = [3,11.]  # (x2,y2)\n",
    "# Kan ändras till input() senare när programmet fungerar\n",
    "\n",
    "\n",
    "def km(l1,l2):\n",
    "  k = (l1[1]-l2[1])/(l1[0]-l2[0])  # k = (y1-y2)/(x1-x2)\n",
    "  m = l2[1]-k*l2[0]  # y2 = kx2 + m -> m = y2 - kx2\n",
    "  \n",
    "  return(k,m)  # Resultat, 2 tal, blir automatiskt en tiple; fungerar ungefär som en lista\n",
    "\n",
    "\n",
    "values = km(L1,L2)  # Anrop\n",
    "\n",
    "# De enskilda värdena i values kan nås med index: values[0] är första elementet\n",
    "print(\"k =\", values[0], \"m =\", values[1])\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Vi gör en annan variant på föregående program om riktningskoefficient. Vi lagrar de 2 värdena i en lista och skickar listan som 1 element. Jämför."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "k = 4.0 m = -1.0\n"
     ]
    }
   ],
   "source": [
    "#Första punkten\n",
    "L1 = [1.0,3.0]  # (x1,y1)\n",
    "#Andra punkten\n",
    "L2 = [3,11.]  # (x2,y2)\n",
    "# Kan ändras till input() senare\n",
    "\n",
    "\n",
    "def km(l1,l2):\n",
    "  k=(l1[1]-l2[1])/(l1[0]-l2[0])  # k = (y1-y2)/(x1-x2)\n",
    "  m=l2[1]-k*l2[0]  # y2 = kx2 + m -> m = y2 - kx2\n",
    "  M=[k,m]  # NY Vi lägger nu de två talen i en lista\n",
    "  return(M)  # NY Vi skickar nu ut listan\n",
    "\n",
    "\n",
    "values = km(L1,L2)  # Anrop. values tilldelas M\n",
    "# values är nu verkligen en lista\n",
    "print(\"k =\", values[0], \"m =\", values[1])\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Precis som i matematiken kan man arbeta med sammansatta funktioner. Skrivsättet liknar det vi är vana vid. Definiera två funktioner."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "f(g(2))= 17\n",
      "g(f(2))= 125\n"
     ]
    }
   ],
   "source": [
    "def f(x):\n",
    "    y = 2*x + 1\n",
    "    return(y)\n",
    "\n",
    "def g(x):\n",
    "    y = x**3\n",
    "    return(y)\n",
    "\n",
    "fg = f(g(2))\n",
    "gf = g(f(2))\n",
    "\n",
    "print(\"f(g(2))=\", fg)\n",
    "\n",
    "print(\"g(f(2))=\", gf)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Definitionen av funktionen kan, som nämnts, inte ligga efter anropet. Det genererar felet NameError."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'ff' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "Cell \u001b[0;32mIn[5], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[43mff\u001b[49m(\u001b[38;5;241m5\u001b[39m))  \u001b[38;5;66;03m# Kan inte ligga före definitionen/deklarationen\u001b[39;00m\n\u001b[1;32m      3\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mff\u001b[39m(x):\n\u001b[1;32m      4\u001b[0m     y \u001b[38;5;241m=\u001b[39m \u001b[38;5;241m2\u001b[39m\u001b[38;5;241m*\u001b[39mx \u001b[38;5;241m+\u001b[39m \u001b[38;5;241m1\u001b[39m\n",
      "\u001b[0;31mNameError\u001b[0m: name 'ff' is not defined"
     ]
    }
   ],
   "source": [
    "print(ff(5))  # Kan inte ligga före definitionen/deklarationen\n",
    "\n",
    "def ff(x):\n",
    "    y = 2*x + 1\n",
    "    return(y)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Rekursiv funktion\n",
    "\n",
    "Att en funktion är rekursiv innebär att den anropar sig själv.\n",
    "Vi studerar den rekursiva funktionen $a_n=3a_{n-1}$ med $a_0=5$. Denna kan också skrivas som $f(n)=3f(n-1)$.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "vilken term ska beräknas?\n",
      "\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ange ordningsindex  1\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "termens storlek är 15\n"
     ]
    }
   ],
   "source": [
    "\"\"\"\n",
    "Löser en rekursiv ekvation\n",
    "a_(n)-3a_(n-1)=0\n",
    "a_(n)=3a_(n-1)\n",
    "\"\"\"\n",
    "\n",
    "\n",
    "def rekur(n):\n",
    "  if n == 0:\n",
    "    return 5  # a0 = 5\n",
    "  else:\n",
    "    print(n) # för felsökning\n",
    "    return 3*rekur(n-1)\n",
    "\n",
    "\n",
    "# Beräknar termen med index n\n",
    "# n=3 ger 5*3*3*3=135 dvs 5*3**3\n",
    "# n=12 ger 2657205 dvs 5*3**12\n",
    "\n",
    "print('vilken term ska beräknas?\\n')\n",
    "a = int(input('ange ordningsindex '))\n",
    "term = rekur(a)\n",
    "print('termens storlek är', term)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Vi löser differensekvationen:\n",
    "$$a_{n+2}-2a_{n+1}+2a_{n}=0$$\n",
    "\n",
    "Vi löser ut $a_n$\n",
    "\n",
    "$$a_{n+2}=2a_{n+1}-2a_{n}$$\n",
    "\n",
    "Vi skriver om den med $m=n+2$.\n",
    "\n",
    "$$a_{m}=2a_{m-1}-2a_{m-2}$$\n",
    "\n",
    "\n",
    "\n",
    "Vi måste också ha 2 startvärden: $a_{-1}=4$, $a_{-2}=5$, då vi börjar på $m=0$.\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "vilken term ska beräknas?\n",
      "\n",
      "3 termens storlek är -16\n"
     ]
    }
   ],
   "source": [
    "\n",
    "def rekur(m):\n",
    "  if m == -1:\n",
    "    return 4  # a(-1) = 4\n",
    "  elif m == -2:\n",
    "    return 5  # a(-2) = 5\n",
    "  else:\n",
    "    am = 2*rekur(m-1)-2*rekur(m-2)\n",
    "    return am\n",
    "\n",
    "\n",
    "print('vilken term ska beräknas?\\n')\n",
    "a = int(input('ange ordningsindex '))\n",
    "term = rekur(a)\n",
    "print(a,'termens storlek är', term)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Variabelt antal argument\n",
    "\n",
    "I exemplet Räta linjen skickas listor till funktionen km(). Funktionen km() är också beredd på att ta emot listor.\n",
    "När funktionen är färdig så skickas 2 tal, k och m, som en tipel (eller lista) och kan nås via index.\n",
    "\n",
    "Men det finns varianter på detta.\n",
    "\n",
    "Låt oss först definiera _positionsbestämda argument_ som att det är argument som tilldelas värden utifrån sina positioner. Första parametern får värdet som anges som första argument, andra parametern får värdet som anges av andra argumentet osv."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.5\n",
      "2.0\n"
     ]
    }
   ],
   "source": [
    "def f(a, b):\n",
    "    adivb = a/b\n",
    "    return (adivb)\n",
    "\n",
    "\n",
    "print(f(5, 10))  # a tilldelas 5 och b tilldelas 10\n",
    "\n",
    "print(f(10, 5))  # a tilldelas 10 och b tilldelas 5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Packa upp:**\n",
    "Att ha data i en lista och skicka till en funktion som har flera parametrar. Lite slarvigt innebär det att elementen i listan som skickas blir argument till parametrarna. För att ange för python att den ska packa upp listan så skriver man * framför argumentet; i nedanstående fall `*vikter`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "7.6\n"
     ]
    }
   ],
   "source": [
    "# Tre tal adderas med olika vikter\n",
    "\n",
    "def viktsumma(a,b,c):\n",
    "  s = 1*a + 5*b + 10*c\n",
    "  return s\n",
    "\n",
    "\n",
    "vikter=[0.1,0.3,0.6]\n",
    "\n",
    "print(viktsumma(*vikter))  # Packa upp listan vikter o dela ut till parametrarna\n",
    "  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "När `viktsumma()` anropas i print-satsen har vi listan `vikter` som argument.\n",
    "Men funktionen är inte inställd på att ta emot en lista (vilket bara är 1 argument) utan är inställd på att ta 3 argument eftersom den har 3 parametrar. Men om python packar upp listan och tilldelar parametern a värdet i vikter[0], tilldelar parametern b värdet i vikter[1] osv, så blir det som jag vill. (naturligtvis kan man packa upp listan själv)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Packa ihop**: Den andra möjligheten som finns är att de argument som ges tas emot av funktionen och där packas ihop till en lista som sedan funktionen använder. Antalet argument är inte bestämt. I regel är det dock 1 parameter, i alla fall för varje lista som ska skapas. Det behöver således inte vara bestämt hur många argument som ska skickas!\n",
    "\n",
    "Egentligen är det inte en lista utan en tipel. Men för vår användning fungerar den på samma sätt. Du kan använda index för att få tag i de olika elementen i tipeln."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Nu har vi gjort en tipel  (2, 3, 1, 5, 3)\n",
      "Vi skriver ut element 3:  1\n",
      "2\n",
      "3\n",
      "1\n",
      "5\n",
      "3\n",
      "summan av tipelns element är 14\n"
     ]
    }
   ],
   "source": [
    "\"\"\"\n",
    "Tecknet * vid parametern gör om de 5 argumenten till en lista som \n",
    "sedan används för en loop\n",
    "\"\"\"\n",
    "\n",
    "def func(*args):  # De 5 argumenten packas ihop till en lista som heter args\n",
    "    print(\"Nu har vi gjort en tipel \", args) # Vi skriver tipeln.\n",
    "    print(\"Vi skriver ut element 3: \", args[2])\n",
    "    \n",
    "    s = 0\n",
    "    for a in args: # Vi loopar igenom tipeln\n",
    "        print(a)\n",
    "        s = s + a\n",
    "    return(s)\n",
    "\n",
    "dd = func(2,3,1,5,3)  # Skickar 5 argument, inte en lista eller tipel\n",
    "print(\"summan av tipelns element är\", dd)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Vill bara påminna om att en tipel är som en lista men du kan inte ändra i den och den skrivs med () och inte []."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Men jag kan själv packa in dem i en lista."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "summan av listans element är 14\n"
     ]
    }
   ],
   "source": [
    "def func(args):  # Tar nu 1 argument\n",
    "    s = 0\n",
    "    for a in args:\n",
    "        s = s + a\n",
    "    return(s)\n",
    "\n",
    "dd = func([2,3,1,5,3])  # Skickar inte 5 argument, utan en lista, vilket är 1 argument.\n",
    "print(\"summan av listans element är\", dd)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Kom ihåg:\n",
    "\n",
    "Stjärna * vid anrop (argument) packar upp: anrop(*upp)\n",
    "\n",
    "Stjärna * vid def (parameter) packar ihop: def(*ihop)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Förinställd parameter\n",
    "\n",
    "I många sammanhang kan man vilja arbeta med en funktion på olika sätt. Man kan då använda _förinställda_ parametrar (default). Jag vill att ett program ska producera enbart slutresultat om den anropas på vanligt sätt. Om jag däremot anger ett extra argument så vill jag tex. att den skriver ut mer information.\n",
    "\n",
    "\n",
    "Man kan ge en parameter ett visst värde i själva deklarationen av funktionen. Om man då anropar funktionen med så att säga för lite argument så kommer den saknade parametern att få värdet som anges i deklarationen."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "vanligt anrop  36\n",
      "speciellt anrop\n",
      " a = 11 b = 12 c = 13\n",
      "36\n"
     ]
    }
   ],
   "source": [
    "# s har värdet True förinställt, så om inget argument anges så är s=True\n",
    "\n",
    "def summa(a, b, c, s=True):\n",
    "    if s != True:\n",
    "        print(\"speciellt anrop\\n\", \"a =\", a, \"b =\", b, \"c =\", c)\n",
    "\n",
    "    return (a+b+c)\n",
    "\n",
    "\n",
    "slutsats = summa(11, 12, 13)\n",
    "print(\"vanligt anrop \", slutsats)\n",
    "\n",
    "slutsats = summa(11, 12, 13, False)\n",
    "print(slutsats)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Förinställt värde är mycket vanligt. Om vi ser tillbaka på kommandot `range(start,stopp,steg)` så kan vi vid ett anrop av denna funktion skriva `range(8)` som anger att stopp är 8. start och steg antar då de *förinställda* värdena 0 respektive 1. Det innebär att i deklarationen av range så står det (i princip)\n",
    "\n",
    "```\n",
    "def range(start=0, steg=1, stopp)\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Nyckelord\n",
    "\n",
    "Om man inte vill ha positionsbestämda variabler så kan man använda nyckelord. Nyckelord är parametrarna. Man anger helt enkelt i anropet vad parametern heter och vilket värde den ska ha; ordningen spelar då ingen roll. Nackdelen är att man måste hålla reda på nyckelorden. Ibland är dock nyckelorden enkla att minnas som tex. color eller size. Detta kallas på engelska för \"keyword arguments\" och förkortas kwargs i pythons dokumentation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.5\n",
      "0.5\n"
     ]
    }
   ],
   "source": [
    "def f(a,b):  # Här i deklarationen är det ingen skillnad.\n",
    "    adivb = a/b\n",
    "    return(adivb)\n",
    "\n",
    "print(f(a=5,b=10))  # a tilldelas 5 och b tilldelas 10\n",
    "      \n",
    "print(f(b=10,a=5))  # a tilldelas 5 och b tilldelas 10. Att vi skrivit dem i annan ordning\n",
    "                    # spelar ingen roll."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Det är tillåtet att använda både positionsbestämda parametrar tillsammans med nyckelord men positionsparametrarna måste stå först, därefter nyckelord.\n",
    "\n",
    "Om position används efter nyckelord erhålls felmeddelande: \"positional argument follows keyword argument\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5 10 2 1 3\n",
      "0.5\n"
     ]
    }
   ],
   "source": [
    "def f(a,b,c,d,e):\n",
    "    print(a,b,c,d,e)\n",
    "    adivb = a/b\n",
    "    return(adivb)\n",
    "\n",
    "print(f(5,10, d=1, c=2, e=3))  # Position för 5 och 10 resten nyckelord, OK.\n",
    "      \n",
    "#print(f(5,10, d=1, c=2, 3))  # Försöker med position på sista variabeln, fungerar ej"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Position och packa ihop kan kombineras. Här låter vi de 2 första argumenten få var sin parameter. Övriga argument, talen 1 och 2, packas ihop till en lista som då får de kvarvarande 2 elementen. Vi adresserar genom index."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5 10 1 2\n",
      "0.5\n"
     ]
    }
   ],
   "source": [
    "def f(a,b,*c):    \n",
    "    print(a,b,c[0],c[1])\n",
    "    adivb = a/b\n",
    "    return(adivb)\n",
    "\n",
    "print(f(5,10,1,2))  # Position för 5 och 10 resten packas ihop vid def.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Avslutar med 2 viktiga påpekanden:\n",
    "\n",
    "1. Placera inte import av moduler inuti loopar. Moduler ska bara importeras en gång i ett program.\n",
    "\n",
    "2. Placera inte def inuti loopar. Funktioner ska bara definieras en gång i ett program.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Uppgifter\n",
    "\n",
    "**Uppgift 1**\n",
    "\n",
    "Det aritmetiska medelvärdet är alltid större än det geometriska. För två tal $x$ och $y$ gäller $$\\frac{x+y}{2}\\geq\\sqrt{xy}.$$ Skriv en funktion(def) som har $x$ och $y$ som parametrar och som skickar tillbaka det aritmetiska och geometriska medelvärdet. Programmet skriver sedan ut båda medelvärdena så de kan jämföras. Användaren ska ange $x$ och $y$.\n",
    "\n",
    "[Lösningsförslag](./uppg/functions2Uppgift1.ipynb)\n",
    "\n",
    "\n",
    "**Uppgift 2**\n",
    "\n",
    "Skriv 2 funktioner som beräknar area respektive omkrets av en rektangel. Funktionernas parametrar ska vara rektangelns bredd och höjd och utdata ska vara arean respektive omkretsen. Användaren anger bredd och höjd.\n",
    "\n",
    "[Lösningsförslag](./uppg/functions2Uppgift2_1.ipynb)\n",
    "\n",
    "\n",
    "\n",
    "**Uppgift 3**\n",
    "\n",
    "Skapa en lista av tal jämnt fördelade mellan $0$ och $2\\pi$. Skapa en funktion(def) som beräknar det kvadratiska trigonometriska medelvärdet av talen i listan:\n",
    "$$\\frac{1}{N}\\sum_{i=1}^{N}\\sin^{2}\\left(x_{i}\\right)$$\n",
    "\n",
    "Vad blir det för värde då $N$ är stort?\n",
    "\n",
    "[Lösningsförslag](./uppg/functions2Uppgift2.ipynb)\n",
    "\n",
    "\n",
    "**Uppgift 4**\n",
    "\n",
    "Skriv en rekursiv funktion som beräknar det n:te talet i talföljden som ges av $a_{n+1}=4a_n-1$ med begynnelsevillkoret $a_0=1$. Funktionens parametrar ska vara talets plats i talföljden och begynnelsevillkoret. Utdata ska vara själva talet. Funktionen ska vara rekursiv, dvs. anropa sig själv inne i funktionen.\n",
    "\n",
    "[Lösningsförslag](./uppg/functions2Uppgift4_1.ipynb)\n",
    "\n",
    "\n",
    "**Uppgift 5**\n",
    "\n",
    "Skapa en rekursiv funktion som beräknar fakulteter. Tex. är $7!=7 \\cdot 6 \\cdot 5 \\cdot 4 \\cdot 3 \\cdot 2 \\cdot 1$ . Rekursiviteten kan beskrivas genom funktionen $(7!=)f(7)=7 \\cdot f(6)$. Och $f(1)=1$. Vi har rent allmänt att $f(n)=n\\cdot f(n-1)$.\n",
    "\n",
    "[Lösningsförslag](./uppg/functions2Uppgift3.ipynb)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.11.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}