namespace2_Lecture.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Namespace/Namnrum/Räckvidd"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Globala och lokala variabler\n",
    "\n",
    "Först en övergripande skiss på hur det är tänkt att fungera i stora drag.\n",
    "\n",
    "Den stora ramen är programmet i sin helhet. Inom denna ram är globala variabler tillgängliga. Globala variabler anges utanför definitionerna av funktioner.\n",
    "\n",
    "Lokala variabler finns i definitionerna av funktionerna. Dessa variabler är inte tillgängliga utanför den enskilda def.\n",
    "\n",
    "<img src=\"https://github.com/cognitrap/progr/blob/master/Pictures/localglobalv.png?raw=true\" width=30% height=20%>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "\n",
    "\n",
    "Variabler i def är inte tillgängliga utanför, i detta fall variabeln b. Att anropa en lokal variabel globalt ger fel."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x i def =  11\n",
      "funktion(2) = 11\n"
     ]
    }
   ],
   "source": [
    "def funktion(a):\n",
    "    x = 11  # Här införs x: lokal variabel\n",
    "    print(\"x i def = \",x)\n",
    "    return(x) # funktion(2) tilldelas värdet x\n",
    "\n",
    "print(\"funktion(2) =\", funktion(2))\n",
    "#print(\"x=\", x)  # Variabeln x är inte tillgänglig här! Den är lokal, endast i def."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Vi har nu x som global variabel, den är då tillgänglig överallt även inne i en def."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x i def =  5\n",
      "funktion(2) = ()\n",
      "x= 5\n"
     ]
    }
   ],
   "source": [
    "def funktion(a):\n",
    "    print(\"x i def = \",x)  # x är global, tillgänglig även här\n",
    "    return()\n",
    "\n",
    "x = 5  # Global variabel\n",
    "print(\"funktion(2) =\", funktion(2))\n",
    "print(\"x=\", x)  # Variabeln x är global, tillgänglig här!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Om vi nu anger x som global och sedan har ett x i en def, så är det 2 olika x. Om vi ändrar x i en def så ändras den inte globalt."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x i def= 7\n",
      "funktion(2)= 11\n",
      "globalt x= 5\n"
     ]
    }
   ],
   "source": [
    "def funktion(a):\n",
    "    x = 7  # Ett lokalt x\n",
    "    print(\"x i def=\", x)\n",
    "    c=11\n",
    "    return(c)\n",
    "\n",
    "x = 5  # Global variabel\n",
    "print(\"funktion(2)=\", funktion(2))\n",
    "print(\"globalt x=\", x)  # Denna blev inte ändrad i def"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Några blandade exempel. Följ variablernas ändringar. När är de globala, när är de lokala?**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a argument 3\n",
      "a ändrat inne i funktionen 6\n",
      "s 6\n",
      "a 2\n"
     ]
    }
   ],
   "source": [
    "def funktion(a): \n",
    "    #automatiskt ett lokalt a; python protesterar ej\n",
    "  print('a argument',a)\n",
    "  a=6 # ändrar a lokalt\n",
    "  print('a ändrat inne i funktionen', a)\n",
    "  return(a) # Detta a är lokalt, dvs 6 skickas iväg\n",
    "\n",
    "a=2\n",
    "s=funktion(3)\n",
    "print('s',s)\n",
    "print('a',a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Rad 8: a tilldelas värdet 2, en global variabel\n",
    "- Rad 9: Funktionen anropas, argumentet 3 skickas, funktionen har parametern a som får värdet 3. Vi går till rad 1.\n",
    "- Rad 3: Vi skriver ut värdet för a inuti funktionen, en lokal variabel. Detta a har värdet 3. Det globala har fortfarande värdet 2.\n",
    "- Rad 4: Lokala variabeln a ändras till 6. Den globala a ändras inte.\n",
    "- Rad 5: Vi skriver ut den lokala som nu är ändrad till 6 på rad 4.\n",
    "- Rad 6: Vi skickar det lokala värdet på a till anropet.\n",
    "- Rad 9: Anropet tar emot return och ger det till s.\n",
    "- Rad 10: Skriver ut s, som ju är från return, ett lokalt värde har skickats ut, s=6.\n",
    "- Rad 11: Lokalt var a=6, men globalt har a alltid varit 2 så print av global ger 2."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Så här gör man inte"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a 1 11\n",
      "a 2 12\n"
     ]
    }
   ],
   "source": [
    "# Bara a, inte god programmeringssed\n",
    "def funktion(a):\n",
    "  print('a 1',a)\n",
    "  a=12\n",
    "  return a\n",
    "\n",
    "a=11\n",
    "a=funktion(a)\n",
    "print('a 2',a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Rad 7: a global är 11.\n",
    "- Rad 8: a global kopieras till a lokal, som finns i def funktion.\n",
    "- Rad 3: Vi ser att a lokal är 11, en kopia av globala a.\n",
    "- Rad 4: Vi ändrar a, endast den lokala!\n",
    "- Rad 5: Den lokala a är ändrad, vi skickar ut den med return.\n",
    "- Rad 8: Den globala a ändras först här; a-global=funktion(a-global)\n",
    "- Rad 9: Vi skriver ut global a."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ännu en att öva på. Håll reda på alla variablernas värden. Skriv gärna a-lokal och a-global. Börja på rad 6. Skriv en lista över vad som skrivs ut. Tryck sedan på Run."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ai 11\n",
      "ay 11\n",
      "b 12\n"
     ]
    }
   ],
   "source": [
    "def funktion(a):\n",
    "  print('ai',a)\n",
    "  a=a+1 #inre, ökar till 12\n",
    "  return a\n",
    "\n",
    "a=11 #yttre\n",
    "b=funktion(a)\n",
    "print('ay',a) #yttre\n",
    "print('b',b) #en kopia av inre"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Loopar\n",
    "\n",
    "Python klarar sig ibland för den är smart konstruerad. Den blandar inte ihop saker fastän de heter samma sak. Men du bör inte skriva så här med i i både den inre och yttre loopen."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "första 1\n",
      "  andra 1\n",
      "  andra 2\n",
      "  andra 3\n",
      "första 2\n",
      "  andra 1\n",
      "  andra 2\n",
      "  andra 3\n",
      "första 3\n",
      "  andra 1\n",
      "  andra 2\n",
      "  andra 3\n"
     ]
    }
   ],
   "source": [
    "for i in [1,2,3]:\n",
    "  print('första', i)\n",
    "  for i in [1,2,3]:\n",
    "    print('  andra', i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Skriv så här i stället"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "i 1\n",
      " k 1\n",
      " k 2\n",
      " k 3\n",
      "i 2\n",
      " k 1\n",
      " k 2\n",
      " k 3\n",
      "i 3\n",
      " k 1\n",
      " k 2\n",
      " k 3\n"
     ]
    }
   ],
   "source": [
    "for i in [1,2,3]:\n",
    "  print('i',i)\n",
    "  for k in [1,2,3]:\n",
    "    print(' k',k)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Även om loopar inuti loopar hanteras av python så kan man inte ha samma variabel utanför en loop som innanför."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "7 \n",
      "\n",
      "0\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n",
      "6\n",
      "7\n",
      "8\n",
      "9\n",
      "10\n",
      "11\n",
      "\n",
      "11 1331\n"
     ]
    }
   ],
   "source": [
    "i=7  # Vi sätter ett i här\n",
    "print(i, \"\\n\")\n",
    "\n",
    "for i in range(12):  # Vi använder i i en loop, ok. i går från 0 till 11.\n",
    "    print(i)\n",
    "\n",
    "print()\n",
    "print(i, i**3)  # Detta i kommer att vara loopens sista värde på i, dvs. 11 och inte 7"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Uppgifter\n",
    "\n",
    "\n",
    "**Uppgift 1**\n",
    "\n",
    "Vad ger följande kod för utskrift?\n",
    "\n",
    "```\n",
    "def g(a):\n",
    "    b = 7\n",
    "    print(\"b1 =\", b)\n",
    "    return(b)\n",
    "\n",
    "def h(a):\n",
    "    b=8\n",
    "    print(\"b2 =\", b)\n",
    "    return(b)\n",
    "\n",
    "b = 5\n",
    "print(\"g(0)\", g(0))\n",
    "print(\"h(0)\", h(0))\n",
    "print(\"b = \", b)\n",
    "\n",
    "```\n",
    "\n",
    "[Lösningsexempel](./uppg/namespace2Uppgift1.ipynb)"
   ]
  }
 ],
 "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.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}