Data-Science-For-Beginners/translations/fi/2-Working-With-Data/08-data-preparation/notebook.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "rQ8UhzFpgRra"
   },
   "source": [
    "# Datan valmistelu\n",
    "\n",
    "[Alkuperäinen muistikirja *Data Science: Introduction to Machine Learning for Data Science Python and Machine Learning Studio by Lee Stott*](https://github.com/leestott/intro-Datascience/blob/master/Course%20Materials/4-Cleaning_and_Manipulating-Reference.ipynb)\n",
    "\n",
    "## `DataFrame`-tietojen tutkiminen\n",
    "\n",
    "> **Oppimistavoite:** Tämän alajakson lopussa sinun pitäisi osata löytää yleistä tietoa pandas DataFrame -tietojen sisällöstä.\n",
    "\n",
    "Kun olet ladannut datasi pandas-kirjastoon, se on todennäköisesti `DataFrame`-muodossa. Mutta jos `DataFrame` sisältää 60 000 riviä ja 400 saraketta, mistä edes aloitat saadaksesi käsityksen siitä, mitä sinulla on käsissäsi? Onneksi pandas tarjoaa käteviä työkaluja, joilla voit nopeasti tarkastella `DataFrame`-kokonaisuuden tietoja sekä sen ensimmäisiä ja viimeisiä rivejä.\n",
    "\n",
    "Tutkiaksemme tätä toiminnallisuutta, tuomme käyttöön Pythonin scikit-learn-kirjaston ja käytämme ikonista datasettiä, jonka jokainen data-analyytikko on nähnyt satoja kertoja: brittiläisen biologin Ronald Fisherin *Iris*-datasetti, jota hän käytti vuonna 1936 julkaistussa artikkelissaan \"The use of multiple measurements in taxonomic problems\":\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": true,
    "id": "hB1RofhdgRrp",
    "trusted": false
   },
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "from sklearn.datasets import load_iris\n",
    "\n",
    "iris = load_iris()\n",
    "iris_df = pd.DataFrame(data=iris['data'], columns=iris['feature_names'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "AGA0A_Y8hMdz"
   },
   "source": [
    "### `DataFrame.shape`\n",
    "Olemme ladanneet Iris-datasarjan muuttujaan `iris_df`. Ennen kuin sukellamme dataan, olisi hyödyllistä tietää, kuinka monta datapistettä meillä on ja mikä on datasarjan kokonaiskoko. On hyödyllistä tarkastella datan määrää, jonka kanssa työskentelemme.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "LOe5jQohhulf",
    "outputId": "fb0577ac-3b4a-4623-cb41-20e1b264b3e9"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(150, 4)"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "iris_df.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "smE7AGzOhxk2"
   },
   "source": [
    "Joten, käsittelemme 150 riviä ja 4 saraketta dataa. Jokainen rivi edustaa yhtä datapistettä, ja jokainen sarake edustaa yhtä ominaisuutta, joka liittyy datafreimiin. Periaatteessa siis on 150 datapistettä, joilla on kukin 4 ominaisuutta.\n",
    "\n",
    "`shape` on tässä datafreimin attribuutti eikä funktio, minkä vuoksi se ei pääty sulkuihin.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "d3AZKs0PinGP"
   },
   "source": [
    "### `DataFrame.columns`\n",
    "Siirrytään nyt neljään datan sarakkeeseen. Mitä kukin niistä tarkalleen ottaen edustaa? `columns`-attribuutti antaa meille dataframeen sisältyvien sarakkeiden nimet.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "YPGh_ziji-CY",
    "outputId": "74e7a43a-77cc-4c80-da56-7f50767c37a0"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Index(['sepal length (cm)', 'sepal width (cm)', 'petal length (cm)',\n",
       "       'petal width (cm)'],\n",
       "      dtype='object')"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "iris_df.columns"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "TsobcU_VjCC_"
   },
   "source": [
    "Kuten voimme nähdä, on neljä (4) saraketta. `columns`-attribuutti kertoo meille sarakkeiden nimet eikä käytännössä mitään muuta. Tämä attribuutti saa merkitystä, kun haluamme tunnistaa, mitä ominaisuuksia datasetti sisältää.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "2UTlvkjmgRrs"
   },
   "source": [
    "### `DataFrame.info`\n",
    "Tietomäärä (annettu `shape`-attribuutilla) ja ominaisuuksien tai sarakkeiden nimet (annettu `columns`-attribuutilla) kertovat jotain datasta. Nyt haluaisimme tutkia datasettiä tarkemmin. `DataFrame.info()`-funktio on tässä erittäin hyödyllinen.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "dHHRyG0_gRrt",
    "outputId": "d8fb0c40-4f18-4e19-da48-c8db77d1d3a5",
    "trusted": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'pandas.core.frame.DataFrame'>\n",
      "RangeIndex: 150 entries, 0 to 149\n",
      "Data columns (total 4 columns):\n",
      " #   Column             Non-Null Count  Dtype  \n",
      "---  ------             --------------  -----  \n",
      " 0   sepal length (cm)  150 non-null    float64\n",
      " 1   sepal width (cm)   150 non-null    float64\n",
      " 2   petal length (cm)  150 non-null    float64\n",
      " 3   petal width (cm)   150 non-null    float64\n",
      "dtypes: float64(4)\n",
      "memory usage: 4.8 KB\n"
     ]
    }
   ],
   "source": [
    "iris_df.info()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "1XgVMpvigRru"
   },
   "source": [
    "Tästä voimme tehdä muutamia havaintoja:\n",
    "1. Jokaisen sarakkeen tietotyyppi: Tässä datassa kaikki tiedot on tallennettu 64-bittisinä liukulukuina.\n",
    "2. Ei-null-arvojen määrä: Null-arvojen käsittely on tärkeä vaihe datan valmistelussa. Tämä käsitellään myöhemmin muistikirjassa.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "IYlyxbpWFEF4"
   },
   "source": [
    "### DataFrame.describe()\n",
    "Oletetaan, että datasetissämme on paljon numeerista dataa. Yksittäisiä tilastollisia laskelmia, kuten keskiarvo, mediaani, kvartiilit jne., voidaan tehdä jokaiselle sarakkeelle erikseen. `DataFrame.describe()`-funktio tarjoaa tilastollisen yhteenvedon datasetin numeerisista sarakkeista.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 297
    },
    "id": "tWV-CMstFIRA",
    "outputId": "4fc49941-bc13-4b0c-a412-cb39e7d3f289"
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>sepal length (cm)</th>\n",
       "      <th>sepal width (cm)</th>\n",
       "      <th>petal length (cm)</th>\n",
       "      <th>petal width (cm)</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>count</th>\n",
       "      <td>150.000000</td>\n",
       "      <td>150.000000</td>\n",
       "      <td>150.000000</td>\n",
       "      <td>150.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>mean</th>\n",
       "      <td>5.843333</td>\n",
       "      <td>3.057333</td>\n",
       "      <td>3.758000</td>\n",
       "      <td>1.199333</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>std</th>\n",
       "      <td>0.828066</td>\n",
       "      <td>0.435866</td>\n",
       "      <td>1.765298</td>\n",
       "      <td>0.762238</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>min</th>\n",
       "      <td>4.300000</td>\n",
       "      <td>2.000000</td>\n",
       "      <td>1.000000</td>\n",
       "      <td>0.100000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>25%</th>\n",
       "      <td>5.100000</td>\n",
       "      <td>2.800000</td>\n",
       "      <td>1.600000</td>\n",
       "      <td>0.300000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>50%</th>\n",
       "      <td>5.800000</td>\n",
       "      <td>3.000000</td>\n",
       "      <td>4.350000</td>\n",
       "      <td>1.300000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>75%</th>\n",
       "      <td>6.400000</td>\n",
       "      <td>3.300000</td>\n",
       "      <td>5.100000</td>\n",
       "      <td>1.800000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>max</th>\n",
       "      <td>7.900000</td>\n",
       "      <td>4.400000</td>\n",
       "      <td>6.900000</td>\n",
       "      <td>2.500000</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "       sepal length (cm)  sepal width (cm)  petal length (cm)  petal width (cm)\n",
       "count         150.000000        150.000000         150.000000        150.000000\n",
       "mean            5.843333          3.057333           3.758000          1.199333\n",
       "std             0.828066          0.435866           1.765298          0.762238\n",
       "min             4.300000          2.000000           1.000000          0.100000\n",
       "25%             5.100000          2.800000           1.600000          0.300000\n",
       "50%             5.800000          3.000000           4.350000          1.300000\n",
       "75%             6.400000          3.300000           5.100000          1.800000\n",
       "max             7.900000          4.400000           6.900000          2.500000"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "iris_df.describe()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "zjjtW5hPGMuM"
   },
   "source": [
    "Yllä oleva tulos näyttää kunkin sarakkeen kokonaisdatapisteiden määrän, keskiarvon, keskihajonnan, minimiarvon, alaneljänneksen (25 %), mediaanin (50 %), yläneljänneksen (75 %) ja maksimiarvon.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "-lviAu99gRrv"
   },
   "source": [
    "### `DataFrame.head`\n",
    "Kaikkien edellä mainittujen funktioiden ja attribuuttien avulla olemme saaneet yleiskuvan datasta. Tiedämme, kuinka monta datapistettä datasetissä on, kuinka monta ominaisuutta siinä on, kunkin ominaisuuden tietotyypin sekä ei-null-arvojen määrän kullekin ominaisuudelle.\n",
    "\n",
    "Nyt on aika tarkastella itse dataa. Katsotaan, miltä ensimmäiset rivit (ensimmäiset datapisteet) `DataFrame`:ssä näyttävät:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 204
    },
    "id": "DZMJZh0OgRrw",
    "outputId": "d9393ee5-c106-4797-f815-218f17160e00",
    "trusted": false
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>sepal length (cm)</th>\n",
       "      <th>sepal width (cm)</th>\n",
       "      <th>petal length (cm)</th>\n",
       "      <th>petal width (cm)</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>5.1</td>\n",
       "      <td>3.5</td>\n",
       "      <td>1.4</td>\n",
       "      <td>0.2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>4.9</td>\n",
       "      <td>3.0</td>\n",
       "      <td>1.4</td>\n",
       "      <td>0.2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>4.7</td>\n",
       "      <td>3.2</td>\n",
       "      <td>1.3</td>\n",
       "      <td>0.2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>4.6</td>\n",
       "      <td>3.1</td>\n",
       "      <td>1.5</td>\n",
       "      <td>0.2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>5.0</td>\n",
       "      <td>3.6</td>\n",
       "      <td>1.4</td>\n",
       "      <td>0.2</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   sepal length (cm)  sepal width (cm)  petal length (cm)  petal width (cm)\n",
       "0                5.1               3.5                1.4               0.2\n",
       "1                4.9               3.0                1.4               0.2\n",
       "2                4.7               3.2                1.3               0.2\n",
       "3                4.6               3.1                1.5               0.2\n",
       "4                5.0               3.6                1.4               0.2"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "iris_df.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "EBHEimZuEFQK"
   },
   "source": [
    "Kun tarkastelemme tässä tulostetta, näemme viisi (5) tietueita datasetistä. Jos katsomme vasemmalla olevaa indeksiä, huomaamme, että nämä ovat datasetin ensimmäiset viisi riviä.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "oj7GkrTdgRry"
   },
   "source": [
    "### Harjoitus:\n",
    "\n",
    "Yllä olevasta esimerkistä käy ilmi, että oletuksena `DataFrame.head` palauttaa `DataFrame`-taulukon ensimmäiset viisi riviä. Voitko alla olevassa koodisolussa keksiä tavan näyttää enemmän kuin viisi riviä?\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": true,
    "id": "EKRmRFFegRrz",
    "trusted": false
   },
   "outputs": [],
   "source": [
    "# Hint: Consult the documentation by using iris_df.head?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "BJ_cpZqNgRr1"
   },
   "source": [
    "### `DataFrame.tail`\n",
    "Toinen tapa tarkastella dataa on sen loppupäästä (alkupään sijaan). `DataFrame.head`-metodin vastakohta on `DataFrame.tail`, joka palauttaa `DataFrame`:n viimeiset viisi riviä:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 0
    },
    "id": "heanjfGWgRr2",
    "outputId": "6ae09a21-fe09-4110-b0d7-1a1fbf34d7f3",
    "trusted": false
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>sepal length (cm)</th>\n",
       "      <th>sepal width (cm)</th>\n",
       "      <th>petal length (cm)</th>\n",
       "      <th>petal width (cm)</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>145</th>\n",
       "      <td>6.7</td>\n",
       "      <td>3.0</td>\n",
       "      <td>5.2</td>\n",
       "      <td>2.3</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>146</th>\n",
       "      <td>6.3</td>\n",
       "      <td>2.5</td>\n",
       "      <td>5.0</td>\n",
       "      <td>1.9</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>147</th>\n",
       "      <td>6.5</td>\n",
       "      <td>3.0</td>\n",
       "      <td>5.2</td>\n",
       "      <td>2.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>148</th>\n",
       "      <td>6.2</td>\n",
       "      <td>3.4</td>\n",
       "      <td>5.4</td>\n",
       "      <td>2.3</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>149</th>\n",
       "      <td>5.9</td>\n",
       "      <td>3.0</td>\n",
       "      <td>5.1</td>\n",
       "      <td>1.8</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "     sepal length (cm)  sepal width (cm)  petal length (cm)  petal width (cm)\n",
       "145                6.7               3.0                5.2               2.3\n",
       "146                6.3               2.5                5.0               1.9\n",
       "147                6.5               3.0                5.2               2.0\n",
       "148                6.2               3.4                5.4               2.3\n",
       "149                5.9               3.0                5.1               1.8"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "iris_df.tail()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "31kBWfyLgRr3"
   },
   "source": [
    "Käytännössä on hyödyllistä pystyä helposti tarkastelemaan `DataFrame`-taulukon ensimmäisiä tai viimeisiä rivejä, erityisesti silloin, kun etsit poikkeamia järjestetyistä aineistoista.\n",
    "\n",
    "Kaikki yllä esitetyt funktiot ja attribuutit, joita havainnollistettiin koodiesimerkkien avulla, auttavat meitä saamaan käsityksen datasta.\n",
    "\n",
    "> **Yhteenveto:** Jo pelkästään tarkastelemalla metatietoja `DataFrame`-taulukon sisällöstä tai sen ensimmäisiä ja viimeisiä arvoja, voit nopeasti saada käsityksen datan koosta, muodosta ja sisällöstä, jonka kanssa työskentelet.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "TvurZyLSDxq_"
   },
   "source": [
    "### Puuttuvat Tiedot\n",
    "Tutustutaan puuttuviin tietoihin. Puuttuvat tiedot syntyvät, kun joissakin sarakkeissa ei ole tallennettu arvoa.\n",
    "\n",
    "Otetaan esimerkki: joku on hyvin tarkka painostaan eikä täytä painokenttää kyselyssä. Tällöin kyseisen henkilön painoarvo jää puuttumaan.\n",
    "\n",
    "Useimmiten todellisissa maailmankokoelmissa esiintyy puuttuvia arvoja.\n",
    "\n",
    "**Kuinka Pandas käsittelee puuttuvia tietoja**\n",
    "\n",
    "Pandas käsittelee puuttuvia arvoja kahdella tavalla. Ensimmäinen tapa, jonka olet nähnyt aiemmissa osioissa, on `NaN`, eli Not a Number. Tämä on itse asiassa erityinen arvo, joka kuuluu IEEE:n liukulukumäärittelyyn, ja sitä käytetään vain puuttuvien liukulukuarvojen merkitsemiseen.\n",
    "\n",
    "Liukulukuja lukuun ottamatta puuttuvien arvojen kohdalla pandas käyttää Pythonin `None`-objektia. Vaikka voi tuntua hämmentävältä, että kohtaat kaksi erilaista arvoa, jotka periaatteessa tarkoittavat samaa asiaa, tälle suunnitteluratkaisulle on hyvät ohjelmalliset syyt. Käytännössä tämä lähestymistapa mahdollistaa sen, että pandas tarjoaa hyvän kompromissin valtaosassa tapauksista. Tästä huolimatta sekä `None` että `NaN` sisältävät rajoituksia, jotka sinun tulee ottaa huomioon niiden käyttöä koskien.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "lOHqUlZFgRr5"
   },
   "source": [
    "### `None`: ei-kelluva puuttuva data\n",
    "Koska `None` tulee Pythonista, sitä ei voida käyttää NumPy- ja pandas-taulukoissa, joiden tietotyyppi ei ole `'object'`. Muista, että NumPy-taulukot (ja pandas-tietorakenteet) voivat sisältää vain yhtä tietotyyppiä. Tämä ominaisuus antaa niille valtavan tehon suurten datamäärien ja laskentatyön käsittelyssä, mutta samalla se rajoittaa niiden joustavuutta. Tällaiset taulukot täytyy muuntaa \"pienimpään yhteiseen nimittäjään\", eli tietotyyppiin, joka kattaa kaiken taulukossa olevan. Kun taulukossa on `None`, se tarkoittaa, että työskentelet Python-objektien kanssa.\n",
    "\n",
    "Tarkastellaan tätä käytännössä seuraavan esimerkkitaulukon avulla (huomaa sen `dtype`):\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "QIoNdY4ngRr7",
    "outputId": "92779f18-62f4-4a03-eca2-e9a101604336",
    "trusted": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([2, None, 6, 8], dtype=object)"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import numpy as np\n",
    "\n",
    "example1 = np.array([2, None, 6, 8])\n",
    "example1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "pdlgPNbhgRr7"
   },
   "source": [
    "Upcast-tyyppien todellisuudella on kaksi sivuvaikutusta. Ensinnäkin operaatiot suoritetaan tulkitun Python-koodin tasolla sen sijaan, että ne suoritettaisiin käännetyn NumPy-koodin tasolla. Käytännössä tämä tarkoittaa, että kaikki operaatiot, jotka koskevat `Series`- tai `DataFrame`-objekteja, joissa on `None`, ovat hitaampia. Vaikka et todennäköisesti huomaisi tätä suorituskyvyn heikkenemistä, suurten tietoaineistojen kohdalla siitä saattaa tulla ongelma.\n",
    "\n",
    "Toinen sivuvaikutus johtuu ensimmäisestä. Koska `None` käytännössä vetää `Series`- tai `DataFrame`-objektit takaisin perinteisen Pythonin maailmaan, NumPy/pandas-yhteenvedot, kuten `sum()` tai `min()`, taulukoissa, jotka sisältävät ``None``-arvon, tuottavat yleensä virheen:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 292
    },
    "id": "gWbx-KB9gRr8",
    "outputId": "ecba710a-22ec-41d5-a39c-11f67e645b50",
    "trusted": false
   },
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "ignored",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-10-ce9901ad18bd>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mexample1\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msum\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/numpy/core/_methods.py\u001b[0m in \u001b[0;36m_sum\u001b[0;34m(a, axis, dtype, out, keepdims, initial, where)\u001b[0m\n\u001b[1;32m     45\u001b[0m def _sum(a, axis=None, dtype=None, out=None, keepdims=False,\n\u001b[1;32m     46\u001b[0m          initial=_NoValue, where=True):\n\u001b[0;32m---> 47\u001b[0;31m     \u001b[0;32mreturn\u001b[0m \u001b[0mumr_sum\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0ma\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0maxis\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdtype\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mkeepdims\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0minitial\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mwhere\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     48\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     49\u001b[0m def _prod(a, axis=None, dtype=None, out=None, keepdims=False,\n",
      "\u001b[0;31mTypeError\u001b[0m: unsupported operand type(s) for +: 'int' and 'NoneType'"
     ]
    }
   ],
   "source": [
    "example1.sum()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "LcEwO8UogRr9"
   },
   "source": [
    "**Keskeinen huomio**: Kokonaislukujen ja `None`-arvojen välinen yhteenlasku (sekä muut operaatiot) on määrittelemätön, mikä voi rajoittaa sitä, mitä voit tehdä niitä sisältävien tietojoukkojen kanssa.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "pWvVHvETgRr9"
   },
   "source": [
    "### `NaN`: puuttuvat liukuluvut\n",
    "\n",
    "Toisin kuin `None`, NumPy (ja siten pandas) tukee `NaN`:ia nopeiden, vektorisoitujen operaatioiden ja ufuncien avulla. Huono uutinen on, että kaikki aritmeettiset laskutoimitukset, jotka tehdään `NaN`:illa, tuottavat aina `NaN`:in. Esimerkiksi:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "rcFYfMG9gRr9",
    "outputId": "699e81b7-5c11-4b46-df1d-06071768690f",
    "trusted": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "nan"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.nan + 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "BW3zQD2-gRr-",
    "outputId": "4525b6c4-495d-4f7b-a979-efce1dae9bd0",
    "trusted": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "nan"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.nan * 0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "fU5IPRcCgRr-"
   },
   "source": [
    "Hyvät uutiset: aggregoinnit, jotka suoritetaan `NaN`-arvoja sisältävillä taulukoilla, eivät aiheuta virheitä. Huonot uutiset: tulokset eivät ole tasaisesti hyödyllisiä:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "LCInVgSSgRr_",
    "outputId": "fa06495a-0930-4867-87c5-6023031ea8b5",
    "trusted": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(nan, nan, nan)"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "example2 = np.array([2, np.nan, 6, 8]) \n",
    "example2.sum(), example2.min(), example2.max()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "nhlnNJT7gRr_"
   },
   "source": [
    "### Harjoitus:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": true,
    "id": "yan3QRaOgRr_",
    "trusted": false
   },
   "outputs": [],
   "source": [
    "# What happens if you add np.nan and None together?\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "_iDvIRC8gRsA"
   },
   "source": [
    "Muista: `NaN` on vain puuttuvia liukulukuja varten; ei ole `NaN`-vastinetta kokonaisluvuille, merkkijonoille tai totuusarvoille.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "kj6EKdsAgRsA"
   },
   "source": [
    "### `NaN` ja `None`: nollaarvot pandas-kirjastossa\n",
    "\n",
    "Vaikka `NaN` ja `None` voivat käyttäytyä hieman eri tavoin, pandas-kirjasto on kuitenkin suunniteltu käsittelemään niitä keskenään vaihdettavina. Katsotaanpa, mitä tämä tarkoittaa, tarkastelemalla kokonaislukujen `Series`-sarjaa:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "Nji-KGdNgRsA",
    "outputId": "36aa14d2-8efa-4bfd-c0ed-682991288822",
    "trusted": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0    1\n",
       "1    2\n",
       "2    3\n",
       "dtype: int64"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "int_series = pd.Series([1, 2, 3], dtype=int)\n",
    "int_series"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "WklCzqb8gRsB"
   },
   "source": [
    "### Harjoitus:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "collapsed": true,
    "id": "Cy-gqX5-gRsB",
    "trusted": false
   },
   "outputs": [],
   "source": [
    "# Now set an element of int_series equal to None.\n",
    "# How does that element show up in the Series?\n",
    "# What is the dtype of the Series?\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "WjMQwltNgRsB"
   },
   "source": [
    "Pandasissa tietotyyppien ylöspäin muuntamisen yhteydessä, kun pyritään luomaan tietojen yhtenäisyyttä `Series`- ja `DataFrame`-objekteissa, puuttuvat arvot voivat vaihtua joustavasti `None`- ja `NaN`-arvojen välillä. Tämän suunnitteluominaisuuden vuoksi voi olla hyödyllistä ajatella `None`- ja `NaN`-arvoja kahtena eri \"null\"-tyyppinä pandasissa. Itse asiassa jotkut keskeisistä menetelmistä, joita käytät puuttuvien arvojen käsittelyyn pandasissa, heijastavat tätä ajatusta nimissään:\n",
    "\n",
    "- `isnull()`: Luo Boolean-maskin, joka osoittaa puuttuvat arvot\n",
    "- `notnull()`: `isnull()`-menetelmän vastakohta\n",
    "- `dropna()`: Palauttaa suodatetun version datasta\n",
    "- `fillna()`: Palauttaa kopion datasta, jossa puuttuvat arvot on täytetty tai imputoitu\n",
    "\n",
    "Nämä menetelmät ovat tärkeitä hallita ja tuntea hyvin, joten käydään ne läpi yksityiskohtaisemmin.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "Yh5ifd9FgRsB"
   },
   "source": [
    "### Null-arvojen havaitseminen\n",
    "\n",
    "Kun olemme ymmärtäneet puuttuvien arvojen merkityksen, meidän täytyy havaita ne aineistossamme ennen niiden käsittelyä. Sekä `isnull()` että `notnull()` ovat ensisijaisia menetelmiä null-arvojen havaitsemiseen. Molemmat palauttavat Boolean-maskit aineistosi yli.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "collapsed": true,
    "id": "e-vFp5lvgRsC",
    "trusted": false
   },
   "outputs": [],
   "source": [
    "example3 = pd.Series([0, np.nan, '', None])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "1XdaJJ7PgRsC",
    "outputId": "92fc363a-1874-471f-846d-f4f9ce1f51d0",
    "trusted": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0    False\n",
       "1     True\n",
       "2    False\n",
       "3     True\n",
       "dtype: bool"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "example3.isnull()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "PaSZ0SQygRsC"
   },
   "source": [
    "Katso tarkasti tulosta. Yllättääkö jokin siinä? Vaikka `0` on aritmeettinen nolla, se on silti täysin kelvollinen kokonaisluku, ja pandas käsittelee sitä sellaisena. `''` on hieman hienovaraisempi tapaus. Vaikka käytimme sitä osassa 1 edustamaan tyhjää merkkijonoarvoa, se on silti merkkijono-objekti eikä pandasissa null-arvon edustaja.\n",
    "\n",
    "Käännetäänpä tämä nyt toisin päin ja käytetään näitä menetelmiä enemmän sillä tavalla, kuin niitä käytetään käytännössä. Voit käyttää Boolen maskeja suoraan ``Series``- tai ``DataFrame``-indeksinä, mikä voi olla hyödyllistä, kun yrität käsitellä eristettyjä puuttuvia (tai olemassa olevia) arvoja.\n",
    "\n",
    "Jos haluamme puuttuvien arvojen kokonaismäärän, voimme yksinkertaisesti laskea yhteen maskin, jonka `isnull()`-metodi tuottaa.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "JCcQVoPkHDUv",
    "outputId": "001daa72-54f8-4bd5-842a-4df627a79d4d"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "example3.isnull().sum()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "PlBqEo3mgRsC"
   },
   "source": [
    "### Harjoitus:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "collapsed": true,
    "id": "ggDVf5uygRsD",
    "trusted": false
   },
   "outputs": [],
   "source": [
    "# Try running example3[example3.notnull()].\n",
    "# Before you do so, what do you expect to see?\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "D_jWN7mHgRsD"
   },
   "source": [
    "**Keskeinen huomio**: Sekä `isnull()`- että `notnull()`-menetelmät tuottavat samanlaisia tuloksia, kun käytät niitä DataFrameissa: ne näyttävät tulokset ja niiden indeksit, mikä auttaa sinua valtavasti, kun käsittelet dataasi.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "BvnoojWsgRr4"
   },
   "source": [
    "### Puuttuvien tietojen käsittely\n",
    "\n",
    "> **Oppimistavoite:** Tämän alajakson lopussa sinun tulisi tietää, miten ja milloin korvata tai poistaa puuttuvat arvot DataFrameista.\n",
    "\n",
    "Koneoppimismallit eivät pysty käsittelemään puuttuvia tietoja itsestään. Siksi ennen datan syöttämistä malliin meidän täytyy käsitellä nämä puuttuvat arvot.\n",
    "\n",
    "Puuttuvien tietojen käsittelyyn liittyy hienovaraisia kompromisseja, jotka voivat vaikuttaa lopulliseen analyysiin ja tosielämän tuloksiin.\n",
    "\n",
    "Puuttuvien tietojen käsittelyyn on pääasiassa kaksi tapaa:\n",
    "\n",
    "1.   Poista rivi, joka sisältää puuttuvan arvon\n",
    "2.   Korvaa puuttuva arvo jollakin muulla arvolla\n",
    "\n",
    "Käsittelemme molempia menetelmiä ja niiden etuja ja haittoja yksityiskohtaisesti.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "3VaYC1TvgRsD"
   },
   "source": [
    "### Null-arvojen poistaminen\n",
    "\n",
    "Mallillemme syötettävän datan määrä vaikuttaa suoraan sen suorituskykyyn. Null-arvojen poistaminen tarkoittaa, että vähennämme datapisteiden määrää ja siten pienennämme datasetin kokoa. Siksi on suositeltavaa poistaa rivit, joissa on null-arvoja, kun datasetti on melko suuri.\n",
    "\n",
    "Toinen tilanne voi olla, että tietyssä rivissä tai sarakkeessa on paljon puuttuvia arvoja. Tällöin ne voidaan poistaa, koska ne eivät todennäköisesti tuo paljon lisäarvoa analyysillemme, kun suurin osa datasta puuttuu kyseiseltä riviltä tai sarakkeelta.\n",
    "\n",
    "Sen lisäksi, että tunnistetaan puuttuvat arvot, pandas tarjoaa kätevän tavan poistaa null-arvoja `Series`- ja `DataFrame`-objekteista. Katsotaanpa tätä käytännössä palaamalla `example3`:een. `DataFrame.dropna()`-funktio auttaa poistamaan rivit, joissa on null-arvoja.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "7uIvS097gRsD",
    "outputId": "c13fc117-4ca1-4145-a0aa-42ac89e6e218",
    "trusted": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0    0\n",
       "2     \n",
       "dtype: object"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "example3 = example3.dropna()\n",
    "example3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "hil2cr64gRsD"
   },
   "source": [
    "Huomaa, että tämän pitäisi näyttää samalta kuin tulos `example3[example3.notnull()]`. Erona tässä on, että sen sijaan, että vain indeksoitaisiin maskattuja arvoja, `dropna` on poistanut puuttuvat arvot `Series`-objektista `example3`.\n",
    "\n",
    "Koska DataFrame-objekteilla on kaksi ulottuvuutta, ne tarjoavat enemmän vaihtoehtoja datan poistamiseen.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 142
    },
    "id": "an-l74sPgRsE",
    "outputId": "340876a0-63ad-40f6-bd54-6240cdae50ab",
    "trusted": false
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>0</th>\n",
       "      <th>1</th>\n",
       "      <th>2</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>1.0</td>\n",
       "      <td>NaN</td>\n",
       "      <td>7</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>2.0</td>\n",
       "      <td>5.0</td>\n",
       "      <td>8</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>NaN</td>\n",
       "      <td>6.0</td>\n",
       "      <td>9</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "     0    1  2\n",
       "0  1.0  NaN  7\n",
       "1  2.0  5.0  8\n",
       "2  NaN  6.0  9"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "example4 = pd.DataFrame([[1,      np.nan, 7], \n",
    "                         [2,      5,      8], \n",
    "                         [np.nan, 6,      9]])\n",
    "example4"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "66wwdHZrgRsE"
   },
   "source": [
    "(Huomasitko, että pandas muutti kaksi saraketta liukuluvuiksi voidakseen käsitellä `NaN`-arvoja?)\n",
    "\n",
    "Et voi poistaa yksittäistä arvoa `DataFrame`-rakenteesta, joten sinun täytyy poistaa kokonaisia rivejä tai sarakkeita. Riippuen siitä, mitä olet tekemässä, saatat haluta tehdä jomman kumman, ja siksi pandas tarjoaa vaihtoehdot molempiin. Koska data-analytiikassa sarakkeet yleensä edustavat muuttujia ja rivit havaintoja, on todennäköisempää, että poistat rivejä datasta; `dropna()`-toiminnon oletusasetuksena on poistaa kaikki rivit, jotka sisältävät minkä tahansa null-arvon:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 80
    },
    "id": "jAVU24RXgRsE",
    "outputId": "0b5e5aee-7187-4d3f-b583-a44136ae5f80",
    "trusted": false
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>0</th>\n",
       "      <th>1</th>\n",
       "      <th>2</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>2.0</td>\n",
       "      <td>5.0</td>\n",
       "      <td>8</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "     0    1  2\n",
       "1  2.0  5.0  8"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "example4.dropna()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "TrQRBuTDgRsE"
   },
   "source": [
    "Jos tarpeen, voit poistaa NA-arvot sarakkeista. Käytä `axis=1` tätä varten:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 142
    },
    "id": "GrBhxu9GgRsE",
    "outputId": "ff4001f3-2e61-4509-d60e-0093d1068437",
    "trusted": false
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>2</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>7</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>8</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>9</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   2\n",
       "0  7\n",
       "1  8\n",
       "2  9"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "example4.dropna(axis='columns')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "KWXiKTfMgRsF"
   },
   "source": [
    "Huomaa, että tämä voi poistaa paljon dataa, jonka haluaisit säilyttää, erityisesti pienemmissä aineistoissa. Entä jos haluat poistaa vain rivit tai sarakkeet, jotka sisältävät useita tai jopa kaikki null-arvot? Voit määrittää nämä asetukset `dropna`-metodissa käyttämällä `how`- ja `thresh`-parametreja.\n",
    "\n",
    "Oletuksena `how='any'` (jos haluat tarkistaa itse tai nähdä, mitä muita parametreja metodilla on, suorita `example4.dropna?` koodisolussa). Voit vaihtoehtoisesti määrittää `how='all'`, jolloin poistetaan vain rivit tai sarakkeet, jotka sisältävät kaikki null-arvot. Laajennetaan esimerkkimme `DataFrame`-taulukkoa, jotta näet tämän toiminnassa seuraavassa harjoituksessa.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 142
    },
    "id": "Bcf_JWTsgRsF",
    "outputId": "72e0b1b8-52fa-4923-98ce-b6fbed6e44b1",
    "trusted": false
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>0</th>\n",
       "      <th>1</th>\n",
       "      <th>2</th>\n",
       "      <th>3</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>1.0</td>\n",
       "      <td>NaN</td>\n",
       "      <td>7</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>2.0</td>\n",
       "      <td>5.0</td>\n",
       "      <td>8</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>NaN</td>\n",
       "      <td>6.0</td>\n",
       "      <td>9</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "     0    1  2   3\n",
       "0  1.0  NaN  7 NaN\n",
       "1  2.0  5.0  8 NaN\n",
       "2  NaN  6.0  9 NaN"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "example4[3] = np.nan\n",
    "example4"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "pNZer7q9JPNC"
   },
   "source": [
    "> Keskeiset huomiot:  \n",
    "1. Puuttuvien arvojen poistaminen on hyvä idea vain, jos tietojoukko on riittävän suuri.  \n",
    "2. Kokonaisia rivejä tai sarakkeita voidaan poistaa, jos suurin osa niiden tiedoista puuttuu.  \n",
    "3. `DataFrame.dropna(axis=)`-metodi auttaa puuttuvien arvojen poistamisessa. `axis`-argumentti määrittää, poistetaanko rivejä vai sarakkeita.  \n",
    "4. `how`-argumenttia voidaan myös käyttää. Oletuksena se on asetettu arvoon `any`, jolloin poistetaan vain ne rivit/sarakkeet, joissa on mitä tahansa puuttuvia arvoja. Sen voi asettaa arvoon `all`, jolloin poistetaan vain ne rivit/sarakkeet, joissa kaikki arvot ovat puuttuvia.  \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "oXXSfQFHgRsF"
   },
   "source": [
    "### Harjoitus:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "collapsed": true,
    "id": "ExUwQRxpgRsF",
    "trusted": false
   },
   "outputs": [],
   "source": [
    "# How might you go about dropping just column 3?\n",
    "# Hint: remember that you will need to supply both the axis parameter and the how parameter.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "38kwAihWgRsG"
   },
   "source": [
    "`thresh`-parametri antaa sinulle tarkemman hallinnan: asetat rivin tai sarakkeen tarvitsemien *ei-null* arvojen määrän, jotta se säilytetään:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 80
    },
    "id": "M9dCNMaagRsG",
    "outputId": "8093713a-54d2-4e54-c73f-4eea315cb6f2",
    "trusted": false
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>0</th>\n",
       "      <th>1</th>\n",
       "      <th>2</th>\n",
       "      <th>3</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>2.0</td>\n",
       "      <td>5.0</td>\n",
       "      <td>8</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "     0    1  2   3\n",
       "1  2.0  5.0  8 NaN"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "example4.dropna(axis='rows', thresh=3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "fmSFnzZegRsG"
   },
   "source": [
    "Tässä ensimmäinen ja viimeinen rivi on pudotettu, koska ne sisältävät vain kaksi ei-null-arvoa.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "mCcxLGyUgRsG"
   },
   "source": [
    "### Puuttuvien arvojen täyttäminen\n",
    "\n",
    "Joskus voi olla järkevää korvata puuttuvat arvot sellaisilla, jotka voisivat olla päteviä. Puuttuvien arvojen täyttämiseen on muutamia tekniikoita. Ensimmäinen on käyttää alakohtaista tietämystä (tietoa aiheesta, johon datasetti perustuu) arvioimaan puuttuvat arvot jollain tavalla.\n",
    "\n",
    "Voit käyttää `isnull`-metodia tähän suoraan, mutta se voi olla työlästä, erityisesti jos täytettäviä arvoja on paljon. Koska tämä on niin yleinen tehtävä datatieteessä, pandas tarjoaa `fillna`-metodin, joka palauttaa kopion `Series`- tai `DataFrame`-objektista, jossa puuttuvat arvot on korvattu valitsemallasi arvolla. Luodaan toinen esimerkki `Series`-objekti, jotta nähdään, miten tämä toimii käytännössä.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "CE8S7louLezV"
   },
   "source": [
    "### Kategorinen data (ei-numeerinen)\n",
    "Aloitetaan tarkastelemalla ei-numeerista dataa. Datoissa on usein sarakkeita, joissa on kategorista dataa, kuten sukupuoli, Totta tai Epätotta jne.\n",
    "\n",
    "Useimmissa tapauksissa puuttuvat arvot korvataan sarakkeen `moodilla`. Esimerkiksi, jos meillä on 100 datapistettä, joista 90 on vastannut Totta, 8 Epätotta ja 2 jättänyt vastaamatta, voimme täyttää nämä 2 puuttuvaa arvoa Totta, ottaen huomioon koko sarakkeen.\n",
    "\n",
    "Tässäkin voimme hyödyntää asiantuntemusta. Tarkastellaan esimerkkiä, jossa täytämme puuttuvat arvot moodilla.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 204
    },
    "id": "MY5faq4yLdpQ",
    "outputId": "19ab472e-1eed-4de8-f8a7-db2a3af3cb1a"
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>0</th>\n",
       "      <th>1</th>\n",
       "      <th>2</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>1</td>\n",
       "      <td>2</td>\n",
       "      <td>True</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>3</td>\n",
       "      <td>4</td>\n",
       "      <td>None</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>5</td>\n",
       "      <td>6</td>\n",
       "      <td>False</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>7</td>\n",
       "      <td>8</td>\n",
       "      <td>True</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>9</td>\n",
       "      <td>10</td>\n",
       "      <td>True</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   0   1      2\n",
       "0  1   2   True\n",
       "1  3   4   None\n",
       "2  5   6  False\n",
       "3  7   8   True\n",
       "4  9  10   True"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fill_with_mode = pd.DataFrame([[1,2,\"True\"],\n",
    "                               [3,4,None],\n",
    "                               [5,6,\"False\"],\n",
    "                               [7,8,\"True\"],\n",
    "                               [9,10,\"True\"]])\n",
    "\n",
    "fill_with_mode"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "MLAoMQOfNPlA"
   },
   "source": [
    "Nyt, etsitään ensin moodi ennen kuin täytetään `None`-arvo moodilla.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "WKy-9Y2tN5jv",
    "outputId": "8da9fa16-e08c-447e-dea1-d4b1db2feebf"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True     3\n",
       "False    1\n",
       "Name: 2, dtype: int64"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fill_with_mode[2].value_counts()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "6iNz_zG_OKrx"
   },
   "source": [
    "Joten, korvaamme None arvolla True\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "id": "TxPKteRvNPOs"
   },
   "outputs": [],
   "source": [
    "fill_with_mode[2].fillna('True',inplace=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 204
    },
    "id": "tvas7c9_OPWE",
    "outputId": "ec3c8e44-d644-475e-9e22-c65101965850"
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>0</th>\n",
       "      <th>1</th>\n",
       "      <th>2</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>1</td>\n",
       "      <td>2</td>\n",
       "      <td>True</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>3</td>\n",
       "      <td>4</td>\n",
       "      <td>True</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>5</td>\n",
       "      <td>6</td>\n",
       "      <td>False</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>7</td>\n",
       "      <td>8</td>\n",
       "      <td>True</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>9</td>\n",
       "      <td>10</td>\n",
       "      <td>True</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   0   1      2\n",
       "0  1   2   True\n",
       "1  3   4   True\n",
       "2  5   6  False\n",
       "3  7   8   True\n",
       "4  9  10   True"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fill_with_mode"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "SktitLxxOR16"
   },
   "source": [
    "Kuten voimme nähdä, null-arvo on korvattu. Tarpeetonta sanoa, että olisimme voineet kirjoittaa mitä tahansa `'True'`-paikalle, ja se olisi tullut korvatuksi.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "heYe1I0dOmQ_"
   },
   "source": [
    "### Numeerinen data\n",
    "Siirrytään nyt numeeriseen dataan. Tässä on kaksi yleistä tapaa korvata puuttuvat arvot:\n",
    "\n",
    "1. Korvaa rivin mediaanilla  \n",
    "2. Korvaa rivin keskiarvolla  \n",
    "\n",
    "Käytämme mediaania, kun data on vinoutunutta ja sisältää poikkeavia arvoja. Tämä johtuu siitä, että mediaani on kestävä poikkeamille.\n",
    "\n",
    "Kun data on normalisoitu, voimme käyttää keskiarvoa, koska siinä tapauksessa keskiarvo ja mediaani ovat melko lähellä toisiaan.\n",
    "\n",
    "Otetaan ensin sarake, joka on normaalijakautunut, ja täytetään puuttuva arvo sarakkeen keskiarvolla.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 204
    },
    "id": "09HM_2feOj5Y",
    "outputId": "7e309013-9acb-411c-9b06-4de795bbeeff"
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>0</th>\n",
       "      <th>1</th>\n",
       "      <th>2</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>-2.0</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>-1.0</td>\n",
       "      <td>2</td>\n",
       "      <td>3</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>NaN</td>\n",
       "      <td>4</td>\n",
       "      <td>5</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>1.0</td>\n",
       "      <td>6</td>\n",
       "      <td>7</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>2.0</td>\n",
       "      <td>8</td>\n",
       "      <td>9</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "     0  1  2\n",
       "0 -2.0  0  1\n",
       "1 -1.0  2  3\n",
       "2  NaN  4  5\n",
       "3  1.0  6  7\n",
       "4  2.0  8  9"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fill_with_mean = pd.DataFrame([[-2,0,1],\n",
    "                               [-1,2,3],\n",
    "                               [np.nan,4,5],\n",
    "                               [1,6,7],\n",
    "                               [2,8,9]])\n",
    "\n",
    "fill_with_mean"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "ka7-wNfzSxbx"
   },
   "source": [
    "Sarakkeen keskiarvo on\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "XYtYEf5BSxFL",
    "outputId": "68a78d18-f0e5-4a9a-a959-2c3676a57c70"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.0"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.mean(fill_with_mean[0])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "oBSRGxKRS39K"
   },
   "source": [
    "Täyttö keskiarvolla\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 204
    },
    "id": "FzncQLmuS5jh",
    "outputId": "00f74fff-01f4-4024-c261-796f50f01d2e"
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>0</th>\n",
       "      <th>1</th>\n",
       "      <th>2</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>-2.0</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>-1.0</td>\n",
       "      <td>2</td>\n",
       "      <td>3</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>0.0</td>\n",
       "      <td>4</td>\n",
       "      <td>5</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>1.0</td>\n",
       "      <td>6</td>\n",
       "      <td>7</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>2.0</td>\n",
       "      <td>8</td>\n",
       "      <td>9</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "     0  1  2\n",
       "0 -2.0  0  1\n",
       "1 -1.0  2  3\n",
       "2  0.0  4  5\n",
       "3  1.0  6  7\n",
       "4  2.0  8  9"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fill_with_mean[0].fillna(np.mean(fill_with_mean[0]),inplace=True)\n",
    "fill_with_mean"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "CwpVFCrPTC5z"
   },
   "source": [
    "Kuten voimme nähdä, puuttuva arvo on korvattu sen keskiarvolla.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "jIvF13a1i00Z"
   },
   "source": [
    "Nyt kokeillaan toista dataframea, ja tällä kertaa korvaamme None-arvot sarakkeen mediaanilla.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 204
    },
    "id": "DA59Bqo3jBYZ",
    "outputId": "85dae6ec-7394-4c36-fda0-e04769ec4a32"
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>0</th>\n",
       "      <th>1</th>\n",
       "      <th>2</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>-2</td>\n",
       "      <td>0.0</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>-1</td>\n",
       "      <td>2.0</td>\n",
       "      <td>3</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>0</td>\n",
       "      <td>NaN</td>\n",
       "      <td>5</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>1</td>\n",
       "      <td>6.0</td>\n",
       "      <td>7</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>2</td>\n",
       "      <td>8.0</td>\n",
       "      <td>9</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   0    1  2\n",
       "0 -2  0.0  1\n",
       "1 -1  2.0  3\n",
       "2  0  NaN  5\n",
       "3  1  6.0  7\n",
       "4  2  8.0  9"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fill_with_median = pd.DataFrame([[-2,0,1],\n",
    "                               [-1,2,3],\n",
    "                               [0,np.nan,5],\n",
    "                               [1,6,7],\n",
    "                               [2,8,9]])\n",
    "\n",
    "fill_with_median"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "mM1GpXYmjHnc"
   },
   "source": [
    "Toisen sarakkeen mediaani on\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "uiDy5v3xjHHX",
    "outputId": "564b6b74-2004-4486-90d4-b39330a64b88"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4.0"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fill_with_median[1].median()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "z9PLF75Jj_1s"
   },
   "source": [
    "Täyttö mediaanilla\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 204
    },
    "id": "lFKbOxCMkBbg",
    "outputId": "a8bd18fb-2765-47d4-e5fe-e965f57ed1f4"
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>0</th>\n",
       "      <th>1</th>\n",
       "      <th>2</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>-2</td>\n",
       "      <td>0.0</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>-1</td>\n",
       "      <td>2.0</td>\n",
       "      <td>3</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>0</td>\n",
       "      <td>4.0</td>\n",
       "      <td>5</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>1</td>\n",
       "      <td>6.0</td>\n",
       "      <td>7</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>2</td>\n",
       "      <td>8.0</td>\n",
       "      <td>9</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   0    1  2\n",
       "0 -2  0.0  1\n",
       "1 -1  2.0  3\n",
       "2  0  4.0  5\n",
       "3  1  6.0  7\n",
       "4  2  8.0  9"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fill_with_median[1].fillna(fill_with_median[1].median(),inplace=True)\n",
    "fill_with_median"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "8JtQ53GSkKWC"
   },
   "source": [
    "Kuten voimme nähdä, NaN-arvo on korvattu sarakkeen mediaanilla\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "0ybtWLDdgRsG",
    "outputId": "b8c238ef-6024-4ee2-be2b-aa1f0fcac61d",
    "trusted": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "a    1.0\n",
       "b    NaN\n",
       "c    2.0\n",
       "d    NaN\n",
       "e    3.0\n",
       "dtype: float64"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "example5 = pd.Series([1, np.nan, 2, None, 3], index=list('abcde'))\n",
    "example5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "yrsigxRggRsH"
   },
   "source": [
    "Voit täyttää kaikki tyhjät kentät yhdellä arvolla, kuten `0`:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "KXMIPsQdgRsH",
    "outputId": "aeedfa0a-a421-4c2f-cb0d-183ce8f0c91d",
    "trusted": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "a    1.0\n",
       "b    0.0\n",
       "c    2.0\n",
       "d    0.0\n",
       "e    3.0\n",
       "dtype: float64"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "example5.fillna(0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "RRlI5f_hkfKe"
   },
   "source": [
    "> Keskeiset huomiot:\n",
    "1. Puuttuvien arvojen täyttö tulisi tehdä, kun dataa on vähän tai kun on olemassa strategia puuttuvien arvojen täyttämiseksi.\n",
    "2. Alakohtainen tieto voi auttaa puuttuvien arvojen täyttämisessä arvioimalla niitä.\n",
    "3. Kategorisessa datassa puuttuvat arvot korvataan yleensä sarakkeen moodilla.\n",
    "4. Numeraalisessa datassa puuttuvat arvot täytetään yleensä sarakkeen keskiarvolla (normalisoiduissa aineistoissa) tai mediaanilla.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "FI9MmqFJgRsH"
   },
   "source": [
    "### Harjoitus:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {
    "collapsed": true,
    "id": "af-ezpXdgRsH",
    "trusted": false
   },
   "outputs": [],
   "source": [
    "# What happens if you try to fill null values with a string, like ''?\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "kq3hw1kLgRsI"
   },
   "source": [
    "Voit **täyttää eteenpäin** null-arvot, eli käyttää viimeistä kelvollista arvoa null-arvon täyttämiseen:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "vO3BuNrggRsI",
    "outputId": "e2bc591b-0b48-4e88-ee65-754f2737c196",
    "trusted": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "a    1.0\n",
       "b    1.0\n",
       "c    2.0\n",
       "d    2.0\n",
       "e    3.0\n",
       "dtype: float64"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "example5.fillna(method='ffill')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "nDXeYuHzgRsI"
   },
   "source": [
    "Voit myös **täyttää taaksepäin** levittääksesi seuraavan kelvollisen arvon taaksepäin täyttääksesi null-arvon:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "4M5onHcEgRsI",
    "outputId": "8f32b185-40dd-4a9f-bd85-54d6b6a414fe",
    "trusted": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "a    1.0\n",
       "b    2.0\n",
       "c    2.0\n",
       "d    3.0\n",
       "e    3.0\n",
       "dtype: float64"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "example5.fillna(method='bfill')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true,
    "id": "MbBzTom5gRsI"
   },
   "source": [
    "Kuten arvata saattaa, tämä toimii samalla tavalla DataFramejen kanssa, mutta voit myös määrittää `axis`-parametrin, jonka mukaan täyttää null-arvot:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 142
    },
    "id": "aRpIvo4ZgRsI",
    "outputId": "905a980a-a808-4eca-d0ba-224bd7d85955",
    "trusted": false
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>0</th>\n",
       "      <th>1</th>\n",
       "      <th>2</th>\n",
       "      <th>3</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>1.0</td>\n",
       "      <td>NaN</td>\n",
       "      <td>7</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>2.0</td>\n",
       "      <td>5.0</td>\n",
       "      <td>8</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>NaN</td>\n",
       "      <td>6.0</td>\n",
       "      <td>9</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "     0    1  2   3\n",
       "0  1.0  NaN  7 NaN\n",
       "1  2.0  5.0  8 NaN\n",
       "2  NaN  6.0  9 NaN"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "example4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 142
    },
    "id": "VM1qtACAgRsI",
    "outputId": "71f2ad28-9b4e-4ff4-f5c3-e731eb489ade",
    "trusted": false
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>0</th>\n",
       "      <th>1</th>\n",
       "      <th>2</th>\n",
       "      <th>3</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>7.0</td>\n",
       "      <td>7.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>2.0</td>\n",
       "      <td>5.0</td>\n",
       "      <td>8.0</td>\n",
       "      <td>8.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>NaN</td>\n",
       "      <td>6.0</td>\n",
       "      <td>9.0</td>\n",
       "      <td>9.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "     0    1    2    3\n",
       "0  1.0  1.0  7.0  7.0\n",
       "1  2.0  5.0  8.0  8.0\n",
       "2  NaN  6.0  9.0  9.0"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "example4.fillna(method='ffill', axis=1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "ZeMc-I1EgRsI"
   },
   "source": [
    "Huomaa, että kun aiempaa arvoa ei ole saatavilla eteenpäin täyttämistä varten, null-arvo säilyy.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "eeAoOU0RgRsJ"
   },
   "source": [
    "### Harjoitus:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {
    "collapsed": true,
    "id": "e8S-CjW8gRsJ",
    "trusted": false
   },
   "outputs": [],
   "source": [
    "# What output does example4.fillna(method='bfill', axis=1) produce?\n",
    "# What about example4.fillna(method='ffill') or example4.fillna(method='bfill')?\n",
    "# Can you think of a longer code snippet to write that can fill all of the null values in example4?\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "YHgy0lIrgRsJ"
   },
   "source": [
    "Voit olla luova `fillna`-menetelmän käytössä. Esimerkiksi tarkastellaan uudelleen `example4`:ää, mutta tällä kertaa täytetään puuttuvat arvot kaikkien `DataFrame`:n arvojen keskiarvolla:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 142
    },
    "id": "OtYVErEygRsJ",
    "outputId": "708b1e67-45ca-44bf-a5ee-8b2de09ece73",
    "trusted": false
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>0</th>\n",
       "      <th>1</th>\n",
       "      <th>2</th>\n",
       "      <th>3</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>1.0</td>\n",
       "      <td>5.5</td>\n",
       "      <td>7</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>2.0</td>\n",
       "      <td>5.0</td>\n",
       "      <td>8</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>1.5</td>\n",
       "      <td>6.0</td>\n",
       "      <td>9</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "     0    1  2   3\n",
       "0  1.0  5.5  7 NaN\n",
       "1  2.0  5.0  8 NaN\n",
       "2  1.5  6.0  9 NaN"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "example4.fillna(example4.mean())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "zpMvCkLSgRsJ"
   },
   "source": [
    "Huomaa, että sarake 3 on edelleen arvoton: oletussuuntana on täyttää arvot rivikohtaisesti.\n",
    "\n",
    "> **Yhteenveto:** Puuttuvien arvojen käsittelyyn datasetissä on useita tapoja. Käyttämäsi strategia (poistaminen, korvaaminen tai tapa, jolla korvaat ne) tulisi määritellä datan erityispiirteiden mukaan. Saat paremman käsityksen puuttuvien arvojen käsittelystä, kun työskentelet ja vuorovaikutat datasetien kanssa enemmän.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "bauDnESIl9FH"
   },
   "source": [
    "### Kategorisen datan koodaus\n",
    "\n",
    "Koneoppimismallit käsittelevät vain numeroita ja kaikenlaista numeerista dataa. Ne eivät pysty erottamaan kyllä- ja ei-vastauksia toisistaan, mutta ne voivat erottaa 0:n ja 1:n. Joten, kun puuttuvat arvot on täytetty, meidän täytyy koodata kategorinen data numeeriseen muotoon, jotta malli ymmärtää sen.\n",
    "\n",
    "Koodaus voidaan tehdä kahdella tavalla. Käymme ne läpi seuraavaksi.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "uDq9SxB7mu5i"
   },
   "source": [
    "**LUOKKAENKODERAUS**\n",
    "\n",
    "Luokkaenkoderaus tarkoittaa käytännössä sitä, että jokainen kategoria muutetaan numeroksi. Esimerkiksi, jos meillä on lentomatkustajien datasetti, jossa on sarake heidän matkustusluokastaan seuraavien joukossa ['business class', 'economy class', 'first class'], luokkaenkoderaus muuttaisi nämä arvoiksi [0,1,2]. Katsotaanpa esimerkki koodin avulla. Koska tulevissa muistikirjoissa opettelemme käyttämään `scikit-learn`-kirjastoa, emme käytä sitä tässä.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 235
    },
    "id": "1vGz7uZyoWHL",
    "outputId": "9e252855-d193-4103-a54d-028ea7787b34"
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>ID</th>\n",
       "      <th>class</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>10</td>\n",
       "      <td>business class</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>20</td>\n",
       "      <td>first class</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>30</td>\n",
       "      <td>economy class</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>40</td>\n",
       "      <td>economy class</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>50</td>\n",
       "      <td>economy class</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>60</td>\n",
       "      <td>business class</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   ID           class\n",
       "0  10  business class\n",
       "1  20     first class\n",
       "2  30   economy class\n",
       "3  40   economy class\n",
       "4  50   economy class\n",
       "5  60  business class"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "label = pd.DataFrame([\n",
    "                      [10,'business class'],\n",
    "                      [20,'first class'],\n",
    "                      [30, 'economy class'],\n",
    "                      [40, 'economy class'],\n",
    "                      [50, 'economy class'],\n",
    "                      [60, 'business class']\n",
    "],columns=['ID','class'])\n",
    "label"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "IDHnkwTYov-h"
   },
   "source": [
    "Jotta voimme suorittaa label encodingin ensimmäiselle sarakkeelle, meidän täytyy ensin määritellä luokkien ja numeroiden välinen vastaavuus ennen korvaamista.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 235
    },
    "id": "ZC5URJG3o1ES",
    "outputId": "aab0f1e7-e0f3-4c14-8459-9f9168c85437"
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>ID</th>\n",
       "      <th>class</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>10</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>20</td>\n",
       "      <td>2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>30</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>40</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>50</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>60</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   ID  class\n",
       "0  10      0\n",
       "1  20      2\n",
       "2  30      1\n",
       "3  40      1\n",
       "4  50      1\n",
       "5  60      0"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class_labels = {'business class':0,'economy class':1,'first class':2}\n",
    "label['class'] = label['class'].replace(class_labels)\n",
    "label"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "ftnF-TyapOPt"
   },
   "source": [
    "Kuten näemme, tulos vastaa odotuksiamme. Milloin siis käytämme label encodingia? Label encodingia käytetään jommassakummassa tai molemmissa seuraavista tapauksista:\n",
    "1. Kun kategorioiden määrä on suuri\n",
    "2. Kun kategoriat ovat järjestyksessä.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "eQPAPVwsqWT7"
   },
   "source": [
    "**ONE HOT ENCODING**\n",
    "\n",
    "Toinen koodaustyyppi on One Hot Encoding. Tässä koodaustavassa jokainen sarakkeen kategoria lisätään erillisenä sarakkeena, ja jokainen datapiste saa arvon 0 tai 1 sen mukaan, sisältääkö se kyseisen kategorian. Jos kategorioita on n kappaletta, datafreimiin lisätään n saraketta.\n",
    "\n",
    "Esimerkiksi, otetaan sama lentokoneen luokkien esimerkki. Kategoriat olivat: ['business class', 'economy class', 'first class']. Jos suoritetaan One Hot Encoding, datasettiin lisätään seuraavat kolme saraketta: ['class_business class', 'class_economy class', 'class_first class'].\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 235
    },
    "id": "ZM0eVh0ArKUL",
    "outputId": "83238a76-b3a5-418d-c0b6-605b02b6891b"
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>ID</th>\n",
       "      <th>class</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>10</td>\n",
       "      <td>business class</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>20</td>\n",
       "      <td>first class</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>30</td>\n",
       "      <td>economy class</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>40</td>\n",
       "      <td>economy class</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>50</td>\n",
       "      <td>economy class</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>60</td>\n",
       "      <td>business class</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   ID           class\n",
       "0  10  business class\n",
       "1  20     first class\n",
       "2  30   economy class\n",
       "3  40   economy class\n",
       "4  50   economy class\n",
       "5  60  business class"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "one_hot = pd.DataFrame([\n",
    "                      [10,'business class'],\n",
    "                      [20,'first class'],\n",
    "                      [30, 'economy class'],\n",
    "                      [40, 'economy class'],\n",
    "                      [50, 'economy class'],\n",
    "                      [60, 'business class']\n",
    "],columns=['ID','class'])\n",
    "one_hot"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "aVnZ7paDrWmb"
   },
   "source": [
    "Tehdään yksi-kuuma-koodaus ensimmäiselle sarakkeelle\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {
    "id": "RUPxf7egrYKr"
   },
   "outputs": [],
   "source": [
    "one_hot_data = pd.get_dummies(one_hot,columns=['class'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 235
    },
    "id": "TM37pHsFr4ge",
    "outputId": "7be15f53-79b2-447a-979c-822658339a9e"
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>ID</th>\n",
       "      <th>class_business class</th>\n",
       "      <th>class_economy class</th>\n",
       "      <th>class_first class</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>10</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>20</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>30</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>40</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>50</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>60</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   ID  class_business class  class_economy class  class_first class\n",
       "0  10                     1                    0                  0\n",
       "1  20                     0                    0                  1\n",
       "2  30                     0                    1                  0\n",
       "3  40                     0                    1                  0\n",
       "4  50                     0                    1                  0\n",
       "5  60                     1                    0                  0"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "one_hot_data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "_zXRLOjXujdA"
   },
   "source": [
    "Jokainen yksi-kuuma koodattu sarake sisältää 0 tai 1, mikä määrittää, onko kyseinen kategorian olemassa kyseiselle datapisteelle.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "bDnC4NQOu0qr"
   },
   "source": [
    "Milloin käytetään one hot -enkoodausta? One hot -enkoodausta käytetään jommassakummassa tai molemmissa seuraavista tapauksista:\n",
    "\n",
    "1. Kun kategorioiden määrä ja datan koko ovat pienempiä.\n",
    "2. Kun kategorioilla ei ole erityistä järjestystä.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "XnUmci_4uvyu"
   },
   "source": [
    "> Keskeiset huomiot:\n",
    "1. Koodaus tehdään muuntamaan ei-numeerinen data numeeriseksi dataksi.\n",
    "2. Koodauksessa on kaksi tyyppiä: Label-koodaus ja One Hot -koodaus, joita voidaan käyttää datasetin tarpeiden mukaan.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "K8UXOJYRgRsJ"
   },
   "source": [
    "## Datan kaksoiskappaleiden poistaminen\n",
    "\n",
    "> **Oppimistavoite:** Tämän alajakson lopussa sinun pitäisi osata tunnistaa ja poistaa kaksoiskappaleet DataFrameista.\n",
    "\n",
    "Puuttuvan datan lisäksi todellisissa tietoaineistoissa törmätään usein myös kaksoiskappaleisiin. Onneksi pandas tarjoaa helpon tavan havaita ja poistaa kaksoiskappaleet.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "qrEG-Wa0gRsJ"
   },
   "source": [
    "### Tunnistetaan kaksoiskappaleet: `duplicated`\n",
    "\n",
    "Voit helposti havaita kaksoiskappaleet käyttämällä pandas-kirjaston `duplicated`-metodia, joka palauttaa Boolean-maskin, joka osoittaa, onko `DataFrame`-tietue aiemman kaksoiskappale. Luodaan toinen esimerkkitietokehys, jotta näet tämän toiminnassa.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 204
    },
    "id": "ZLu6FEnZgRsJ",
    "outputId": "376512d1-d842-4db1-aea3-71052aeeecaf",
    "trusted": false
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>letters</th>\n",
       "      <th>numbers</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>A</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>B</td>\n",
       "      <td>2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>A</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>B</td>\n",
       "      <td>3</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>B</td>\n",
       "      <td>3</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "  letters  numbers\n",
       "0       A        1\n",
       "1       B        2\n",
       "2       A        1\n",
       "3       B        3\n",
       "4       B        3"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "example6 = pd.DataFrame({'letters': ['A','B'] * 2 + ['B'],\n",
    "                         'numbers': [1, 2, 1, 3, 3]})\n",
    "example6"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "cIduB5oBgRsK",
    "outputId": "3da27b3d-4d69-4e1d-bb52-0af21bae87f2",
    "trusted": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0    False\n",
       "1    False\n",
       "2     True\n",
       "3    False\n",
       "4     True\n",
       "dtype: bool"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "example6.duplicated()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "0eDRJD4SgRsK"
   },
   "source": [
    "### Duplikaattien poistaminen: `drop_duplicates`\n",
    "`drop_duplicates` palauttaa yksinkertaisesti kopion datasta, jossa kaikki `duplicated`-arvot ovat `False`:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 142
    },
    "id": "w_YPpqIqgRsK",
    "outputId": "ac66bd2f-8671-4744-87f5-8b8d96553dea",
    "trusted": false
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>letters</th>\n",
       "      <th>numbers</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>A</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>B</td>\n",
       "      <td>2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>B</td>\n",
       "      <td>3</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "  letters  numbers\n",
       "0       A        1\n",
       "1       B        2\n",
       "3       B        3"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "example6.drop_duplicates()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "69AqoCZAgRsK"
   },
   "source": [
    "Sekä `duplicated` että `drop_duplicates` oletuksena tarkastelevat kaikkia sarakkeita, mutta voit määrittää, että ne tarkastelevat vain tiettyä osajoukkoa sarakkeista `DataFrame`-objektissasi:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 111
    },
    "id": "BILjDs67gRsK",
    "outputId": "ef6dcc08-db8b-4352-c44e-5aa9e2bec0d3",
    "trusted": false
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>letters</th>\n",
       "      <th>numbers</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>A</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>B</td>\n",
       "      <td>2</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "  letters  numbers\n",
       "0       A        1\n",
       "1       B        2"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "example6.drop_duplicates(['letters'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "GvX4og1EgRsL"
   },
   "source": [
    "> **Yhteenveto:** Duplicaatin datan poistaminen on olennainen osa lähes jokaista data-analytiikkaprojektia. Duplicaatin data voi muuttaa analyysiesi tuloksia ja antaa sinulle virheellisiä tuloksia!\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Todellisen maailman datan laadun tarkistukset\n",
    "\n",
    "> **Oppimistavoite:** Tämän osion lopussa sinun pitäisi osata tunnistaa ja korjata yleisiä todellisen maailman datan laatuongelmia, kuten epäjohdonmukaiset kategoriset arvot, poikkeavat numeeriset arvot (äärimmäiset poikkeamat) ja samankaltaiset entiteetit pienillä eroilla.\n",
    "\n",
    "Vaikka puuttuvat arvot ja täsmälleen samat duplikaatit ovat yleisiä ongelmia, todellisen maailman datassa esiintyy usein hienovaraisempia ongelmia:\n",
    "\n",
    "1. **Epäjohdonmukaiset kategoriset arvot**: Sama kategoria kirjoitettuna eri tavoin (esim. \"USA\", \"U.S.A\", \"United States\")\n",
    "2. **Poikkeavat numeeriset arvot**: Äärimmäiset poikkeamat, jotka viittaavat virheisiin datan syötössä (esim. ikä = 999)\n",
    "3. **Lähes identtiset rivit**: Tietueet, jotka edustavat samaa entiteettiä pienillä eroilla\n",
    "\n",
    "Tutkitaan tekniikoita näiden ongelmien tunnistamiseen ja käsittelyyn.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Luodaan esimerkkidatasetti \"likaisesta\" datasta\n",
    "\n",
    "Aloitetaan luomalla esimerkkidatasetti, joka sisältää tyypillisiä ongelmia, joita kohtaamme todellisessa datassa:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import numpy as np\n",
    "\n",
    "# Create a sample dataset with quality issues\n",
    "dirty_data = pd.DataFrame({\n",
    "    'customer_id': [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12],\n",
    "    'name': ['John Smith', 'Jane Doe', 'John Smith', 'Bob Johnson', \n",
    "             'Alice Williams', 'Charlie Brown', 'John  Smith', 'Eva Martinez',\n",
    "             'Bob Johnson', 'Diana Prince', 'Frank Castle', 'Alice Williams'],\n",
    "    'age': [25, 32, 25, 45, 28, 199, 25, 31, 45, 27, -5, 28],\n",
    "    'country': ['USA', 'UK', 'U.S.A', 'Canada', 'USA', 'United Kingdom',\n",
    "                'United States', 'Mexico', 'canada', 'USA', 'UK', 'usa'],\n",
    "    'purchase_amount': [100.50, 250.00, 105.00, 320.00, 180.00, 90.00,\n",
    "                       102.00, 275.00, 325.00, 195.00, 410.00, 185.00]\n",
    "})\n",
    "\n",
    "print(\"Sample 'Dirty' Dataset:\")\n",
    "print(dirty_data)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1. Havaitse epäjohdonmukaiset kategoriset arvot\n",
    "\n",
    "Huomaa, että `country`-sarake sisältää useita esitystapoja samoille maille. Tunnistetaan nämä epäjohdonmukaisuudet:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Check unique values in the country column\n",
    "print(\"Unique country values:\")\n",
    "print(dirty_data['country'].unique())\n",
    "print(f\"\\nTotal unique values: {dirty_data['country'].nunique()}\")\n",
    "\n",
    "# Count occurrences of each variation\n",
    "print(\"\\nValue counts:\")\n",
    "print(dirty_data['country'].value_counts())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Kategoristen arvojen standardisointi\n",
    "\n",
    "Voimme luoda kartoituksen näiden arvojen standardisoimiseksi. Yksinkertainen tapa on muuntaa arvot pieniksi kirjaimiksi ja luoda kartoitussanakirja:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create a standardization mapping\n",
    "country_mapping = {\n",
    "    'usa': 'USA',\n",
    "    'u.s.a': 'USA',\n",
    "    'united states': 'USA',\n",
    "    'uk': 'UK',\n",
    "    'united kingdom': 'UK',\n",
    "    'canada': 'Canada',\n",
    "    'mexico': 'Mexico'\n",
    "}\n",
    "\n",
    "# Standardize the country column\n",
    "dirty_data['country_clean'] = dirty_data['country'].str.lower().map(country_mapping)\n",
    "\n",
    "print(\"Before standardization:\")\n",
    "print(dirty_data['country'].value_counts())\n",
    "print(\"\\nAfter standardization:\")\n",
    "print(dirty_data[['country_clean']].value_counts())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Vaihtoehto: Epätarkka vertailu**\n",
    "\n",
    "Monimutkaisemmissa tapauksissa voimme käyttää epätarkkaa merkkijonojen vertailua `rapidfuzz`-kirjaston avulla havaitaksemme automaattisesti samankaltaiset merkkijonot:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "try:\n",
    "    from rapidfuzz import process, fuzz\n",
    "except ImportError:\n",
    "    print(\"rapidfuzz is not installed. Please install it with 'pip install rapidfuzz' to use fuzzy matching.\")\n",
    "    process = None\n",
    "    fuzz = None\n",
    "\n",
    "# Get unique countries\n",
    "unique_countries = dirty_data['country'].unique()\n",
    "\n",
    "# For each country, find similar matches\n",
    "if process is not None and fuzz is not None:\n",
    "    print(\"Finding similar country names (similarity > 70%):\")\n",
    "    for country in unique_countries:\n",
    "        matches = process.extract(country, unique_countries, scorer=fuzz.ratio, limit=3)\n",
    "        # Filter matches with similarity > 70 and not identical\n",
    "        similar = [m for m in matches if m[1] > 70 and m[0] != country]\n",
    "        if similar:\n",
    "            print(f\"\\n'{country}' is similar to:\")\n",
    "            for match, score, _ in similar:\n",
    "                print(f\"  - '{match}' (similarity: {score}%)\")\n",
    "else:\n",
    "    print(\"Skipping fuzzy matching because rapidfuzz is not available.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2. Epänormaalien numeeristen arvojen (poikkeamien) tunnistaminen\n",
    "\n",
    "Kun tarkastelemme `age`-saraketta, huomaamme joitakin epäilyttäviä arvoja, kuten 199 ja -5. Käytetään tilastollisia menetelmiä näiden poikkeamien tunnistamiseen.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Display basic statistics\n",
    "print(\"Age column statistics:\")\n",
    "print(dirty_data['age'].describe())\n",
    "\n",
    "# Identify impossible values using domain knowledge\n",
    "print(\"\\nRows with impossible age values (< 0 or > 120):\")\n",
    "impossible_ages = dirty_data[(dirty_data['age'] < 0) | (dirty_data['age'] > 120)]\n",
    "print(impossible_ages[['customer_id', 'name', 'age']])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### IQR-menetelmän käyttö (Interkvartiilivälin menetelmä)\n",
    "\n",
    "IQR-menetelmä on vankka tilastollinen tekniikka poikkeavien arvojen tunnistamiseen, joka on vähemmän herkkä äärimmäisille arvoille:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Calculate IQR for age (excluding impossible values)\n",
    "valid_ages = dirty_data[(dirty_data['age'] >= 0) & (dirty_data['age'] <= 120)]['age']\n",
    "\n",
    "Q1 = valid_ages.quantile(0.25)\n",
    "Q3 = valid_ages.quantile(0.75)\n",
    "IQR = Q3 - Q1\n",
    "\n",
    "# Define outlier bounds\n",
    "lower_bound = Q1 - 1.5 * IQR\n",
    "upper_bound = Q3 + 1.5 * IQR\n",
    "\n",
    "print(f\"IQR-based outlier bounds for age: [{lower_bound:.2f}, {upper_bound:.2f}]\")\n",
    "\n",
    "# Identify outliers\n",
    "age_outliers = dirty_data[(dirty_data['age'] < lower_bound) | (dirty_data['age'] > upper_bound)]\n",
    "print(f\"\\nRows with age outliers:\")\n",
    "print(age_outliers[['customer_id', 'name', 'age']])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Z-score-menetelmän käyttö\n",
    "\n",
    "Z-score-menetelmä tunnistaa poikkeamat keskiarvosta laskettujen keskihajontojen perusteella:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "try:\n",
    "    from scipy import stats\n",
    "except ImportError:\n",
    "    print(\"scipy is required for Z-score calculation. Please install it with 'pip install scipy' and rerun this cell.\")\n",
    "else:\n",
    "    # Calculate Z-scores for age, handling NaN values\n",
    "    age_nonan = dirty_data['age'].dropna()\n",
    "    zscores = np.abs(stats.zscore(age_nonan))\n",
    "    dirty_data['age_zscore'] = np.nan\n",
    "    dirty_data.loc[age_nonan.index, 'age_zscore'] = zscores\n",
    "\n",
    "    # Typically, Z-score > 3 indicates an outlier\n",
    "    print(\"Rows with age Z-score > 3:\")\n",
    "    zscore_outliers = dirty_data[dirty_data['age_zscore'] > 3]\n",
    "    print(zscore_outliers[['customer_id', 'name', 'age', 'age_zscore']])\n",
    "\n",
    "    # Clean up the temporary column\n",
    "    dirty_data = dirty_data.drop('age_zscore', axis=1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Poikkeamien käsittely\n",
    "\n",
    "Kun poikkeamat on havaittu, niitä voidaan käsitellä useilla tavoilla:\n",
    "1. **Poista**: Poista rivit, joissa on poikkeamia (jos ne ovat virheitä)\n",
    "2. **Rajoita**: Korvaa raja-arvoilla\n",
    "3. **Korvaa NaN-arvolla**: Käsittele puuttuvana tietona ja käytä imputointitekniikoita\n",
    "4. **Pidä**: Jos ne ovat oikeutettuja äärimmäisiä arvoja\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create a cleaned version by replacing impossible ages with NaN\n",
    "dirty_data['age_clean'] = dirty_data['age'].apply(\n",
    "    lambda x: np.nan if (x < 0 or x > 120) else x\n",
    ")\n",
    "\n",
    "print(\"Age column before and after cleaning:\")\n",
    "print(dirty_data[['customer_id', 'name', 'age', 'age_clean']])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3. Lähes samankaltaisten rivien tunnistaminen\n",
    "\n",
    "Huomaa, että datassamme on useita merkintöjä \"John Smithille\" hieman erilaisilla arvoilla. Tunnistetaan mahdolliset kaksoiskappaleet nimien samankaltaisuuden perusteella.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# First, let's look at exact name matches (ignoring extra whitespace)\n",
    "dirty_data['name_normalized'] = dirty_data['name'].str.strip().str.lower()\n",
    "\n",
    "print(\"Checking for duplicate names:\")\n",
    "duplicate_names = dirty_data[dirty_data.duplicated(['name_normalized'], keep=False)]\n",
    "print(duplicate_names.sort_values('name_normalized')[['customer_id', 'name', 'age', 'country']])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Läheisten kaksoiskappaleiden löytäminen epätarkalla vastaavuudella\n",
    "\n",
    "Kehittyneempää kaksoiskappaleiden tunnistusta varten voimme käyttää epätarkkaa vastaavuutta löytääksemme samankaltaisia nimiä:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "try:\n",
    "    from rapidfuzz import process, fuzz\n",
    "\n",
    "    # Function to find potential duplicates\n",
    "    def find_near_duplicates(df, column, threshold=90):\n",
    "        \"\"\"\n",
    "        Find near-duplicate entries in a column using fuzzy matching.\n",
    "        \n",
    "        Parameters:\n",
    "        - df: DataFrame\n",
    "        - column: Column name to check for duplicates\n",
    "        - threshold: Similarity threshold (0-100)\n",
    "        \n",
    "        Returns: List of potential duplicate groups\n",
    "        \"\"\"\n",
    "        values = df[column].unique()\n",
    "        duplicate_groups = []\n",
    "        checked = set()\n",
    "        \n",
    "        for value in values:\n",
    "            if value in checked:\n",
    "                continue\n",
    "                \n",
    "            # Find similar values\n",
    "            matches = process.extract(value, values, scorer=fuzz.ratio, limit=len(values))\n",
    "            similar = [m[0] for m in matches if m[1] >= threshold]\n",
    "            \n",
    "            if len(similar) > 1:\n",
    "                duplicate_groups.append(similar)\n",
    "                checked.update(similar)\n",
    "        \n",
    "        return duplicate_groups\n",
    "\n",
    "    # Find near-duplicate names\n",
    "    duplicate_groups = find_near_duplicates(dirty_data, 'name', threshold=90)\n",
    "\n",
    "    print(\"Potential duplicate groups:\")\n",
    "    for i, group in enumerate(duplicate_groups, 1):\n",
    "        print(f\"\\nGroup {i}:\")\n",
    "        for name in group:\n",
    "            matching_rows = dirty_data[dirty_data['name'] == name]\n",
    "            print(f\"  '{name}': {len(matching_rows)} occurrence(s)\")\n",
    "            for _, row in matching_rows.iterrows():\n",
    "                print(f\"    - Customer {row['customer_id']}: age={row['age']}, country={row['country']}\")\n",
    "except ImportError:\n",
    "    print(\"rapidfuzz is not installed. Skipping fuzzy matching for near-duplicates.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Käsittele duplikaatteja\n",
    "\n",
    "Kun duplikaatit on tunnistettu, sinun täytyy päättää, miten ne käsitellään:\n",
    "1. **Pidä ensimmäinen esiintymä**: Käytä `drop_duplicates(keep='first')`\n",
    "2. **Pidä viimeinen esiintymä**: Käytä `drop_duplicates(keep='last')`\n",
    "3. **Yhdistä tiedot**: Yhdistä tietoja duplikaattiriveistä\n",
    "4. **Manuaalinen tarkistus**: Merkitse ihmisen tarkistettavaksi\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Example: Remove duplicates based on normalized name, keeping first occurrence\n",
    "cleaned_data = dirty_data.drop_duplicates(subset=['name_normalized'], keep='first')\n",
    "\n",
    "print(f\"Original dataset: {len(dirty_data)} rows\")\n",
    "print(f\"After removing name duplicates: {len(cleaned_data)} rows\")\n",
    "print(f\"Removed: {len(dirty_data) - len(cleaned_data)} duplicate rows\")\n",
    "\n",
    "print(\"\\nCleaned dataset:\")\n",
    "print(cleaned_data[['customer_id', 'name', 'age', 'country_clean']])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Yhteenveto: Täydellinen datan puhdistusputki\n",
    "\n",
    "Kootaan kaikki yhteen kattavaksi puhdistusputkeksi:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def clean_dataset(df):\n",
    "    \"\"\"\n",
    "    Comprehensive data cleaning function.\n",
    "    \"\"\"\n",
    "    # Create a copy to avoid modifying the original\n",
    "    cleaned = df.copy()\n",
    "    \n",
    "    # 1. Standardize categorical values (country)\n",
    "    country_mapping = {\n",
    "        'usa': 'USA', 'u.s.a': 'USA', 'united states': 'USA',\n",
    "        'uk': 'UK', 'united kingdom': 'UK',\n",
    "        'canada': 'Canada', 'mexico': 'Mexico'\n",
    "    }\n",
    "    cleaned['country'] = cleaned['country'].str.lower().map(country_mapping)\n",
    "    \n",
    "    # 2. Clean abnormal age values\n",
    "    cleaned['age'] = cleaned['age'].apply(\n",
    "        lambda x: np.nan if (x < 0 or x > 120) else x\n",
    "    )\n",
    "    \n",
    "    # 3. Remove near-duplicate names (normalize whitespace)\n",
    "    cleaned['name'] = cleaned['name'].str.strip()\n",
    "    cleaned = cleaned.drop_duplicates(subset=['name'], keep='first')\n",
    "    \n",
    "    return cleaned\n",
    "\n",
    "# Apply the cleaning pipeline\n",
    "final_cleaned_data = clean_dataset(dirty_data)\n",
    "\n",
    "print(\"Before cleaning:\")\n",
    "print(f\"  Rows: {len(dirty_data)}\")\n",
    "print(f\"  Unique countries: {dirty_data['country'].nunique()}\")\n",
    "print(f\"  Invalid ages: {((dirty_data['age'] < 0) | (dirty_data['age'] > 120)).sum()}\")\n",
    "\n",
    "print(\"\\nAfter cleaning:\")\n",
    "print(f\"  Rows: {len(final_cleaned_data)}\")\n",
    "print(f\"  Unique countries: {final_cleaned_data['country'].nunique()}\")\n",
    "print(f\"  Invalid ages: {((final_cleaned_data['age'] < 0) | (final_cleaned_data['age'] > 120)).sum()}\")\n",
    "\n",
    "print(\"\\nCleaned dataset:\")\n",
    "print(final_cleaned_data[['customer_id', 'name', 'age', 'country', 'purchase_amount']])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 🎯 Haasteharjoitus\n",
    "\n",
    "Nyt on sinun vuorosi! Alla on uusi tietorivi, jossa on useita laatuongelmia. Voitko:\n",
    "\n",
    "1. Tunnistaa kaikki ongelmat tässä rivissä\n",
    "2. Kirjoittaa koodin jokaisen ongelman korjaamiseksi\n",
    "3. Lisätä puhdistetun rivin tietojoukkoon\n",
    "\n",
    "Tässä on ongelmallinen data:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# New problematic row\n",
    "new_row = pd.DataFrame({\n",
    "    'customer_id': [13],\n",
    "    'name': ['  Diana  Prince  '],  # Extra whitespace\n",
    "    'age': [250],  # Impossible age\n",
    "    'country': ['U.S.A.'],  # Inconsistent format\n",
    "    'purchase_amount': [150.00]\n",
    "})\n",
    "\n",
    "print(\"New row to clean:\")\n",
    "print(new_row)\n",
    "\n",
    "# TODO: Your code here to clean this row\n",
    "# Hints:\n",
    "# 1. Strip whitespace from the name\n",
    "# 2. Check if the name is a duplicate (Diana Prince already exists)\n",
    "# 3. Handle the impossible age value\n",
    "# 4. Standardize the country name\n",
    "\n",
    "# Example solution (uncomment and modify as needed):\n",
    "# new_row_cleaned = new_row.copy()\n",
    "# new_row_cleaned['name'] = new_row_cleaned['name'].str.strip()\n",
    "# new_row_cleaned['age'] = np.nan  # Invalid age\n",
    "# new_row_cleaned['country'] = 'USA'  # Standardized\n",
    "# print(\"\\nCleaned row:\")\n",
    "# print(new_row_cleaned)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Keskeiset huomiot\n",
    "\n",
    "1. **Epäjohdonmukaiset kategoriat** ovat yleisiä todellisessa datassa. Tarkista aina yksilölliset arvot ja yhdenmukaista ne käyttämällä kartoituksia tai epätarkkaa vastaavuutta.\n",
    "\n",
    "2. **Poikkeamat** voivat vaikuttaa merkittävästi analyysiisi. Käytä alakohtaista tietämystä yhdistettynä tilastollisiin menetelmiin (IQR, Z-score) niiden havaitsemiseksi.\n",
    "\n",
    "3. **Lähes kaksoiskappaleet** ovat vaikeampia havaita kuin tarkat kaksoiskappaleet. Harkitse epätarkkaa vastaavuutta ja datan normalisointia (pienet kirjaimet, välilyöntien poisto) niiden tunnistamiseksi.\n",
    "\n",
    "4. **Datan puhdistus on iteratiivista**. Saatat joutua käyttämään useita tekniikoita ja tarkistamaan tulokset ennen kuin viimeistelet puhdistetun datasetin.\n",
    "\n",
    "5. **Dokumentoi päätöksesi**. Pidä kirjaa siitä, mitä puhdistusvaiheita sovelsit ja miksi, sillä tämä on tärkeää toistettavuuden ja läpinäkyvyyden kannalta.\n",
    "\n",
    "> **Paras käytäntö:** Säilytä aina kopio alkuperäisestä \"likaisesta\" datasta. Älä koskaan korvaa lähdedatatiedostoja – luo puhdistettuja versioita selkeillä nimeämiskäytännöillä, kuten `data_cleaned.csv`.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n---\n\n**Vastuuvapauslauseke**:  \nTämä asiakirja on käännetty käyttämällä tekoälypohjaista käännöspalvelua [Co-op Translator](https://github.com/Azure/co-op-translator). Vaikka pyrimme tarkkuuteen, huomioithan, että automaattiset käännökset voivat sisältää virheitä tai epätarkkuuksia. Alkuperäistä asiakirjaa sen alkuperäisellä kielellä tulisi pitää ensisijaisena lähteenä. Kriittisen tiedon osalta suositellaan ammattimaista ihmiskäännöstä. Emme ole vastuussa väärinkäsityksistä tai virhetulkinnoista, jotka johtuvat tämän käännöksen käytöstä.\n"
   ]
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "colab": {
   "name": "notebook.ipynb",
   "provenance": []
  },
  "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.5.4"
  },
  "coopTranslator": {
   "original_hash": "6301339d1c9a301b00639c635dc9b731",
   "translation_date": "2025-10-03T20:26:42+00:00",
   "source_file": "2-Working-With-Data/08-data-preparation/notebook.ipynb",
   "language_code": "fi"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}