Python för Geodata

Ovning_1.ipynb

Ovning_1_Losningar.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "MK8vXs3lKhKc"
   },
   "source": [
    "# Avsnitt 1.1: Lära känna IPython/Jupyter/Collaboratory\n",
    "\n",
    "Mig kan du dubbeklicka på för att ändra innehållet i!\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 35
    },
    "colab_type": "code",
    "id": "YZ4k9GtxLVpP",
    "outputId": "b2e9464f-985d-427a-cab4-cd1769dea98b"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello World!\n"
     ]
    }
   ],
   "source": [
    "# Jag är en cell som innehåller Pythonkod, du kan köra mig genom och se resultatet genom att:\n",
    "# 1. Klicka på mig och sedan trycka Ctrl+Enter eller Alt+Enter (skapar även en ny cell direkt under)\n",
    "# 2. Klicka på Play-knappen till vänster\n",
    "print(\"Hello World!\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 35
    },
    "colab_type": "code",
    "id": "gVwX-jFlL77I",
    "outputId": "2661c8f0-d050-41d7-907f-9ebe9ea39764"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8"
      ]
     },
     "execution_count": 2,
     "metadata": {
      "tags": []
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Om sista raden i en kodcell ger ett värde kommer du även få se det\n",
    "3 + 5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 35
    },
    "colab_type": "code",
    "id": "Qz1UcF82MGXh",
    "outputId": "d07c310b-b677-4fa9-e770-937dc07958e0"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Inget matteresultat här inte!\n"
     ]
    }
   ],
   "source": [
    "# Dock inte för andra rader, och print returnerar inget (None)\n",
    "9 + 2\n",
    "print(\"Inget matteresultat här inte!\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 72
    },
    "colab_type": "code",
    "id": "h4b1Tt7hMQLF",
    "outputId": "b050007d-02d3-4666-c7b3-7f798b44ea40"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "7\n",
      "hejhejhej\n",
      "[4, 2, 3]\n"
     ]
    }
   ],
   "source": [
    "# Med print kan du dock se flera resultat\n",
    "print(5 + 2)\n",
    "print(\"hej\" * 3)\n",
    "print([4, 2, 3])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "jkx9XwubM50A"
   },
   "outputs": [],
   "source": [
    "# Celler hänger ihop!\n",
    "a = 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 35
    },
    "colab_type": "code",
    "id": "U8nDl1g5M6PF",
    "outputId": "a0b3a453-7b91-488c-840a-8603362441ef"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n"
     ]
    }
   ],
   "source": [
    "print(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "IWkXeOqDK9SJ"
   },
   "source": [
    "# Avsnitt 1.2: Variabler, värden och datatyper\n",
    "\n",
    "Välj mellan att använda `print` eller att ha uträkningen på sista raden för att lösa uppgifterna"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "pZyOwutBNEAi"
   },
   "source": [
    "## Uppgift 1.2.1: Räkna ut antalet fingrar i rummet, samt minst en _bra_ kommentar"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 35
    },
    "colab_type": "code",
    "id": "WUNAEzNcQaP6",
    "outputId": "4bc6218d-c1a7-43d7-c8f6-fe88ba26407d"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "60"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "antal_personer = 6\n",
    "antal_personer * 10  # en vanlig person har 10 fingrar"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "784w4DdDQeFp"
   },
   "source": [
    "## Uppgift 1.2.2: Byt ut alla förekomster av `{}` mot något passande"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "iI-zLuQ7RH9v"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Det har hittats 4 byggnader\n"
     ]
    }
   ],
   "source": [
    "byggnader = [4, 7, 2, 3]\n",
    "antal_byggnader = len(byggnader)\n",
    "print('Det har hittats ' + str(antal_byggnader) + ' byggnader')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "ozNIYxjWRfYX"
   },
   "source": [
    "# Avsnitt 1.3: Funktioner"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "zgnU7nZ9SFiL"
   },
   "source": [
    "## Uppgift 1.3.1: Skriv en funktion som beräknar volymen av en boll\n",
    "\n",
    "* Tips: Formeln du behöver är \\begin{equation}\n",
    "V_{klot} = \\frac{{4 * \\pi * r^3 }}{3}\n",
    "\\end{equation} där radien är i meter och volymen i kubikmeter\n",
    "* Tips: Om du inleder med raden `import math` kan du sedan skriva `math.pi` för att få ett exakt värde för π\n",
    "* Tips: Exponenter skriver du som `x**y` i Python"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 35
    },
    "colab_type": "code",
    "id": "bW-Lc372TFGk",
    "outputId": "0ba43be7-a543-485c-f04a-58e4abd70f53"
   },
   "outputs": [],
   "source": [
    "import math\n",
    "\n",
    "def spherical_volume(r):\n",
    "    return (4 * math.pi * r**3) / 3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "6ECi_GMFText"
   },
   "source": [
    "## Uppgift 1.3.2: Använd din funktion för att beräkna storleken av boll med radien 3 meter"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "GP01BraqT6ZD"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "113.09733552923255"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "spherical_volume(3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "Fwk_Qp1PT7FX"
   },
   "source": [
    "## Uppgift 1.3.3: Använd din funktion för att skriva en ny funktion som beräknar summan av volymerna av ett givet antal bollar av samma radius, och använd den för att beräkna den summerade volumen av 6 bolar med radien 2 meter"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "DPUAs1tpUIYE"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "201.06192982974676"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def summed_spherical_volume(r, count_balls):\n",
    "    return spherical_volume(r) * count_balls\n",
    "\n",
    "summed_spherical_volume(2, 6)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "zcGxCr-_ULKJ"
   },
   "source": [
    "# Avsnitt 1.4: Listor, Loopar & If-satser"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "H38OxUvmUUWK"
   },
   "source": [
    "## Uppgift 1.4.1: Skapa en lista med 3-5 tal\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "EiPg8iREVHzU"
   },
   "outputs": [],
   "source": [
    "min_lista = [7, 4, 9, 2]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "aj43bdCSXscf"
   },
   "source": [
    "## Uppgift 1.4.2: Använd If-statser för att skriva ut olika meddelanden beroende på om din lista innehåller 3, 4 eller 5 element\n",
    "\n",
    "Tips: Den inbyggda funktionen `len` ger dig antalet element i en lista\n",
    "\n",
    "OBS: Prova också lägga till eller ta bort element i din lista och köra båda celler igen för att se att du faktiskt skriver ut olika meddelanden\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "det finns 4 element\n"
     ]
    }
   ],
   "source": [
    "if len(min_lista) == 3:\n",
    "    print('det finns 3 element')\n",
    "elif len(min_lista) == 4:\n",
    "    print('det finns 4 element')\n",
    "elif len(min_lista) == 5:\n",
    "    print('det finns 5 element')\n",
    "else:\n",
    "    print('antalet element var inte 3, 4 eller 5')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "ehNkVtVaVKKH"
   },
   "source": [
    "## Uppgift 1.4.3: Använd din volymfunktion och `print` (ett anrop till `print` för varje element i listan) för att beräkna volymen för bollar med radierna i din lista"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "4NPfTz8_VclE"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1436.755040241732\n",
      "268.082573106329\n",
      "3053.6280592892786\n",
      "33.510321638291124\n"
     ]
    }
   ],
   "source": [
    "for radius in min_lista:\n",
    "    print(spherical_volume(radius))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "P7wZdmQMVbfu"
   },
   "source": [
    "## Uppgift 1.4.4: Använd din volymfunktion för att skapa en ny lista med samtliga volymer, skriv sedan ut summan av värdena i den listan\n",
    "\n",
    "Tips: Den inbyggda funktionen `sum` beräknar summan av värdena i en sekvens (t.ex. en lista)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "76swsK5qV-c7"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4791.975994275631"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ny_lista = []\n",
    "for radius in min_lista:\n",
    "    ny_lista.append(spherical_volume(radius))\n",
    "sum(ny_lista)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "srwceJfTV-5k"
   },
   "source": [
    "## Uppgift 1.4.5: Upprepa 1.4.4 men med den givna listan och spara endast volymer större än 50 m<sup>3</sup> i den nya listan"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 127
    },
    "colab_type": "code",
    "id": "bf-3QpeSWOxw",
    "outputId": "6a428474-f105-4da2-d2f1-bd27e56ad4e9"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1817.9349488772937\n"
     ]
    }
   ],
   "source": [
    "radier = [4, 2, 7, 1, 3, 2]\n",
    "ny_lista = []\n",
    "for radius in radier:\n",
    "    volume = spherical_volume(radius)\n",
    "    if volume > 50:\n",
    "        ny_lista.append(volume)\n",
    "print(sum(ny_lista))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "2W5HmVejWu6B"
   },
   "source": [
    "## Bonusuppgift 1.4.6: Upprepa 1.4.4 och 1.4.5 men använd dig av list comprehensions istället för vanliga loopar\n",
    "\n",
    "Fundera även på när vanliga loopar respektive comprehensions är att föredra. Finns det någon bra regel?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4791.975994275631\n",
      "1817.9349488772937\n"
     ]
    }
   ],
   "source": [
    "print(sum([spherical_volume(r) for r in min_lista]))\n",
    "print(sum(spherical_volume(r) for r in radier if spherical_volume(r) > 50))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "SYuxClatYhHa"
   },
   "source": [
    "# Avsnitt 1.5: Fler samlingstyper"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "j2PbLnQGYqaj"
   },
   "source": [
    "## Uppgift 1.5.1: Skapa en `list`, ett `set`, en `tuple` och en `dict` med minst 2-3 värden vardera\n",
    "\n",
    "Prova gärna använda olika datatyper (heltal, flyttal, strängar, boolska värden, även samlingstyper)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "ybGQPBbYY4T_"
   },
   "outputs": [],
   "source": [
    "min_lista = ['a', 'b', 'f', 'e']\n",
    "mitt_set = {3, 5, 1, 3}\n",
    "min_tuple = (True, False, False, True, False)\n",
    "mitt_dict = dict(foo=3.14, bar=2.222222, baz=[3, 5])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "OVIxEQhjY4_l"
   },
   "source": [
    "## Uppgift 1.5.2: Lägg till ett värde i vardera variabel du just skapat\n",
    "\n",
    "Gick det med alla?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "oeMGA0UhZHAN"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['a', 'b', 'f', 'e', 'test', 'test', 'test', 'test', 'test']\n",
      "{99, 1, 3, 5}\n",
      "(True, False, False, True, False)\n",
      "{'foo': 3.14, 'bar': 2.222222, 'baz': [3, 5], 'testing': 'test'}\n"
     ]
    }
   ],
   "source": [
    "min_lista.append('test')\n",
    "mitt_set.add(99)\n",
    "#min_tuple.append(True)\n",
    "mitt_dict['testing'] = 'test'\n",
    "\n",
    "print(min_lista)\n",
    "print(mitt_set)\n",
    "print(min_tuple)\n",
    "print(mitt_dict)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "XSz-4RFOZHmU"
   },
   "source": [
    "## Uppgift 1.5.3: Ta bort ett värde och uppdatera ett annat med vardera variabel\n",
    "\n",
    "Vilka gick det med?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "GTXA52LLZVQ9"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['A', 'f', 'e', 'test', 'test', 'test', 'test', 'test']\n",
      "{99, 1, 3}\n",
      "(True, False, False, True, False)\n",
      "{'bar': 'DETTA HAR ÄNDRATS', 'baz': [3, 5], 'testing': 'test'}\n"
     ]
    }
   ],
   "source": [
    "min_lista.remove('a')  # eller del min_lista[0]\n",
    "mitt_set.remove(5)\n",
    "#min_tuple.remove(1)\n",
    "del mitt_dict['foo']\n",
    "\n",
    "min_lista[0] = 'A'\n",
    "#mitt_set[0] = 99\n",
    "#min_tuple[0] = False\n",
    "mitt_dict['bar'] = 'DETTA HAR ÄNDRATS'\n",
    "\n",
    "print(min_lista)\n",
    "print(mitt_set)\n",
    "print(min_tuple)\n",
    "print(mitt_dict)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "QWL5OZeMZV_N"
   },
   "source": [
    "## Uppgift 1.5.4: Använd `print` i en loop för att skriva ut alla värden i ditt `dict`\n",
    "\n",
    "Tips:\n",
    "* `my_dict.items()` returnerar en lista (eller för att vara helt korrekt, en \"generator\") av tuplar i formen `(key, value)`\n",
    "* Du kan direkt \"packa upp\" tuplar i en `for` loop såhär: `for a, b in [(3, 4), (1, 5), (6, 4)]:`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "bar DETTA HAR ÄNDRATS\n",
      "baz [3, 5]\n",
      "testing test\n"
     ]
    }
   ],
   "source": [
    "for key, value in mitt_dict.items():\n",
    "    print(key, value)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Avsnitt 1.6: Klasser"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Uppgift 1.6.1: Byt ut alla `{}` så att det blir en korrekt Python-klass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "30"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class Byggnad:\n",
    "    def __init__(self, width, height):\n",
    "        self._width = width\n",
    "        self._height = height\n",
    "    \n",
    "    def omkrets(self):\n",
    "        return self._width * 2 + self._height * 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Uppgift 1.6.2: Skapa en instans av byggnadsklassen med valfria dimensioner, och beräkna omkretsen"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "30"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "byggnad = Byggnad(5, 10)\n",
    "byggnad.omkrets()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Uppgift 1.6.3: Redigera byggnadsklassen ovan genom att lägga till en funktion som beräknar arean, och beräkna sedan arean för din byggnadsinstans\n",
    "\n",
    "Tips: Behöver du göra något mer än att ändra i klassdefinitionen och sedan anropa den nya funktionen här?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "50"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class Byggnad:\n",
    "    def __init__(self, width, height):\n",
    "        self._width = width\n",
    "        self._height = height\n",
    "    \n",
    "    def omkrets(self):\n",
    "        return self._width * 2 + self._height * 2\n",
    "    \n",
    "    def area(self):\n",
    "        return self._width * self._height\n",
    "\n",
    "byggnad.area()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Avsnitt 1.7: Mer om strängar"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Uppgift 1.7.1: Skriv några valfria rader kod som använder sig av funktionerna `replace`, `split` och `join`\n",
    "\n",
    "Är lista den enda möjliga datatypen som kan ges till `join`?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hej!\n",
      "['Python', 'för', 'Geodata']\n",
      "Pythonkurs\n"
     ]
    }
   ],
   "source": [
    "print('hejdå'.replace('då', '!'))\n",
    "print('Python för Geodata'.split(' '))\n",
    "print(''.join(['Python', 'kurs']))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Uppgift 1.7.2: Använd `format` för att skapa en textsträng som innehåller din byggnads (från avsnitt 1.6) area och omkrets _på olika rader_"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Area: 50 m2\n",
      "Omkrets: 30 m\n"
     ]
    }
   ],
   "source": [
    "print('Area: {} m2\\nOmkrets: {} m'.format(byggnad.area(), byggnad.omkrets()))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Avsnitt 1.8: Avslut\n",
    "\n",
    "\n",
    "\n",
    "Nu ska du få prova använda flera av de saker du lärt dig vid dessa övningar.\n",
    "\n",
    "* Slutresultatet måste innehålla anrop till samtliga funktioner/metoder du skapat\n",
    "\n",
    "Gör __en__ av följande uppgifter:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Uppgiftsalternativ 1.8.1: Byggnad och lägenhet\n",
    "\n",
    "* Skapa en ny klass för en byggnad\n",
    "* Denna gång ska du inte spara bredd/längd utan istället x/y-koordinater. Exempel på koordinatlistor:\n",
    "```python\n",
    "[(0, 0), (1, 0), (1, 1), (0, 1), (0, 0)]\n",
    "[(5, 5), (10, 5), (10, 10), (5, 10), (5, 5)]\n",
    "```\n",
    "* Klassen ska ha minst metoderna `area` och `omkrets`\n",
    "\n",
    "Tips:\n",
    "* Du hittar en formel för att beräkna en polygons area [här](https://www.mathopenref.com/coordpolygonarea.html)\n",
    "* Liksom `pi` hittar du funktionen `sqrt` (kvadratroten) i modulen `math`\n",
    "\n",
    "Gör så många av dessa som du hinner:\n",
    "\n",
    "* Skapa subklasser för bostadsbyggnad respektive komplementbyggnad\n",
    "* Skapa en enkel klass för en lägenhet med minst 2 attribut\n",
    "* Lägg till en lägenhetslista i en byggnadsklass. Vilken byggnadsklass passar den bäst i?\n",
    "* Lägg till funktioner för att hantera lägenhetslistan (minst lägg till och ta bort)\n",
    "* Skapa en lista med några bostadsbyggnader och med 0-2 lägenheter vardera, använd sedan `print` in en loop för att skriva ut byggnaderna i tabellform med kolumnerna _area_, _omkrets_ och _antal lägenheter_\n",
    "\n",
    "* Om du gjort samtliga av dessa har du använt både komposition och arv. Men vilken är vilken?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Area\tOmkrets\tLägenheter\n",
      "1.0 m2\t4.0 m\t1\n",
      "25.0 m2\t20.0 m\t3\n"
     ]
    }
   ],
   "source": [
    "class BasByggnad:\n",
    "    def __init__(self, koordinater):\n",
    "        self.koordinater = koordinater\n",
    "    \n",
    "    def area(self):\n",
    "        summering = 0\n",
    "        for index, koordinat in enumerate(self.koordinater):\n",
    "            if index == (len(self.koordinater)-1):\n",
    "                break\n",
    "            x1, y1 = koordinat\n",
    "            x2, y2 = self.koordinater[index+1]\n",
    "            summering += x1*y2 - x2*y1\n",
    "        return abs(summering/2)\n",
    "    \n",
    "    @property\n",
    "    def omkrets(self):\n",
    "        strackor = []\n",
    "        for index, koordinat in enumerate(self.koordinater):\n",
    "            if index == (len(self.koordinater)-1):\n",
    "                break\n",
    "            x1, y1 = koordinat\n",
    "            x2, y2 = self.koordinater[index + 1]\n",
    "            strackor.append(math.sqrt((x1-x2)**2 + (y1-y2)**2))\n",
    "        return sum(strackor)\n",
    "\n",
    "class Lagenhet:\n",
    "    def __init__(self, yta, nummer):\n",
    "        self.yta = yta\n",
    "        self.nummer = nummer\n",
    "\n",
    "class BostadsByggnad(BasByggnad):\n",
    "    def __init__(self, koordinater):\n",
    "        super(BostadsByggnad, self).__init__(koordinater)\n",
    "        self._lagenheter = []\n",
    "    \n",
    "    def ny_lagenhet(self, lagenhet):\n",
    "        self._lagenheter.append(lagenhet)\n",
    "    \n",
    "    def radera_lagenhet(self, lagenhet):\n",
    "        self._lagenheter.remove(lagenhet)\n",
    "    \n",
    "    def antal_lagenheter(self):\n",
    "        return len(self._lagenheter)\n",
    "\n",
    "class KomplementByggad(BasByggnad):\n",
    "    pass\n",
    "\n",
    "b1 = BostadsByggnad([(0, 0), (1, 0), (1, 1), (0, 1), (0, 0)])\n",
    "b2 = BostadsByggnad([(5, 5), (10, 5), (10, 10), (5, 10), (5, 5)])\n",
    "b1.ny_lagenhet(Lagenhet(1, 1001))\n",
    "b2.ny_lagenhet(Lagenhet(5, 1001))\n",
    "b2.ny_lagenhet(Lagenhet(3, 1002))\n",
    "b2.ny_lagenhet(Lagenhet(4, 1003))\n",
    "\n",
    "print('Area\\tOmkrets\\tLägenheter')\n",
    "for byggnad in [b1, b2]:\n",
    "    print('{} m2\\t{} m\\t{}'.format(byggnad.area(), byggnad.omkrets, byggnad.antal_lagenheter()))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Uppgiftsalternativ 1.8.2: Geometrier och attributtabeller\n",
    "\n",
    "Du kommer ni skapa ett mycket simpelt GIS.\n",
    "\n",
    "* Skapa klasserna `Object` och `Polygon` där `Object` är en grundklass för alla olika typer av geometrityper och där `Polygon` är en subklass av `Object`\n",
    "* Lägg till attribut för koordinater. Vilken/vilka klasser passar detta i? Exempel på koordinatlistor:\n",
    "```python\n",
    "[(0, 0), (1, 0), (1, 1), (0, 1), (0, 0)]\n",
    "[(5, 5), (10, 5), (10, 10), (5, 10), (5, 5)]\n",
    "```\n",
    "* Lägg till metoderna `area` och `omkrets` i `Polygon` klassen\n",
    "\n",
    "Tips: Du hittar en formel för att beräkna en polygons area [här](https://www.mathopenref.com/coordpolygonarea.html)\n",
    "\n",
    "Gör så många av dessa som du hinner:\n",
    "\n",
    "* Skapa en ytterligare subklass av `Object` för punktobjekt\n",
    "* Ge objekten användardefinerbara attribut samt metoder för att lägga till, ändra och ta bort dem. Vilken samlingstyp passar bra för detta?\n",
    "* Skapa en funktion som givet en lista av polygoner lägger till de användardefinerbara attributen _area_ och _omkrets_ med värden enligt respektive funktion, och sedan returnerar listan\n",
    "* Skapa en lista med några polygoner med varierande koordinater och använd den funktion du skapade i förgående steg för att ge dem attributen _area_ och _omkrets_, använd sedan `print` in en loop för att skriva ut objekten med deras attribut i tabellform"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Area\tOmkrets\n",
      "1.0 m2\t4.0 m\n",
      "25.0 m2\t20.0 m\n",
      "Area\tColor\tOmkrets\n",
      "1.0\tred\t4.0\n",
      "25.0\tNone\t20.0\n"
     ]
    }
   ],
   "source": [
    "class Object:\n",
    "    def __init__(self):\n",
    "        self._attributes = dict()\n",
    "    \n",
    "    def set_attribute(self, name, value):\n",
    "        self._attributes[name] = value\n",
    "    def get_attribute(self, name):\n",
    "        if name in self._attributes:\n",
    "            return self._attributes[name]\n",
    "        return None\n",
    "    def remove_attribute(self, name):\n",
    "        del self._attributes[name]\n",
    "    def attribute_names(self):\n",
    "        return self._attributes.keys()\n",
    "\n",
    "class Polygon(Object):\n",
    "    def __init__(self, koordinater):\n",
    "        super(Polygon, self).__init__()\n",
    "        self.koordinater = koordinater\n",
    "    \n",
    "    def area(self):\n",
    "        summering = 0\n",
    "        for index, koordinat in enumerate(self.koordinater):\n",
    "            if index == (len(self.koordinater)-1):\n",
    "                break\n",
    "            x1, y1 = koordinat\n",
    "            x2, y2 = self.koordinater[index+1]\n",
    "            summering += x1*y2 - x2*y1\n",
    "        return abs(summering/2)\n",
    "    \n",
    "    @property\n",
    "    def omkrets(self):\n",
    "        strackor = []\n",
    "        for index, koordinat in enumerate(self.koordinater):\n",
    "            if index == (len(self.koordinater)-1):\n",
    "                break\n",
    "            x1, y1 = koordinat\n",
    "            x2, y2 = self.koordinater[index + 1]\n",
    "            strackor.append(math.sqrt((x1-x2)**2 + (y1-y2)**2))\n",
    "        return sum(strackor)\n",
    "\n",
    "class Point(Object):\n",
    "    pass\n",
    "\n",
    "def berakna_till_attribut(polygoner):\n",
    "    for polygon in polygoner:\n",
    "        polygon.set_attribute('area', polygon.area())\n",
    "        polygon.set_attribute('omkrets', polygon.omkrets)\n",
    "    return polygoner\n",
    "\n",
    "p1 = Polygon([(0, 0), (1, 0), (1, 1), (0, 1), (0, 0)])\n",
    "p2 = Polygon([(5, 5), (10, 5), (10, 10), (5, 10), (5, 5)])\n",
    "polygoner = berakna_till_attribut([p1, p2])\n",
    "\n",
    "print('Area\\tOmkrets')\n",
    "for polygon in polygoner:\n",
    "    print('{} m2\\t{} m'.format(polygon.get_attribute('area'), polygon.get_attribute('omkrets')))\n",
    "\n",
    "# eller\n",
    "\n",
    "p1.set_attribute('color', 'red')\n",
    "\n",
    "alla_nycklar = {name for polygon in polygoner for name in polygon.attribute_names()}\n",
    "alla_nycklar = [name.capitalize() for name in alla_nycklar]\n",
    "alla_nycklar = sorted(alla_nycklar)\n",
    "print('\\t'.join(alla_nycklar))\n",
    "for polygon in polygoner:\n",
    "    values = [str(polygon.get_attribute(name.lower())) or '' for name in alla_nycklar]\n",
    "    print('\\t'.join(values))"
   ]
  }
 ],
 "metadata": {
  "colab": {
   "collapsed_sections": [],
   "name": "Python för Geodata Övning 1.ipynb",
   "provenance": [],
   "toc_visible": true,
   "version": "0.3.2"
  },
  "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.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}

Ovning_2.ipynb

Ovning_2_Losningar.ipynb

idrottsplatser.geojson