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

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "rQ8UhzFpgRra"
   },
   "source": [
    "# Duomenų Paruošimas\n",
    "\n",
    "[Originalus užrašų knygelės šaltinis iš *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` informacijos tyrinėjimas\n",
    "\n",
    "> **Mokymosi tikslas:** Šios poskirsnio pabaigoje turėtumėte jaustis patogiai ieškodami bendros informacijos apie pandas `DataFrame` saugomus duomenis.\n",
    "\n",
    "Kai jau įkėlėte savo duomenis į pandas, jie greičiausiai bus `DataFrame` formatu. Tačiau, jei jūsų `DataFrame` duomenų rinkinys turi 60 000 eilučių ir 400 stulpelių, nuo ko pradėti, kad suprastumėte, su kuo dirbate? Laimei, pandas siūlo keletą patogių įrankių, leidžiančių greitai peržiūrėti bendrą informaciją apie `DataFrame`, taip pat pirmąsias ir paskutines kelias eilutes.\n",
    "\n",
    "Norėdami išbandyti šią funkcionalumą, importuosime Python biblioteką scikit-learn ir naudosime ikoninius duomenis, kuriuos kiekvienas duomenų mokslininkas yra matęs šimtus kartų: britų biologo Ronaldo Fisherio *Iris* duomenų rinkinį, naudotą jo 1936 metų straipsnyje „Daugybinių matavimų naudojimas taksonomijos problemose“:\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",
    "Mes įkėlėme Iris duomenų rinkinį į kintamąjį `iris_df`. Prieš pradedant analizuoti duomenis, būtų naudinga sužinoti, kiek duomenų taškų turime ir kokio dydžio yra visas duomenų rinkinys. Naudinga pažvelgti į duomenų apimtį, su kuria dirbame.\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": [
    "Taigi, mes dirbame su 150 eilučių ir 4 stulpeliais duomenų. Kiekviena eilutė atspindi vieną duomenų tašką, o kiekvienas stulpelis – vieną su duomenų rėmeliu susijusią savybę. Taigi, iš esmės yra 150 duomenų taškų, kurių kiekvienas turi 4 savybes.\n",
    "\n",
    "`shape` čia yra duomenų rėmelio atributas, o ne funkcija, todėl jis nesibaigia skliausteliais.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "d3AZKs0PinGP"
   },
   "source": [
    "### `DataFrame.columns`\n",
    "Dabar pereikime prie 4 duomenų stulpelių. Ką tiksliai kiekvienas iš jų reiškia? `columns` atributas pateiks mums stulpelių pavadinimus duomenų rėmelyje.\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": [
    "Kaip matome, yra keturios (4) stulpeliai. `columns` atributas nurodo stulpelių pavadinimus ir iš esmės nieko daugiau. Šis atributas tampa svarbus, kai norime nustatyti, kokias ypatybes duomenų rinkinys turi.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "2UTlvkjmgRrs"
   },
   "source": [
    "### `DataFrame.info`\n",
    "Duomenų kiekis (nurodytas per `shape` atributą) ir savybių arba stulpelių pavadinimai (nurodyti per `columns` atributą) suteikia mums tam tikrą informaciją apie duomenų rinkinį. Dabar norėtume giliau pasinerti į duomenų rinkinį. Funkcija `DataFrame.info()` yra labai naudinga šiuo atveju.\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": [
    "Iš čia galime padaryti kelias pastabas:  \n",
    "1. Kiekvieno stulpelio duomenų tipas: Šiame duomenų rinkinyje visi duomenys saugomi kaip 64 bitų slankiojo kablelio skaičiai.  \n",
    "2. Ne-null reikšmių skaičius: Darbas su null reikšmėmis yra svarbus duomenų paruošimo etapas. Tai bus sprendžiama vėliau šiame užrašų knygelėje.  \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "IYlyxbpWFEF4"
   },
   "source": [
    "### DataFrame.describe()\n",
    "Tarkime, turime daug skaitinių duomenų savo duomenų rinkinyje. Vieno kintamojo statistiniai skaičiavimai, tokie kaip vidurkis, mediana, kvartiliai ir pan., gali būti atliekami kiekvienam stulpeliui atskirai. Funkcija `DataFrame.describe()` pateikia statistinę santrauką apie skaitinius duomenų rinkinio stulpelius.\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": [
    "Pateiktas rezultatas rodo bendrą duomenų taškų skaičių, vidurkį, standartinį nuokrypį, mažiausią reikšmę, apatinį kvartilį (25%), medianą (50%), viršutinį kvartilį (75%) ir didžiausią kiekvienos stulpelio reikšmę.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "-lviAu99gRrv"
   },
   "source": [
    "### `DataFrame.head`\n",
    "Naudodami visas aukščiau paminėtas funkcijas ir atributus, jau turime bendrą duomenų rinkinio vaizdą. Žinome, kiek yra duomenų taškų, kiek yra savybių, kiekvienos savybės duomenų tipą ir kiek yra nenulinių reikšmių kiekvienai savybei.\n",
    "\n",
    "Dabar metas pažvelgti į pačius duomenis. Pažiūrėkime, kaip atrodo pirmosios kelios eilutės (pirmieji keli duomenų taškai) mūsų `DataFrame`:\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": [
    "Kaip matome išvestyje, čia pateikti penki (5) duomenų rinkinio įrašai. Jei pažvelgsime į indeksą kairėje, sužinosime, kad tai yra pirmosios penkios eilutės.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "oj7GkrTdgRry"
   },
   "source": [
    "### Užduotis:\n",
    "\n",
    "Iš pateikto pavyzdžio aišku, kad pagal numatytuosius nustatymus `DataFrame.head` grąžina pirmas penkias `DataFrame` eilutes. Ar galite žemiau esančiame kodo langelyje sugalvoti būdą, kaip parodyti daugiau nei penkias eilutes?\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",
    "Kitas būdas peržiūrėti duomenis yra nuo pabaigos (užuot pradėjus nuo pradžios). Priešingybė `DataFrame.head` yra `DataFrame.tail`, kuris grąžina paskutines penkias `DataFrame` eilutes:\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": [
    "Praktikoje naudinga lengvai peržiūrėti pirmas kelias arba paskutines kelias `DataFrame` eilutes, ypač kai ieškote išskirtinių reikšmių tvarkinguose duomenų rinkiniuose.\n",
    "\n",
    "Visos aukščiau pateiktos funkcijos ir atributai, parodyti su kodo pavyzdžiais, padeda mums susidaryti įspūdį apie duomenis.\n",
    "\n",
    "> **Svarbiausia mintis:** Net paprasčiausiai pažvelgus į metaduomenis apie informaciją `DataFrame` arba į pirmas ir paskutines kelias reikšmes, galite iš karto susidaryti vaizdą apie duomenų dydį, formą ir turinį, su kuriais dirbate.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "TvurZyLSDxq_"
   },
   "source": [
    "### Trūkstami duomenys\n",
    "Panagrinėkime trūkstamus duomenis. Trūkstami duomenys atsiranda, kai kai kuriuose stulpeliuose nėra išsaugota jokia reikšmė.\n",
    "\n",
    "Pavyzdžiui: tarkime, kažkas labai rūpinasi savo svoriu ir nepildo svorio laukelio apklausoje. Tokiu atveju to asmens svorio reikšmė bus trūkstama.\n",
    "\n",
    "Dažniausiai realaus pasaulio duomenų rinkiniuose pasitaiko trūkstamų reikšmių.\n",
    "\n",
    "**Kaip Pandas tvarko trūkstamus duomenis**\n",
    "\n",
    "Pandas trūkstamas reikšmes tvarko dviem būdais. Pirmąjį jau matėte ankstesnėse dalyse: `NaN`, arba Not a Number (ne skaičius). Tai iš tikrųjų yra speciali reikšmė, kuri yra IEEE slankiojo kablelio specifikacijos dalis ir naudojama tik trūkstamoms slankiojo kablelio reikšmėms nurodyti.\n",
    "\n",
    "Kitoms trūkstamoms reikšmėms, išskyrus slankiojo kablelio reikšmes, pandas naudoja Python objektą `None`. Nors gali atrodyti painu, kad susidursite su dviem skirtingais reikšmių tipais, kurie iš esmės reiškia tą patį, yra pagrįstų programavimo priežasčių, kodėl buvo pasirinktas toks dizainas. Praktikoje toks sprendimas leidžia pandas pasiekti gerą kompromisą daugeliu atvejų. Nepaisant to, tiek `None`, tiek `NaN` turi apribojimų, kuriuos reikia žinoti, atsižvelgiant į tai, kaip jie gali būti naudojami.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "lOHqUlZFgRr5"
   },
   "source": [
    "### `None`: ne skaičių trūkstami duomenys\n",
    "Kadangi `None` yra iš Python, jo negalima naudoti NumPy ir pandas masyvuose, kurių duomenų tipas nėra `'object'`. Atminkite, kad NumPy masyvai (ir pandas duomenų struktūros) gali turėti tik vieno tipo duomenis. Tai suteikia jiems didžiulę galią dirbant su didelio masto duomenimis ir atliekant skaičiavimus, tačiau tuo pačiu riboja jų lankstumą. Tokie masyvai turi būti konvertuoti į „mažiausią bendrą vardiklį“, t. y. duomenų tipą, kuris apims viską masyve. Kai masyve yra `None`, tai reiškia, kad dirbate su Python objektais.\n",
    "\n",
    "Norėdami tai pamatyti praktiškai, apsvarstykite šį pavyzdinį masyvą (atkreipkite dėmesį į jo `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": [
    "Duomenų tipų konvertavimas į aukštesnį lygį turi du šalutinius poveikius. Pirma, operacijos bus vykdomos interpretuojamo Python kodo lygiu, o ne kompiliuoto NumPy kodo lygiu. Iš esmės tai reiškia, kad bet kokios operacijos, susijusios su `Series` ar `DataFrame` objektais, kuriuose yra `None`, bus lėtesnės. Nors greičiausiai nepastebėsite šio našumo sumažėjimo, dideliems duomenų rinkiniams tai gali tapti problema.\n",
    "\n",
    "Antrasis šalutinis poveikis kyla iš pirmojo. Kadangi `None` iš esmės grąžina `Series` ar `DataFrame` į paprasto Python pasaulį, naudojant NumPy/pandas agregacijas, tokias kaip `sum()` ar `min()`, masyvuose, kuriuose yra ``None`` reikšmė, paprastai bus generuojama klaida:\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": [
    "**Svarbiausia išvada**: Sudėtis (ir kitos operacijos) tarp sveikųjų skaičių ir `None` reikšmių yra neapibrėžta, todėl tai gali apriboti, ką galima atlikti su duomenų rinkiniais, kuriuose jos yra.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "pWvVHvETgRr9"
   },
   "source": [
    "### `NaN`: trūkstamos slankiojo kablelio reikšmės\n",
    "\n",
    "Skirtingai nuo `None`, NumPy (ir todėl pandas) palaiko `NaN`, kad būtų galima atlikti greitas, vektorizuotas operacijas ir ufuncs. Bloga žinia yra ta, kad bet kokia aritmetinė operacija su `NaN` visada duoda `NaN`. Pavyzdžiui:\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": [
    "Geros naujienos: agregacijos, vykdomos su masyvais, kuriuose yra `NaN`, nesukelia klaidų. Blogos naujienos: rezultatai nėra vienodai naudingi:\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": [
    "### Pratimas:\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": [
    "Atminkite: `NaN` yra skirtas tik trūkstamoms slankiojo kablelio reikšmėms; nėra `NaN` atitikmens sveikiesiems skaičiams, eilutėms ar loginėms reikšmėms.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "kj6EKdsAgRsA"
   },
   "source": [
    "### `NaN` ir `None`: null reikšmės pandas\n",
    "\n",
    "Nors `NaN` ir `None` gali elgtis šiek tiek skirtingai, pandas vis tiek sukurta taip, kad galėtų juos tvarkyti kaip lygiaverčius. Kad suprastumėte, ką turime omenyje, apsvarstykite `Series` su sveikaisiais skaičiais:\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": [
    "### Pratimas:\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": [
    "Atliekant duomenų tipų konvertavimą į aukštesnį lygį, siekiant užtikrinti duomenų homogeniškumą `Series` ir `DataFrame` objektuose, pandas lengvai keičia trūkstamas reikšmes tarp `None` ir `NaN`. Dėl šios dizaino ypatybės naudinga galvoti apie `None` ir `NaN` kaip apie dvi skirtingas „null“ reikšmių formas pandas bibliotekoje. Iš tiesų, kai kurie pagrindiniai metodai, kuriuos naudosite dirbdami su trūkstamomis reikšmėmis pandas, atspindi šią idėją savo pavadinimuose:\n",
    "\n",
    "- `isnull()`: Sukuria loginę kaukę, nurodančią trūkstamas reikšmes\n",
    "- `notnull()`: Priešingas `isnull()`\n",
    "- `dropna()`: Grąžina filtruotą duomenų versiją\n",
    "- `fillna()`: Grąžina duomenų kopiją su užpildytomis arba įvertintomis trūkstamomis reikšmėmis\n",
    "\n",
    "Tai yra svarbūs metodai, kuriuos verta išmokti ir gerai suprasti, todėl panagrinėkime juos kiekvieną išsamiau.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "Yh5ifd9FgRsB"
   },
   "source": [
    "### Aptikti null reikšmes\n",
    "\n",
    "Dabar, kai supratome, kodėl trūkstamos reikšmės yra svarbios, turime jas aptikti savo duomenų rinkinyje, prieš pradėdami jas tvarkyti. \n",
    "Tiek `isnull()`, tiek `notnull()` yra pagrindiniai metodai, skirti aptikti null duomenis. Abu metodai grąžina Boole'o kaukes jūsų duomenims.\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": [
    "Atidžiai pažvelkite į rezultatą. Ar kas nors jus nustebino? Nors `0` yra aritmetinis nulis, jis vis tiek yra visiškai tinkamas sveikasis skaičius, ir pandas jį taip ir traktuoja. `''` yra šiek tiek subtilesnis. Nors 1 skyriuje jį naudojome kaip tuščios eilutės reikšmę, jis vis tiek yra eilutės objektas, o ne null reprezentacija pandas požiūriu.\n",
    "\n",
    "Dabar apsukime situaciją ir panaudokime šiuos metodus taip, kaip dažniausiai juos naudosite praktikoje. Boolean kaukes galite naudoti tiesiogiai kaip ``Series`` arba ``DataFrame`` indeksą, kas gali būti naudinga dirbant su izoliuotomis trūkstamomis (arba esamomis) reikšmėmis.\n",
    "\n",
    "Jei norime sužinoti bendrą trūkstamų reikšmių skaičių, tiesiog galime atlikti sumą per kaukę, kurią sukuria `isnull()` metodas.\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": [
    "### Pratimas:\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": [
    "**Svarbiausia**: Tiek `isnull()`, tiek `notnull()` metodai duoda panašius rezultatus, kai juos naudojate „DataFrame“ objektuose: jie parodo rezultatus ir tų rezultatų indeksus, kurie jums labai padės dirbant su duomenimis.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "BvnoojWsgRr4"
   },
   "source": [
    "### Darbas su trūkstamais duomenimis\n",
    "\n",
    "> **Mokymosi tikslas:** Šios poskyrio pabaigoje turėtumėte žinoti, kaip ir kada pakeisti arba pašalinti null reikšmes iš DataFrames.\n",
    "\n",
    "Mašininio mokymosi modeliai patys negali apdoroti trūkstamų duomenų. Todėl prieš perduodant duomenis modeliui, turime išspręsti šias trūkstamas reikšmes.\n",
    "\n",
    "Kaip tvarkomi trūkstami duomenys, turi subtilių kompromisų, kurie gali paveikti jūsų galutinę analizę ir realaus pasaulio rezultatus.\n",
    "\n",
    "Yra du pagrindiniai būdai, kaip spręsti trūkstamų duomenų problemą:\n",
    "\n",
    "1.   Pašalinti eilutę, kurioje yra trūkstama reikšmė\n",
    "2.   Pakeisti trūkstamą reikšmę kita reikšme\n",
    "\n",
    "Abi šias metodikas aptarsime išsamiai, įskaitant jų privalumus ir trūkumus.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "3VaYC1TvgRsD"
   },
   "source": [
    "### Null reikšmių pašalinimas\n",
    "\n",
    "Duomenų kiekis, kurį perduodame savo modeliui, tiesiogiai veikia jo našumą. Pašalinus null reikšmes, sumažiname duomenų taškų skaičių, o kartu ir duomenų rinkinio dydį. Todėl patartina pašalinti eilutes su null reikšmėmis, kai duomenų rinkinys yra pakankamai didelis.\n",
    "\n",
    "Kitas atvejis gali būti, kai tam tikra eilutė ar stulpelis turi daug trūkstamų reikšmių. Tokiu atveju jie gali būti pašalinti, nes jie nedaug prisidėtų prie mūsų analizės, kadangi dauguma duomenų toje eilutėje/stulpelyje yra trūkstami.\n",
    "\n",
    "Be trūkstamų reikšmių identifikavimo, pandas suteikia patogų būdą pašalinti null reikšmes iš `Series` ir `DataFrame`. Kad pamatytume, kaip tai veikia, grįžkime prie `example3`. Funkcija `DataFrame.dropna()` padeda pašalinti eilutes su null reikšmėmis.\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": [
    "Atkreipkite dėmesį, kad tai turėtų atrodyti kaip jūsų išvestis iš `example3[example3.notnull()]`. Skirtumas čia yra tas, kad vietoj tiesiog indeksavimo pagal užmaskuotas reikšmes, `dropna` pašalino tas trūkstamas reikšmes iš `Series` `example3`.\n",
    "\n",
    "Kadangi `DataFrame` turi dvi dimensijas, jos suteikia daugiau galimybių duomenims pašalinti.\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": [
    "(Ar pastebėjote, kad pandas pakeitė dviejų stulpelių tipą į float, kad galėtų apdoroti `NaN` reikšmes?)\n",
    "\n",
    "Negalite pašalinti vienos reikšmės iš `DataFrame`, todėl turite pašalinti visas eilutes arba stulpelius. Priklausomai nuo to, ką darote, galite norėti pasirinkti vieną ar kitą variantą, todėl pandas suteikia galimybę naudoti abu. Kadangi duomenų moksle stulpeliai paprastai atspindi kintamuosius, o eilutės – stebėjimus, dažniau pašalinamos eilutės su duomenimis; numatytasis `dropna()` nustatymas yra pašalinti visas eilutes, kuriose yra bet kokių null reikšmių:\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": [
    "Jei reikia, galite pašalinti NA reikšmes iš stulpelių. Naudokite `axis=1`, kad tai padarytumėte:\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": [
    "Atkreipkite dėmesį, kad tai gali pašalinti daug duomenų, kuriuos galbūt norėtumėte išsaugoti, ypač mažesniuose duomenų rinkiniuose. O kas, jei norite pašalinti tik tas eilutes ar stulpelius, kuriuose yra keli arba net visi null reikšmės? Šiuos nustatymus galite nurodyti `dropna` naudojant `how` ir `thresh` parametrus.\n",
    "\n",
    "Pagal numatytuosius nustatymus `how='any'` (jei norite patikrinti patys arba pamatyti, kokius kitus parametrus turi šis metodas, vykdykite `example4.dropna?` kodų langelyje). Taip pat galite nurodyti `how='all'`, kad pašalintumėte tik tas eilutes ar stulpelius, kuriuose yra visos null reikšmės. Išplėskime mūsų pavyzdinį `DataFrame`, kad pamatytume tai veikiant kitame pratime.\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": [
    "> Pagrindinės mintys:  \n",
    "1. Naikinti null reikšmes verta tik tada, kai duomenų rinkinys yra pakankamai didelis.  \n",
    "2. Pilnos eilutės ar stulpeliai gali būti pašalinti, jei dauguma jų duomenų trūksta.  \n",
    "3. `DataFrame.dropna(axis=)` metodas padeda pašalinti null reikšmes. Argumentas `axis` nurodo, ar reikia šalinti eilutes, ar stulpelius.  \n",
    "4. Taip pat galima naudoti argumentą `how`. Pagal numatytąją reikšmę jis nustatytas kaip `any`. Taigi, pašalinamos tik tos eilutės/stulpeliai, kuriuose yra bet kokių null reikšmių. Jį galima nustatyti kaip `all`, kad būtų pašalintos tik tos eilutės/stulpeliai, kur visi duomenys yra null.  \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "oXXSfQFHgRsF"
   },
   "source": [
    "### Pratimas:\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` parametras suteikia jums smulkesnę kontrolę: jūs nustatote *ne-null* reikšmių skaičių, kurį eilutė ar stulpelis turi turėti, kad būtų išsaugotas:\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": [
    "Čia pirmoji ir paskutinė eilutės buvo pašalintos, nes jos turi tik dvi nenull reikšmes.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "mCcxLGyUgRsG"
   },
   "source": [
    "### Užpildymas trūkstamomis reikšmėmis\n",
    "\n",
    "Kartais prasminga užpildyti trūkstamas reikšmes tokiomis, kurios galėtų būti tinkamos. Yra keletas būdų, kaip užpildyti null reikšmes. Pirmasis – pasitelkti domeno žinias (žinias apie temą, kuria pagrįstas duomenų rinkinys), kad būtų galima apytiksliai nustatyti trūkstamas reikšmes.\n",
    "\n",
    "Galite naudoti `isnull`, kad tai atliktumėte vietoje, tačiau tai gali būti varginantis procesas, ypač jei turite daug reikšmių, kurias reikia užpildyti. Kadangi tai yra labai dažna užduotis duomenų moksle, pandas siūlo `fillna`, kuris grąžina `Series` arba `DataFrame` kopiją su trūkstamomis reikšmėmis, pakeistomis jūsų pasirinktomis. Sukurkime dar vieną `Series` pavyzdį, kad pamatytume, kaip tai veikia praktiškai.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "CE8S7louLezV"
   },
   "source": [
    "### Kategoriniai duomenys (ne skaitiniai)\n",
    "Pirmiausia apsvarstykime ne skaitinius duomenis. Duomenų rinkiniuose turime stulpelius su kategoriniais duomenimis, pvz., lytis, tiesa arba melas ir pan.\n",
    "\n",
    "Daugeliu atvejų trūkstamas reikšmes pakeičiame stulpelio `moda`. Tarkime, turime 100 duomenų taškų, iš kurių 90 nurodė „Tiesa“, 8 nurodė „Melas“, o 2 neatsakė. Tuomet tuos 2 galime užpildyti „Tiesa“, atsižvelgdami į visą stulpelį.\n",
    "\n",
    "Vėlgi, čia galime pasinaudoti srities žiniomis. Pavyzdžiui, apsvarstykime užpildymą pagal modą.\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": [
    "Dabar pirmiausia suraskime modą prieš užpildydami `None` reikšmę moda.\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": [
    "Taigi, mes pakeisime None į 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": [
    "Kaip matome, null reikšmė buvo pakeista. Nereikia nė sakyti, kad galėjome parašyti bet ką vietoje `'True'` ir tai būtų buvę pakeista.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "heYe1I0dOmQ_"
   },
   "source": [
    "### Skaitiniai Duomenys\n",
    "Dabar pereikime prie skaitinių duomenų. Čia yra du dažniausiai naudojami būdai, kaip pakeisti trūkstamas reikšmes:\n",
    "\n",
    "1. Pakeisti eilutės mediana\n",
    "2. Pakeisti eilutės vidurkiu\n",
    "\n",
    "Mediana naudojama, kai duomenys yra iškreipti ir turi išskirtis. Taip yra todėl, kad mediana yra atspari išskirtims.\n",
    "\n",
    "Kai duomenys yra normalizuoti, galima naudoti vidurkį, nes tokiu atveju vidurkis ir mediana bus gana panašūs.\n",
    "\n",
    "Pirmiausia paimkime stulpelį, kuris yra normaliai pasiskirstęs, ir užpildykime trūkstamą reikšmę stulpelio vidurkiu.\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": [
    "Stulpelio vidurkis yra\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": [
    "Užpildymas vidurkiu\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": [
    "Kaip matome, trūkstama reikšmė buvo pakeista jos vidurkiu.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "jIvF13a1i00Z"
   },
   "source": [
    "Dabar pabandykime kitą duomenų rėmelį, ir šį kartą pakeisime None reikšmes stulpelio mediana.\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": [
    "Antrosios stulpelio mediana yra\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": [
    "Užpildymas medianos reikšme\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": [
    "Kaip matome, NaN reikšmė buvo pakeista stulpelio mediana.\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": [
    "Galite užpildyti visas tuščias reikšmes viena verte, pavyzdžiui, `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": [
    "> Pagrindinės mintys:\n",
    "1. Trūkstamas reikšmes reikėtų užpildyti, kai duomenų yra mažai arba kai yra strategija, kaip užpildyti trūkstamus duomenis.\n",
    "2. Trūkstamas reikšmes galima užpildyti naudojant srities žinias, jas apytiksliai įvertinant.\n",
    "3. Kategoriniams duomenims dažniausiai trūkstamos reikšmės pakeičiamos stulpelio moda.\n",
    "4. Skaitiniams duomenims trūkstamos reikšmės paprastai užpildomos stulpelio vidurkiu (normalizuotų duomenų atveju) arba mediana.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "FI9MmqFJgRsH"
   },
   "source": [
    "### Pratimas:\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": [
    "Galite **užpildyti pirmyn** null reikšmes, naudodami paskutinę galiojančią reikšmę null reikšmei užpildyti:\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": [
    "Taip pat galite **užpildyti atgal**, kad paskleistumėte kitą galiojančią reikšmę atgal ir užpildytumėte null:\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": [
    "Kaip galite spėti, tai veikia taip pat su „DataFrames“, tačiau taip pat galite nurodyti `axis`, pagal kurį užpildyti null reikšmes:\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": [
    "Atkreipkite dėmesį, kad kai ankstesnė reikšmė nėra prieinama užpildymui į priekį, null reikšmė lieka.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "eeAoOU0RgRsJ"
   },
   "source": [
    "### Pratimas:\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": [
    "Galite kūrybiškai naudoti `fillna`. Pavyzdžiui, pažvelkime į `example4` dar kartą, tačiau šį kartą užpildykime trūkstamas reikšmes visų `DataFrame` reikšmių vidurkiu:\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": [
    "Atkreipkite dėmesį, kad 3 stulpelis vis dar neturi reikšmių: numatytoji kryptis yra užpildyti reikšmes eilutėmis.\n",
    "\n",
    "> **Svarbu:** Yra daugybė būdų, kaip spręsti trūkstamų reikšmių problemą jūsų duomenų rinkiniuose. Konkreti strategija (jų pašalinimas, pakeitimas ar net tai, kaip juos pakeisite) turėtų būti nustatoma pagal konkrečius duomenų ypatumus. Kuo daugiau dirbsite su duomenų rinkiniais, tuo geriau suprasite, kaip tvarkyti trūkstamas reikšmes.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "bauDnESIl9FH"
   },
   "source": [
    "### Kategorinių duomenų kodavimas\n",
    "\n",
    "Mašininio mokymosi modeliai dirba tik su skaičiais ir bet kokia skaitine informacija. Jie negalės atskirti „Taip“ nuo „Ne“, tačiau galės atskirti 0 nuo 1. Todėl, užpildžius trūkstamas reikšmes, reikia koduoti kategorinius duomenis į tam tikrą skaitinę formą, kad modelis juos suprastų.\n",
    "\n",
    "Kodavimą galima atlikti dviem būdais. Toliau aptarsime juos.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "uDq9SxB7mu5i"
   },
   "source": [
    "**ETIKEČIŲ KODAVIMAS**\n",
    "\n",
    "Etikečių kodavimas iš esmės reiškia kiekvienos kategorijos pavertimą skaičiumi. Pavyzdžiui, tarkime, turime oro linijų keleivių duomenų rinkinį, kuriame yra stulpelis, nurodantis jų klasę iš šių ['verslo klasė', 'ekonominė klasė', 'pirma klasė']. Jei būtų atliktas etikečių kodavimas, tai būtų paversta į [0,1,2]. Pažiūrėkime pavyzdį per kodą. Kadangi artimiausiuose užrašuose mokysimės apie `scikit-learn`, čia jo nenaudosime.\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": [
    "Norėdami atlikti etikečių kodavimą pirmoje stulpelyje, pirmiausia turime aprašyti kiekvienos klasės atvaizdavimą į skaičių, prieš pakeičiant.\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": [
    "Kaip matome, rezultatas atitinka tai, ką tikėjomės. Taigi, kada naudojame etikečių kodavimą? Etikečių kodavimas naudojamas vienu ar abiem šiais atvejais:\n",
    "1. Kai kategorijų skaičius yra didelis\n",
    "2. Kai kategorijos yra tvarkoje.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "eQPAPVwsqWT7"
   },
   "source": [
    "**VIENOS KARŠTOS KODAVIMAS**\n",
    "\n",
    "Kitas kodavimo tipas yra Vienos Karštos Kodavimas (One Hot Encoding). Šio tipo kodavime kiekviena stulpelio kategorija pridedama kaip atskiras stulpelis, o kiekvienas duomenų taškas gauna 0 arba 1, priklausomai nuo to, ar jis atitinka tą kategoriją. Taigi, jei yra n skirtingų kategorijų, į duomenų rinkinį bus pridėti n stulpeliai.\n",
    "\n",
    "Pavyzdžiui, paimkime tą patį lėktuvo klasių pavyzdį. Kategorijos buvo: ['verslo klasė', 'ekonominė klasė', 'pirma klasė']. Taigi, jei atliksime vienos karštos kodavimą, į duomenų rinkinį bus pridėti šie trys stulpeliai: ['class_verslo klasė', 'class_ekonominė klasė', 'class_pirma klasė'].\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": [
    "Atlikime vienos karštosios kodavimo metodą pirmajai stulpeliui\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": [
    "Kiekviena vieno karšto kodavimo stulpelis turi 0 arba 1, kurie nurodo, ar ta kategorija egzistuoja tam duomenų taškui.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "bDnC4NQOu0qr"
   },
   "source": [
    "Kada naudojame vieno karšto kodavimą? Vieno karšto kodavimas naudojamas vienu ar abiem šiais atvejais:\n",
    "\n",
    "1. Kai kategorijų skaičius ir duomenų rinkinio dydis yra mažesni.\n",
    "2. Kai kategorijos neturi jokios konkrečios tvarkos.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "XnUmci_4uvyu"
   },
   "source": [
    "> Pagrindinės mintys:\n",
    "1. Kodavimas atliekamas siekiant konvertuoti ne skaitinius duomenis į skaitinius.\n",
    "2. Yra du kodavimo tipai: žymų kodavimas ir vieno karšto kodavimas, kurie gali būti atliekami atsižvelgiant į duomenų rinkinio poreikius.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "K8UXOJYRgRsJ"
   },
   "source": [
    "## Duomenų dubliavimo pašalinimas\n",
    "\n",
    "> **Mokymosi tikslas:** Šio poskyrio pabaigoje turėtumėte jaustis užtikrintai identifikuodami ir pašalindami pasikartojančias reikšmes iš DataFrame.\n",
    "\n",
    "Be trūkstamų duomenų, realiuose duomenų rinkiniuose dažnai susidursite su pasikartojančiais duomenimis. Laimei, pandas suteikia paprastą būdą aptikti ir pašalinti pasikartojančius įrašus.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "qrEG-Wa0gRsJ"
   },
   "source": [
    "### Dubliu atpažinimas: `duplicated`\n",
    "\n",
    "Naudodami pandas metodą `duplicated`, galite lengvai nustatyti pasikartojančias reikšmes. Šis metodas grąžina Boole'o kaukę, nurodančią, ar įrašas `DataFrame` yra ankstesnio įrašo dublikatas. Sukurkime dar vieną pavyzdinį `DataFrame`, kad pamatytume, kaip tai veikia.\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": [
    "### Pašalinimas pasikartojančių reikšmių: `drop_duplicates`\n",
    "`drop_duplicates` tiesiog grąžina duomenų kopiją, kurioje visos `duplicated` reikšmės yra `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": [
    "Tiek `duplicated`, tiek `drop_duplicates` pagal numatytuosius nustatymus atsižvelgia į visas stulpelius, tačiau galite nurodyti, kad jie tikrintų tik tam tikrą jūsų `DataFrame` stulpelių dalį:\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": [
    "> **Svarbiausia:** Pašalinti pasikartojančius duomenis yra būtina beveik kiekvieno duomenų mokslo projekto dalis. Pasikartojantys duomenys gali pakeisti jūsų analizės rezultatus ir pateikti netikslius rezultatus!\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Tikrinimas duomenų kokybės realiame pasaulyje\n",
    "\n",
    "> **Mokymosi tikslas:** Šio skyriaus pabaigoje turėtumėte jaustis užtikrintai aptikdami ir taisydami dažniausiai pasitaikančias duomenų kokybės problemas, tokias kaip nenuoseklūs kategoriniai reikšmės, nenormalios skaitinės reikšmės (išskirtiniai atvejai) ir pasikartojančios esybės su variacijomis.\n",
    "\n",
    "Nors trūkstamos reikšmės ir tikslūs dublikatai yra dažnos problemos, realaus pasaulio duomenų rinkiniuose dažnai pasitaiko subtilesnių problemų:\n",
    "\n",
    "1. **Nenuoseklūs kategoriniai reikšmės**: Ta pati kategorija užrašyta skirtingai (pvz., \"USA\", \"U.S.A\", \"United States\")\n",
    "2. **Nenormalios skaitinės reikšmės**: Ekstremalūs išskirtiniai atvejai, rodantys klaidas duomenų įvedime (pvz., amžius = 999)\n",
    "3. **Beveik pasikartojančios eilutės**: Įrašai, kurie atspindi tą pačią esybę su nedideliais skirtumais\n",
    "\n",
    "Pažvelkime į metodus, kaip aptikti ir spręsti šias problemas.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Sukurkime pavyzdinį „nešvarų“ duomenų rinkinį\n",
    "\n",
    "Pirmiausia sukurkime pavyzdinį duomenų rinkinį, kuriame būtų problemų, su kuriomis dažnai susiduriame realiuose duomenyse:\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. Nenuoseklių kategorinių reikšmių aptikimas\n",
    "\n",
    "Atkreipkite dėmesį, kad `country` stulpelyje yra kelios to paties šalies reprezentacijos. Išsiaiškinkime šiuos neatitikimus:\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": [
    "#### Kategorinių reikšmių standartizavimas\n",
    "\n",
    "Galime sukurti žemėlapį, kad standartizuotume šias reikšmes. Paprastas būdas yra konvertuoti į mažąsias raides ir sukurti žemėlapio žodyną:\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": [
    "**Alternatyva: Naudojant neaiškų atitikimą**\n",
    "\n",
    "Sudėtingesniais atvejais galime naudoti neaiškų teksto atitikimą su `rapidfuzz` biblioteka, kad automatiškai aptiktume panašius tekstus:\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. Aptikti neįprastas skaitines reikšmes (išskirtis)\n",
    "\n",
    "Žvelgiant į `age` stulpelį, pastebime keletą įtartinų reikšmių, tokių kaip 199 ir -5. Pasitelkime statistinius metodus, kad aptiktume šias išskirtis.\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": [
    "#### Naudojant IQR (Tarpkvartilinis diapazonas) metodą\n",
    "\n",
    "IQR metodas yra patikimas statistinis būdas aptikti išskirtines reikšmes, kuris yra mažiau jautrus ekstremalioms reikšmėms:\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": [
    "#### Naudojant Z-reitingo metodą\n",
    "\n",
    "Z-reitingo metodas nustato išskirtis pagal standartinius nuokrypius nuo vidurkio:\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": [
    "#### Darbas su išskirtimis\n",
    "\n",
    "Aptikus išskirtis, jas galima tvarkyti keliais būdais:\n",
    "1. **Pašalinti**: Ištrinti eilutes su išskirtimis (jei tai klaidos)\n",
    "2. **Apriboti**: Pakeisti ribinėmis reikšmėmis\n",
    "3. **Pakeisti į NaN**: Traktuoti kaip trūkstamus duomenis ir taikyti imputacijos metodus\n",
    "4. **Palikti**: Jei tai teisėtos ekstremalios reikšmės\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. Aptikti beveik pasikartojančias eilutes\n",
    "\n",
    "Pastebėkite, kad mūsų duomenų rinkinyje yra kelios „John Smith“ įrašų versijos su šiek tiek skirtingomis reikšmėmis. Pabandykime nustatyti galimus pasikartojimus pagal vardų panašumą.\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": [
    "#### Artimų dublikatų paieška naudojant neaiškų atitikimą\n",
    "\n",
    "Norint atlikti sudėtingesnį dublikatų aptikimą, galime naudoti neaiškų atitikimą, kad rastume panašius vardus:\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": [
    "#### Tvarkymas su pasikartojančiais duomenimis\n",
    "\n",
    "Kai pasikartojimai yra nustatyti, reikia nuspręsti, kaip juos tvarkyti:\n",
    "1. **Palikti pirmą pasikartojimą**: Naudokite `drop_duplicates(keep='first')`\n",
    "2. **Palikti paskutinį pasikartojimą**: Naudokite `drop_duplicates(keep='last')`\n",
    "3. **Apjungti informaciją**: Sujungti informaciją iš pasikartojančių eilučių\n",
    "4. **Rankinis peržiūrėjimas**: Pažymėti peržiūrai žmogui\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": [
    "### Santrauka: Pilnas duomenų valymo procesas\n",
    "\n",
    "Sujunkime viską į išsamų valymo procesą:\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": [
    "### 🎯 Iššūkio užduotis\n",
    "\n",
    "Dabar tavo eilė! Žemiau pateikta nauja duomenų eilutė su daugybe kokybės problemų. Ar gali:\n",
    "\n",
    "1. Nustatyti visas problemas šioje eilutėje\n",
    "2. Parašyti kodą, kuris išsprendžia kiekvieną problemą\n",
    "3. Pridėti išvalytą eilutę prie duomenų rinkinio\n",
    "\n",
    "Štai probleminiai duomenys:\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": [
    "### Pagrindinės įžvalgos\n",
    "\n",
    "1. **Nesuderintos kategorijos** yra dažnas reiškinys realiuose duomenyse. Visada patikrinkite unikalius reikšmių sąrašus ir standartizuokite jas naudodami žemėlapius arba neaiškų atitikimą.\n",
    "\n",
    "2. **Išskirtinės reikšmės** gali stipriai paveikti jūsų analizę. Naudokite srities žinias kartu su statistiniais metodais (IQR, Z-score), kad jas aptiktumėte.\n",
    "\n",
    "3. **Beveik pasikartojančias reikšmes** sunkiau aptikti nei tikslius pasikartojimus. Apsvarstykite galimybę naudoti neaiškų atitikimą ir normalizuoti duomenis (mažosios raidės, tarpų pašalinimas), kad jas identifikuotumėte.\n",
    "\n",
    "4. **Duomenų valymas yra iteratyvus procesas**. Gali tekti taikyti kelis metodus ir peržiūrėti rezultatus prieš galutinai išvalant duomenų rinkinį.\n",
    "\n",
    "5. **Dokumentuokite savo sprendimus**. Sekite, kokius valymo veiksmus taikėte ir kodėl, nes tai svarbu atkuriamumui ir skaidrumui.\n",
    "\n",
    "> **Geriausia praktika:** Visada išsaugokite originalius „nešvarius“ duomenis. Niekada neperrašykite pirminių duomenų failų – sukurkite išvalytas versijas su aiškiais pavadinimais, pvz., `data_cleaned.csv`.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n---\n\n**Atsakomybės apribojimas**:  \nŠis dokumentas buvo išverstas naudojant AI vertimo paslaugą [Co-op Translator](https://github.com/Azure/co-op-translator). Nors stengiamės užtikrinti tikslumą, prašome atkreipti dėmesį, kad automatiniai vertimai gali turėti klaidų ar netikslumų. Originalus dokumentas jo gimtąja kalba turėtų būti laikomas autoritetingu šaltiniu. Kritinei informacijai rekomenduojama naudoti profesionalų žmogaus vertimą. Mes neprisiimame atsakomybės už nesusipratimus ar neteisingą interpretaciją, atsiradusią dėl šio vertimo naudojimo.\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-03T21:27:21+00:00",
   "source_file": "2-Working-With-Data/08-data-preparation/notebook.ipynb",
   "language_code": "lt"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}