03 Logiske operatorer.ipynb

{
  "cells": [
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "# Logiske operatorer\nLogiske operatorer brukes til å utføre sammenliknger. Vi må ofte sammenlikne ulike størrelser med hverandre, og sammenlikninger blir særlig viktig når vi ser på if-else-strukturer, som er helt sentralt i programmering. Vi gjør sammenlikninger i hverdagen: Vi sammenlikner priser på to liknende produkter. Vi sammenlikner prisen på et produkt med beløpet vi er villig til å bruke. Vi sammenlikner tittelene på bøker hvis de skal sorteres alfabetisk. Vi sammenlikner hvor lang tid vi tror noe vil ta med tiden vi har tilgjengelig.\n\nVi har som regel 6 typer sammenlikninger. Vi kan sjekke om to ting er like, om de er ulike, om den første er mindre enn den andre, mindre enn eller lik den andre, større enn den andre eller større enn eller lik den andre. I Python bruker vi operatorene i tabellen under. Legg særlig merke til at det er to likhetstegn i den første sammenlikninger. Vi bruker ETT likhetstegn når en variabel skal få en verdi, og vi bruker TO likhetstegn når vi skal undersøke om to ting er like.\n\n| Symbol | Type sammenlikning   |\n|------|------|\n|  ==  | Lik|\n|  !=  | Ulik|\n|   <  | Mindre enn|\n|  <=  | Mindre enn eller lik|\n|   >  | Større enn|\n|  >=  | Større enn eller lik|\n\nNår vi gjør en (lovlig) sammenlikning får vi ett av to resultater. Enten \"True\" eller \"False\". Hvis vi gjør en ulovlig sammenlikning får vi en feilmelding. Prøv selv å sammenlikne et tall med en tekst, en streng. La oss se på noen grunnleggende eksempler:"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "print(3 == 5)\nprint(3 != 5)\nprint(2 < 2)\nprint(2 <= 2)\nprint(8 > -15)\nprint(8 >= -15)",
      "execution_count": 1,
      "outputs": [
        {
          "output_type": "stream",
          "text": "False\nTrue\nFalse\nTrue\nTrue\nTrue\n",
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "Øving: Tenk over hva som vil printes dersom følgende kommandoer kjøres. Når du har tenkt over det og skrevet ned resultatet, kjør kommandoene i en ny celle. (Dersom du dobbelklikker i denne cellen vil du se hvordan man kan skrive to stjerner uten at det skal tolkes som \"fet skrift\". Legg merke til at dette brukes bare når vi skriver tekst i \"markdown\"-cellene. I kode-cellene skriver vi bare * som vanlig.)\n* print(-12 < -8)\n* print(5+8 != 13)\n* print(2*4 > 2+6)\n* print(-3 > -5)"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "## Sammenlikninger av variabler\nI de forrige eksemplene sammenlignet vi to konstanter. For å gjøre noe som virkelig er av verdi må vi være i stand til å sammenligne variabler. Under er et enkelt eksempel:"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "x = 5\ny = 3\nprint(x <= y)\nprint(x+y < x*y)",
      "execution_count": 2,
      "outputs": [
        {
          "output_type": "stream",
          "text": "False\nTrue\n",
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "Øving: Tenk over hva som vil printes dersom følgende kommandoer kjøres. Når du har tenkt over det og skrevet ned resultatet, kjør kommandoene i en ny celle.\n* a = 1\n* b = 2\n* c = 3\n* print(b-a != c+2)\n* a = -3\n* b = 2\n* c = -2\n* print(b-a <= c+2)\n* a = -1\n* b = 2\n* c = -2\n* print(b-a == c+2)\n* print(b*(-a) >= b-a )"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "## Intervaller\nVi kan sjekke om en verdi ligger i et intervall ved å skrive f.eks. 3 < x <= 5 for å sjekke om x er større enn 3 og mindre enn eller lik 5, altså $ 3 < x \\le 5 $."
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "x = 3\ny = 4\nz = 5\nprint(3 < x <= 5)\nprint(3 <= x < 5)\nprint(x < y < z)\nprint(3+x < 2*y < z-z)",
      "execution_count": 3,
      "outputs": [
        {
          "output_type": "stream",
          "text": "False\nTrue\nTrue\nFalse\n",
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "Øving: Tenk over hva som vil printes dersom følgende kommandoer kjøres. Når du har tenkt over det og skrevet ned resultatet, kjør kommandoene i en ny celle.\n* x = 3\n* y = 4\n* z = 5\n* print(3 < x <= 3)\n* print(z <= 2*x < y+2)\n* print(z-2 <= x+y < x*y-2)"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "# Flere logiske operatorer: and, or, not\nDet finnes tre andre operatorer vi trenger for å lage logiske uttrykk. Av og til er det ikke bare én ting vi ønsker å sjekke. Vi kan sjekke om to ting begge er sanne med \"and\"-operatoren, eller om minst én av to ting er sanne med \"or\"-operatoren, eller om noe ikke er sant med \"not\"-operatoren.\n\n## Oppsummering av and/or/not\n\nHer er en tabell som viser sannhetsverdiene for alle fire muligheter for A og B\n\n\n| A     | B     || not(A)| A and B | A or B |\n|-------|-------||-------|---------|--------|\n| True  | True  || False |  True   |  True  |\n| True  | False || False |  False  |  True  |\n| False | True  || True  |  False  |  True  |\n| False | False || True  |  False  |  False |\n\nLegg merke til at \"A and B\" er sant bare hvis begge er sanne, og \"A or B\" er usant bare hvis begge er usanne.\n\n## And-operatoren\nJeg har svømmetrening mellom 10 og 13 på tirsdager. For å nå den må jeg gå hjemmefra senest 9 tirsdag morgen. Da ønsker jeg både å sjekke om klokka er mindre enn eller lik 9, og jeg ønsker å sjekke om det er tirsdag. (Det lønner seg å sjekke om det er tirsdag først, siden det bare er på tirsdager det er noe poeng i å sjekke om klokka er mindre enn eller lik 9.) Hvis vi trenger å sjekke to ting som begge må være sanne bruker vi \"and\". Operatoren \"and\" krever at begge utsagn er sanne, ellers returnerer den \"False\"."
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "dag = \"mandag\"\ntid = 7.5 # 07:30, halv åtte\nprint(dag == \"tirsdag\" and tid <= 9)\n\ndag = \"tirsdag\"\nprint(dag == \"tirsdag\" and tid <= 9)",
      "execution_count": 4,
      "outputs": [
        {
          "output_type": "stream",
          "text": "False\nTrue\n",
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "Øving: Tenk over hva som vil printes dersom følgende kommandoer kjøres. Når du har tenkt over det og skrevet ned resultatet, kjør kommandoene i en ny celle.\n\n* by = \"Oslo\n* land = \"Sverige\"\n* print(\"København\" == by and \"Sverige\" == land)\n* print(\"København\" == by or \"Sverige\" == land)"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "## Or-operatoren\nEn annen situasjon er beskrevet her: Jeg har to naboer. Jeg lurer på om noen av naboene min heter Monroe eller Kennedy (eller noe helt annet). Det er ikke så viktig akkurat hvilket navn, så lenge minst ett av navnene står på postkassen.\n\nDersom det holder om en av to ting er sanne bruker vi \"or\". Denne operatoren sjekker om minst en av de påstandene to er sanne. Den returnerer \"False\" hvis ingen av de to er sanne.\n\nVi kan også gjøre dette med tall. Kanskje jeg lurer på om et tall er mindre enn -5 eller større enn 4. Det er ikke så viktig hvilken av de, så lenge en av de gjelder. Or-operatoren kan leses som \"og/eller\"."
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "nabo1 = \"Nixon\"\nnabo2 = \"Kennedy\"\nprint(nabo1 == \"Monroe\" or nabo1 == \"Kennedy\") # Heter nabo1 Monroe eller Kennedy?\nprint(nabo2 == \"Monroe\" or nabo2 == \"Kennedy\") # Heter nabo2 Monroe eller Kennedy?",
      "execution_count": 5,
      "outputs": [
        {
          "output_type": "stream",
          "text": "False\nTrue\n",
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {
        "scrolled": true,
        "trusted": true
      },
      "cell_type": "code",
      "source": "tall1 = 3\ntall2 = -8\nprint(tall1 < -5 or tall1 > 4) # Er tall1 mindre enn minus fem eller større enn fire?\nprint(tall2 < -5 or tall2 > 4) # Er tall2 mindre enn minus fem eller større enn fire?\n\nprint(5 > 3 or 5 < 9) # Her ser vi at det gjør ingenting om begge de logiske utsagnene er sanne. \"or\" returnerer likevel \"True\".",
      "execution_count": 6,
      "outputs": [
        {
          "output_type": "stream",
          "text": "False\nTrue\nTrue\n",
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "Øving: Tenk over hva som vil printes dersom følgende kommandoer kjøres. Når du har tenkt over det og skrevet ned resultatet, kjør kommandoene i en ny celle.\n\n* smykke = \"ring\"\n* edelsten = \"rubin\"\n* print(smykke == \"halskjede\" or smykke == \"ring\")\n* print(edelsten == \"diamant\" or smykke == \"øredobb\")"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "## Not-operatoren\nDen siste operatoren vi skal se på her er not. Det er en operator som sjekker om noe ikke er sant."
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "dag = \"tirsdag\"\nprint(dag == \"onsdag\")\nprint(not (dag == \"onsdag\"))\nprint(dag == \"tirsdag\")\nprint(not (dag == \"tirsdag\"))",
      "execution_count": 7,
      "outputs": [
        {
          "output_type": "stream",
          "text": "False\nTrue\nTrue\nFalse\n",
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "Not-operatoren gjelder bare det aller nærmeste logiske utsagnet. Dersom vi ønsker å ta negasjonen til et sammensatt uttrykk av flere logiske utsagn må vi sette parentes rundt hele uttrykket. Se eksempler under."
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "tall1 = 7\nprint(tall1 < -5 or tall1 > 4)\nprint(not tall1 < -5 or tall1 > 4) # not gjelder første logiske utsagn\nprint(not (tall1 < -5) or tall1 > 4) # Samme virkning som over\nprint(tall1 < -5 or not (tall1 > 4)) # Sjekker det andre utsagnet\nprint(not (tall1 < -5 or tall1 > 4)) # Sjekker motsetningen av hele det sammensatte utsagnet",
      "execution_count": 8,
      "outputs": [
        {
          "output_type": "stream",
          "text": "True\nTrue\nTrue\nFalse\nFalse\n",
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "Øving: Tenk over hva som vil printes dersom følgende kommandoer kjøres. Når du har tenkt over det og skrevet ned resultatet, kjør kommandoene i en ny celle.\n\n* sport = \"fotball\"\n* print(not(sport == \"golf\")"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "### Sammensatte oppgaver"
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "Øving: Tenk over hva som vil printes dersom følgende kommandoer kjøres. Når du har tenkt over det og skrevet ned resultatet, kjør kommandoene i en ny celle.\n* favorittfrukt1 = \"eple\"\n* favorittfrukt2 = \"kiwi\"\n* frukt = \"ananas\"\n* print(frukt == favorittfrukt1)\n* print(not(frukt == favorittfrukt1))\n* print(frukt == favorittfrukt1 and frukt == favorittfrukt2)\n* print(not frukt == favorittfrukt1 and frukt == favorittfrukt2)\n* print(not (frukt == favorittfrukt1 and frukt == favorittfrukt2))"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {
        "collapsed": true
      },
      "cell_type": "markdown",
      "source": "Øving: Tenk over hva som vil printes dersom følgende kommandoer kjøres. Når du har tenkt over det og skrevet ned resultatet, kjør kommandoene i en ny celle.\n* x = 1\n* y = 2\n* z = 3\n* print(x == y or y > z)\n* print(not(y != z))\n* print(not(y != z) or x > z)\n* print((y != z or x > z) and (z <= z))\n* print(not(x <= y and y != x))\n* print(z >= y and x > y)\n* print(not(x <= y and y != x) or (z >= y and x > y))"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {
        "collapsed": true
      },
      "cell_type": "markdown",
      "source": "Øving: Fyll inn \"True\" og \"False\" på alle plasser i tabellen under. Sørg for at du får med deg alle fire kombinasjoner av A og B. (Når du skriver i denne tabellen gjør det ikke noe om kolonneskillene ikke liner opp helt.)\n\n| A     | B     || not(B)|  A or B | A and B |\n|-------|-------||-------|---------|---------|\n|       |       ||       |         |         |\n|       |       ||       |         |         |\n|       |       ||       |         |         |\n|       |       ||       |         |         |"
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "# Ekstra materiale\nStoffet under er nyttig, men kan vente til senere om du ikke vil se på det nå."
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "## Sammenlikning av strenger\nVi kan også sammenligne strenger. Det lar oss sortere alfabetisk."
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "streng1 = \"tekst\"\nstreng2 = \"Tekst\"\nstreng3 = \"annerledes\"\nprint(streng1 == \"tekst\")\nprint(\"annerledes\" == streng3)\nprint(streng1 == streng3)\nprint(streng1 == streng2)",
      "execution_count": 9,
      "outputs": [
        {
          "output_type": "stream",
          "text": "True\nTrue\nFalse\nFalse\n",
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "## Mer om not-operatoren\nNot-operatoren er særlig nyttig dersom det finnes mange tilfeller, og alle utenom en eller to er akseptable. F.eks. er det 12 måneder, og hvis vi skal gå på skolen i januar, februar, mars, april, mai, august, september, oktober, november og desember, mens juni og juli er feriemåneder. Vi kan skrive \"or\" med alle akseptable alternativer, men det er lettere å skrive \"ikke juni eller juli\"."
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "måned = \"juli\"\n\nprint(måned == 'januar' or måned == 'februar' or måned == 'mars' or måned == 'april' or måned == 'mai' or måned == 'august' or måned == 'september' or måned == 'oktober' or måned == 'november' or måned == 'desembe')\nprint(not måned == 'juni' or måned == 'juli')",
      "execution_count": 10,
      "outputs": [
        {
          "output_type": "stream",
          "text": "False\nTrue\n",
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "Siste linje i cellen over var merkelig. Det var jo juli, så hvorforfår vi \"True\" ut av \"ikke juni eller juli\"? \"ikke juni eller juli\" skal jo være \"False\", siden det ER juli.\n\nDet skjedde fordi not bare gjelder den første logiske påstanden, som her var \"måned == 'juni'\". Vi må bruke en parentes, eller skrive \"not\" to ganger."
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "print(not(måned == 'juni' or måned == 'juli'))",
      "execution_count": 11,
      "outputs": [
        {
          "output_type": "stream",
          "text": "False\n",
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "###### Øystein Grøndahl, oktober 2018"
    }
  ],
  "metadata": {
    "anaconda-cloud": {},
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3",
      "language": "python"
    },
    "language_info": {
      "mimetype": "text/x-python",
      "nbconvert_exporter": "python",
      "name": "python",
      "pygments_lexer": "ipython3",
      "version": "3.5.4",
      "file_extension": ".py",
      "codemirror_mode": {
        "version": 3,
        "name": "ipython"
      }
    }
  },
  "nbformat": 4,
  "nbformat_minor": 1
}