05. Lister.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Lister (engelsk: lists)\n",
    "En liste er en rekke elementer. Elementene kan være omtrent hva som helst, f.eks. tekst (string), tall, andre lister. Mange av metodene for lister er tilsvarende som kommandoene for strenger. Det er mange metoder for lister, og vi skal se på de enkleste. En full oversikt finnes på https://docs.python.org/3/, særlig på https://docs.python.org/3/library/stdtypes.html#lists, https://docs.python.org/3/library/stdtypes.html#sequence-types-list-tuple-range, https://docs.python.org/3/library/stdtypes.html#mutable-sequence-types og https://docs.python.org/3/tutorial/datastructures.html.\n",
    "\n",
    "I tillegg til å se på selve metodene skal vi også se på noen anvendelser av lister."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Opprettelse av en liste\n",
    "Vi kan lage en liste på flere måter, men for vår del er det en metoder som er vanligst: Skriv et par firkant-parenteser med null, ett eller flere elementer i mellom, adskilt med kommaer. Jeg bruker også mellomrom for at det skal være lettere å lese.\n",
    "* []\n",
    "* [element]\n",
    "* [element1, element2, element3]\n",
    "\n",
    "Advarsel: Når vi bruker en eksisterende liste til å generere en ny liste må vi være forsiktige, av og til vil modifiseringer av den ene også innebære at den andre modifiseres. Mer om dette i ekstra stoff lenger ned i dette dokumentet.\n",
    "\n",
    "Under ser vi hvordan tre ulike lister ser ut. Vi kan ha både heltall, desimaltall, regnestykker, tekst og lister (og mange andre ting) som elementer i lister. Legg merke til at det siste elementet i den siste listen er en liste i seg selv."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[]\n",
      "['drue']\n",
      "[4, 2.5, 55, 'banan', [7, 6, 5, 'eple']]\n"
     ]
    }
   ],
   "source": [
    "liste1 = []\n",
    "liste2 = [\"drue\"]\n",
    "liste3 = [4, 2.5, 3+4*13, \"banan\", [7, 6, 5, \"eple\"]]\n",
    "print(liste1)\n",
    "print(liste2)\n",
    "print(liste3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Den første listen er tom. Tomme lister er viktige. For å få en følelse av hva en tom liste er kan vi se for oss at vi har en liste med navn på folk vi skal ringe før vi kan gå hjem fra kontoret. Vi leser et navn fra listen, ringer vedkommende, krysser ut det navnet, og når det ikke er noen navn igjen (når listen er tom) kan vi gå hjem. Vi kan sjekke hvor mange elementer det er i en liste ved å bruke len()-funksjonen."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Metoder for lister\n",
    "Noen av metodene er på formen liste.metode(). Her er \"liste\" enten listen selv, eller navnet til en variabel som inneholder en liste, mens \"metode\" er navnet på en av metodene som kan brukes på lister. Parentesen etter \"metode\" er ofte tom, men for noen metoder skriver vi inn argumenter i denne parentesen for å styre hvordan metoden skal virke akkurat denne gangen.\n",
    "\n",
    "Andre metoder har andre former, f.eks.:\n",
    "* liste[4]\n",
    "* liste_1 + liste_2\n",
    "* len(liste)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Elementer og utvalg ved bruk av index\n",
    "Vi kan plukke ut elementer fra en liste på følgende måter:\n",
    "* Elementet med index i: liste[i]\n",
    "* Elementene fra og med index i til (men ikke med) index j: liste[i:j]\n",
    "* Elementene fra og med index i til (men ikke med) index j med mellomrom k: liste[i:j:k]\n",
    "\n",
    "Vi må være bevisst at lister i Python har index som begynner på 0. Dersom vi ber om en index som ikke finnes får vi en feilmelding. Under har vi en streng med 10 elementer, det vil si at indexene går fra og med 0 til og med 9.\n",
    "\n",
    "Denne listen skal brukes i de følgende oppgavene."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Hello World!', 4, 3.9, 'Mer tekst her.', 55, 0.1234, 'a', 'b', 'c', 'Goodbye World!']\n",
      "Hello World!\n",
      "3.9\n"
     ]
    }
   ],
   "source": [
    "listen = ['Hello World!', 4, 3.9, 'Mer tekst her.', 3+4*13, 0.1234, \"a\", \"b\", \"c\", \"Goodbye World!\"]\n",
    "print(listen)\n",
    "alpha = listen[0]\n",
    "print(alpha)\n",
    "print(listen[2])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "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",
    "* print(listen[4])\n",
    "* print(listen[10])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Øving: Skriv ned to linjer som gir følgende print på skjermen når de kjøres:\n",
    "\n",
    "4\n",
    "\n",
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Negative indexer\n",
    "Vi kan bruke negative indexer for å referere til elementer en viss avstand fra slutten av listen. Skriver vi liste[-1] refererer vi til det siste elementet, liste[-2] refererer til det nest siste elementet."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Goodbye World!\n",
      "c\n"
     ]
    }
   ],
   "source": [
    "print(listen[-1])\n",
    "print(listen[-2])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "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",
    "* print(listen[-4])\n",
    "* print(listen[-7])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Øving: Skriv ned to linjer som gir følgende print på skjermen når de kjøres. Bruk negative indexer.\n",
    "\n",
    "Hello World!\n",
    "\n",
    "3.9"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Utvalg av flere elementer (engelsk: slicing)\n",
    "Vi kan gjøre et utvalg som vist under. I det første eksempelet velger vi alle elementene med index fra og med 2 til (men ikke med) 5. Effektivt betyr det index 2-4, og det gir element nummer 3-5 (siden indexene begynner på 0)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[3.9, 'Mer tekst her.', 55]\n"
     ]
    }
   ],
   "source": [
    "print(listen[2:5])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "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",
    "* print(listen[4:7])\n",
    "* print(listen[0:9])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Øving: Skriv ned to linjer som gir følgende print på skjermen når de kjøres:\n",
    "\n",
    "[0.1234, 'a']\n",
    "\n",
    "['Mer tekst her.', 55, 0.1234, 'a', 'b', 'c']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Vi kan bruke negative indekser også når vi slicer en liste:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[3.9, 'Mer tekst her.', 55, 0.1234]\n",
      "[0.1234, 'a', 'b', 'c']\n"
     ]
    }
   ],
   "source": [
    "print(listen[2:-4])\n",
    "print(listen[-5:-1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "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",
    "* print(listen[-6:-3])\n",
    "* print(listen[-9:-1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Øving: Skriv ned to linjer som gir følgende print på skjermen når de kjøres. Bruk negative indexer for både start- og sluttpunktet.\n",
    "\n",
    "[55, 0.1234, 'a']\n",
    "\n",
    "['b', 'c']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Utelatelse av indexer\n",
    "Vi kan gå til enden av en liste ved å skrive liste[3:]. Ved å ikke ha noe avsluttende element går utvalget helt til og med det siste elementet. Vi kan også utelate den første indexen, da går utvalget fra og med det første elementet (index 0). Ved å kombinere disse kan vi skrive liste[:] for å få alle elementene. Dette kan virke meningsløst, men det er viktig for lister, og er beskrevet under ekstra materiale lenger ned i dette dokumentet."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Mer tekst her.', 55, 0.1234, 'a', 'b', 'c', 'Goodbye World!']\n",
      "['Hello World!', 4, 3.9, 'Mer tekst her.', 55]\n",
      "['Hello World!', 4, 3.9, 'Mer tekst her.', 55, 0.1234, 'a', 'b', 'c', 'Goodbye World!']\n"
     ]
    }
   ],
   "source": [
    "print(listen[3:])\n",
    "print(listen[:5])\n",
    "print(listen[:])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Øving: Tenk over hva som vil printes dersom følgende kommandoer kjøres. Etter at du har bestemt deg og skrevet ned svaret ditt, kjør kommandoene og sjekk om det stemte.\n",
    "* print(listen[:-7])\n",
    "* print(listen[-5:])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Lister i lister\n",
    "Vi kan finne elementer i lister i lister ved å legge på en ekstra [j] bak liste[i]: liste[i][j] velger elementet med index j i elementet med index i i selve listen."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2, 'kanin', 'hest', [4, 2.5, 55, 'banan', [7, 6, 5, 'eple']]]\n",
      "[4, 2.5, 55, 'banan', [7, 6, 5, 'eple']]\n",
      "[7, 6, 5, 'eple']\n",
      "eple\n",
      "p\n"
     ]
    }
   ],
   "source": [
    "listen = [2, \"kanin\", \"hest\", [4, 2.5, 3+4*13, \"banan\", [7, 6, 5, \"eple\"]]]\n",
    "print(listen) # Hele listen.\n",
    "print(listen[3]) # Listen som er på index 3.\n",
    "print(listen[3][-1]) # Listen som er siste element.\n",
    "print(listen[3][-1][3]) # Elementet på index 3.\n",
    "print(listen[3][-1][3][1]) # Vi kan til og med velge en bokstav i en streng."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Øving: Lag en liste med to lister i seg. Hver av disse to listene skal inneholde to lister. Hver av de fire listene skal inneholde noen tall og noen ord. Skriv kommandoer som printer enkeltelementer i disse fire listene, inkludert å printe enkeltbokstaver i ordene."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Lengden av en liste (og lister i en liste)\n",
    "Vi kan finne antall elementer i en liste ved å bruke len(liste). Dette er en svært nyttig kommando som brukes i mange sammenhenger. For å se det må vi bli bedre kjent med flere verktøy, som f.eks. løkker (engelsk: loops)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "5\n"
     ]
    }
   ],
   "source": [
    "liste1 = []\n",
    "liste2 = [\"drue\"]\n",
    "liste3 = [4, 2.5, 3+4*13, \"banan\", [7, 6, 5, \"eple\"]]\n",
    "print(len(liste1))\n",
    "print(len(liste2))\n",
    "print(len(liste3))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Legg merke til at lengden av den siste listen er bare 5 selv om det ser ut som det er 8 elementer i den. Det er fordi det siste elementet i denne listen selv er en liste, og denne underlistens elementer telles ikke av len()-funksjonen."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Vi kan også finne lengden av lister og strenger i en liste. I den siste listen har vi en streng på index 3 og en liste på index 4."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "banan\n",
      "5\n",
      "[7, 6, 5, 'eple']\n",
      "4\n",
      "eple\n",
      "4\n",
      "p\n"
     ]
    }
   ],
   "source": [
    "print(liste3[3])\n",
    "print(len(liste3[3]))\n",
    "print(liste3[4])\n",
    "print(len(liste3[4]))\n",
    "print(liste3[4][3])\n",
    "print(len(liste3[4][3]))\n",
    "print(liste3[4][3][1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Øving: Lag og print noen lister. Lag lister som inneholder lister. Lag en liste der du bruker de andre listenes variabelnavn som elementer. Print lengden til listene."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Legge sammen lister\n",
    "Dersom vi har flere lister kan de slås sammen til én liste. Dette kan gjøres på flere måter, her er en den mest direkte og enkleste (i enkle tilfeller):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['drue', 4, 2.5, 55, 'banan', [7, 6, 5, 'eple']]\n"
     ]
    }
   ],
   "source": [
    "liste1 = []\n",
    "liste2 = [\"drue\"]\n",
    "liste3 = [4, 2.5, 3+4*13, \"banan\", [7, 6, 5, \"eple\"]]\n",
    "listen = liste1 + liste2 + liste3\n",
    "print(listen)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Det virket, men det kan se ut som om det mangler noe. Skulle vi ikke hatt med den tomme listen i liste1 som første element i den sammensatte listen?\n",
    "\n",
    "Nei, det er innholdet i listene som blir lagt sammen, og det er ikke noe innhold i den første listen. Dersom vi vil ha inn den tomme listen som et element i den sammensatte listen kan vi gjøre som vist under. Legg merke til at den tomme listen er et element som teller på lengden av den endelige listen."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[], 'drue', 4, 2.5, 55, 'banan', [7, 6, 5, 'eple']]\n",
      "7\n"
     ]
    }
   ],
   "source": [
    "liste1 = [[]]\n",
    "liste2 = [\"drue\"]\n",
    "liste3 = [ 4, 2.5, 3+4*13, \"banan\", [7, 6, 5, \"eple\"]]\n",
    "listen = liste1 + liste2 + liste3\n",
    "print(listen)\n",
    "print(len(listen))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Dersom det er mange lister som skal legges sammen blir det kontraproduktivt (og nesten uoverkommelig) å skrive dette manuelt. Da kan vi bruke løkker eller automatisere på annet vis. Se delen om for-løkker for et eksempel på dette."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Øving: Lag noen lister, sett dem sammen på måten vist over og print den sammensatte listen."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Søk i lister\n",
    "Vi kan søke i innholdet i en liste. Vi kan både sjekke om noe (ikke) finnes der (True/False) og telle antall forekomster av noe, og vi kan sjekke hvor i listen noe finnes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[4, 2.5, 55, 'banan', [7, 6, 5, 'eple']]\n",
      "True\n",
      "False\n",
      "True\n",
      "True\n",
      "1\n",
      "2\n"
     ]
    }
   ],
   "source": [
    "listen = [4, 2.5, 3+4*13, \"banan\", [7, 6, 5, \"eple\"]]\n",
    "print(listen)\n",
    "print(\"banan\" in listen)\n",
    "print(\"eple\" in listen)\n",
    "print(55 in listen)\n",
    "print(3+4 in listen[-1])\n",
    "print(listen.count(2.5))\n",
    "print(listen.index(55))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Legg merke til at \"eple\" ikke er i listen. Det er fordi \"eple\" ikke er et element i listen. Det er ingen verdi for i som gjør at print(listen[i]) gir \"eple\". \"eple\" er et element i ett av elementene i listen. Det går an å sjekke alle lister i en liste også, men for å gjøre det generelt krever det at vi kjenner både løkker, funksjoner og rekursjon.\n",
    "\n",
    "Legg merke til at tallet 55 er i listen, selv om vi definerte et regnestykke der. Vi kan også skrive et regnestykke i kommandoen som søker etter tallet. 3+4 er 7, og 7 er et element i listen som er siste element i selve listen vår."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Øving: Skriv kode som teller antall tilfeller av tallene 1, 2, og 3 (hver for seg) fra listen under. Skriv kode som søker gjennom listen for å se om tallene 5 og 6 er der. Skriv kode som søker gjennom listen for å se om teksten \"hei\" er der.\n",
    "\n",
    "For de tingene du søkte etter som du ikke fant i listen: Legg til elementer i listen og søk på nytt slik at de blir funnet."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "listen = [3,4,5,2,1,2,3,1,5,2,1,2,3,4,2,1,2,3,4,5]\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Utvidelse av lister\n",
    "Vi kan utvide en liste med nytt innhold på flere måter. De vanligste er å sette inn et bestemt element en bestemt plass i listen vår, å sette inn innholdet fra en annen liste mellom to elementer i listen vår eller å legge til ett eller flere elementer på slutten av listen vår.\n",
    "\n",
    "Legg særlig merke til forskjellen på extend og append. Det er viktig å vite om vi legger til et element som er en liste, eller om vi tar alle elementene fra en liste og legger dem til hver for seg."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 1, 2, 3, 4, 5, 6, 7, 'Tiger', 8, 9]\n",
      "[0, 1, 2, 3, 'Løve', 'Panter', 'Gepard', 4, 5, 6, 7, 'Tiger', 8, 9]\n",
      "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 'Løve', 'Panter', 'Gepard']\n",
      "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, ['Løve', 'Panter', 'Gepard']]\n"
     ]
    }
   ],
   "source": [
    "listen = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n",
    "tillegg = [\"Løve\", \"Panter\", \"Gepard\"]\n",
    "listen.insert(8, \"Tiger\") # Setter inn \"Tiger\" på index 8.\n",
    "print(listen)\n",
    "\n",
    "listen[4:4] = tillegg # Setter inn elementene fra \"tillegg\" enkeltvis på index 4 og utover, altså mellom index 3 og 4 i eksisterende liste.\n",
    "print(listen)\n",
    "\n",
    "listen = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n",
    "listen.extend(tillegg) # Utvider listen med elementene i \"tillegg\".\n",
    "print(listen)\n",
    "\n",
    "listen = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n",
    "listen.append(tillegg) # Legger til ett eneste nytt element. Det elementet er en egen liste.\n",
    "print(listen)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "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",
    "* listen = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n",
    "* tillegg = [\"Løve\", \"Panter\", \"Gepard\"]\n",
    "* listen.append(tillegg)\n",
    "* listen[5:7] = tillegg[1:]\n",
    "* print(listen)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Øving: Bruk listene under og de fire metodene vist over til å lage følgende liste:\n",
    "\n",
    "[0, 1, 'katt', [0, 1, 2, 3, 4, 5], 'hund', 'ulv', 2, 3, 4, 5, ['appelsin', 'banan', 'citrus', 'drue'], 'katt', 'hund', 'ulv']\n",
    "\n",
    "Hint: Lag en ny liste i stedet for å modifisere de eksisterende."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "liste1 = [0, 1, 2, 3, 4, 5]\n",
    "liste2 = [\"katt\", \"hund\", \"ulv\"]\n",
    "liste3 = [\"appelsin\", \"banan\", \"citrus\", \"drue\"]\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Dersom vi har en liste som vi vil utvide med seg selv flere ganger kan vi skrive som vist under."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[3, 5, 7, 3, 5, 7]\n"
     ]
    }
   ],
   "source": [
    "listo = [3, 5, 7]\n",
    "listo.extend(listo)\n",
    "print(listo)\n",
    "listo.extend(listo)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Legg merke til at den blir dobbelt så lang for hver gang vi gjør dette. Dersom vi vil ha den opprinnelige listen 3 ganger etter hverandre kan vi ikke gjøre det slik. Og dersom vi skal ha den mange ganger etter hverandre er dette tungvint. Vi kan gange den med et heltall."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[3, 5, 7, 3, 5, 7, 3, 5, 7]\n"
     ]
    }
   ],
   "source": [
    "listo = [3, 5, 7]\n",
    "# listo = listo * 3\n",
    "listo *= 3 # Mer effektiv skrivemåte enn på linjen over.\n",
    "print(listo)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Endring av listers innhold, sletting av elementer\n",
    "Vi har nettopp sett på hvordan vi utvider en liste ved å legge til flere elementer. Nå skal vi se hvordan vi endrer på elementene som finnes og hvordan vi sletter elementer fra en liste.\n",
    "\n",
    "Først skal vi innholdet på en bestemt index eller på flere indexer. Legg merke til at opprinnelig innhold på en index blir borte. Legg merke til at den nye listen i andre del av eksempelet må være like lang som antall indexer vi sier at skal erstattes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 1, 2, 3, 'Kattepus', 5, 6, 7, 8, 9]\n",
      "[0, 1, 2, 'Løve', 'Panter', 'Gepard', 6, 7, 8, 9]\n"
     ]
    }
   ],
   "source": [
    "listen = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n",
    "listen[4] = \"Kattepus\" # Elementet med index 4 erstattes.\n",
    "print(listen)\n",
    "\n",
    "listen[3:6] = [\"Løve\", \"Panter\", \"Gepard\"] # Elementene med index 3, 4 og 5 erstattes av den nye listen.\n",
    "print(listen)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Øving: Lag en liste og endre verdien av enkeltelementer som vist over. Endre deretter flere elementer på en gang som vist over."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Vi kan fjerne elementet på en bestemt plass ved å bruke liste.pop(index). Vi kan fjerne det siste elementet i en liste ved å bruke liste.pop(). Vi kan fjerne en bestemt verdi fra en liste ved å bruke liste.remove(verdi).\n",
    "\n",
    "Legg merke til forskjellen på pop og remove. Metoden pop fjerner elementet fra listen OG gir oss elementet så det kan printes eller brukes på andre måter. Metoden remove fjerner elementet, men lar oss ikke bruke elementet i det øyeblikket det fjernes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Pitbull\n",
      "['Løve', 'Panter', 'Gepard', 'Løve', 'Schäfer', 'Dobermann']\n",
      "Gepard\n",
      "['Løve', 'Panter', 'Løve', 'Schäfer', 'Dobermann']\n",
      "None\n",
      "['Panter', 'Løve', 'Schäfer', 'Dobermann']\n"
     ]
    }
   ],
   "source": [
    "listen = [\"Løve\", \"Panter\", \"Gepard\", \"Løve\", \"Schäfer\", \"Dobermann\", \"Pitbull\"]\n",
    "print(listen.pop()) # Fjerner siste element fra listen.\n",
    "print(listen)\n",
    "print(listen.pop(2)) # Fjerner elementet med index 2.\n",
    "print(listen)\n",
    "print(listen.remove(\"Løve\")) # Fjerner første tilfelle av \"Løve\" fra listen.\n",
    "print(listen)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Vi kan også slette elementer fra bestemte indexer uten å vite hva verdiene er."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Løve', 'Panter', 'Gepard', 'Schäfer', 'Dobermann', 'Pitbull']\n",
      "['Panter', 'Gepard', 'Schäfer', 'Dobermann', 'Pitbull']\n",
      "['Dobermann', 'Pitbull']\n",
      "[]\n"
     ]
    }
   ],
   "source": [
    "listen = [\"Løve\", \"Panter\", \"Gepard\", \"Schäfer\", \"Dobermann\", \"Pitbull\"]\n",
    "print(listen)\n",
    "del(listen[0]) # Sletter elementet med index 0.\n",
    "print(listen)\n",
    "listen[0:3] = [] # Erstatter elementene med index 0, 1 og 2 med en tom liste, effektivt det samme som å slette dem.\n",
    "print(listen)\n",
    "listen.clear() # Sletter alle elementene i listen.\n",
    "print(listen)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "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",
    "* listen = [\"Løve\", \"Panter\", \"Gepard\", \"Schäfer\", \"Dobermann\", \"Pitbull\"]\n",
    "* listen.pop()\n",
    "* listen.remove(\"løve\")\n",
    "* listen[1:3] = []\n",
    "* print(listen)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Ekstra materiale\n",
    "Stoffet under er nyttig, men kan vente til senere om du ikke vil se på det nå."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Mer om utvalg av elementer i lister\n",
    "Vi kan også gjøre et utvalg av elementer som ikke følger direkte etter hverandre:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[]\n"
     ]
    }
   ],
   "source": [
    "print(listen[1:9:2])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Legg merke til at i det forrige eksempelet fikk vi elementene med index 1, 3, 5 og 7. Det neste ville vært 9, men vi skulle stoppe før 9, så det ble ikke med."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "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",
    "* print(listen[0:7:3])\n",
    "* print(listen[-9:6:2])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Øving: Skriv ned fire linjer som gir følgende print på skjermen når de kjøres. Gjør det en gang med bare positive indexer og en gang med bare negative indexer for både start- og sluttpunktet.\n",
    "\n",
    "['Mer tekst her.', 0.1234]\n",
    "\n",
    "[4, 0.1234]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Dersom vi gjør et utvalg der vi ber om å starte på et element og stoppe på et tidligere element får vi ingen elementer. I eksempelet under produserer print-kommandoen ingenting fordi utvalget blir en streng uten elementer. Dette kan være aktuelt dersom vi ikke vet hvor mange elementer som skal være med, men har en formel for å beregne hva som er første og siste element. Dersom formlene gir en startverdi som er lik eller større enn sluttverdien blir lengden 0."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[]\n"
     ]
    }
   ],
   "source": [
    "print(listen[4:1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Øving: Tenk over hva som vil printes dersom følgende kommandoer kjøres. Hvilke av kommandoene gir ingen output? Etter at du har bestemt deg og skrevet ned svaret ditt, kjør kommandoene og sjekk om det stemte.\n",
    "* print(listen[2:5:7])\n",
    "* print(listen[-2:3])\n",
    "* print(listen[-8:-3])\n",
    "* print(listen[-5:7:2])\n",
    "* print(listen[-3:8])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Reversering av en liste\n",
    "Dette gjøres med kommandoen liste.reverse()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[7, 6, 5, 'eple'], 'banan', 55, 2.5, 4]\n",
      "[['eple', 5, 6, 7], 'banan', 55, 2.5, 4]\n"
     ]
    }
   ],
   "source": [
    "listen = [4, 2.5, 3+4*13, \"banan\", [7, 6, 5, \"eple\"]]\n",
    "listen.reverse()\n",
    "print(listen)\n",
    "listen[0].reverse() # Reversering av en liste i listen.\n",
    "print(listen)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Kopi av en liste\n",
    "Vi må være forsiktige med hvordan vi tar kopier av lister. La oss se på et eksempel."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2 2\n",
      "2 5\n"
     ]
    }
   ],
   "source": [
    "a = 2\n",
    "b = a\n",
    "print(a, b)\n",
    "b = 5\n",
    "print(a, b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Som forventet: Vi lot b få verdien til a, og selv om vi endret verdien til b ble verdien til a ikke endret. La oss nå se hvordan dette virker for en liste."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[3, 5, 7, 9] [3, 5, 7, 9]\n",
      "[3, 5, 7, 9, 11, 13] [3, 5, 7, 9, 11, 13]\n"
     ]
    }
   ],
   "source": [
    "a = [3, 5, 7, 9]\n",
    "b = a\n",
    "print(a, b)\n",
    "b.append(11)\n",
    "b.append(13)\n",
    "print(a, b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Som vi ser ble først b lik a. Deretter la vi til to nye tall i b, men dette endret både a OG b. Dette er slik lister virker. Dersom vi ønsker å endre bare kopien kan det gjøres på flere måter. Her er en av de: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[3, 5, 7, 9] [3, 5, 7, 9]\n",
      "[3, 5, 7, 9] [3, 5, 7, 9, 11, 13]\n"
     ]
    }
   ],
   "source": [
    "a = [3, 5, 7, 9]\n",
    "b = a.copy()\n",
    "print(a, b)\n",
    "b.append(11)\n",
    "b.append(13)\n",
    "print(a, b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###### Øystein Grøndahl, oktober 2018"
   ]
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "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": 1
}