Level2_Nedbørsoppgaven/Del5_Forløkke.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Del 5: For-løkker\n",
    "\n",
    "*Nedbørsoppgavene Del 1 til 6 er laget som støtte-oppgaver til oppgaven \"Nedbør i Norge\". Oppgaven \"Nedbør i Norge\" er en lengre oppgave som kommer innom mange forskjellige programerings-elementer. Intensjonen er at hvis man først gjør deloppgavene 1 til 6 og så går gjennom det nokså omfattende eksempelet på starten av oppgaven \"Nedbør i Norge\" så vil det programeringstekniske i oppgaven \"Nedbør i Norge\" være repetisjon, slik at man kan fokusere på den naturvitenskaplige tolkningen av dataene. På denne måten får man både trening i programmering og erfaring med hvordan det kan brukes til å studere og forstå naturvitenskaplige prosesser.*\n",
    "\n",
    "-------------\n",
    "\n",
    "For-løkker er nyttige når man skal gjøre nesten det samme flere ganger på rad. Det gjør koden ryddig og oversiktlig, og det blir enklere å holde oversikten på hvilke beregninger som egentlig gjøres. I blant kan de samme operasjonene gjøres med både for-løkker og vektoroperasjoner. \n",
    "\n",
    "Det kan bli forvirrende å holde kontroll på indekseringen til forløkker i starten, særlig hvis det er flere \"nivåer\" med for-løkker (\"nested\" loops). Dette ser vi på i [Del 6: doble forløkker](https://github.com/irendundas/EkteData/blob/main/Level2_Nedb%C3%B8rsoppgaven/Del6_dobbel_forl%C3%B8kke.ipynb).\n",
    "\n",
    "I denne oppgaven bruker vi data av årlig gjennomsnittstemperatur i Bergen fra 1861 til 2021 for å vise et eksempel på hvordan en for-løkke kan brukes. \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np # for regneoperasjoner\n",
    "import matplotlib.pyplot as plt # for figurer\n",
    "import matplotlib\n",
    "\n",
    "import sys\n",
    "# Bytt ut stien under slik at den peker på hvor på din PC du har \n",
    "# lagret mappen \"Funksjoner\".\n",
    "#sys.path.append(r\"W:\\Work\\Documents\\EkteData\\EkteData\\Funksjoner\")\n",
    "sys.path.append(r\"C:\\Users\\iren_\\Documents\\EkteData\\Funksjoner\")\n",
    "from EkteDataFunk import loadData # for filinnlasting"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "file='TempBergenYearlyNonan.txt'\n",
    "temp,tid = loadData(file)\n",
    "temp=np.squeeze(temp)\n",
    "temp.shape, tid.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Tenk deg at du vil gjøre en beregning (for ekesmpel ta gjennomsnittet) over hvert tiår med data. Da må du 1) dele datasettet inn i tiårs-bolker, og 2) ta gjennomsnittet over hver bolk."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For å finne gjennomsnittstemperaturen for hver av de 16 tiårsperiodene kan man bruke en for-løkke."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 1. Kjør en for-løkke\n",
    "Vi går først gjennom fire små eksempler for å forklare hvordan en for-løkke fungerer. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Print ut en og en verdi i listen [0, 1, 2, 3]\n",
    "print('Example 1')\n",
    "for i in [0,1,2,3]:\n",
    "    print(i)    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Print ut en og en verdi i range(4). range(4) betyr fire verdier fra og med 0\n",
    "print('Example 2')\n",
    "for i in range(4):\n",
    "    print(i)    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Print ut verdiene i temperaturvektoren med indekser 0, 1, 2, 3 \n",
    "print('Example 3')\n",
    "for i in range(4):\n",
    "    print(temp[i])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Print ut verdiene i tids-vektoren med indekser 30 til og ikke med 40\n",
    "print('Example 4')\n",
    "for i in temp[30:40]:\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Eksempel 3 og 4 illustrerer to viktige ting. I linjen `for a in b:` kan `b` være både en liste med indekser som i eksempel 3 og en liste med faktiske verdier som i eksempel 4. Legg merke til at i eksempel 3 printer vi ut `temp[i]` mens i eksempel 4 printer vi `i` direkte.\n",
    "\n",
    "\n",
    "#### Oppgave 1.\n",
    "Lag tre for-løkker.\n",
    "- en som printer ut de første fem temperaturene i \"temp\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- samme som over, men med en annerledes for-løkke"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- en som printer ut både år og temperatur mellom år 1876 og 1883"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 2. Del datasettet inn i tiårs-bolker\n",
    "\n",
    "Tilbake til hovedoppgaven: Vi lager en vektor `ind10` (index 10, 10 fordi vi seinere skal gjøre det samme med 20-års bolker) med indeksene som skiller hver 10års bolk.\n",
    "\n",
    "Vi bruker funksjonen `np.linspace(start, stop, lengde)` til å lage vektoren med indekser som gir oss start og slutt på alle 10års-bolkene våre. `lengde` beskriver hvor mange 10års-bolker vi har plass til i tidsserien vår. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "start=0\n",
    "stop=len(tid)\n",
    "\n",
    "# \"lengde\" må være en integer, altså et heltall uten desimaler. \n",
    "# Vi må legge til 1 for å få inndelingen rett: siden vi vil ha med \n",
    "# endepunktet trenger vi en ekstra verdi.\n",
    "lengde=int(stop/10)+1\n",
    "    \n",
    "# Husk: np.linspace(start, stop, antall verdier)\n",
    "ind10=np.linspace(start, stop, lengde) \n",
    "\n",
    "# ind10 består nå av start- og slutt-indeks til hver av de 16 tiårs-bolkene \n",
    "# (0 er start-indeks og 10 er slutt-indeks til den første bolken etc)\n",
    "ind10 "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Husk fra Del 1 om indeksering: indekser MÅ være integers\n",
    "ind10=ind10.astype(int) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ind10"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Vi kunne fått det samme resultatet ved å bruke f.eks. `np.arange` istedet. Da må vi bruke `stop + 1` istedet for `stop` for å definere at vi vil ha med endepunktet. \n",
    "\n",
    "**Notat:** Tidsserien vi har på 160 år kan deles perfekt inn i 10års-bolker. I andre tilfeller måtte man tatt stilling til hva man skulle gjort med rest-verdier, f.eks. hvis datasettet var 167 tidssteg langt. Skal man la de 7 siste årene gjelde som en tiårspreiode, eller skal man kutte disse årene ut fra analysen?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.arange(start,stop+1,10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Oppgave 2:\n",
    "Hva skjer dersom du ikke legger til 1 i beregningen av `lengde`? Prøv!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Kjør denne cellen for å resette feilen du introduserte i oppgave 2\n",
    "start=0\n",
    "stop=len(tid)\n",
    "lengde=int(stop/10)+1 \n",
    "    \n",
    "ind10=np.linspace(start, stop, lengde)\n",
    "ind10=ind10.astype(int)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 3. Bruk en for-løkke til å finne gjennomsnittstemperaturen for hver av de 16 tiårsperiodene\n",
    "\n",
    "For-løkken i cellen under betyr: \"`for` hvert element `i` i `range(16)=[0,1,2,...,15]`, skriv ut gjennomsnittsverdien av temperatur i perioden med indeks `ind[i]` til `ind[i+1]`\". \n",
    "\n",
    "For f.eks. `i=3` betyr dette: skriv ut gjennomsnittet av temperatur fra `ind[3]` til `ind[4]`. Dette er det samme som `30` til `40`, altså `temp[30:40]`, som er det samme som temperaturen fra  1891-1900. Denne utregningen gjøres for alle `i` mellom 0 og 15 (16 elementer i `range(16)`). Hver gang utregningen gjøres heter en **iterasjon**. Siden utregningen her gjøres 16 ganger er det 16 iterasjoner i denne for-løkken. \n",
    "\n",
    "Vi må ta gjennomsnitt med nanmean fordi det er NaN-verdier i datasettet.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in range(16):\n",
    "    print(np.nanmean(temp[ind10[i]:ind10[i+1]]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Oppgave 3.\n",
    "Skriv ut gjennomsnittstemperaturen for de 9 første tiårsperiodene ved å bruke en for-løkke. Skriv også ut året hver disse 9 tiårsperiodene starter. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 4. Lagre verdiene fra en for-løkke\n",
    "I cellene over skriver vi ut verdiene, men i blant trenger man å lagre verdiene for seinere bruk. Da må man skrive resultatet til en ny variabel etter hver iterasjon. For en effektiv kode er det lurt å lage en variabel på forhånd som du kan skrive resultatene inn i underveis. Dette funker dersom man vet dimensjonene til resultatet på forhånd, noe man ikke alltid gjør - da må man istedet la variablen bygge på dimensjonene sine underveis, og det er ofte tidkrevende. Vi trenger imidlertid ikke ta stilling til det her, fordi vi vet hvor stor resultat-matrisen vår skal være: (16, 1) for 16 tiårsperioder.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Vi ser først på tre metoder for å beregne gjennomsnittstemperatur for hver av de 9 første tiårs-bolkene ved hjelp av en for-løkke, og lagrer resultatet i `test`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "test=np.zeros((9,1)) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Metode 1:**\n",
    "I denne metoden er `i` selve de 9 første elementene i `ind=0,10,20,...,80`. Indeksen til `test` blir da `int(i/10)=0,1,2,...,8`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in ind10[:9]: \n",
    "\n",
    "    # temp[i:i+10] er temperaturen fra startåret og ti år frem i tid. \n",
    "    # Er f.eks. i=40 blir dette temp[40:50]=temp fra 1901 til 1910. \n",
    "    test[int(i/10)]=np.nanmean(temp[i:i+10]) \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "test.shape, test"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Metode 2:** Cellen under er en annen for-løkke som gir nøyaktig samme resultat. Denne metoden ligner mer på eksempelet i seksjon 3 der vi ikke skrev resultatene til en variabel."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in range(9): # range(9) = fra 0 til og IKKE med 9, i.e., 9 elementer. \n",
    "    \n",
    "    # for e.g., i=0 blir dette temp[ind[0]:ind[1]]=temp[0:10]\n",
    "    test[i]=np.nanmean(temp[ind10[i]:ind10[i+1]]) \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "test"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Metode 3:\n",
    "Istedet for å iterere gjennom *enten* indekser *eller* faktiske verdier (`range(9)` vs `ind10[:9]`) kan man gjøre begge deler på en gang med `np.enumerate()`. Vi går gjennom et enkelt eksempel først:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for count, val in enumerate(ind10):\n",
    "    print('count=', count, ', val=', val, )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Her er `val` selve verdien til `ind10`, og `count` teller gjennom antall iterasjoner. \n",
    "\n",
    "Eksempelet med gjennomsnittet for hver av de første 9 10års-periodene blir da: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for count, val in enumerate(ind10[:9]):\n",
    "    test[count]=np.nanmean(temp[val:val+10]) \n",
    "\n",
    "test"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Oppgave 4.\n",
    "Lag en for-løkke som lagrer gjennomsnittstemperaturen av ikke bare de 9 første, men alle de 16 tiårsperiodene til variablen `meanTemp10`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "I cellen under lager vi en variabel som du etterpå kan skrive gjennomsnittsverdiene til inni for-løkken. Først er de 16 plassene bare fylt med 0. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "meanTemp10=np.zeros((16, 1)) \n",
    "meanTemp10.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Forslag 1\n",
    "for i in ind10[:16]: \n",
    "    meanTemp10[int(i/10)]=np.nanmean(temp[i:i+10]) \n",
    "   \n",
    "print('forslag1:',meanTemp10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Forslag 2\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 5. Plot dataene"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For å plotte dataene tenger vi en tidsvektor med midtpunktet av hver tiårs-bolk.\n",
    "\n",
    "Vi starter på `tid[4]` og slutter på `tid[-5]` fordi dette er midtpunktene til den første og den siste tiårsperioden. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(tid[4]), print(tid[-5])\n",
    "T10=np.arange(tid[4],tid[-5],10)\n",
    "# For å dobbeltsjekke hvordan np.arange funker, sjekk dokumentasjonen. Her \n",
    "# finner du at inputene er (start,stop,step).\n",
    "T10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.plot(T10,meanTemp10)\n",
    "plt.title('Temperatur 1860-2020')\n",
    "plt.xlabel('År')\n",
    "plt.ylabel('Temperatur [\\u2103]') \n",
    "plt.xlim([1860,2020]) \n",
    "plt.ylim([7,9]) \n",
    "plt.show() "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For å kontrollere at dette gjennomsnittet gjenspeiler de faktiske dataene på en god måte kan det være lurt å plotte begge linjene i samme figur."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.plot(tid, temp, label='årlig') # legg til de originale dataene i bakgrunnen.\n",
    "plt.plot(T10, meanTemp10, label='hvert tiår')\n",
    "plt.title('Temperatur 1860-2020')\n",
    "plt.xlabel('År')\n",
    "plt.ylabel('Temperatur [\\u2103]')\n",
    "plt.xlim([1860,2020])\n",
    "plt.ylim([5.5,10])\n",
    "plt.legend()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Oppgave 5:\n",
    "Se tilbake på [Del 3: Plotting av tidsserier](https://github.com/irendundas/EkteData/blob/main/Level2_Nedb%C3%B8rsoppgaven/Del3_Plotting_av_tidsserier.ipynb) der vi plottet hvert tiende datapunkt. Kommenter på forskjellene mellom denne figuren og figuren rett over."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Oppgave 6:\n",
    "Beregn temperatur for tjueårs-bolker. Bruk den metoden som er mest intuitiv/logisk for deg. Om du gjør det på en annen måte enn i eksemplene over er det helt ok. For å sjekke at metoden din funker kan du gjøre det likt som over og se om du får samme resultat med begge fremgangsmåter. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Oppgave 7:\n",
    "Lag en figur der du viser de originale dataene, gjennomsnittet over tiårsbolkene, og gjennomsnittet over tjueårs-bolkene i samme figur. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "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.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}