Tunti 3 listat ja funktiot-vastaukset.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "a4485f3f",
   "metadata": {},
   "source": [
    "# Tunti 3 Listat ja funktiot\n",
    "\n",
    "## Listat\n",
    "\n",
    "Lista on tietorakenne, eli vähän kuin muuttujatyyppi. Sen avulla yhteen muuttujaan voidaan tallentaa monta arvoa. \n",
    "\n",
    "Lista luodaan hakasuluilla [ ]."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "58bbce01",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Luodaan muuttuja lista, joka on tyhjä lista\n",
    "lista = []"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "013a4628",
   "metadata": {},
   "source": [
    "Muuttujassa `lista` on nyt tyhjä lista.\n",
    "\n",
    "\n",
    "Jos listaan haluaa alussa tietoja, ne erotetaan pilkulla:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "b692c30b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "# lista muutttuja, jonka nimi on a\n",
    "a = [3, 4, 5, 6]\n",
    "print(a[0])\n",
    "print(a[1])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ecb57a85",
   "metadata": {},
   "source": [
    "Pythonissa lista voi sisältää mitä tahansa muuttujatyyppejä, myös muita listoja. Yleensä kuitenkin yhdessä listassa kannattaa olla vain yhtä muuttujatyyppiä, eli ei esimerkiksi sekoita numeroita ja merkkijonoja.\n",
    "\n",
    "\n",
    "Listan loppuun voi lisätä alkion append-metodilla:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6d4e4923",
   "metadata": {},
   "outputs": [],
   "source": [
    "lista = []\n",
    "lista.append(0)\n",
    "lista.append(1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "cab824da",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Matti', 'Liisa']\n",
      "Liisa\n"
     ]
    }
   ],
   "source": [
    "nimet =[]\n",
    "nimet.append(\"Matti\")\n",
    "nimet.append(\"Liisa\")\n",
    "print(nimet)\n",
    "print(nimet[1])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f3104409",
   "metadata": {},
   "source": [
    "Listan alkioita voi käsitellä `[]`-merkinnällä, jossa hakasulkujen väliin tulee alkion paikka eli indeksi:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3ef75589",
   "metadata": {},
   "outputs": [],
   "source": [
    "lista = []\n",
    "lista.append(\"a\")\n",
    "lista.append(\"b\")\n",
    "lista.append(\"c\")\n",
    "\n",
    "print(lista[0])\n",
    "print(lista[1])\n",
    "print(lista[2])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "80c7e458",
   "metadata": {},
   "source": [
    "Tulostaa a, b, c. Pythonissa listat alkavat nollasta, eli ensimmäisen paikka on 0.\n",
    "\n",
    "Listan voi järjestää metodilla `sort`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "de242652",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[7, 8, 9, 10, 6, 4, 1, 3, 5, 2]\n",
      "järjestetty lista:\n",
      "[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n",
      "[10, 9, 8, 7, 6, 5, 4, 3, 2, 1]\n"
     ]
    }
   ],
   "source": [
    "lista = [7, 8, 9, 10, 6, 4, 1, 3, 5, 2]\n",
    "print(lista)\n",
    "lista.sort()\n",
    "print(\"järjestetty lista:\")\n",
    "print(lista)\n",
    "lista.reverse()\n",
    "print(lista)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dd2e9219",
   "metadata": {},
   "source": [
    "Listoja käydään usein läpi `for`-silmukan avulla:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "207633fe",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n",
      "6\n",
      "7\n",
      "8\n",
      "9\n",
      "10\n"
     ]
    }
   ],
   "source": [
    "lista = [1,2,3,4,5,6,7,8,9,10]\n",
    "\n",
    "for luku in lista:\n",
    "    print(luku)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "9f9896ee",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(lista)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "7c451288",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "muuttuja i arvo on nyt:  0\n",
      "listan alkio tällä i:n arvolla:  1\n",
      "muuttuja i arvo on nyt:  1\n",
      "listan alkio tällä i:n arvolla:  2\n",
      "muuttuja i arvo on nyt:  2\n",
      "listan alkio tällä i:n arvolla:  3\n",
      "muuttuja i arvo on nyt:  3\n",
      "listan alkio tällä i:n arvolla:  4\n",
      "muuttuja i arvo on nyt:  4\n",
      "listan alkio tällä i:n arvolla:  5\n",
      "muuttuja i arvo on nyt:  5\n",
      "listan alkio tällä i:n arvolla:  6\n",
      "muuttuja i arvo on nyt:  6\n",
      "listan alkio tällä i:n arvolla:  7\n",
      "muuttuja i arvo on nyt:  7\n",
      "listan alkio tällä i:n arvolla:  8\n",
      "muuttuja i arvo on nyt:  8\n",
      "listan alkio tällä i:n arvolla:  9\n",
      "muuttuja i arvo on nyt:  9\n",
      "listan alkio tällä i:n arvolla:  10\n"
     ]
    }
   ],
   "source": [
    "for i in range(len(lista)):\n",
    "    print(\"muuttuja i arvo on nyt: \", i)\n",
    "    print(\"listan alkio tällä i:n arvolla: \",lista[i])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3962bea9",
   "metadata": {},
   "source": [
    "Listaan voi kysyä monta lukua käyttäjältä, esimerkki:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "95a7af3f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Monenko luvun keskiarvon haluat laskea? 4\n",
      "Anna luku -10\n",
      "Anna luku -4\n",
      "Anna luku +9\n",
      "Anna luku 100\n",
      "Keskiarvo on 23.75\n"
     ]
    }
   ],
   "source": [
    "n = int(input(\"Monenko luvun keskiarvon haluat laskea? \"))\n",
    "\n",
    "# tyhjä lista\n",
    "lista = []\n",
    "\n",
    "# kysytään käyttäjältä liukulukuja, eli desimaalilukut\n",
    "for i in range(n):\n",
    "    luku = float(input(\"Anna luku \"))\n",
    "    lista.append(luku)\n",
    "\n",
    "summa = 0\n",
    "\n",
    "for luku in lista:\n",
    "    summa = summa + luku\n",
    "print(\"Keskiarvo on\", summa / n)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1c29b1f1",
   "metadata": {},
   "source": [
    "Listoja voi yhdistää `+ -`merkeillä:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "1a42a73b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 1, 2, 3, 4, 5]\n"
     ]
    }
   ],
   "source": [
    "print([0, 1, 2] + [3, 4, 5])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9af050b8",
   "metadata": {},
   "source": [
    "Listan pituuden saa selville `len`-funktiolla:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "3e8fd4e3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "7\n"
     ]
    }
   ],
   "source": [
    "lista = [0, 1, 2, 3, 4, 5, 6]\n",
    "print(len(lista))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "51b9c52b",
   "metadata": {},
   "source": [
    "## Tehtäviä listoista\n",
    "\n",
    "### Tehtävä 3.1\n",
    "Tee ohjelma, joka etsii suurimman ja pienimmän luvun listasta:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "0bbf19e0",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "listan pienin luku:  3\n",
      "Listan suurin luku on viimeisenä:  108\n"
     ]
    }
   ],
   "source": [
    "# käytä valmista listaa testaukseen\n",
    "lista = [7, 8, 11, 10, 6, 4, 108, 3, 55, 22]\n",
    "\n",
    "lista.sort()\n",
    "\n",
    "print(\"listan pienin luku: \", lista[0])\n",
    "#print(\"listan suurin luku: \", lista[len(lista)-1])\n",
    "# TAI\n",
    "print(\"Listan suurin luku on viimeisenä: \", lista[-1])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2e1dbf1b",
   "metadata": {},
   "source": [
    "###  Tehtävä 3.2\n",
    "Alla on lista, jossa on 100 kappaletta satunnaisia lukuja\n",
    "\n",
    "a) tee ohjelma joka laskee ja tulostaa listassa olevien lukujen summan.\n",
    "\n",
    "b) tee ohjelma, joka laskee ja tulostaa listan parillisten lukujen summan.\n",
    "\n",
    "c) Kirjoita ohjelma, joka tulostaa listan suurimman ja piennimmän luvun.\n",
    "\n",
    "d) Kirjoita ohjelma, joka kertoo listan kahden peräkkäisen jäsenen suurimman erotuksen.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "95a9b844",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Lukujen summa: 49202\n"
     ]
    }
   ],
   "source": [
    "# Kirjoita ohjelmasi tähän\n",
    "\n",
    "lista = [932, 168, 876, 250, 426, 231, 554, 105, 888, 684, 639, 131, 140, 382, 479, 402, 125, 264, 286, 290, 205, 944, 761, 735, 611, 646, 908, 438, 852, 937, 397, 503, 591, 736, 734, 124, 434, 952, 269, 13, 164, 161, 128, 170, 646, 200, 331, 946, 590, 973, 569, 784, 778, 358, 463, 712, 283, 357, 959, 598, 518, 853, 305, 767, 44, 135, 175, 407, 677, 749, 714, 517, 766, 346, 488, 687, 338, 375, 341, 582, 912, 389, 224, 326, 561, 106, 756, 709, 445, 106, 727, 258, 671, 48, 857, 69, 171, 840, 335, 696]\n",
    "\n",
    "# lasketaan lukujen summa\n",
    "summa = 0\n",
    "\n",
    "for luku in lista:\n",
    "    summa = summa + luku\n",
    "    # summa += luku \n",
    "\n",
    "    \n",
    "print(\"Lukujen summa:\", summa)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "768e1f60",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Parillisten lukujen summa:  27452\n",
      "Parittomien summa:  21750\n"
     ]
    }
   ],
   "source": [
    "# parillisten lukujen summa\n",
    "parillinen_summa  = 0\n",
    "parittomien_summa = 0\n",
    "\n",
    "for luku in lista:\n",
    "    # lasketaan jakojäännös\n",
    "    if luku % 2 == 0:\n",
    "        parillinen_summa += luku\n",
    "    else:\n",
    "        parittomien_summa += luku\n",
    "\n",
    "print(\"Parillisten lukujen summa: \", parillinen_summa)\n",
    "print(\"Parittomien summa: \", parittomien_summa)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "ae9ac612",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "suurin luku listassa:  973\n",
      "pienin luku listassa:  13\n"
     ]
    }
   ],
   "source": [
    "# c) Kirjoita ohjelma, joka tulostaa listan suurimman ja piennimmän luvun.\n",
    "# lista ei ole järjestetty\n",
    "\n",
    "suurin = lista[0]\n",
    "pienin = lista[0]\n",
    "\n",
    "\n",
    "for luku in lista:\n",
    "    if luku < pienin:\n",
    "        pienin = luku\n",
    "    if luku > suurin:\n",
    "        suurin = luku\n",
    "\n",
    "print(\"suurin luku listassa: \", suurin)\n",
    "print(\"pienin luku listassa: \", pienin)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "0eb6a332",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "pienin:  13\n",
      "suurin:  973\n"
     ]
    }
   ],
   "source": [
    "# tarkistus\n",
    "lista.sort()\n",
    "print(\"pienin: \", lista[0])\n",
    "print(\"suurin: \", lista[-1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "6244ef82",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "suurin erotus on 809 kun ollaan listan indeksissä 93\n",
      "48\n",
      "857\n"
     ]
    }
   ],
   "source": [
    "# palataan alkuperäiseen listaan\n",
    "# Kirjoita ohjelma, joka kertoo listan kahden peräkkäisen jäsenen suurimman erotuksen.\n",
    "lista = [932, 168, 876, 250, 426, 231, 554, 105, 888, 684, 639, 131, 140, 382, 479, 402, 125, 264, 286, 290, 205, 944, 761, 735, 611, 646, 908, 438, 852, 937, 397, 503, 591, 736, 734, 124, 434, 952, 269, 13, 164, 161, 128, 170, 646, 200, 331, 946, 590, 973, 569, 784, 778, 358, 463, 712, 283, 357, 959, 598, 518, 853, 305, 767, 44, 135, 175, 407, 677, 749, 714, 517, 766, 346, 488, 687, 338, 375, 341, 582, 912, 389, 224, 326, 561, 106, 756, 709, 445, 106, 727, 258, 671, 48, 857, 69, 171, 840, 335, 696]\n",
    "\n",
    "suurin_erotus = 0\n",
    "kohta = 0\n",
    "\n",
    "for j in range (len(lista)-1):\n",
    "    if suurin_erotus < lista[j+1] - lista[j]:\n",
    "        suurin_erotus = lista[j+1] - lista[j]\n",
    "        kohta = j\n",
    "\n",
    "print(\"suurin erotus on\", suurin_erotus, \"kun ollaan listan indeksissä\", kohta)\n",
    "print(lista[kohta])\n",
    "print(lista[kohta+1])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dd41bc9a",
   "metadata": {},
   "source": [
    "### Tehtävä 3.3\n",
    "Alla tilastomatikan kaavoja käsitteitä.\n",
    "\n",
    "Moodi eli tyyppiarvo on havaintoaineistossa useimmiten esiintyvä arvo.\n",
    "\n",
    "\n",
    "mediaani = Satunnaismuuttujan keskimmäinen arvo, jos arvot lueteltu peräkkäin. Mediaanin kohdalla suhteellinen summafrekvenssi ylittää 50%ia.\n",
    "\n",
    "\n",
    "Alla olevassa koodissa taulukko lkm esittää lukiolaisten päivittäin seuraamien uutissivustojen lukumäärää. Taulukossa frekvenssi on esitetty jakauma miten lukiolaiset vastasivat uutissivustojen lukumäärää selvittävään kyselyyn.\n",
    "\n",
    "Ohjelma tulostaa kuinka monta lukiolaista kyselyyn osallistui. Ohjelma tulostaa seurattujen uutissivustojen lukumäärän tyyppiarvon ja mediaanin ja kuinka moni seurasi suosituinta sivustoa.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "571ddaac",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Osallistujia oli  150 kpl\n"
     ]
    }
   ],
   "source": [
    "# kirjoita vastauksesi tähän\n",
    "lkm = [0, 1, 2, 3, 4]i\n",
    "frekvenssi = [15, 55, 45, 30, 5]\n",
    "\n",
    "# osallistujien lukumäärä tutkimuksessa\n",
    "summa = 0\n",
    "for luku in frekvenssi:\n",
    "    summa += luku\n",
    "print(\"Osallistujia oli \", summa, \"kpl\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "d5faee2c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 1, 1, 1, 1]\n"
     ]
    }
   ],
   "source": [
    "# testi kuinka taulukkoon lisätään alkioita\n",
    "a = []\n",
    "a += 5*[1]\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "id": "08663f6a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4]\n",
      "Mediaani, eli järjesten listan keskimmäinen: 2.0 seurattua uutissivua\n"
     ]
    }
   ],
   "source": [
    "# kerätään vastaukset yhteen listaan\n",
    "vastaukset = []\n",
    "\n",
    "for i in range (len(frekvenssi)):\n",
    "    vastaukset +=[lkm[i]]*frekvenssi[i]\n",
    "    \n",
    "vastaukset.sort()\n",
    "print(vastaukset)\n",
    "\n",
    "keski1 = vastaukset[len(vastaukset) // 2 - 1]\n",
    "keski2 = vastaukset[len(vastaukset) // 2]\n",
    "keski = (keski1 + keski2) / 2\n",
    "print(\"Mediaani, eli järjesten listan keskimmäinen:\", keski, \"seurattua uutissivua\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "id": "8d5a99ab",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Suurin frekvenssi on 55 . Eli eniten seurataa  1 tiktok-kanavaa.\n"
     ]
    }
   ],
   "source": [
    "# etsitään suurin frekvenssi:\n",
    "suurin = 0\n",
    "kohta = 0\n",
    "suurimman_kohta = 0\n",
    "for luku in frekvenssi:\n",
    "    if luku > suurin:\n",
    "        suurin = luku\n",
    "        suurin_kohta = kohta\n",
    "    kohta += 1\n",
    "\n",
    "print(\"Suurin frekvenssi on\", suurin, \". Eli eniten seurataa \", lkm[suurin_kohta],\"tiktok-kanavaa.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6eeb0985",
   "metadata": {},
   "source": [
    "### Tehtävä 3.4\n",
    "Taulukossa on esitetty kahden koulun A ja B arvosanojen jakaumat. Ohjelma laskee arvosanojen keskiarvot molemmissa kouluissa. Ohjelma etsii koulun A parhaimman arvosanan."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "13e3bb8e",
   "metadata": {},
   "outputs": [],
   "source": [
    "# laadi ratkaisusi tähän, voit käyttää alla olevia valmiita muuttujia\n",
    "arvosanat = [10, 9, 8, 7, 6, 5, 4]\n",
    "frekvenssi_A = [0, 12, 27, 29, 4, 9, 0]\n",
    "frekvenssi_B = [24, 28, 32, 16, 7, 17, 1]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e87a931f",
   "metadata": {},
   "source": [
    "### Tehtävä 3.5\n",
    "Ohje: Laske ensin sadepäivien keskiarvo. Todennäiköisyys saadaan laskettua sadepäivien keskiarvon suhteellisena osuutena 31 vuorokaudesta."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0a759c9f",
   "metadata": {},
   "outputs": [],
   "source": [
    "# kirjoita ratkaisusi tähän\n",
    "# muuttuja sadepaivat sisältää sadepäivien määrän 6 kk:n ajanjaksolta\n",
    "sadepaivat = [8, 12, 9, 6, 10, 9]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0cc88ae9",
   "metadata": {},
   "source": [
    "### Funktiot Matematiikassa\n",
    "Matematiikassa funktion voi ajatella olevan operaatio, joka muokkaa lukuja. Operaation jälkeen saadaan uusi luku.\n",
    "\n",
    "$f(x) = x^2$\n",
    "\n",
    "$f(3) = 9$\n",
    "\n",
    "$g(a, b) = a \\cdot b$\n",
    "\n",
    "$g(5, 9) = 5 \\cdot 9 = 45$"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cfda0539",
   "metadata": {},
   "source": [
    "### Pythonissa\n",
    "Myös pythonissa funktio voi olla operaatio, joka muokkaa lukuja. Funktio voi olla kuitenkin paljon monimutkaisempi, koska funktion sisällä voi suorittaa mitä tahansa python-koodia. \n",
    "\n",
    "Pythonissa funktioita voi siis käyttää paljon muuhunkin kuin pelkkään lukujen käsittelyyn. Niillä voi esimerkiksi välttää saman koodin kirjoittamista moneen kertaan.\n",
    "\n",
    "Funktioita voi luoda itse ja niitä on valmiina. Esimerkiksi `print` ja `len` ovat valmiiksi määriteltyjä funktioita.\n",
    "\n",
    "Funktio voi ottaa parametreja ja palauttaa jonkun arvon. Parametreja voi olla mikä tahansa määrä. Funktio voi palauttaa arvon `return`-rakenteella, mutta tämäkään ei ole pakollista."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e0114699",
   "metadata": {},
   "outputs": [],
   "source": [
    "def f(x):\n",
    "    return x ** 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "75a6f0a7",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Funktion f(x) parametriksi asetetaan luku 4 ja tallennetaan funktion palauttama arvo muuttujaan tulos\n",
    "tulos = f(4)\n",
    "print(tulos)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e7c2ccdb",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Funktiolla g on kaksi parametria a ja b\n",
    "def g(a, b):\n",
    "    return a * b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0856243d",
   "metadata": {},
   "outputs": [],
   "source": [
    "tulos = g(4, 10)\n",
    "print(tulos)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3bc7c09c",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Määritellään funktio, mutta ei vielä kutsuta sitä suoritettavaksi. Funktio2 ei palauta mitään\n",
    "# Funktio suoritetaan vasta kun se kutsutaan.\n",
    "def funktio2():\n",
    "    print(\"printataan funktion sisältä\")\n",
    "\n",
    "\n",
    "# Kutsutaan print-funktiota kaksi kertaa\n",
    "print(1)\n",
    "print(2)\n",
    "# Kutsutaan nyt itse määriteltyä funktiota suoritettavaksi\n",
    "funktio2()\n",
    "print(4)\n",
    "funktio2()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6d711aca",
   "metadata": {},
   "source": [
    "## Tehtäviä funktioista\n",
    "\n",
    "### Tehtävä 3.6\n",
    "Tee funktio, joka ottaa parametrikseen luvun ja palauttaa luvun itseisarvon\n",
    "\n",
    "$\\left|x\\right|=\\begin{cases}\n",
    "x&{,}\\ jos\\ x\\ge 0\\\\\n",
    "-x&{,}\\ muuten\n",
    "\\end{cases}$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "41093bd6",
   "metadata": {},
   "outputs": [],
   "source": [
    "# kirjoita koodi tähän"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2ee6df57",
   "metadata": {},
   "source": [
    "### Tehtävä 3.7\n",
    "Kirjoita funktio, joka \n",
    "\n",
    "a) ottaa parametrikseen kaksi lukua ja laskee niiden keskiarvon\n",
    "\n",
    "b) Ottaa parametrikseen listan `[2, 3, 4, 5]` ja laskee sen jäsenten keskiarvon. Listan `[2, 3, 4, 5]` alkioita ovat luvut `2, 3, 4 ja 5`. Alla esimerkki miten voit käydä läpi listan jäsenet `for`-silmukassa."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "82128516",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "3\n",
      "4\n",
      "5\n"
     ]
    }
   ],
   "source": [
    "# listan alkioiden läpikäynti\n",
    "lista = [2,3,4,5]\n",
    "for luku in lista:\n",
    "    print(luku)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6dd9ba1e",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "0beccee0",
   "metadata": {},
   "source": [
    "### Tehtävä 3.8\n",
    "Kirjoita funktio, joka ottaa parametrikseen listan ja palauttaa listan kaikkien lukujen tulon."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "696a34be",
   "metadata": {},
   "outputs": [],
   "source": [
    "# testilista\n",
    "a = [3,2,4,5,6,7,8]\n",
    "def tulo(lista):\n",
    "    tulo = 1\n",
    "    for luku in lista:\n",
    "        tulo = tulo * luku\n",
    "    return tulo\n",
    "print(tulo([3,2,4]))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cfd34076",
   "metadata": {},
   "source": [
    "### Tehtävä 3.9\n",
    "Arvioi numeerinen derivaatta funktioista $f(x) = x^2$, $g(x) = 4x$ ja $s(x) = \\sqrt{x}$ haluamassasi kohdissa. Numeerisen derivaatan voi arvioida kaavalla $\\dfrac{f(x+h)-f(x)}{h}$, kun $h$ on pieni luku."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "992e7370",
   "metadata": {},
   "outputs": [],
   "source": [
    "import math\n",
    "\n",
    "\n",
    "def f(x):\n",
    "    return x ** 2\n",
    "\n",
    "\n",
    "def g(x):\n",
    "    return 4 * x\n",
    "\n",
    "\n",
    "def s(x):\n",
    "    return math.sqrt(x)\n",
    "\n",
    "\n",
    "h = 0.000001\n",
    "x = 1\n",
    "\n",
    "\n",
    "derivaatta = (g(x + h) - g(x)) / h\n",
    "\n",
    "print(\"funktion 4x numeerinen on:\", derivaatta)\n",
    "\n",
    "derivaatta2 = (f(1 + h) - f(1)) / h\n",
    "print(\"funktion f(x) derivaatta kohdassa x=1 on\", derivaatta2)\n",
    "\n",
    "derivaatta3 = (s(2 + h) - s(2)) / h\n",
    "print(\"funktion s(x) derivaatta kohdassa x=2 on\", derivaatta3)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a72ec590",
   "metadata": {},
   "source": [
    "## Rekursio\n",
    "Rekursio tarkoittaa sitä, että funktio kutsuu itseään. Näin saadaan toistorakenne ilman silmukkaa.\n",
    "\n",
    "Yleinen rekursiolla määritelty lukujono on Fibonaccin lukujono. $F_1 = 1, F_2 = 1, F_n = F_{n-1} + F_{n-2}$\n",
    "\n",
    "Pythonissa tämän voi ohjelmoida rekursiivisesti:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3b17426c",
   "metadata": {},
   "outputs": [],
   "source": [
    "def fibonacci(n):\n",
    "    if n == 1:\n",
    "        return 1\n",
    "    if n == 2:\n",
    "        return 1\n",
    "    return fibonacci(n - 1) + fibonacci(n - 2)\n",
    "\n",
    "\n",
    "fibonacci(10)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0983beb2",
   "metadata": {},
   "source": [
    "### Tehtävä 3.10\n",
    "Ohjelmoi kaksi funktiota, joista toinen laskee kertoman rekursiivisesti ja toinen silmukalla. Kertoma on määritelty $n! = n\\cdot(n-1)!$ tai $n! = 1 \\cdot 2\\cdot \\ldots \\cdot n$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4b5424c5",
   "metadata": {},
   "outputs": [],
   "source": [
    "# koodaa tähän"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "05fea8df",
   "metadata": {},
   "source": [
    "### Tehtävä 3.11\n",
    "Lukujonon jäsenet lasketaan rekursiivisesti säännöllä\n",
    "\n",
    "$a_n=a_{n-2}a_{n-1}$ kun $n=3,4, 5...$\n",
    "\n",
    "a) Tutki, lähestyvätkö jonon jäsenet jotain tiettyä lukua, kun $a_1=\\frac{3}{2}$ ja $a_2=\\frac{2}{3}$.\n",
    "\n",
    "b)  $a_1=2$ ja $a_2=\\frac{2}{3}$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ed22f080",
   "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.10.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}