GrundIntro.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Introduktion"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## De fyra räknesätten\n",
    "\n",
    "Vi börjar med att använda python som en vanlig räknare.\n",
    "\n",
    "Tecknet # betyder i en cell med pythonkod (grå cell nedan) att det som följer efter på raden är en kommentar; det som står efter # på raden bryr sig python inte om. Tecknet gäller bara för den rad det står på, inte nästa rad.\n",
    "Det är till för att förklara tex. vad koden gör, men man kan skriva vad som helst. (# kallas för nummertecken, på engelska är ordet hashmark eller bara hash vanligt).\n",
    "\n",
    "Se nedan i cellen (grå) med pythonkod: `print()` måste vi skriva för att python ska skriva svaret till oss. Arbetar du interaktivt behövs det dock inte, då kan du skriva 1+1 direkt, jämför nedan. Om du arbetar vid en terminal så arbetar du interaktivt; skriver du rader i en texthanterare för att sedan köra koden (Run) så är det inte interaktivt. \n",
    "\n",
    "\n",
    "Jupyter, som detta är skrivet i, är egentligen interaktivt och print behövs inte här, men i regel ska koden som finns här användas av dig i en fil, då är det inte interaktivt. Så för att du ska kunna kopiera och klistra in koden någon annan stans så är koden här i jupyter skriven med print-kommandot.\n",
    "\n",
    "Placera markören i en kodcell nedan; klicka sedan på 'run'-pilen i menyn ovan; eller tryck ctrl-enter(kör koden och bli kvar i cellen) eller shift-enter(kör koden och gå till nästa cell). Ändra gärna i cellerna, du kan inte förstöra något. Vi börjar med att räkna med heltal endast."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "-1\n",
      "-5\n"
     ]
    }
   ],
   "source": [
    "print(1 + 1)  # Addition\n",
    "print(2 - 3)  # Subtraktion\n",
    "print(-2 - 3)  # Subtraktion"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6\n"
     ]
    }
   ],
   "source": [
    "print(2 * 3)  # Multiplikation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.6666666666666666\n"
     ]
    }
   ],
   "source": [
    "print(2 / 3)  # Vanlig division"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n"
     ]
    }
   ],
   "source": [
    "print(2 // 3)  # Heltalsdivision"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n"
     ]
    }
   ],
   "source": [
    "print(4 // 3)  # Heltalsdivision jfr föregående"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "-1\n",
      "-2\n"
     ]
    }
   ],
   "source": [
    "print(1 // 3)\n",
    "print(-1 // 3)  # obs avrundning mot minus-oändligheten (se math.floor())\n",
    "print(-4 // 3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n",
      "-2\n"
     ]
    }
   ],
   "source": [
    "print(6 % 3)  # Resten vid divison\n",
    "print(7 % 3)  # \n",
    "print(-7 % 3) # Observera resultatet\n",
    "print(7 % -3) # Observera resultatet"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "8\n",
      "1\n",
      "1.4142135623730951\n",
      "0.0009765625\n"
     ]
    }
   ],
   "source": [
    "print(2**3)  # Exponentiering\n",
    "print(0**0)\n",
    "print(2**0.5)\n",
    "print(0.5**10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Datatyper\n",
    "\n",
    "Datatyper är det som man utför operationer på."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Vi börjar med 4 datatyper. De kallas för:\n",
    "\n",
    "1. Heltal (integer)\n",
    "2. Flyttal (float)\n",
    "3. Strängar/teckenföljd (string)\n",
    "4. Boolska eller Logiska (boolean)\n",
    "\n",
    "Det finns fler. Vi kommer till dem senare. Vi studerar datatyperna närmare i det följande."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Heltal"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Med datatypen heltal (eng. integer, förkortat till int) avses det vi i matematiken menar med heltal. Heltal skrivs som 2 eller 124 eller -3. Talen ska inte anges med decimaltecken (decimaltecken i python är en punkt). Talet 2.0 är inte ett heltal/int. \n",
    "\n",
    "Med kommandot `print(type(x))` erhåller vi vilken datatyp x är. De anges som tillhörande olika klasser, class."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'int'>\n",
      "<class 'int'>\n"
     ]
    }
   ],
   "source": [
    "print(type(2))\n",
    "print(type(-2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Flyttal"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Med flyttal (eng. float) avses något som påminner om reella tal. Men naturligtvis kan datorn inte hantera reella tal i allmänhet eftersom de har ett oändligt antal decimaler och kan därför inte få plats att lagras i datorn. Exempelvis talet $ \\pi $. Flyttal är en delmängd av de rationella talen (och därmed naturligtvis en delmängd av de reella talen)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Om man skriver 2.3 (decimalpunkt!) så tolkas det som flyttal.\n",
    "Om man skriver 2 så tolkas det som heltal.\n",
    "Om man skriver 2. så tolkas det som flyttal.\n",
    "2/3 omvandlas automatiskt till flyttal. Vi låter `type()` visa oss."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'int'>\n",
      "<class 'float'>\n",
      "<class 'float'>\n"
     ]
    }
   ],
   "source": [
    "print(type(2))\n",
    "print(type(2.))\n",
    "print(type(2/3))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2.0\n",
      "2.0\n",
      "-0.5714285714285714\n"
     ]
    }
   ],
   "source": [
    "print(6/3)  # Division ger flyttal även om det går jämnt upp\n",
    "print(6/3.0)\n",
    "print(-1 + 3/7)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\\\n",
    "\\\n",
    "Observera att följande två uttryck är matematiskt ekvivalenta men ger inte samma resultat i python:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.10000000000000003"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "0.4 - 0.3  # Flyttal"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.1"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(4 - 3)/10"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Anledningen till att det är så här ligger i att det finns ändliga decimaltal i bas 10 som inte är ändliga i bas 2 som datorn använder. Det ger upphov till avrundningsfel i bas 2.\n",
    "\n",
    "$0.4_{10}=0.0110011001100110011..._2$    &nbsp; Ett oändligt antal decimaler skilda från 0 om skrivet i basen 2 $\\newline$ \n",
    "$0.3_{10}=0.0100110011001100110..._2$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Strängar"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Med sträng avses en följd av symboler/tecken. En sträng markeras med \" eller ' (dvs citat-tecken).\n",
    "Om man skriver '1' avses symbolen. Om man skriver 1 avses heltalet/int.\n",
    "\n",
    "Tecken för operationer får olika betydelser beroende på datatyp. \n",
    "\n",
    "Det är skillnad på '2'+'3' (lägga ihop symboler) och 2+3 (lägga ihop tal). Plustecknet har egentligen olika betydelser men för enkelhets skull används samma tecken för addition av tal respektive konkatenering av symboler. Konkatenering betyder att symboler placeras sidan om varandra, de kedjas samman.\n",
    "\n",
    "Håll isär operationer och tecken. För  flyttal i python gäller att vid:\n",
    "* addition använder vi plustecken +\n",
    "* subtraktion använder vi minustecken -\n",
    "* multiplikation använder vi stjärna/centrumpunkt *\n",
    "* division använder vi snedstreck /"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n"
     ]
    }
   ],
   "source": [
    "print(2 + 3)  # Vanlig addition av heltal"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "23\n"
     ]
    }
   ],
   "source": [
    "print('2' + '3')  # Konkatenering av symboler"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "32\n"
     ]
    }
   ],
   "source": [
    "print('3' + '2')  #  I annan ordning"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Som vi vet är addition kommutativt för tal. Konkatenering av symboler är inte kommutativt ty\n",
    "\"3\"+\"2\" $ \\neq $ \"2\"+\"3\". Att använda samma tecken för olika saker kallas på engelska att ett tecken är 'overloaded', överbelastad. Andra programmeringsspråk gör på andra sätt. Tex. använder språken Ada och Visual Basic symbolen & för konkatenering. `type()` visar oss vad som gäller. På engelska är typen string som förkortas str."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'int'>\n",
      "<class 'str'>\n"
     ]
    }
   ],
   "source": [
    "print(type(2))\n",
    "print(type('2'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Boolska\n",
    "\n",
    "Med en Boolsk datatyp avses något som kan anta värdena sant eller falskt, dvs i python True eller False. Kallas också logisk datatyp. True representeras med värdet 1 och False med värdet 0.\n",
    "Operationerna är lite annorlunda. Man kan testa om två objekt är lika med hjälp av dubbelt likhetstecken == som står för ekvivalens.\n",
    "\n",
    "Den logiska datatypen kan ses som en delmängd av heltal."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2 == 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2 == 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'a' == 'a'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'a' == 'b'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(0.4 - 0.3)==(4 - 3)/10 # Beräkningarna ger lite olika resultat, som nämnts tidigare"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Kan således vara problem när man testar om två tal är lika. Matematiskt tänker du att de är lika men pga att datorn använder bas 2 kan avrundningsproblem uppkomma."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "True == True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "True == False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'bool'>\n"
     ]
    }
   ],
   "source": [
    "print(type(True))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Man kan också testa större än, större än eller lika med, mindre än...inte lika med...:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2 < 3  # 2 är mindre än 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "3 < 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "3 <= 3  # Mindre än eller lika med"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "3 != 2  # 3 är inte lika med 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "not(2 == 3 )  # Negera, Icke"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Man kan också använda de logiska konnektiven and, or."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "True and False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "False or True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "not (True and False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Falsk representeras av 0 och True av 1. Alla tal större än 1 ger också True."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "print(not(4))  # 4 anger True så not ger False\n",
    "print(not(1.1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Lite om variabler\n",
    "\n",
    "En variabel kan *tilldelas* ett värde. Det görs genom likhetstecken. Se nedan. Vi tilldelar variabeln a värdet 5 och variabeln b värdet 7. Variabeln måste stå till vänster och talet eller värdet till höger.\n",
    "\n",
    "Detta är så viktigt att jag upprepar det: Likhetstecken (=) är inte \"lika med\" som i matematiken utan en tilldelning; en variabel tilldelas ett värde. I engelsk litteratur kallas det för 'assignment'; man säger inte 'equal'."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "12\n",
      "-2\n",
      "1.4\n",
      "78125\n"
     ]
    }
   ],
   "source": [
    "a = 5  # a tilldelas värdet 5\n",
    "b = 7  # b tilldelas värdet 7\n",
    "print(a+b)\n",
    "print(a-b)\n",
    "print(b/a)\n",
    "c = a**b\n",
    "print(c)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "cannot assign to literal here. Maybe you meant '==' instead of '='? (218069805.py, line 1)",
     "output_type": "error",
     "traceback": [
      "\u001b[0;36m  Cell \u001b[0;32mIn[18], line 1\u001b[0;36m\u001b[0m\n\u001b[0;31m    5 = a # Är ok i en matematikbok men inte i python, felmeddelande!\u001b[0m\n\u001b[0m    ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m cannot assign to literal here. Maybe you meant '==' instead of '='?\n"
     ]
    }
   ],
   "source": [
    "5 = a # Är ok i en matematikbok men inte i python, felmeddelande!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Efter Söndag kommer Måndag.\n"
     ]
    }
   ],
   "source": [
    "# Även strängar är värden som variabler kan anta\n",
    "\n",
    "a = 'Efter Söndag kommer'\n",
    "b = ' Måndag.'\n",
    "print(a+b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True True\n"
     ]
    }
   ],
   "source": [
    "# Logiska variabler\n",
    "\n",
    "a = (5 > 3)  # a tilldelas värdet True\n",
    "b = a or False  # b tilldelas värdet True\n",
    "print(a, b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "a = 5\n",
    "b = 6\n",
    "c = not(a == b)\n",
    "print(c)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Utskrift\n",
    "\n",
    "Kommandot `print()`, som vi redan använt ett flertal gånger, används för att skriva ut saker."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a = 3\n"
     ]
    }
   ],
   "source": [
    "a = 3\n",
    "print('a =', a)  # Först skrivs strängen sedan värdet på a, på samma rad"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "talet a är 4\n"
     ]
    }
   ],
   "source": [
    "a = 4\n",
    "print('talet a är', a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Det som står inom apostroferna ' skrivs ut som det är, det är strängar.\n",
    "Beroende på omständigheter kan man också skriva"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = 5\n",
    "a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Om man arbetar interaktivt med python, i terminal, så kan saker skrivas ut som i det föregående med `a = 5` för tilldelning och sedan `a` för utskrift. Arbetar du inte interaktivt med python utan skriver kommandon i en fil som ska köras måste du skriva `print(a)` för att få reda på a:s värde då programmet körs."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "b = 3 och a = 2\n"
     ]
    }
   ],
   "source": [
    "a = 2\n",
    "b = 3\n",
    "print('b =',b, 'och a =',a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Programmet bestämmer alla primtal; 17  är ett primtal\n",
      "Även tomma positioner                  räknas\n"
     ]
    }
   ],
   "source": [
    "print('Programmet bestämmer alla primtal;', 2+3+5+7,' är ett primtal')\n",
    "\n",
    "print('Även tomma positioner                  räknas')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Lägg märke till att följande är också möjligt med strängar."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hej på dej!\n",
      "Hej och adjö\n"
     ]
    }
   ],
   "source": [
    "a = 'Hej'\n",
    "print(a, 'på dej!')\n",
    "b = a +' och adjö'\n",
    "print(b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Input\n",
    "\n",
    "Att ta in data till ett program görs via kommandot `input()`.\n",
    "I kommandot kan man samtidigt skriva en utskrift genom att skriva text inom citattecken (sträng).\n",
    "\n",
    "\n",
    "Det som användaren anger, inputen, tex. skriver 55 på tangentbordet, tolkas av python som en sträng. För att det ska kunna användas som ett tal i beräkningar måste det omvandlas från sträng till heltal via kommandot `int()` och till flyttal med `float()`.\n",
    "\n",
    "Med `;` kan man ha 2 eller fler kommandon på en rad. När du kör kod-cellen så kommer en ruta upp för dig att fylla i ett tal; gör det och tryck sedan på Enter."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Ange ett heltal  3\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n",
      "<class 'str'>\n",
      "3\n",
      "<class 'int'>\n",
      "3.0\n",
      "<class 'float'>\n"
     ]
    }
   ],
   "source": [
    "x = input(\"Ange ett heltal \")\n",
    "print(x); print(type(x))  # x är sträng (string)\n",
    "\n",
    "y = int(x)\n",
    "print(y); print(type(y))  # y är heltal (integer)\n",
    "\n",
    "z = float(x)\n",
    "print(z); print(type(z))  # z är flyttal (float)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Parenteser\n",
    "\n",
    "I uttryck blir det lätt ett flertal parenteser. Man skiljer på inre parenteser och yttre parenteser. I `print(type(z))` är parenteserna kring z inre parenteser och parenteserna kring type(z) är yttre parenteser. Man föreställer sig en rörelse utifrån och in, som lådor inuti lådor.\n",
    "\n",
    "Antalet vänsterparenteser ska vara lika med antalet högerparenteser. Editorer hjälper ofta till med detta genom att markera den parentes som hör ihop med den parentes som markören är placerad vid."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "## Uppgifter\n",
    "\n",
    "**Uppgift 1**\n",
    "Skriv in följande kod och få den att fungera. Skriv på jupyter https://jupyter.org/try eller på din dator. Du kan också skapa en kod-ruta genom att klicka på + symbolen sidan om saxen här ovan och sedan skriva i kod-rutan; den försvinner när du stänger ner och finns inte kvar när du startar dessa sidor nästa gång.\n",
    "\n",
    "```\n",
    "a = 37\n",
    "b = 11\n",
    "summa = a + b\n",
    "print(\"Summan av\", a, \"och\", b, \"är\", summa)\n",
    "\n",
    "differens = a - b\n",
    "print(\"Differensen mellan\", a, \"och\", b, \"är\", differens)\n",
    "\n",
    "heltalsrest = a % b\n",
    "print(\"Heltalsresten vid division av\", a, \"och\", b,\"är\", heltalsrest)\n",
    "\n",
    "heltalskvot = a // b\n",
    "print(b,\"går\", heltalskvot,\"gånger i\",a)\n",
    "```\n",
    "a) Ändra värdena på variablerna a och b till andra heltal.\n",
    "\n",
    "b) Skriv in exponentiering, `a**b`, på samma sätt som de andra.\n",
    "\n",
    "c) Ändra a och b till flyttal; tex. a = 37.1 och b = 11.5 (observera decimalpunkt)\n",
    "Kommenterar python detta?\n",
    "\n",
    "d) Ändra i programmet så att en användare kan ange talen med hjälp av t.ex. `a=input(\"ange ett heltal: \")`. Glöm inte omvandla de inmatade 'talen', som är av datatypen sträng, till datatypen heltal.\n",
    "\n",
    "[Lösningsförslag](./uppg/GrundintroUppg0.ipynb)\n",
    "\n",
    "\n",
    "\n",
    "**Uppgift 2**\n",
    "\n",
    "Skriv ett program som läser in två heltal och sedan undersöker om de har en gemensam faktor. Det kan göras genom att observera att heltalsdivisionen är lika med den vanliga divisionen a//b == a/b då de har en gemensam faktor. Låt programmet skriva ut sanningsvärdet.\n",
    "\n",
    "[Lösningsförslag](./uppg/GrundintroUppg1.ipynb)\n",
    "\n",
    "\n",
    "\n",
    "**Uppgift 3**\n",
    "\n",
    "Låt oss fuska vid omvandling av ett tal i bas 10 till bas 2 genom att inte själva skriva ett program för det utan använda kommandot `bin()` som omvandlar ett tal i bas 10 till ett tal i bas 2: `bastvå = bin(bastio)`. Användaren ska mata in talet. Om du anger talet 13 kommer Python svara på formen `0b1101` där `0b` anger att det är ett binärt tal. I matematiken skriver vi samma tal som $1101_2$ (talet är $1 \\cdot 2^3+1 \\cdot 2^2+0 \\cdot 2^1+1 \\cdot 2^0=13$)\n",
    "\n",
    "[Lösningsförslag](./uppg/GrundintroUppg3.ipynb)\n",
    "\n",
    "**Uppgift 4**\n",
    "\n",
    "En av de Morgans lagar i logiken är att $ \\lnot(p\\lor q) $ är ekvivalent med $ \\lnot p\\land\\lnot q $. Detta innebär med pythons symboler att `not(A or B)` är ekvivalent med `not(A) and not(B)`. Att de är ekvivalenta innebär att de har samma sanningsvärdestabell. Sanningsvärdestabellen består av alla kombinationer av `True`  och `False` för de 2 variablerna `A` och `B`. Konstruera ett program som skriver ut de 2 sanningsvärdestabellerna (4 rader med värden: ss,sf,fs,ff). (Det här blir enklare när vi har tillgång till loopar senare.)\n",
    "\n",
    "[Lösningsförslag](./uppg/GrundintroUppg4.ipynb)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python [conda env:base] *",
   "language": "python",
   "name": "conda-base-py"
  },
  "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.12.2"
  },
  "toc-autonumbering": true,
  "toc-showtags": false
 },
 "nbformat": 4,
 "nbformat_minor": 4
}