Listor2.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Mer om listor\n",
    "\n",
    "\n",
    "Vi hade lite om listor inför loopar. Vi fördjupar oss nu i listor.\n",
    "\n",
    "Listor är en sammansatt datatyp. Det finns fler sammansatta datatyper, t.ex.:\n",
    "\n",
    "* mängder (eng. set) $\\left\\{ 1,3,2\\right\\} $.\n",
    "\n",
    "* tiplar eller tuplar (eng. tuples) $\\left(4,2,1\\right)$.\n",
    "\n",
    "Vi behandlar dem inte här men tiplar dyker upp då vi anropar olika funktioner (se 2.4) i python. Skillnaden mellan tiplar och listor är att tiplar inte kan ändras, de är så kallade 'immutables'.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Ett element i lista\n",
    "\n",
    "Python använder hakparenteser för att ange ett element i en lista `L[0]` är första elementet, `L[2]` är tredje elementet. I listan `L=[5,3,8,9]` är L[0] talet 5 och L[2] är talet 8.\n",
    "\n",
    "Vi kan skriva:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n",
      "8\n",
      "9\n"
     ]
    }
   ],
   "source": [
    "L = [5,3,8,9]\n",
    "a = L[0]\n",
    "print(a)\n",
    "\n",
    "print(L[2])\n",
    "print(L[-1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Om vi vill ändra, listor är 'mutable', ett element med ett visst index skriver vi:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[5, 7, 8, 9]\n"
     ]
    }
   ],
   "source": [
    "L = [5,3,8,9]\n",
    "\n",
    "L[1] = 7  # Talet 3 har index 1\n",
    "print(L)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Del av lista\n",
    "\n",
    "När vi anger att index ska gå mellan 2 värden i matematiken kan man ange det som $L_i$ då $i=2...5$ som innebär $L_2$, $L_3$, $L_4$ och $L_5$.\n",
    "\n",
    "I python skriver man med kolon inom hakparenteserna (inte semikolon, som skrivs ;)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2]\n"
     ]
    }
   ],
   "source": [
    "L = [1, 2, 2, 5, 3, 7]\n",
    "print(L[0:2])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Kör koden! Men det blev bara 2 tal fastän vi skrivit 0 och 2 som gränser.\n",
    "\n",
    "Python tolkar det som *från och med* 0 *till* 2. Dvs. inklusive 0 men exklusive 2. Argument för detta finns i dokumentationen av python. Man kan se det som L[inkl:exkl]\n",
    "\n",
    "Denna typ av 'utsnitt' kallas på engelska för 'slice'. Observera att det är en lista, inte bara 2 tal. L[0] är däremot ett tal.\n",
    "\n",
    "Ok, det kan man acceptera. Men vad händer då om man skriver L[0:0] där den ena nollan är inklusive och den andra exklusive? Testa är en ok metod."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[]\n"
     ]
    }
   ],
   "source": [
    "L = [1, 2, 2, 5, 3, 7]\n",
    "\n",
    "print(L[0:0])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python svarar [] vilket betyder den tomma listan (precis som tomma mängden), inga tal från listan är med, således exklusive vinner."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Observera, igen, skillnaden mellan L[1] som är ett element och L[1:2] som är en lista! som innehåller samma element som L[1]."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "[2]\n"
     ]
    }
   ],
   "source": [
    "L = [1, 2, 2, 5, 3, 7]\n",
    "print(L[1])  # Element\n",
    "print(L[1:2])  # Lista, slice"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "En lista behöver inte ha samma typer av element utan de kan blandas. En lista kan innehålla heltal, booleska variabler, strängar osv."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[-1, True, 'w']\n"
     ]
    }
   ],
   "source": [
    "M = [2, 3.11, -1, True, 'w']\n",
    "print(M[2:5])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Om man ska ha en lista från ett visst element till slutet räcker det med att ange starten tex. M[2:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[-1, True, 'w']\n"
     ]
    }
   ],
   "source": [
    "M = [2, 3.11, -1, True, 'w']\n",
    "\n",
    "print(M[2:])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Och om vi vänder på det M[:2]? Då är det upp till men exklusivt index 2. M[0:2] är samma som M[:2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2, 3.11]\n",
      "[2, 3.11]\n"
     ]
    }
   ],
   "source": [
    "M = [2, 3.11, -1, True, 'w']\n",
    "\n",
    "print(M[:2])\n",
    "print(M[0:2])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Vill man ha reda på hur många element en lista innehåller så använder man len(M), som i length."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n"
     ]
    }
   ],
   "source": [
    "M = [2, 3.11, -1, True, 'w']\n",
    "\n",
    "print(len(M))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Om längden är 5 så går index från 0 till 4, inte 1 till 5."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Observera att listor kan adresseras direkt, de måste inte namnges. Se rad 4."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n",
      "3\n"
     ]
    }
   ],
   "source": [
    "L = [5, 3, 1]\n",
    "print(L[1])\n",
    "\n",
    "print([5, 3, 1][1])  # Direkt adressering"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Operationer på listor\n",
    "\n",
    "\n",
    "Vi tar bort elementet med ett visst index i en lista."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[3, 4, 5]\n",
      "[3, 5]\n"
     ]
    }
   ],
   "source": [
    "L = [3,4,5]\n",
    "print(L)\n",
    "L[1:2] = []  # dvs element med index 1, som är talet 4\n",
    "print(L)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Vi kan ta bort det sista."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[3, 4]\n"
     ]
    }
   ],
   "source": [
    "L = [3,4,5]\n",
    "\n",
    "L[-1:] = []  # dvs element med index -1, som är talet 5\n",
    "print(L)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Vi lägger till element från en lista sist."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[3, 4, 5, 1, 1, 0]\n"
     ]
    }
   ],
   "source": [
    "L = [3,4,5]\n",
    "L[3:] = [1,1,0]\n",
    "print(L)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "Vi lägger till element från en lista först."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['a', 'b', 'c', 3, 4, 5]\n"
     ]
    }
   ],
   "source": [
    "L = [3,4,5]\n",
    "L[:0] = [\"a\",\"b\",\"c\"]\n",
    "print(L)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Man börjar undra?\n",
    "Kan man stoppa in elemet från en lista in i listan? Vi provar med följande:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[3, 'a', 'b', 'c', 5]\n"
     ]
    }
   ],
   "source": [
    "L = [3,4,5]\n",
    "L[1:2] = [\"a\",\"b\",\"c\"]\n",
    "print(L)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Tydligen ersatte vi talet 4 med vår lista över strängar. Kanske kan vi få in våra element utan att ta bort något? Vi försöker med"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[3, 'a', 'b', 'c', 4, 5]\n"
     ]
    }
   ],
   "source": [
    "L = [3,4,5]\n",
    "L[1:1] = [\"a\",\"b\",\"c\"]\n",
    "print(L)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Ett annat sätt att lägga till ett element sist\n",
    "\n",
    "Att lägga till ett element *sist* i en lista kan göras med något som kallas för metod enligt mallen `objekt.metod`. Objektet är variabeln och metod är vad som ska utföras på variabeln.\n",
    "\n",
    "Vi använder metoden `append()` på ett objekt som är en lista."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[4, 3, 5, 3, -1, 0]\n",
      "[4, 3, 5, 3, -1, 0, 12]\n"
     ]
    }
   ],
   "source": [
    "N = [4, 3, 5, 3, -1, 0]\n",
    "print(N)\n",
    "\n",
    "N.append(12)  # objekt.metod()\n",
    "print(N)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Observera att `N = N + [12]` gör samma sak.\n",
    "\n",
    "Observera också att kommandot är inte `N = N.append(12)`. Man behöver ingen tilldelning. Det kallas att man gör ändringen 'in place', dvs på plats direkt i objektet.\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "### Ta bort element\n",
    "\n",
    "Tidigare tog vi bort element med ett visst index, oavsett elementets värde. \n",
    "\n",
    "Med metoder kan vi ta bort ett visst värde oavsett vilket index det har.\n",
    "\n",
    "Och vi kan ta bort ett värde tex. en av de två 3:orna. `remove(3)` tar bort den 3:a med lägst index."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[4, 3, 5]\n",
      "[4, 5]\n"
     ]
    }
   ],
   "source": [
    "N = [4, 3, 5]\n",
    "\n",
    "print(N)\n",
    "N.remove(3)\n",
    "print(N)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Om det fler än en 3:a tas den första bort."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[4, 3, 5, 3]\n",
      "[4, 5, 3]\n"
     ]
    }
   ],
   "source": [
    "N = [4, 3, 5, 3]\n",
    "\n",
    "print(N)\n",
    "N.remove(3)\n",
    "print(N)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`.remove()` kan inte ersättas med `N = N - [3]` (du får ett felmeddelande om du försöker). Dock kan 3, i vårt exempel, tas bort genom `N[1:2] = []`. Men det är inte samma. I ena fallet (remove) tar man bort ett tal oavsett var det är och i det andra tar man bort det tal som har ett visst index oavsett talets värde.\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Konkatenera, antal element, reversera mm.\n",
    "\n",
    "\n",
    "Konkatenera listor görs med plustecknet som vi ursprungligen använde för addition. (viktigt skilja på tecknet och operationen)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 4, -1, -2, -3, -3]\n",
      "[-1, -2, -3, -3, 1, 2, 3, 4]\n",
      "[1, 2, 3, 4, 7, 8]\n",
      "[7, 8, 1, 2, 3, 4]\n"
     ]
    }
   ],
   "source": [
    "S = [1, 2, 3, 4]\n",
    "T = [-1, -2, -3, -3]\n",
    "print(S + T)\n",
    "print(T + S)\n",
    "print(S + [7, 8])\n",
    "print([7, 8] + S)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Man kan få python till att addera elementvis men då gör man om listan till något som heter array(). En array fungerar som en vektor eller matris i matematiken. Detta finns senare i kursen.\n",
    "\n",
    "Antalet element med ett visst värde i en lista kan räknas."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n"
     ]
    }
   ],
   "source": [
    "L = [2,3,2,4,2]\n",
    "L_nr2 = L.count(2)  # Räknar antalet 2:or i listan\n",
    "print(L_nr2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ändra listans ordning."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[37, 2, 1]\n"
     ]
    }
   ],
   "source": [
    "L = [1,2,37]\n",
    "L.reverse()\n",
    "print(L)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Vissa  genvägar har införts för att göra det enklare. Vill man tex. starta ett program med en lista med nollor så skriver man"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 0, 0, 0, 0]\n"
     ]
    }
   ],
   "source": [
    "K = 5*[0]\n",
    "print(K)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Samma tankegång gäller för strängar"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "aaaaa\n"
     ]
    }
   ],
   "source": [
    "W = 5*\"a\"\n",
    "print(W)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Nu följer 2 uppgifter men det kommer mer efter uppgifterna."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Uppgifter\n",
    "\n",
    "\n",
    "**Uppgift 1**\n",
    "\n",
    "Skriv in listan `La=[2,9,11,18,5,4,15,7,5]` i ett program.\n",
    "a) Skriv ut element nr 3 (som har index 2!).\n",
    "b) Lägg till talet 21 sist i listan.\n",
    "c) Ta bort talet 5 i listan (det med lägst index).\n",
    "\n",
    "\n",
    "[Lösningsförslag](./uppg/ListorUppg1.ipynb)\n",
    "\n",
    "\n",
    "**Uppgift 2**\n",
    "\n",
    "Vad skrivs ut av följande kod?\n",
    "\n",
    "```\n",
    "L = [2, 3, False, 'gg', [4,4]]\n",
    "print(L)\n",
    "print(L[2:4])\n",
    "print(L[2:])\n",
    "print(L[-2])\n",
    "\n",
    "L.append(-1)\n",
    "print(L)\n",
    "\n",
    "L[2:3] = [True]  # Obs. L[2:3] = True fungerar inte!\n",
    "print(L)\n",
    "\n",
    "M=[2,3,4,5,3,1]\n",
    "M.remove(3)  # Vilken 3:a tas bort?\n",
    "print(M)\n",
    "```\n",
    "\n",
    "[Lösningsförslag](./uppg/ListorUppg2.ipynb)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## range() i listor\n",
    "\n",
    "\n",
    "I avsnittet om loopar hade vi kommandot range(). Kommandot kan också användas för att skapa listor.\n",
    "Vi skapar en lista med hjälp av `range()` och komandot `list()` för att omvandla till lista."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 1, 2, 3, 4, 5, 6, 7]\n",
      "[3, 5, 7]\n"
     ]
    }
   ],
   "source": [
    "L = list(range(8)) # bara stopp behöver vara med\n",
    "print(L)\n",
    "\n",
    "M = list(range(3,9,2))\n",
    "print(M)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Vi behöver kommandot `list()` som gör om `range()` till en lista."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Omvandlingar\n",
    "\n",
    "\n",
    "Föregående exempel innehåller en omvandling av en inbyggd funktion (range) till en lista. Omvandlingar går att göra med fler datatyper. En populär som vi träffat på tidigare vid `input()` är int()."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "18\n"
     ]
    }
   ],
   "source": [
    "a = \"6\"  # Som är en sträng\n",
    "a = int(a)  # Omvandlar sträng till datatypen heltal\n",
    "print(3*a)  # Nu kan vi räkna med den"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Omvandlaren float() klarar även knepigare saker som att tolka decimalpunkt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "18.6\n"
     ]
    }
   ],
   "source": [
    "a = \"6.2\"  # Som är en sträng\n",
    "a = float(a)  # Omvandlar sträng till datatypen flyttal\n",
    "print(3*a)  # Nu kan vi räkna med den"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Man börjar undra... Vad händer om vi gör"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 0\n"
     ]
    }
   ],
   "source": [
    "a = True; b = False\n",
    "a = int(a); b = int(b) \n",
    "print(a, b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Eller till boolean (testa själv genom att ändra b)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False True\n"
     ]
    }
   ],
   "source": [
    "a = 0; b = 2  # Observera att det inte är 1\n",
    "a = bool(a); b = bool(b)\n",
    "print(a, b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Komandot list() kan göra ännu mer. Strängar kan plockas i delar till en lista."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['D', 'e', 't', ' ', 'v', 'a', 'r', ' ', 'l', 'ä', 'n', 'g', 'e', ' ', 's', 'e', \"'\", 'n']\n"
     ]
    }
   ],
   "source": [
    "a = \"Det var länge se'n\"\n",
    "b = list(a)\n",
    "print(b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Eller om man vill ta bort något felstavat"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Konkatenering\n"
     ]
    }
   ],
   "source": [
    "a = \"Konkatanering\"  # Vår felstavade sträng\n",
    "a = list(a)  # Vi gör om den till en lista\n",
    "a[6] = \"e\"  # Vi rättar\n",
    "a = \"\".join(a)  # Sätter ihop till sträng igen\n",
    "print(a) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Kommandot `\"\".join` lägger ihop elementen i listan och placerar inget mellan elementen. Det som är mellan citattecknen placeras mellan elementen men vi har inget mellan dem. Testa gärna med att skriva in något annat mellan citattecknen tex. `\"?\".join(a)`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Skivor av listor och felmeddelande\n",
    "\n",
    "\n",
    "Vi skivar upp listor på lite olika sätt för att repetera. Och fokuserar på hur felmeddelanden fungerar.\n",
    "\n",
    "Om listan innehåller 5 element har vi som index\n",
    "\n",
    "|    |    |    |    |    |\n",
    "|----|----|----|----|----|\n",
    "| 0  | 1  | 2  | 3  | 4  |\n",
    "| -5 | -4 | -3 | -2 | -1 |\n",
    "\n",
    "Och om vi exempelvis väljer listan `L=[3,7,4,1,8]` så har vi \n",
    "\n",
    "| 3 | 7 | 4 | 1 | 8 |\n",
    "|----|----|----|----|----|\n",
    "| 0  | 1  | 2  | 3  | 4  |\n",
    "| -5 | -4 | -3 | -2 | -1 |"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[4, 1]"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "L = [3,7,4,1,8]\n",
    "L[2:4]  # 2 inkl, till 4 exkl"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Vi får inget felmeddelande om index är utanför listan."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[4, 1, 8]"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "L = [3,7,4,1,8]\n",
    "L[2:7]  # 7 är utanför sista index som är 4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "L[-2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[3, 7, 4]"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "L[:-2]  # Startar i 0 inkl går till -2 exkl"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 8]"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "L[-2:]  # Startar i -2 går till slutet"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Listkommandon ger inte alltid felmeddelande om du ger kommandon utanför indexets gränser.\n",
    "I vårt exempel har vi icke-negativa index från 0 tom. 4. Vad händer om man skriver"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "ename": "IndexError",
     "evalue": "list index out of range",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mIndexError\u001b[0m                                Traceback (most recent call last)",
      "Cell \u001b[0;32mIn[27], line 3\u001b[0m\n\u001b[1;32m      1\u001b[0m L \u001b[38;5;241m=\u001b[39m [\u001b[38;5;241m3\u001b[39m,\u001b[38;5;241m7\u001b[39m,\u001b[38;5;241m4\u001b[39m,\u001b[38;5;241m1\u001b[39m,\u001b[38;5;241m8\u001b[39m]\n\u001b[0;32m----> 3\u001b[0m \u001b[43mL\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;241;43m5\u001b[39;49m\u001b[43m]\u001b[49m\n",
      "\u001b[0;31mIndexError\u001b[0m: list index out of range"
     ]
    }
   ],
   "source": [
    "L = [3,7,4,1,8]\n",
    "\n",
    "L[5]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Lägg märke till skillnaden. `L[2:7]` ger inte felmeddelande men `L[5]` ger felmeddelande!\n",
    "\n",
    "Så om vi kanske tänkt helt fel och skriver"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "L = [3,7,4,1,8]\n",
    "L[0:3000]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Så får vi inget felmeddelande.\n",
    "\n",
    "Vad händer om båda gränserna anges fel (utanför listans index)?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[]"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "L = [3,7,4,1,8]\n",
    "L[10:100]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Jo, vi får en tom lista. Var det det vi ville ha?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Vad finns i listan?\n",
    "\n",
    "Man kan kontrollera om ett visst tal finns i en lista med hjälp av `in` och `not in`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "L = [3,4,5]\n",
    "\n",
    "3 in L"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "L = [3,4,5]\n",
    "\n",
    "0 in L"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Slumplistor\n",
    "\n",
    "Vi genererar listor med slumpmässigt valda naturliga tal (vi provade på detta när vi tittade på loopar).\n",
    "Det centrala kommandot är `random`.\n",
    "Vi använder _metoden_ sample. Vi plockar värdena från listan M.\n",
    "\n",
    "\n",
    "`random.sample(M,k)` betyder att vi tar k tal slumpmässigt från listan M."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[3], [5], [3], [7], [5], [1], [1], [7], [5], [3]]\n"
     ]
    }
   ],
   "source": [
    "import random\n",
    "\n",
    "M = [3,5,1,7]  # Tal tas slumpmässigt från denna lista\n",
    "L=[]  # Här lägger vi de tal vi tagit\n",
    "\n",
    "for i in range(1,11,1):  # Vi gör det 10 gånger\n",
    "    L.append(random.sample(M,1))\n",
    "\n",
    "print(L)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Observera ovan att vi får listor i listor."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Se nedan. Vi får tal i intervallet 0 (inkl) till 10 (exkl). Vi får 8 tal. I detta kommando kan antalet genererade slumptal inte överstiga antalet tal i intervallet. Vi kan maximalt få 10 slumpade tal, alla olika. `range(0,10)` anger nu listan som vi får plocka tal ifrån. Slump utan återläggning."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[7, 9, 3, 1, 8, 5, 2, 0]\n"
     ]
    }
   ],
   "source": [
    "import random\n",
    "L = random.sample(range(0,10),8)\n",
    "print(L)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Nedanstående fungerar inte eftersom vi ber om fler tal än vad som finns i mängden, det är utan återläggning."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "ename": "ValueError",
     "evalue": "Sample larger than population or is negative",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "Cell \u001b[0;32mIn[29], line 3\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[38;5;28;01mimport\u001b[39;00m \u001b[38;5;21;01mrandom\u001b[39;00m\n\u001b[0;32m----> 3\u001b[0m L \u001b[38;5;241m=\u001b[39m \u001b[43mrandom\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43msample\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mrange\u001b[39;49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m0\u001b[39;49m\u001b[43m,\u001b[49m\u001b[38;5;241;43m10\u001b[39;49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\u001b[38;5;241;43m11\u001b[39;49m\u001b[43m)\u001b[49m  \u001b[38;5;66;03m# Fungerar ej\u001b[39;00m\n\u001b[1;32m      4\u001b[0m \u001b[38;5;28mprint\u001b[39m(L)\n",
      "File \u001b[0;32m~/anaconda3/lib/python3.9/random.py:449\u001b[0m, in \u001b[0;36mRandom.sample\u001b[0;34m(self, population, k, counts)\u001b[0m\n\u001b[1;32m    447\u001b[0m randbelow \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_randbelow\n\u001b[1;32m    448\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;241m0\u001b[39m \u001b[38;5;241m<\u001b[39m\u001b[38;5;241m=\u001b[39m k \u001b[38;5;241m<\u001b[39m\u001b[38;5;241m=\u001b[39m n:\n\u001b[0;32m--> 449\u001b[0m     \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mValueError\u001b[39;00m(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mSample larger than population or is negative\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n\u001b[1;32m    450\u001b[0m result \u001b[38;5;241m=\u001b[39m [\u001b[38;5;28;01mNone\u001b[39;00m] \u001b[38;5;241m*\u001b[39m k\n\u001b[1;32m    451\u001b[0m setsize \u001b[38;5;241m=\u001b[39m \u001b[38;5;241m21\u001b[39m        \u001b[38;5;66;03m# size of a small set minus size of an empty list\u001b[39;00m\n",
      "\u001b[0;31mValueError\u001b[0m: Sample larger than population or is negative"
     ]
    }
   ],
   "source": [
    "import random\n",
    "\n",
    "L = random.sample(range(0,10),11)  # Fungerar ej\n",
    "print(L)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Slumpade tal med återläggning ges av `random.choices()`. Observera att det är plural choices, det finns ett annat kommando choice() som är singular."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[8, 1, 2, 9, 4, 4, 0, 6, 4, 2, 9]\n"
     ]
    }
   ],
   "source": [
    "import random\n",
    "\n",
    "L = random.choices(range(0,10),k=11)  # Fungerar med k=11 eftersom det är med återläggning\n",
    "print(L)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Observera att i choises måste man ange antalet som ett nyckelord, 'keyword', dvs du måste skriva k=11. I kommandot 'sample' ska du inte göra det, där är det *positionen* som används och du behöver bara skriva 11."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Slumptalen är naturligtvis inte alls slumptal utan helt deterministiska. De genereras med en algoritm som heter Mersenne-Twistor och ger en upprepning efter $2^{19937}-1$ tal. Funktionerna kan således inte användas för tex. kryptering. För kryptering finns en modul som heter 'secrets'.\n",
    "\n",
    "\n",
    "Vill man ha kontroll över sina slumptal, få samma slumptal varje gång man kör ett program så måste man ange ett slumpfrö. Anger man inte ett slumpfrö startar genereringen mha datorns systemtid. Vi anger nedan fröet 5 och kör choises() 2 gånger. Vi får exakt samma slumptal!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[6, 7, 7]\n",
      "[6, 7, 7]\n"
     ]
    }
   ],
   "source": [
    "import random\n",
    "\n",
    "# Vi kör det en gång med fröet 5\n",
    "random.seed(a=5)\n",
    "L = random.choices(range(0,10),k=3)\n",
    "print(L)\n",
    "\n",
    "# Vi kör det en gång till med samma frö\n",
    "random.seed(a=5)\n",
    "L = random.choices(range(0,10),k=3)\n",
    "print(L)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Listor i listor\n",
    "\n",
    "Man kan ha listor som element i listor."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, ['a', 'b'], 2, 3]\n",
      "[1, 'a', 'b', 2, 3]\n"
     ]
    }
   ],
   "source": [
    "a = [1,2,3]\n",
    "b = [\"a\",\"b\"]\n",
    "a[1:1] = [b]  # observera skillnaden mot a[1:1]=b, se längre ner\n",
    "# Vi har satt in listan b i listan a\n",
    "print(a)\n",
    "\n",
    "# Men vad är\n",
    "a = [1,2,3]\n",
    "b = [\"a\",\"b\"]\n",
    "a[1:1] = b  # observera skillnaden mot a[1:1]=[b], se ovan\n",
    "# Vi har satt in element i listan b i listan a\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Vi konstruerar direkt en lista med listor med listor."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "L = [2,3, [4,5,['a','b']]]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Listan L ovan har en lista i sig och i den listan finns ytterligare en lista. Hur adresserar man ett element? Och hur många element har listan egentligen? Vi testar med kommandot len."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "L = [2,3, [4,5,['a','b']]]\n",
    "len(L)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Om vi vill ha tag i strängen `'a'` så anger vi först att det är elementet med index 2 i den yttre listan, däri är det element 2 i listan innanför och däri, innersta listan, element 0."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "L = [2,3, [4,5,['a','b']]]\n",
    "L[2][2][0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "För att få den första inre listan"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[4, 5, ['a', 'b']]"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "L[2]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Och hela den inre listan i den"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['a', 'b']"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "L[2][2]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Från elementet som är talet 5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[5, ['a', 'b']]"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "L[2][1:]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ytterligare ett exempel"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['b', 3, 4]"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "K = [2,3, [4,5,['a','b', 3,4,5,7]]]\n",
    "K[2][2][1:4]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Och ett till"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1, 2, 3], [4, 5, 6], [7, 8, 9]]\n"
     ]
    }
   ],
   "source": [
    "a = [1,2,3]\n",
    "b = [4,5,6]\n",
    "c = [7,8,9]\n",
    "L = [a,b,c]\n",
    "print(L)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Kopiera listor (deep-copy)\n",
    "\n",
    "Kopiering av listor är lite speciellt i förhållande till enkla variabler.\n",
    "Om vi skriver\n",
    "\n",
    "```\n",
    "x=1\n",
    "y=x\n",
    "print(y)\n",
    "y=2\n",
    "print(x)\n",
    "```\n",
    "\n",
    "så förväntar vi oss i den sista printsatsen att få svaret 1, inget annat; och så är det i detta fallet.\n",
    "Så fungerar det inte för listor. Det finns 2 sätt att kopiera, två sätt att tänka.\n",
    "\n",
    "Vi betecknar listor med L respektive M. Om man skriver:\n",
    "```\n",
    "L=[1,2]  # original L\n",
    "M=L  # kopia M\n",
    "M.append(5) # vi lägger till 5 i kopian\n",
    "print(L) # men vi har då lagt till 5 i originalet också!\n",
    "```\n",
    "\n",
    "så ger print-satsen: `[1,2,5]`. Som om vi hade ändrat originalet L när vi ändrade i kopian M.\n",
    "Satsen `M = L` innebär att M och L pekar på samma objekt, så ändrar du den ena ändrar du den andra. Man kan säga att L och M pekar på samma adress och där ligger en lista. `M = L` betyder peka på samma adress.\n",
    "\n",
    "Naturligtvis kan man få en 'riktig' kopia, dvs en lista till som ser ut som L men som ligger någon annanstans i datorn och heter M. För att göra detta behöver man importera modulen copy och däri använda kommandot `copy.deepcopy(list)`.\n",
    "\n",
    "<!-- ![deepcopy](./Pictures/deepcopy.png) -->\n",
    "\n",
    "<img src=\"./Pictures/deepcopy.png\" width=400 height=400 />\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "original= [1, 2, 5] ändrad kopia= [1, 2, 5]\n",
      "original= [1, 2] ändrad djup-kopia= [1, 2, 5]\n"
     ]
    }
   ],
   "source": [
    "import copy\n",
    "\n",
    "L = [1,2]  # Original\n",
    "M = L  # Kopia\n",
    "M.append(5)  # Ändrad kopia och ändrad original\n",
    "print(\"original=\", L, \"ändrad kopia=\", M)\n",
    "\n",
    "# men\n",
    "\n",
    "S = [1,2]  # Original\n",
    "T = copy.deepcopy(S)  # Djup-kopia\n",
    "T.append(5)  # Ändrad djup-kopia, ändrar inte original S\n",
    "print(\"original=\", S, \"ändrad djup-kopia=\", T)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Uppgifter\n",
    "\n",
    "\n",
    "**Uppgift 1**\n",
    "\n",
    "Använd `range()` för att skriva ut:\n",
    "a) De 100 första positiva heltalen.\n",
    "b) De 20 första positiva udda heltalen.\n",
    "c) De 25 första positiva jämna talen i fallande ordning.\n",
    "d) Samtliga talpar (R,B) som representerar de möjliga utfallen vid kast med två tärningar R och B, där B tärningen visar minst lika många prickar som R.\n",
    "\n",
    "[Lösningsförslag](./uppg/Listor2Uppgift0.ipynb)\n",
    "\n",
    "\n",
    "\n",
    "**Uppgift 2**\n",
    "\n",
    "Väv ihop 2 lika långa listor så  att elementen tas omväxlande, varannan, från de 2 listorna.\n",
    "Konstruera listorna slumpmässigt med tal från 1 till 10 och 10 element i varje lista.\n",
    "\n",
    "[Lösningsförslag](./uppg/Listor2Uppgift1.ipynb)\n",
    "\n",
    "**Uppgift 3**\n",
    "\n",
    "Ändra ordningen på elementen i en lista. Säg att vi har en lista L, ändra om så att första elementet i listan hamnar sist i listan M, andra elementet i L hamnar näst sist i M osv.\n",
    "Det finns ett kommando för detta `L.reverse()` men det ska du naturligtvis inte använda.\n",
    "\n",
    "[Lösningsförslag](./uppg/Listor2Uppgift2.ipynb)\n",
    "\n",
    "\n",
    "**Uppgift 4**\n",
    "\n",
    "Hur många tal ligger parvis i rätt ordning? Att tal ligger i rätt ordning parvis innebär att det med högre index är större än det med lägre index. I listan [7,11] ligger de i rätt ordning även om de inte direkt följer på varandra som 7 och 8 tex.\n",
    "Gå igenom en lista och testa talen parvis; först tal med index 0 och 1, sedan 1 och 2, sedan 2 och 3 osv.\n",
    "Anteckna antalet gånger talen ligger parvis rätt.\n",
    "Listan skapas slumpmässigt.\n",
    "\n",
    "[Lösningsförslag](./uppg/Listor2Uppgift3.ipynb)\n",
    "\n",
    "\n",
    "**Uppgift 5**\n",
    "\n",
    "Leta upp det största talet i en lista.\n",
    "I python finns ett kommando för just den uppgiften. Om L är en lista letar max(L) upp det största talet i listan L. Men nu ska du själv leta upp den genom att jämföra talen i listan med varandra. Slumpa listan och leta sedan upp det största talet i listan (utan att använda max). Listan ska innehålla 10 tal valda i intervallet 1-100.\n",
    "\n",
    "[Lösningsförslag](./uppg/Listor2Uppgift4.ipynb)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Uppgift 6**\n",
    "\n",
    "Generera långa listor och beräkna sannolikheten för att få tal omedelbart efter varandra som är lika.\n",
    "Listan L=[1,1,3,5,3,6,6,8,12,14,1,32,1,5,8,9,9,9] innehåller 4 händelser med 2 lika tal: (1,1), (6,6), (9,9) de 2 första och (9,9) de 2 sista. \n",
    "\n",
    "Vi håller oss till tal i range(10). Svara med tabell. Slumptal skapas genom `s=random.randrange(0,10)` som ger ett tal from. 0 tom. 9. Man behöver inte göra listor men föreslår ändå att du börjar med att generera listor och använder dem (du ska öva på listor i detta avsnitt). Undersök listor med 100000 element och beräkna sannolikheten för längden 2 på sviter. Om du läst sannolikhetslära, beräkna det även teoretiskt.\n",
    "\n",
    "[Lösningsförslag](./uppg/Listor2Uppgift5.ipynb)\n",
    "\n",
    "**Uppgift 7**\n",
    "\n",
    "Skriv en lista med värden för sinus för heltal i grader från 0 till 90 i steg om 10 (0,10,20...90).\n",
    "Observera att Python är förinställt på radianer. Importera sin och pi från math.\n",
    "\n",
    "[Lösningsförslag](./uppg/Listor2Uppgift7.ipynb)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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
}