ValIf.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Att göra val\n",
    "\n",
    "## Flöde\n",
    "\n",
    "Ofta hamnar man i en situation där man måste välja bland olika fall vad som ska göras. Tex. om en variabels värde är större än 0 så ska programmet göra på ett sätt men om variabelns värde är mindre än 0 så ska programmet göra något annat. Detta hanteras med så kallade 'if-satser'(om-så-satser).\n",
    "\n",
    "I figuren nedan illustreras ett vanligt linjärt flöde där satserna följer på varandra uppifrån och ner. Inga alternativ. Python läser rad för rad uppifrån och ner (radnummer) och utför kommandona. Python börjar med att tilldela a värdet 4, sedan beräkna 2 gånger a och tilldela c detta värde osv.\n",
    "\n",
    "\n",
    "<img src=\"./Pictures/flowchart1.png\" width=300 height=300>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "I figuren nedan illustreras en punkt i programmet där vi ska utföra olika satser beroende på värdet på en variabel. Överst i figuren visas ett flödesschema med de logiska alternativen. Nedanför visas motsvarande kod i python.\n",
    "\n",
    "\n",
    "<img src=\"./Pictures/flowchart2.png\" width=300 height=300>\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Se nedersta figuren i bilden ovan. I flödet har jag skrivit in en rad som ska göras då det är sant att `d < 0` och det är satsen `x = x + 1`. Om det inte är sant att `d < 0` så görs det som står i `else` delen dvs `x = x - 1`.\n",
    "\n",
    "Så om `d < 0` görs bara `x = x + 1`. Även om `x = x - 1` kommer efter `x = x + 1` så utförs den _inte_ om `d < 0` är sant; python hoppar.\n",
    "\n",
    "När python läst antingen `x = x + 1` eller `x = x + 1` (den har bara läst en av dem) så läser den satsen `d = d*2`; den satsen har inget indrag.\n",
    "\n",
    "Observera att satserna `x = x + 1` och `x = x - 1` har ett indrag (indent). Det är inte av estetiska skäl utan det _måste_ vara så. Det är en del av språkets syntax (grammatiska regler, absoluta och måste följas). Detta kan ibland ställa till problem om man kopierar och klistrar in kod; indragen går ibland förlorade. `d = d*2` är utanför if-satsen eftersom den inte har något indrag.\n",
    "\n",
    "Observera tecknet kolon dvs :\n",
    "Det _måste_ vara där.\n",
    "\n",
    "Man kan också skriva in flera satser; ett kodblock. Python tolkar alla indragna satser som ett _block_ eller _svit_ av kod; båda uttrycken används i svenskan. Se nästa cell."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x var större än 0\n",
      "5\n"
     ]
    }
   ],
   "source": [
    "x = 4  # Ändra och prova\n",
    "if x > 0:\n",
    "    x = x + 1  # Dessa 3 rader är ett block/en svit\n",
    "    d = 7\n",
    "    print(\"x var större än 0\")\n",
    "else:\n",
    "    x = x - 1  # Dessa 3 rader är ett block/en svit\n",
    "    d = 2*x\n",
    "    print(d)\n",
    "print(x) # utanför if-satsen"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Det finns också en enklare konstruktion (motsvarande att inget görs i else-delen)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n",
      "Denna skrivs alltid ut\n"
     ]
    }
   ],
   "source": [
    "x = int(input(\"Ange ett heltal\"))\n",
    "\n",
    "if x > 0:\n",
    "    print(x)\n",
    "print(\"Denna skrivs alltid ut\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Anger du tex. 3 så skrivs 3 ut. Anger du tex. -5 så skrivs inte x ut. Däremot skrivs den sista (inte indragen) printsatsen _alltid_ ut."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "\n",
    "\n",
    "Indragen i python måste vara minst ett mellanslag. Varje rad i ett block av kod måste ha samma storlek på indraget. Men olika block kan ha olika indrag. Dock är seden den att man i regel använder 4 mellanslag och ALDRIG har olika indrag i en kod; alltid heltalsmultiplar av 4.\n",
    "\n",
    "Stödprogram för att skriva kod har funktioner som hjälper dig i ditt skrivande med att hålla reda på indrag och olika block av kod.\n",
    "\n",
    "På python.org kan du läsa i PEP 8 om stilregler för kod. PEP står för \"Python Enhancement Proposals\".\n",
    "När man skriver kommentarer på en rad med kod (inline) så ska det vara 2 mellanslag innan # och sedan ett mellanslag innan texten börjar. Här nedan följer några utdrag från PEP 8. https://www.python.org/dev/peps/pep-0008/\n",
    "\n",
    "Comments should be complete sentences. The first word should be capitalized, unless it is an identifier that begins with a lower case letter (never alter the case of identifiers!).\n",
    "\n",
    "An inline comment is a comment on the same line as a statement. Inline comments should be separated by at least two spaces from the statement. They should start with a # and a single space."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Uppgifter\n",
    "\n",
    "**Uppgift 1**\n",
    "\n",
    "Skriv ett program som beräknar tionde-roten ur ett tal som användaren anger. Om talet inte är större än 0 ska programmet meddela att det inte går och avsluta.\n",
    "\n",
    "[Lösningsförslag](./uppg/ValIfUppg1.ipynb)\n",
    "\n",
    "\n",
    "\n",
    "**Uppgift 2**\n",
    "\n",
    "Skriv ett program som beräknar $\\left|x-y\\right|$. Användaren anger $x$ och $y$. Använd inte absolutbelopps-funktion utan beräkna skillnaden så tecknet alltid är positivt. Testa vilket tal som är störst.\n",
    "\n",
    "[Lösningsförslag](./uppg/ValIfUppg2.ipynb)\n",
    "\n",
    "\n",
    "**Uppgift 3**\n",
    "\n",
    "Skriv ett program som beräknar $x//y$ där $y\\leq x$. Användaren anger $x$ och $y$. Med en if-sats kontrolleras vilket tal som är störst. Be inte användaren ange största först eller liknande.\n",
    "\n",
    "[Lösningsförslag](./uppg/ValIfUppg3.ipynb)\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Att göra flera val\n",
    "\n",
    "Ibland är valmöjligheterna flera och då behövs mer komplicerade strukturer. Vi har tittat på\n",
    "\n",
    "```\n",
    "if x > 0:\n",
    "    x = x + 1\n",
    "else:  # x=0 och x<0\n",
    "    x = x - 1 \n",
    "```\n",
    "\n",
    "och den enklare\n",
    "\n",
    "```\n",
    "if x > 0:\n",
    "    x = x + 1\n",
    "```\n",
    "\n",
    "Det finns en konstruktion för upprepade val. Ett  `else` skrivs ihop med ett nytt `if` till `elif`. I exemplet nedan har vi 3 fall, inte 2 denna gång:\n",
    "\n",
    "```\n",
    "if x > 7:\n",
    "  print(\"x är större än 7\")\n",
    "elif x == 7:\n",
    "  print(\"x är lika med 7\")\n",
    "else:\n",
    "  print(\"x är mindre än 7\")\n",
    "```\n",
    "\n",
    "Vi använder koden och ber användaren ange ett heltal (och omvandlar strängen i input till ett heltal)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x är mindre än 7\n",
      "klart\n"
     ]
    }
   ],
   "source": [
    "\n",
    "x = int(input(\"Ange ett heltal\"))\n",
    "\n",
    "if x > 7:\n",
    "  print(\"x är större än 7\")\n",
    "elif x == 7:\n",
    "  print(\"x är lika med 7\")\n",
    "else:\n",
    "  print(\"x är mindre än 7\")\n",
    "print(\"klart\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python tillåter ett obegränsat antal elif men bara ett else.\n",
    "\n",
    "\n",
    "Exempel på uppdelning i 4 olika fall. Vi gör olika kommandon beroende på om x = 1, eller x = 2, eller x = 3, eller övriga fall:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Ange ett heltal 3\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n"
     ]
    }
   ],
   "source": [
    "x = int(input(\"Ange ett heltal\"))\n",
    "\n",
    "if x == 1:\n",
    "    x = x + 1\n",
    "elif x == 2:\n",
    "    x = x + 3\n",
    "elif x == 3:\n",
    "    x = x - 2\n",
    "else:\n",
    "    x = 0\n",
    "\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Se koden nedan. Python besöker bara ett av alternativen sedan lämnar den. Säg att vi matar in 1. Den testar inte fler om ett av fallen inträffat. Om vi först testar om x>0 och den är sann så utförs tillhörande indraget kodblock. Visserligen är också testet x=1 sann, men python testar inte den. \n",
    "\n",
    "'elif' står för else...if, vilket innebär att utfallet från ett tidigare if måste vara att gå till else(elif) och sedan testas ett nytt if(elif). Så är det första if uppfylld så hamnar man inte på else och kan då inte testa if som finns i denna elif.\n",
    "\n",
    "\n",
    "\n",
    "Se koden nedan. Om x anges som 1 så utförs första print-satsen. Faktum är att om x>0 så utförs endast första print-satsen. 0 och alla negativa tal gör att sista print-satsen skrivs. Andra printsatsen kommer aldrig att användas! Testa tex. med 1, 5, 0, -5."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Ange ett heltal 8\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x större än 0\n"
     ]
    }
   ],
   "source": [
    "x = int(input(\"Ange ett heltal\"))\n",
    "\n",
    "if x > 0:\n",
    "    print(\"x större än 0\")\n",
    "elif x == 1:\n",
    "    print(\"x är lika med 1\")\n",
    "else:\n",
    "    print(\"trillade igenom\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "\n",
    "Vi kan ha if-satser inuti if-satser. Nedanstående skriver ut att x är större än 0 och om x är 1 så skriver den det också. Om x inte är 1 men större än noll skrivs bara att x är större än 0. Om x är 0 eller negativt så skrivs 'trillade igenom' ut. Testa med 1, 2, 0, -5.\n",
    "\n",
    "Lägg märke till att skillnader i indrag visar att 'else' tillhör den yttre if-satsen (inget indrag); indrag måste vara av rätt längd."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Ange ett heltal 3\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x större än 0\n"
     ]
    }
   ],
   "source": [
    "x = int(input(\"Ange ett heltal\"))\n",
    "\n",
    "if x > 0:\n",
    "    print(\"x större än 0\")\n",
    "    if x == 1:\n",
    "        print(\"x är 1\")\n",
    "else:\n",
    "    print(\"trillade igenom\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "   "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "I nedanstående har vi 2 else med olika indrag, det markerar vilket if det tillhör."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Ange ett heltal 1\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x större än 0\n",
      "x är 1\n",
      "Denna rad är utanför if-satserna, utförs alltid\n"
     ]
    }
   ],
   "source": [
    "x = int(input(\"Ange ett heltal\"))\n",
    "\n",
    "if x > 0:\n",
    "    print(\"x större än 0\")\n",
    "    if x == 1:\n",
    "        print(\"x är 1\")\n",
    "    else:\n",
    "        print(\"x är inte 1\")\n",
    "else:\n",
    "    print(\"trillade igenom\")\n",
    "\n",
    "print(\"Denna rad är utanför if-satserna, utförs alltid\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Utan indrag fungerar det inte."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "ename": "IndentationError",
     "evalue": "expected an indented block after 'if' statement on line 3 (780783294.py, line 4)",
     "output_type": "error",
     "traceback": [
      "\u001b[0;36m  Cell \u001b[0;32mIn[3], line 4\u001b[0;36m\u001b[0m\n\u001b[0;31m    print(\"x större än 0\")\u001b[0m\n\u001b[0m    ^\u001b[0m\n\u001b[0;31mIndentationError\u001b[0m\u001b[0;31m:\u001b[0m expected an indented block after 'if' statement on line 3\n"
     ]
    }
   ],
   "source": [
    "x = int(input(\"Ange ett heltal\"))\n",
    "\n",
    "if x > 0:\n",
    "print(\"x större än 0\")\n",
    "if x == 1:\n",
    "print(\"x är 1\")\n",
    "else:\n",
    "print(\"x är inte 1\")\n",
    "else:\n",
    "print(\"trillade igenom\")\n",
    "\n",
    "print(\"Denna rad är utanför if-satserna, utförs alltid\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If-satser och logik har en speciell twist. Se kodcellen nedan för illustration.\n",
    "\n",
    "Logiskt är testvillkoren (rad 4 respektive 10) i cellen nedan lika. Men python 'vet' att för att det logiska 'och' ska vara sant så måste båda sidorna vara sant. När python beräknar den första delen av 'och' (rad 4) och det visar sig att den är falsk så beräknas aldrig den andra delen; python noterar inte att sqrt() inte finns. Speciellt intressant är detta om den andra delen skulle kunna ge ett avbrott. I rad 10 blir det avbrott eftersom vi försöker använda sqrt() (i första delen av 'och') men den finns inte i grundversionen utan måste importeras i en modul."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Välkommen!\n"
     ]
    },
    {
     "ename": "NameError",
     "evalue": "name 'sqrt' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m/home/luleka/jupyternb/progr/ValIf.ipynb Cell 24\u001b[0m line \u001b[0;36m1\n\u001b[1;32m      <a href='vscode-notebook-cell:/home/luleka/jupyternb/progr/ValIf.ipynb#X32sZmlsZQ%3D%3D?line=5'>6</a>\u001b[0m \u001b[39melse\u001b[39;00m:\n\u001b[1;32m      <a href='vscode-notebook-cell:/home/luleka/jupyternb/progr/ValIf.ipynb#X32sZmlsZQ%3D%3D?line=6'>7</a>\u001b[0m     \u001b[39mprint\u001b[39m(\u001b[39m\"\u001b[39m\u001b[39mVälkommen!\u001b[39m\u001b[39m\"\u001b[39m)\n\u001b[0;32m---> <a href='vscode-notebook-cell:/home/luleka/jupyternb/progr/ValIf.ipynb#X32sZmlsZQ%3D%3D?line=9'>10</a>\u001b[0m \u001b[39mif\u001b[39;00m sqrt(i) \u001b[39m>\u001b[39m \u001b[39m10\u001b[39m \u001b[39mand\u001b[39;00m i \u001b[39m<\u001b[39m \u001b[39mmax\u001b[39m:  \u001b[39m# Första delen ger felmeddelande för sqrt() är inte definierad\u001b[39;00m\n\u001b[1;32m     <a href='vscode-notebook-cell:/home/luleka/jupyternb/progr/ValIf.ipynb#X32sZmlsZQ%3D%3D?line=10'>11</a>\u001b[0m     \u001b[39mprint\u001b[39m(\u001b[39m\"\u001b[39m\u001b[39mAdjö!\u001b[39m\u001b[39m\"\u001b[39m)\n\u001b[1;32m     <a href='vscode-notebook-cell:/home/luleka/jupyternb/progr/ValIf.ipynb#X32sZmlsZQ%3D%3D?line=11'>12</a>\u001b[0m \u001b[39melse\u001b[39;00m:\n",
      "\u001b[0;31mNameError\u001b[0m: name 'sqrt' is not defined"
     ]
    }
   ],
   "source": [
    "max = 10\n",
    "i = 11\n",
    "\n",
    "if i < max and sqrt(i) > 10:  # Första delen (i<max) är F så vi går direkt till else\n",
    "    print(\"Adjö!\")\n",
    "else:\n",
    "    print(\"Välkommen!\")\n",
    "    \n",
    "\n",
    "if sqrt(i) > 10 and i < max:  # Första delen ger felmeddelande för sqrt() är inte definierad\n",
    "    print(\"Adjö!\")\n",
    "else:\n",
    "    print(\"Välkommen!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Uppgifter\n",
    "\n",
    "**Uppgift 4**\n",
    "\n",
    "Skriv ett program som ber användaren ange sin längd i hela centimetrar. Om längden är större än 172 cm så ska programmet skriva ut \"Du är längre än jag är\". Om längden är mindre så ska det skriva ut \"Du är kortare än jag är\". Och om längden är 172 cm så ska det skriva ut \"Vi är lika långa\".\n",
    "\n",
    "[Lösningsförslag](./uppg/ValIfUppg4.ipynb)\n",
    "\n",
    "\n",
    "**Uppgift 5**\n",
    "\n",
    "Skriv ett program som undersöker om ett tal är positivt eller negativt eller noll. Om talet är positivt ska det kontrollera om det är jämnt delbart med 5 eller inte; skriv ut slutsatsen. Om talet är negativt ska det kontrollera om talet är jämnt delbart med 2; skriv ut slutsatsen. Om det är 0 ska inget göras mer än att skriva ut att det är talet 0.\n",
    "\n",
    "\n",
    "[Lösningsförslag](./uppg/ValIfUppg5.ipynb)\n",
    "\n",
    "\n",
    "**Uppgift 6**\n",
    "\n",
    "Skriv ett program som räknar antalet siffror i ett heltal som användaren anger; talet kan vara positivt eller negativt. Om talet är negativt måste minustecknet naturligtvis räknas bort. Antalet element i en sträng ges av len() där strängen anges mellan parenteserna tex. len(\"hej\") är 3. Om strängen betecknas med variabeln x skriver man len(x); skriver du len(\"x\") får du 1 som svar.\n",
    "\n",
    "\n",
    "[Lösningsförslag](./uppg/ValIfUppg6.ipynb)\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.11.5"
  },
  "toc-autonumbering": true
 },
 "nbformat": 4,
 "nbformat_minor": 4
}