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

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "rQ8UhzFpgRra"
   },
   "source": [
    "# Припрема података\n",
    "\n",
    "[Оригинални извор бележнице из *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`\n",
    "\n",
    "> **Циљ учења:** На крају овог пододељка, требало би да будете у могућности да пронађете опште информације о подацима који се чувају у pandas DataFrame-овима.\n",
    "\n",
    "Када учитате своје податке у pandas, веома је вероватно да ће бити у облику `DataFrame`. Међутим, ако ваш скуп података у `DataFrame`-у има 60,000 редова и 400 колона, како уопште да почнете да разумете са чим радите? Срећом, pandas пружа неке практичне алате за брз преглед општих информација о `DataFrame`, као и првих и последњих неколико редова.\n",
    "\n",
    "Да бисмо истражили ову функционалност, увешћемо Python библиотеку scikit-learn и користити један иконичан скуп података који је сваки научник података видео стотине пута: скуп података британског биолога Роналда Фишера *Iris*, коришћен у његовом раду из 1936. године \"The use of multiple measurements in taxonomic problems\":\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": true,
    "id": "hB1RofhdgRrp",
    "trusted": false
   },
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "from sklearn.datasets import load_iris\n",
    "\n",
    "iris = load_iris()\n",
    "iris_df = pd.DataFrame(data=iris['data'], columns=iris['feature_names'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "AGA0A_Y8hMdz"
   },
   "source": [
    "### `DataFrame.shape`\n",
    "Учитали смо Iris Dataset у променљиву `iris_df`. Пре него што се удубимо у податке, било би корисно знати број података које имамо и укупну величину скупа података. Корисно је погледати обим података са којима радимо.\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": [
    "Дакле, имамо 150 редова и 4 колоне података. Сваки ред представља једну тачку података, а свака колона представља једну карактеристику повезану са оквиром података. У суштини, постоји 150 тачака података које садрже по 4 карактеристике.\n",
    "\n",
    "`shape` је овде атрибут оквира података, а не функција, због чега се не завршава са паром заграда.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "d3AZKs0PinGP"
   },
   "source": [
    "### `DataFrame.columns`\n",
    "Хајде сада да пређемо на 4 колоне података. Шта тачно представља свака од њих? Атрибут `columns` ће нам дати имена колона у датафрејму.\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": [
    "Као што можемо видети, постоје четири (4) колоне. Атрибут `columns` нам говори имена колона и у суштини ништа више. Овај атрибут постаје важан када желимо да идентификујемо карактеристике које скуп података садржи.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "2UTlvkjmgRrs"
   },
   "source": [
    "### `DataFrame.info`\n",
    "Количина података (датих преко атрибута `shape`) и имена карактеристика или колона (датих преко атрибута `columns`) нам говоре нешто о скупу података. Сада бисмо желели да се детаљније позабавимо скупом података. Функција `DataFrame.info()` је веома корисна за ово.\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": [
    "Одавде можемо направити неколико запажања:\n",
    "1. Тип података сваке колоне: У овом скупу података, сви подаци су сачувани као 64-битни бројеви са покретним зарезом.\n",
    "2. Број вредности које нису Null: Рад са Null вредностима је важан корак у припреми података. Овим ће се бавити касније у бележници.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "IYlyxbpWFEF4"
   },
   "source": [
    "### DataFrame.describe()\n",
    "Рецимо да имамо много нумеричких података у нашем сету података. Једноваријантне статистичке прорачуне, као што су средња вредност, медијана, квартили итд., можемо извршити за сваку колону појединачно. Функција `DataFrame.describe()` нам пружа статистички преглед нумеричких колона у сету података.\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": [
    "Горњи излаз приказује укупан број података, средњу вредност, стандардну девијацију, минимум, доњи квартил (25%), медијану (50%), горњи квартил (75%) и максималну вредност сваке колоне.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "-lviAu99gRrv"
   },
   "source": [
    "### `DataFrame.head`\n",
    "Са свим горе наведеним функцијама и атрибутима, добили смо преглед на високом нивоу скупа података. Знамо колико има тачака података, колико има карактеристика, тип података сваке карактеристике и број вредности које нису null за сваку карактеристику.\n",
    "\n",
    "Сада је време да погледамо самe податке. Хајде да видимо како изгледају првих неколико редова (првих неколико тачака података) нашег `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": [
    "Као што је приказано овде, можемо видети пет (5) уноса из скупа података. Ако погледамо индекс са леве стране, откривамо да су то првих пет редова.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "oj7GkrTdgRry"
   },
   "source": [
    "### Вежба:\n",
    "\n",
    "Из горњег примера је јасно да `DataFrame.head` подразумевано враћа првих пет редова `DataFrame`-а. У коду испод, можете ли смислити начин да прикажете више од пет редова?\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",
    "Још један начин гледања на податке може бити од краја (уместо од почетка). Супротност `DataFrame.head` је `DataFrame.tail`, који враћа последњих пет редова `DataFrame`:\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": [
    "У пракси је корисно моћи лако прегледати првих неколико редова или последњих неколико редова `DataFrame`, посебно када тражите екстремне вредности у уређеним скуповима података.\n",
    "\n",
    "Све функције и атрибути приказани изнад уз помоћ примера кода помажу нам да стекнемо увид у податке.\n",
    "\n",
    "> **Закључак:** Чак и само гледањем метаподатака о информацијама у `DataFrame`-у или првих и последњих неколико вредности у њему, можете одмах добити идеју о величини, облику и садржају података са којима радите.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "TvurZyLSDxq_"
   },
   "source": [
    "### Недостајући подаци\n",
    "Хајде да се позабавимо недостајућим подацима. Недостајући подаци се јављају када нека вредност није ускладиштена у одређеним колонама.\n",
    "\n",
    "Узмимо пример: рецимо да је неко свестан своје тежине и не попуни поље за тежину у анкети. Тада ће вредност тежине за ту особу недостајати.\n",
    "\n",
    "У већини случајева, у стварним скуповима података, јављају се недостајуће вредности.\n",
    "\n",
    "**Како Pandas обрађује недостајуће податке**\n",
    "\n",
    "Pandas обрађује недостајуће вредности на два начина. Први начин сте већ видели у претходним одељцима: `NaN`, или Not a Number. Ово је заправо посебна вредност која је део IEEE спецификације за бројеве са покретним зарезом и користи се само за означавање недостајућих вредности са покретним зарезом.\n",
    "\n",
    "За недостајуће вредности које нису бројеви са покретним зарезом, pandas користи Python објекат `None`. Иако може изгледати збуњујуће што ћете наићи на две различите врсте вредности које у суштини значе исто, постоје добри програмски разлози за овај избор дизајна, а у пракси, овај приступ омогућава pandas-у да пружи добар компромис за велику већину случајева. Упркос томе, и `None` и `NaN` имају ограничења која треба имати на уму у погледу начина на који се могу користити.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "lOHqUlZFgRr5"
   },
   "source": [
    "### `None`: недостајући подаци који нису типа float\n",
    "Пошто `None` потиче из Python-а, не може се користити у NumPy и pandas низовима који нису типа података `'object'`. Запамтите, NumPy низови (и структуре података у pandas-у) могу садржати само један тип података. Управо то им даје огромну моћ за рад са великим количинама података и обраду, али истовремено ограничава њихову флексибилност. Такви низови морају да се конвертују у „најнижи заједнички именилац“, односно тип података који може обухватити све у низу. Када је `None` у низу, то значи да радите са Python објектима.\n",
    "\n",
    "Да бисте видели како ово функционише, погледајте следећи пример низа (обратите пажњу на `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": [
    "Реалност надограђених типова података носи са собом два споредна ефекта. Прво, операције ће се изводити на нивоу интерпретираног Python кода, а не компајлираног NumPy кода. У суштини, то значи да ће све операције које укључују `Series` или `DataFrames` са `None` у њима бити спорије. Иако вероватно нећете приметити овај пад перформанси, код великих скупова података то би могло постати проблем.\n",
    "\n",
    "Други споредни ефекат произилази из првог. Пошто `None` у суштини враћа `Series` или `DataFrame` у свет обичног Python-а, коришћење NumPy/pandas агрегација као што су `sum()` или `min()` на низовима који садрже вредност ``None`` генерално ће произвести грешку:\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": [
    "**Кључна порука**: Сабирање (и друге операције) између целих бројева и вредности `None` је недефинисано, што може ограничити оно што можете урадити са скуповима података који их садрже.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "pWvVHvETgRr9"
   },
   "source": [
    "### `NaN`: недостајуће вредности типа float\n",
    "\n",
    "За разлику од `None`, NumPy (а самим тим и pandas) подржава `NaN` за своје брзе, векторизоване операције и ufuncs. Лоша вест је да свака аритметичка операција извршена над `NaN` увек резултира `NaN`. На пример:\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": [
    "Добра вест: агрегације које се извршавају на низовима са `NaN` у њима не изазивају грешке. Лоша вест: резултати нису униформно корисни:\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": [
    "### Вежба:\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": [
    "Запамти: `NaN` је само за недостајуће вредности са покретним зарезом; не постоји еквивалент `NaN` за целе бројеве, стрингове или булове вредности.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "kj6EKdsAgRsA"
   },
   "source": [
    "### `NaN` и `None`: нулте вредности у pandas-у\n",
    "\n",
    "Иако се `NaN` и `None` могу понашати мало другачије, pandas је ипак направљен тако да их обрађује наизменично. Да бисмо објаснили шта то значи, размотримо `Series` целих бројева:\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": [
    "### Вежба:\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": [
    "У процесу подизања типова података ради успостављања хомогености података у `Series` и `DataFrame` објектима, pandas ће без проблема заменити недостајуће вредности између `None` и `NaN`. Због ове дизајнерске карактеристике, корисно је размишљати о `None` и `NaN` као о две различите врсте \"нултог\" у pandas-у. Заиста, неки од основних метода које ћете користити за рад са недостајућим вредностима у pandas-у одражавају ову идеју у својим називима:\n",
    "\n",
    "- `isnull()`: Генерише Булову маску која указује на недостајуће вредности\n",
    "- `notnull()`: Супротно од `isnull()`\n",
    "- `dropna()`: Враћа филтрирану верзију података\n",
    "- `fillna()`: Враћа копију података са попуњеним или импутираним недостајућим вредностима\n",
    "\n",
    "Ово су важни методи које треба савладати и са којима треба бити комфоран, па хајде да их детаљније размотримо.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "Yh5ifd9FgRsB"
   },
   "source": [
    "### Откривање null вредности\n",
    "\n",
    "Сада када смо разумели значај недостајућих вредности, потребно је да их откријемо у нашем скупу података пре него што их обрадимо. \n",
    "И `isnull()` и `notnull()` су ваши основни методи за откривање null података. Оба враћају Булове маске преко ваших података.\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": [
    "Пажљиво погледајте резултат. Да ли вас нешто изненађује? Иако је `0` аритметичка нула, он је ипак сасвим добар целобројни тип, и pandas га тако третира. `''` је мало суптилнији. Иако смо га у Секцији 1 користили да представимо празну вредност стринга, он је ипак објекат типа стринг, а не представљање null вредности када је у питању pandas.\n",
    "\n",
    "Сада, хајде да ово окренемо и користимо ове методе на начин који је ближи стварној пракси. Boolean маске можете користити директно као индекс ``Series`` или ``DataFrame``, што може бити корисно када покушавате да радите са изолованим недостајућим (или присутним) вредностима.\n",
    "\n",
    "Ако желимо укупан број недостајућих вредности, можемо једноставно урадити суму преко маске коју производи метода `isnull()`.\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": [
    "### Вежба:\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": [
    "**Кључна ствар**: И `isnull()` и `notnull()` методе дају сличне резултате када их користите у DataFrame-овима: приказују резултате и индекс тих резултата, што ће вам изузетно помоћи док се борите са вашим подацима.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "BvnoojWsgRr4"
   },
   "source": [
    "### Рад са недостајућим подацима\n",
    "\n",
    "> **Циљ учења:** До краја овог пододељка, требало би да знате како и када да замените или уклоните null вредности из DataFrame-ова.\n",
    "\n",
    "Модели машинског учења не могу сами да обрађују недостајуће податке. Зато је неопходно да се ти недостајући подаци обраде пре него што се проследе моделу.\n",
    "\n",
    "Начин на који се недостајући подаци обрађују носи са собом суптилне компромисе, може утицати на вашу коначну анализу и исходе у стварном свету.\n",
    "\n",
    "Постоје два основна начина за рад са недостајућим подацима:\n",
    "\n",
    "1.   Уклонити ред који садржи недостајућу вредност\n",
    "2.   Заменити недостајућу вредност неком другом вредношћу\n",
    "\n",
    "Размотрићемо оба ова метода и њихове предности и мане у детаљима.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "3VaYC1TvgRsD"
   },
   "source": [
    "### Уклањање празних вредности\n",
    "\n",
    "Количина података коју прослеђујемо нашем моделу директно утиче на његову перформансу. Уклањање празних вредности значи да смањујемо број тачака података, а тиме и величину скупа података. Због тога је препоручљиво уклонити редове са празним вредностима када је скуп података прилично велик.\n",
    "\n",
    "Други случај може бити да одређени ред или колона имају много недостајућих вредности. У том случају, могу бити уклоњени јер не би значајно допринели нашој анализи, пошто је већина података за тај ред/колону недостајућа.\n",
    "\n",
    "Поред идентификовања недостајућих вредности, pandas пружа практичан начин за уклањање празних вредности из `Series` и `DataFrame`-ова. Да бисмо видели како то функционише, вратићемо се на `example3`. Функција `DataFrame.dropna()` помаже у уклањању редова са празним вредностима.\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": [
    "Имајте на уму да ово треба да изгледа као ваш излаз из `example3[example3.notnull()]`. Разлика овде је у томе што је, уместо само индексирања на маскиране вредности, `dropna` уклонио те недостајуће вредности из `Series` `example3`.\n",
    "\n",
    "Пошто DataFrame има две димензије, пружа више опција за уклањање података.\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": [
    "(Да ли сте приметили да је pandas претворио две колоне у тип података `float` како би прилагодио `NaN` вредности?)\n",
    "\n",
    "Не можете уклонити само једну вредност из `DataFrame`, већ морате уклонити целе редове или колоне. У зависности од тога шта радите, можда ћете желети да урадите једно или друго, па вам pandas пружа могућности за оба. Пошто у науци о подацима колоне углавном представљају променљиве, а редови представљају запажања, вероватније је да ћете уклањати редове података; подразумевана поставка за `dropna()` је да уклони све редове који садрже било какве null вредности:\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": [
    "Ако је потребно, можете уклонити NA вредности из колона. Користите `axis=1` да то урадите:\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": [
    "Имајте на уму да ово може уклонити много података које можда желите да задржите, посебно у мањим скуповима података. Шта ако желите да уклоните само редове или колоне које садрже неколико или чак све null вредности? Те поставке можете одредити у `dropna` помоћу параметара `how` и `thresh`.\n",
    "\n",
    "Подразумевано, `how='any'` (ако желите сами да проверите или видите које друге параметре метода има, покрените `example4.dropna?` у коду). Алтернативно, можете одредити `how='all'` како бисте уклонили само редове или колоне које садрже све null вредности. Проширићемо наш пример `DataFrame` да бисмо видели како ово функционише у наредној вежби.\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": [
    "> Кључне напомене:  \n",
    "1. Уклањање празних вредности је добра идеја само ако је скуп података довољно велики.  \n",
    "2. Цели редови или колоне могу бити уклоњени ако већина њихових података недостаје.  \n",
    "3. Метода `DataFrame.dropna(axis=)` помаже у уклањању празних вредности. Аргумент `axis` означава да ли треба уклонити редове или колоне.  \n",
    "4. Аргумент `how` такође може бити коришћен. Подразумевано је постављен на `any`. Дакле, уклањају се само они редови/колоне који садрже било какве празне вредности. Може бити постављен на `all` да би се одредило да ће бити уклоњени само они редови/колоне где су све вредности празне.  \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "oXXSfQFHgRsF"
   },
   "source": [
    "### Вежба:\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` вам пружа прецизнију контролу: постављате број *не-null* вредности које ред или колона морају имати да би били задржани:\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": [
    "Овде су први и последњи ред уклоњени, јер садрже само две ненулте вредности.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "mCcxLGyUgRsG"
   },
   "source": [
    "### Попуњавање празних вредности\n",
    "\n",
    "Понекад има смисла попунити недостајуће вредности оним које би могле бити валидне. Постоји неколико техника за попуњавање празних вредности. Прва је коришћење доменског знања (знања о теми на којој се заснива скуп података) како би се на неки начин приближно одредиле недостајуће вредности.\n",
    "\n",
    "Можете користити `isnull` за попуњавање вредности директно, али то може бити напорно, нарочито ако имате много вредности које треба попунити. Пошто је ово веома чест задатак у науци о подацима, pandas пружа функцију `fillna`, која враћа копију `Series` или `DataFrame` са недостајућим вредностима замењеним оним које сами изаберете. Хајде да направимо још један пример `Series` да видимо како ово функционише у пракси.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "CE8S7louLezV"
   },
   "source": [
    "### Категоријски подаци (Ненумерички)\n",
    "Прво, хајде да размотримо ненумеричке податке. У скуповима података имамо колоне са категоријским подацима, на пример, пол, тачно или нетачно итд.\n",
    "\n",
    "У већини ових случајева, недостајуће вредности замењујемо `модом` колоне. Рецимо, имамо 100 података, од којих је 90 одговорило тачно, 8 нетачно, а 2 нису попуњена. Тада можемо попунити та два са тачно, узимајући у обзир целу колону.\n",
    "\n",
    "И овде можемо користити знање из домена. Хајде да размотримо пример попуњавања модом.\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": [
    "Сада, хајде прво да пронађемо мод пре него што попунимо вредност `None` модом.\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": [
    "Дакле, заменићемо 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": [
    "Као што можемо видети, нулта вредност је замењена. Наравно, могли смо написати било шта уместо `'True'` и то би било замењено.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "heYe1I0dOmQ_"
   },
   "source": [
    "### Нумерички подаци\n",
    "Сада прелазимо на нумеричке податке. Овде постоје два уобичајена начина за замену недостајућих вредности:\n",
    "\n",
    "1. Замена медијаном реда\n",
    "2. Замена средњом вредношћу реда\n",
    "\n",
    "Медијан користимо у случају искривљених података са екстремним вредностима. То је зато што је медијан отпоран на екстремне вредности.\n",
    "\n",
    "Када су подаци нормализовани, можемо користити средњу вредност, јер би у том случају средња вредност и медијан били прилично блиски.\n",
    "\n",
    "Прво, узмимо колону која је нормално распоређена и попунимо недостајућу вредност средњом вредношћу те колоне.\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": [
    "Средња вредност колоне је\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": [
    "Попуњавање са средњом вредношћу\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": [
    "Као што можемо видети, недостајућа вредност је замењена њеном средином.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "jIvF13a1i00Z"
   },
   "source": [
    "Сада хајде да пробамо други датафрејм, и овог пута ћемо заменити вредности None медијаном колоне.\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": [
    "Медијана друге колоне је\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": [
    "Попуњавање медијаном\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": [
    "Као што можемо видети, вредност NaN је замењена медијаном колоне.\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": [
    "Можете попунити све празне уносе једном вредношћу, као што је `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": [
    "> Главне напомене:\n",
    "1. Попуњавање недостајућих вредности треба обавити када има мање података или постоји стратегија за попуњавање недостајућих података.\n",
    "2. Доменско знање може се користити за попуњавање недостајућих вредности приближним проценама.\n",
    "3. Код категоријских података, недостајуће вредности се углавном замењују модом колоне.\n",
    "4. Код нумеричких података, недостајуће вредности се обично попуњавају просеком (за нормализоване скупове података) или медијаном колона.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "FI9MmqFJgRsH"
   },
   "source": [
    "### Вежба:\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": [
    "Можете **попунити унапред** празне вредности, што значи користити последњу важећу вредност за попуњавање празног места:\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": [
    "Можете такође **уназад попунити** да бисте уназад пренели следећу важећу вредност како бисте попунили празнину:\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": [
    "Као што можете претпоставити, ово функционише исто са DataFrame-овима, али можете такође одредити `axis` дуж којег ће се попуњавати null вредности:\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": [
    "Имајте на уму да када претходна вредност није доступна за попуњавање унапред, празна вредност остаје.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "eeAoOU0RgRsJ"
   },
   "source": [
    "### Вежба:\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": [
    "Можете бити креативни у начину на који користите `fillna`. На пример, хајде да поново погледамо `example4`, али овог пута да попунимо недостајуће вредности просеком свих вредности у `DataFrame`:\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": [
    "Приметите да је колона 3 и даље без вредности: подразумевани начин је попуњавање вредности ред по ред.\n",
    "\n",
    "> **Закључак:** Постоји више начина за решавање недостајућих вредности у вашим скуповима података. Конкретна стратегија коју користите (уклањање, замена или чак начин на који их замењујете) треба да буде одређена специфичностима тих података. Развићете бољи осећај за решавање недостајућих вредности што више радите и интерагујете са скуповима података.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "bauDnESIl9FH"
   },
   "source": [
    "### Кодирање категоријалних података\n",
    "\n",
    "Машинско учење ради искључиво са бројевима и било којим обликом нумеричких података. Неће моћи да разликује између \"Да\" и \"Не\", али ће моћи да разликује између 0 и 1. Зато, након попуњавања недостајућих вредности, потребно је да категоријалне податке кодирамо у неки нумерички облик како би модел могао да их разуме.\n",
    "\n",
    "Кодирање се може обавити на два начина. О њима ћемо говорити у наставку.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "uDq9SxB7mu5i"
   },
   "source": [
    "**КОДИРАЊЕ ЕТИКЕТА**\n",
    "\n",
    "Кодирање етикета подразумева претварање сваке категорије у број. На пример, рецимо да имамо скуп података о путницима авиона и постоји колона која садржи њихову класу међу следећим ['бизнис класа', 'економска класа', 'прва класа']. Ако се изврши кодирање етикета, ово би се трансформисало у [0,1,2]. Хајде да видимо пример кроз код. Како ћемо учити `scikit-learn` у наредним бележницама, овде га нећемо користити.\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": [
    "Да бисмо извршили кодирање етикета на првој колони, прво морамо описати пресликавање сваке класе у број, пре него што заменимо.\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": [
    "Као што можемо видети, резултат одговара ономе што смо очекивали. Дакле, када користимо кодирање етикета? Кодирање етикета се користи у једном или оба следећа случаја:\n",
    "1. Када је број категорија велики\n",
    "2. Када су категорије у одређеном редоследу.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "eQPAPVwsqWT7"
   },
   "source": [
    "**ONE HOT ENCODING**\n",
    "\n",
    "Један од типова кодирања је One Hot Encoding. Код овог типа кодирања, свака категорија из колоне се додаје као посебна колона, а свака тачка података добија 0 или 1 у зависности од тога да ли садржи ту категорију. Дакле, ако постоји n различитих категорија, n колона ће бити додато у датасет.\n",
    "\n",
    "На пример, узмимо исти пример класе авиона. Категорије су биле: ['business class', 'economy class', 'first class']. Дакле, ако применимо One Hot Encoding, следеће три колоне ће бити додате у датасет: ['class_business class', 'class_economy class', 'class_first class'].\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 235
    },
    "id": "ZM0eVh0ArKUL",
    "outputId": "83238a76-b3a5-418d-c0b6-605b02b6891b"
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>ID</th>\n",
       "      <th>class</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>10</td>\n",
       "      <td>business class</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>20</td>\n",
       "      <td>first class</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>30</td>\n",
       "      <td>economy class</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>40</td>\n",
       "      <td>economy class</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>50</td>\n",
       "      <td>economy class</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>60</td>\n",
       "      <td>business class</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   ID           class\n",
       "0  10  business class\n",
       "1  20     first class\n",
       "2  30   economy class\n",
       "3  40   economy class\n",
       "4  50   economy class\n",
       "5  60  business class"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "one_hot = pd.DataFrame([\n",
    "                      [10,'business class'],\n",
    "                      [20,'first class'],\n",
    "                      [30, 'economy class'],\n",
    "                      [40, 'economy class'],\n",
    "                      [50, 'economy class'],\n",
    "                      [60, 'business class']\n",
    "],columns=['ID','class'])\n",
    "one_hot"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "aVnZ7paDrWmb"
   },
   "source": [
    "Хајде да извршимо једно-вруће кодирање на првој колони\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": [
    "Свака колона кодирана методом један-на-један садржи 0 или 1, што означава да ли та категорија постоји за ту тачку података.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "bDnC4NQOu0qr"
   },
   "source": [
    "Када користимо one hot encoding? One hot encoding се користи у једном или оба следећа случаја:\n",
    "\n",
    "1. Када је број категорија и величина скупа података мањи.\n",
    "2. Када категорије не прате никакав одређени редослед.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "XnUmci_4uvyu"
   },
   "source": [
    "> Главне тачке:\n",
    "1. Кодирање се врши како би се неконумерички подаци претворили у нумеричке.\n",
    "2. Постоје два типа кодирања: кодирање етикета и One Hot кодирање, оба се могу применити у зависности од потреба скупа података.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "K8UXOJYRgRsJ"
   },
   "source": [
    "## Уклањање дуплираних података\n",
    "\n",
    "> **Циљ учења:** На крају овог пододељка, требало би да будете спремни да идентификујете и уклоните дуплиране вредности из DataFrame-ова.\n",
    "\n",
    "Поред недостајућих података, често ћете наилазити на дуплиране податке у стварним скуповима података. Срећом, pandas пружа једноставан начин за откривање и уклањање дуплираних уноса.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "qrEG-Wa0gRsJ"
   },
   "source": [
    "### Препознавање дупликата: `duplicated`\n",
    "\n",
    "Можете лако уочити дупликате користећи метод `duplicated` у pandas-у, који враћа Булову маску која показује да ли је неки унос у `DataFrame`-у дупликат ранијег. Хајде да направимо још један пример `DataFrame`-а да видимо како то функционише.\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": [
    "### Уклањање дупликата: `drop_duplicates`\n",
    "`drop_duplicates` једноставно враћа копију података за које су све вредности `duplicated` `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": [
    "И `duplicated` и `drop_duplicates` подразумевано узимају у обзир све колоне, али можете одредити да испитују само подскуп колона у вашем `DataFrame`:\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": [
    "> **Закључак:** Уклањање дупликата података је суштински део готово сваког пројекта из области науке о подацима. Дупликати података могу променити резултате ваших анализа и дати вам нетачне резултате!\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Провера квалитета података у стварном свету\n",
    "\n",
    "> **Циљ учења:** До краја овог одељка, требало би да будете способни да откривате и исправљате уобичајене проблеме са квалитетом података у стварном свету, укључујући недоследне категоријске вредности, абнормалне нумеричке вредности (изузетке) и дупликате ентитета са варијацијама.\n",
    "\n",
    "Иако су недостајуће вредности и тачни дупликати уобичајени проблеми, скупови података из стварног света често садрже суптилније проблеме:\n",
    "\n",
    "1. **Недоследне категоријске вредности**: Иста категорија написана на различите начине (нпр. \"USA\", \"U.S.A\", \"United States\")\n",
    "2. **Абнормалне нумеричке вредности**: Екстремни изузеци који указују на грешке у уносу података (нпр. старост = 999)\n",
    "3. **Редови који су скоро дупликати**: Записи који представљају исти ентитет са благим варијацијама\n",
    "\n",
    "Хајде да истражимо технике за откривање и решавање ових проблема.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Прављење примерка „нечистог“ скупа података\n",
    "\n",
    "Прво, хајде да направимо пример скупа података који садржи типове проблема са којима се често сусрећемо у стварним подацима:\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. Откривање недоследних категоријских вредности\n",
    "\n",
    "Приметите да колона `country` има више представљања за исте земље. Хајде да идентификујемо те недоследности:\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": [
    "#### Стандардизација категоријских вредности\n",
    "\n",
    "Можемо направити мапирање за стандардизацију ових вредности. Једноставан приступ је конвертовање у мала слова и креирање речника за мапирање:\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": [
    "**Алтернатива: Коришћење фазијског упоређивања**\n",
    "\n",
    "За сложеније случајеве, можемо користити фазијско упоређивање стрингова са библиотеком `rapidfuzz` како бисмо аутоматски открили сличне стрингове:\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. Откривање необичних нумеричких вредности (изузетака)\n",
    "\n",
    "Гледајући колону `age`, имамо неке сумњиве вредности као што су 199 и -5. Хајде да користимо статистичке методе за откривање ових изузетака.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Display basic statistics\n",
    "print(\"Age column statistics:\")\n",
    "print(dirty_data['age'].describe())\n",
    "\n",
    "# Identify impossible values using domain knowledge\n",
    "print(\"\\nRows with impossible age values (< 0 or > 120):\")\n",
    "impossible_ages = dirty_data[(dirty_data['age'] < 0) | (dirty_data['age'] > 120)]\n",
    "print(impossible_ages[['customer_id', 'name', 'age']])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Коришћење методе IQR (Интерквартилни опсег)\n",
    "\n",
    "Метода IQR је робусна статистичка техника за откривање одступајућих вредности која је мање осетљива на екстремне вредности:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Calculate IQR for age (excluding impossible values)\n",
    "valid_ages = dirty_data[(dirty_data['age'] >= 0) & (dirty_data['age'] <= 120)]['age']\n",
    "\n",
    "Q1 = valid_ages.quantile(0.25)\n",
    "Q3 = valid_ages.quantile(0.75)\n",
    "IQR = Q3 - Q1\n",
    "\n",
    "# Define outlier bounds\n",
    "lower_bound = Q1 - 1.5 * IQR\n",
    "upper_bound = Q3 + 1.5 * IQR\n",
    "\n",
    "print(f\"IQR-based outlier bounds for age: [{lower_bound:.2f}, {upper_bound:.2f}]\")\n",
    "\n",
    "# Identify outliers\n",
    "age_outliers = dirty_data[(dirty_data['age'] < lower_bound) | (dirty_data['age'] > upper_bound)]\n",
    "print(f\"\\nRows with age outliers:\")\n",
    "print(age_outliers[['customer_id', 'name', 'age']])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Коришћење Z-Score методе\n",
    "\n",
    "Метода Z-score идентификује одступања на основу стандардних девијација од просека:\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": [
    "#### Руковање одступањима\n",
    "\n",
    "Када се открију, одступања могу бити обрађена на неколико начина:\n",
    "1. **Уклонити**: Избрисати редове са одступањима (ако су грешке)\n",
    "2. **Ограничити**: Заменити граничним вредностима\n",
    "3. **Заменити са NaN**: Третирати као недостајуће податке и користити технике импутације\n",
    "4. **Задржати**: Ако су легитимне екстремне вредности\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. Откривање скоро идентичних редова\n",
    "\n",
    "Приметите да наш скуп података има више уноса за „John Smith“ са мало различитим вредностима. Хајде да идентификујемо потенцијалне дупликате на основу сличности имена.\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": [
    "#### Проналажење скоро идентичних подударности помоћу фазијског упаривања\n",
    "\n",
    "За напредније откривање дупликата, можемо користити фазијско упаривање за проналажење сличних имена:\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": [
    "#### Руковање дупликатима\n",
    "\n",
    "Када их идентификујете, потребно је да одлучите како да поступите са дупликатима:\n",
    "1. **Задржати прво појављивање**: Користите `drop_duplicates(keep='first')`\n",
    "2. **Задржати последње појављивање**: Користите `drop_duplicates(keep='last')`\n",
    "3. **Агрегирати информације**: Комбиновати информације из редова који се понављају\n",
    "4. **Ручна провера**: Означити за преглед од стране човека\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": [
    "### Резиме: Комплетан процес чишћења података\n",
    "\n",
    "Хајде да све спојимо у свеобухватан процес чишћења података:\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": [
    "### 🎯 Вежба изазова\n",
    "\n",
    "Сада је ваш ред! Испод је нови ред података са више проблема у квалитету. Можете ли:\n",
    "\n",
    "1. Идентификовати све проблеме у овом реду\n",
    "2. Написати код за исправљање сваког проблема\n",
    "3. Додати очишћени ред у скуп података\n",
    "\n",
    "Ево проблематичних података:\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": [
    "### Кључне тачке\n",
    "\n",
    "1. **Неконзистентне категорије** су честе у подацима из стварног света. Увек проверите јединствене вредности и стандардизујте их користећи мапирање или фази упоређивање.\n",
    "\n",
    "2. **Екстремне вредности** могу значајно утицати на вашу анализу. Користите знање из области у комбинацији са статистичким методама (IQR, Z-score) да их откријете.\n",
    "\n",
    "3. **Скоро дупликати** су теже уочљиви од потпуних дупликата. Размотрите употребу фази упоређивања и нормализацију података (претварање у мала слова, уклањање празних места) како бисте их идентификовали.\n",
    "\n",
    "4. **Чишћење података је итеративно**. Можда ћете морати да примените више техника и прегледате резултате пре него што финализујете очишћен скуп података.\n",
    "\n",
    "5. **Документујте своје одлуке**. Водите евиденцију о корацима чишћења које сте применили и разлозима за то, јер је то важно за репродуктивност и транспарентност.\n",
    "\n",
    "> **Најбоља пракса:** Увек чувајте копију оригиналних \"неочишћених\" података. Никада не преписујте изворне датотеке са подацима - креирајте очишћене верзије са јасним конвенцијама именовања, као што је `data_cleaned.csv`.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n---\n\n**Одрицање од одговорности**:  \nОвај документ је преведен помоћу услуге за превођење уз помоћ вештачке интелигенције [Co-op Translator](https://github.com/Azure/co-op-translator). Иако настојимо да обезбедимо тачност, молимо вас да имате у виду да аутоматски преводи могу садржати грешке или нетачности. Оригинални документ на његовом изворном језику треба сматрати меродавним извором. За критичне информације препоручује се професионални превод од стране људског преводиоца. Не преузимамо одговорност за било каква погрешна тумачења или неспоразуме који могу настати услед коришћења овог превода.\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:09:31+00:00",
   "source_file": "2-Working-With-Data/08-data-preparation/notebook.ipynb",
   "language_code": "sr"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}