{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# IN1000 - Seminartime uke 5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Husk: Dette dokumentet er kun for hjelp, det er forelesningsfoilene og pensumsboka som bestemmer pensum og læringsmål. Om noe her motstrider med det som er gjennomgått i forelesning, si ifra til meg (sondrbw@uio.no), og følg det som forelesningen sier.\n",
    "\n",
    "NB: Kan hende man ønsker å tømme alt som er skrevet ut/kjørt i notebooken, for å få til dette trykk på Kernel -> Restart and clear output"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Stikkord for timen\n",
    "\n",
    "* skop\n",
    "* input/output"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "## Forskjeller på funksjon, prosedyre og metode (repetisjon fra sist)\n",
    "\n",
    "### Funksjon \n",
    "En funksjon som defineres med *def*, som ikke er del av en klasse (ordet self brukes ikke). Funksjoner har alltid en returverdi.\n",
    "Eks:    \n",
    "```python\n",
    "def sum(a, b):\n",
    "    c = a + b        \n",
    "    return c\n",
    "```\n",
    "På engelsk kalles dette function.\n",
    "\n",
    "### Prosedyre \n",
    "Tilsvarende funksjon, men uten returverdi. Bruker aldri ordet self, og er ikke del av en klasse.\n",
    "Eks:\n",
    "```python\n",
    "    def superprint(ord):\n",
    "        print(“ordet er”, ord)\n",
    "```\n",
    "På engelsk kalles dette procedure.\n",
    "\n",
    "\n",
    "### Metode\n",
    "Tilsvarende funksjon, men som del av en klasse. Har alltid self som første parameter. Kan, men må ikke, ha en returverdi.\n",
    "Eks:\n",
    "```python\n",
    "    def areal(self):\n",
    "        firkant_areal = self.lengde * self.bredde\n",
    "        return firkant_areal\n",
    "```\n",
    "På engelsk kalles dette method.\n",
    "\n",
    "\n",
    "### NB!\n",
    "\n",
    "Frem til vi lærer mer om objekter er det kun funksjoner og prosedyrer vi fokuserer på.\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "## Sende med parametere (repetisjon fra sist)\n",
    "\n",
    "* Til prosedyrer/funksjoner kan man også sende med parametre, som er en type variabler. Variablene man sender med “blir” de som er med som argument i prosedyren.\n",
    "\n",
    "Syntaks:\n",
    "\n",
    "```python\n",
    "def prosedyre_navn(parameter1, parameter2, …)  # kan ha så mange parametere man vil\n",
    "\t<gjøre ting>\n",
    "```\n",
    "F.eks.\n",
    "```python\n",
    "def summer(a, b):\n",
    "\tprint(\"sum: \", a + b)\n",
    "```\n",
    "\n",
    "Inni prosedyren “summer” vil a her ha verdien 5 og b ha verdien 6. \n",
    "Man kan også sende med variabler når man kaller på en prosedyre:\n",
    "Feks.\n",
    "```python\n",
    "z = 7\n",
    "y = 3.5\n",
    "summer(z, y)\n",
    "```\n",
    "\n",
    "Her vil a få verdien 7 og b får verdien 3.5. \n",
    "\n",
    "**NB! Når prosedyren summer er ferdig så vil ikke a og b “beholde” verdiene sine.\n",
    "Repetere igjen; Fordel med prosedyrer -> kan gjenbruke kode! Kan kalle på en prosedyre flere ganger**\n",
    "\n",
    "Tegn opp disse kallene, forklar hvordan a og b får sine “verdier”.\n",
    "\n",
    "Parametrene som sendes med kan være hvilke som helst verdier.\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Med returverdi - funksjoner:\n",
    "\n",
    "I eksemplene fra forrige uke skrev vi ut verdiene.\n",
    "\n",
    "Noen ganger ønsker man metoder som i stedet for å skrive ut noe, returnerer noe til oss (gjerne basert på parametrene vi sender med) som vi kan bruke videre i programmet.\n",
    "\n",
    "Syntaks:\n",
    "``` python\n",
    "def funksjons_navn(parameter1, parameter2, …)  # kan ha så mange parametere man vil\n",
    "    <gjøre ting>\n",
    "    return <returverdien>\n",
    "```\n",
    "\n",
    "Eks.\n",
    "```python\n",
    "def summer(a, b):\n",
    "\tsum = a + b\t# i stede for å skrive ut så regner vi sammen summen og lagrer i variabelen “sum”.\n",
    "\treturn sum\t# deretter returnerer vi verdien til sum.\n",
    "```\n",
    "\n",
    "Slik kaller vi funksjonen:\n",
    "\n",
    "```python\n",
    "verdi_fra_summer = summer(2, 3)\n",
    "```\n",
    "\n",
    "**NB!** En funksjon kan kun returnere **én** ting(!).\n",
    "\n",
    "Dersom man ønsker å returnere mer enn 1 ting må man lage en liste, legge tingene i listen og returnere hele listen.\n",
    "Som regel når man kaller en funksjon tar man vare på verdien den returnerer med en variabel."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Hva får vi hvis vi nå skriver ut verdi_fra_summer? \n",
    "\n",
    "```python\n",
    "print(verdi_fra_summer) \n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "# Oppgave 1\n",
    "\n",
    "1. Skriv en funksjon som tar i mot to tall og returnerer det største av de to tallene (ikke skrive det ut). \n",
    "\n",
    "2. Lag en main prosedyre som kaller på funksjonen din "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Skop\n",
    "\n",
    "“Skop” vil si den delen av programmet du kan aksessere/få tilgang på en variabel. En variabel som er definert i en prosedyre kalles for en “lokal variabel”. Defineres variabler utenfor en prosedyre vil den være en “global variabel” og dermed tilgjengelig for alle. \n",
    "\n",
    "Generelt burde man bruke lokale variabler og heller lage prosedyrer som returnerer verdier fremfor globale variabler som oppdateres av mange prosedyrer.\n",
    "\n",
    "Gitt koden som beregner gjennomsnittet under her:\n",
    "\n",
    "```python\n",
    "def gjennomsnitt(tall1, tall2):\n",
    "    snitt = (tall1 + tall2)/2\n",
    "    return snitt\n",
    "    \n",
    "gjennomsnitt(2,6)\n",
    "```\n",
    "\n",
    "Vil variablene `tall1` og `tall2` **kun** eksistere inne i funksjonen gjennomsnitt. \n",
    "\n",
    "Det vil si at det f.eks. ikke er mulig å skrive ut `tall2` etter linjen `gjennomsnitt(2,6)`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "# Skop er viktig\n",
    "\n",
    "Skop er veldig viktig, siden det sier noe om hva deler av programmet “ser”.\n",
    "\n",
    "\n",
    "Vi fortsetter med det første eksempelet:\n",
    "```python\n",
    "def summer():\n",
    "\tprint(\"sum: \", a + b)\t\n",
    "\n",
    "a = 3\n",
    "b = 2\n",
    "summer()\n",
    "```\n",
    "\n",
    "Å skrive det på denne måten går fint, da benyttes verdiene til a og b til summeringen. Her er a og b *globale variabler*. (dette kommer vi tilbake til)\n",
    "\n",
    "Vi skriver om på den:\n",
    "```python\n",
    "def minus(): \n",
    "\ta = 3\n",
    "\tb = 2\n",
    "\n",
    "def summer():\n",
    "\tprint(“sum: “, a + b)\n",
    "\n",
    "summer()\n",
    "```\n",
    "Og ser at dette ikke går. *Hvorfor går ikke dette?*\n",
    "\n",
    "[comment]: <> (fordi a og b er definert inne i metoden “minus\" og eksisterer derfor ikke utenfor.)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# NB! Om man har definert noe (variabler, funksjoner) tidligere i jupyter notebook \"husker\" jupyter\n",
    "# dette på samme måte som om man hadde skrevet alt inn i en python-fil.\n",
    "\n",
    "# Altså, om vi først kjører\n",
    "def minus(): \n",
    "\ta = 3\n",
    "\tb = 2\n",
    "\n",
    "def summer():\n",
    "\tprint(“sum: “, a + b)\n",
    "\n",
    "summer()\n",
    "# Får vi en feilmelding, men ikke om vi allerede har definert \n",
    "# a og b som globale variabeler tidligere i notebooken."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Filer og tekster\n",
    "Av og til ønsker vi å lese eller skrive noe til fil. Når vi skal bruke filer, enten lese fra dem eller skrive til dem, må vi åpne **og** lukke dem. \n",
    "\n",
    "Når vi åpner filen må vi også bestemme hva vi skal kunne gjøre med den.\n",
    "\n",
    "## Åpne fil\n",
    "Syntaks:\n",
    "\tLese en fil:\n",
    "```python\n",
    "\tinnfil = open(“filnavn.filtype”, “r”)\t# “r” står for “read”\n",
    "```\n",
    "Eksempel: Gitt at det finnes en fil som heter “input.txt”, hvis vi skal lese den skriver vi:\n",
    "```python\n",
    "\tinnfil = open(“input.txt”, “r”`# åpner fila\n",
    "```\n",
    "For å kunne skrive til en:\n",
    "```python\n",
    "\tutfil = open(“filnavn.fitype”, “w”)\t# w står for “write”\n",
    "```\n",
    "For å kunne skrive til ved å legge til:\n",
    "```python\n",
    "\tutfil = open(“filnavn.filtype”, “a”)\t# a står for  “append”\n",
    "```\n",
    "\n",
    "## Lese fra fil\n",
    "```python\n",
    "    linje = innfil.readline()\t        \n",
    "```\n",
    "`.readline()` vil lese en linje fra oppgitt fil som en String, her lagres denne string-verdien i variabelen “linje”.\n",
    "## Lukke fil\n",
    "```python\n",
    "    innfil.close()\t# lukker når man er helt ferdig med filen.\n",
    "\tutfil.close()\n",
    "\n",
    "```\n",
    "\n",
    "\n",
    "\n",
    "Altså:\n",
    "1. Åpne filen\n",
    "2. Gjør det du skal med fila (lese/skrive)\n",
    "3. Lukk filen"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Eksempel\n",
    "Eks. tenk at test.txt består av følgende linjer:\n",
    "```\n",
    "Hei!\n",
    "Dette er en fil\n",
    "```\n",
    "\n",
    "Så for å lese fila `test.txt` skriver vi følgende kode:\n",
    "```python\n",
    "innfil = open(“test.txt”, “r”)\n",
    "linje = innfil.readline()\t# første linje i filen leses, dvs. “Hei!”\n",
    "```\n",
    "Når denne så lagres i variablen “linje” lagres den som `Hei!\\n` (\\n = newline, linjeskift.) \n",
    "\n",
    "Når det ikke lenger er noe innhold i filen, dvs. Tom linje (“ ”), så leses dette som `“\\n\"` av filleseren.\n",
    "\n",
    "Om vi ønsker åskrive til fil. (sjekk boken kap 7/side 386 om du interessert i dette.)\n",
    "Syntaks: \n",
    "```\n",
    "    utfil.write(“Skriv dette til fil\\n”) \n",
    "```\n",
    "\n",
    "Og når vi er ferdig med filen må vi huske å lukke den.\n",
    "```python\n",
    "innfil.close()    # lukker når man er helt ferdig med filen.\n",
    "utfil.close()\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Minieksemepel: lese alle linjene i filen\n",
    "```python\n",
    "linje = innfil.readline()\n",
    "while linje != “” :\t# lese helt frem til tom linje/slutten av filen\n",
    "\t# <gjøre noe med variabelen “linje”/det som er lest inn>\n",
    "\tlinje = innfil.readline() # lese neste linje i filen, repeter while-løkken\n",
    "```\n",
    "\n",
    "Er også mulig å løse denne med\n",
    "\n",
    "```python\n",
    "for linje in fil:\n",
    "    # gjør noe med \"linje\"/det som er lest inn\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Oppgave 2\n",
    "Anta at du har filen “historie.txt”. Les inn alle linjene og lagre dem i en liste. Første linje skal ligge først i listen, osv.\n",
    "\n",
    "(Tips: husk å åpne og lukke filen..)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Konvertere til tall:\n",
    "Når man leser en linje fra en fil så leses det som string, dersom man ønsker å konvertere til tall skriver man\n",
    "```python\n",
    "verdi = float(linje)\t# konverterer til flyttall/float\n",
    "verdi = int (linje)\t# konverterer til heltall/int\n",
    "```\n",
    ", \\n vil da ignoreres\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Oppgave 3\n",
    "Skriv en funksjon som tar i mot to sannhetsverdier (True/False) og returnerer 1 hvis begge verdier er sanne, 0 hvis begge verdier ikke er sanne.\n",
    "\n",
    "Gruble:\n",
    "Hva tar ikke funksjonen høyde for? Hva kan gå “galt”?\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Ekstra eksempel/oppgave til de på gruppetimen denne uka (om folk ønsker): \n",
    "\n",
    "Oppgave der vi bruker løkker, lister/ordbøker funksjoner og ser på fordeler med skop."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "celltoolbar": "Slideshow",
  "kernelspec": {
   "display_name": "Python 3",
   "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.8.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}