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",
    "Са свим горе наведеним функцијама и атрибутима, добили смо преглед података на највишем нивоу. Знамо колико има података, колико има карактеристика, који је тип података за сваку карактеристику и колико има вредности које нису празне за сваку карактеристику.\n",
    "\n",
    "Сада је време да погледамо саме податке. Хајде да видимо како изгледају првих неколико редова (првих неколико тачака података) нашег `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",
    "Хајде да се позабавимо недостајућим подацима. Недостајући подаци се јављају када нека вредност није унетa у одређене колоне.\n",
    "\n",
    "Узмимо пример: рецимо да је неко ко је свестан своје тежине одлучио да не попуни поље за тежину у анкети. У том случају, вредност тежине за ту особу ће недостајати.\n",
    "\n",
    "У већини случајева, у стварним скуповима података, недостајуће вредности су честа појава.\n",
    "\n",
    "**Како Pandas обрађује недостајуће податке**\n",
    "\n",
    "Pandas обрађује недостајуће вредности на два начина. Први начин сте већ видели у претходним одељцима: `NaN`, или Not a Number. Ово је заправо посебна вредност која је део IEEE спецификације за бројеве са покретним зарезом и користи се искључиво за означавање недостајућих вредности са покретним зарезом.\n",
    "\n",
    "За недостајуће вредности које нису типа float, 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` за своје брзе, векторизоване операције и ufunc-ове. Лоша вест је да свака аритметичка операција извршена над `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`: null вредности у 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` као о две различите врсте \"null\" вредности у 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 да представимо празну вредност низа, он је ипак објекат низа и није представљање нуле у смислу како 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": [
    "### Уклањање null вредности\n",
    "\n",
    "Количина података коју прослеђујемо нашем моделу директно утиче на његове перформансе. Уклањање null вредности значи да смањујемо број података, а самим тим и величину скупа података. Због тога је препоручљиво уклонити редове са null вредностима када је скуп података прилично велик.\n",
    "\n",
    "Други случај може бити да одређени ред или колона имају много недостајућих вредности. У том случају, могу се уклонити јер не би значајно допринели нашој анализи, с обзиром на то да већина података недостаје за тај ред/колону.\n",
    "\n",
    "Поред идентификовања недостајућих вредности, pandas пружа згодан начин за уклањање null вредности из `Series` и `DataFrame` објеката. Да бисмо видели како то функционише, вратимо се на `example3`. Функција `DataFrame.dropna()` помаже у уклањању редова са null вредностима.\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": [
    "Имајте на уму да ово може уклонити доста података које можда желите да задржите, нарочито у мањим скуповима података. Шта ако желите да уклоните само редове или колоне које садрже неколико или чак све недостајуће вредности? Те поставке можете одредити у `dropna` помоћу параметара `how` и `thresh`.\n",
    "\n",
    "Подразумевано, `how='any'` (ако желите сами да проверите или видите које друге параметре метода има, покрените `example4.dropna?` у код ћелији). Алтернативно, можете одредити `how='all'` како бисте уклонили само редове или колоне које садрже све недостајуће вредности. Хајде да проширимо наш пример `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. Уклањање null вредности је добра идеја само ако је скуп података довољно велик.  \n",
    "2. Цели редови или колоне могу се уклонити ако им недостаје већина података.  \n",
    "3. Метода `DataFrame.dropna(axis=)` помаже у уклањању null вредности. Аргумент `axis` означава да ли се уклањају редови или колоне.  \n",
    "4. Аргумент `how` такође може бити коришћен. Подразумевано је подешен на `any`. Дакле, уклања само оне редове/колоне који садрже било какве null вредности. Може се подесити на `all` како би се прецизирало да ће бити уклоњени само они редови/колоне где су све вредности null.  \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` вам пружа прецизнију контролу: подешавате број *ненултих* вредности које ред или колона треба да имају како би били задржани:\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 нису попуњена. Тада можемо попунити та 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": []
  },
  {
   "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": []
  },
  {
   "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": []
  },
  {
   "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": []
  },
  {
   "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": [
    "Имајте на уму да је трећа колона још увек без вредности: подразумевани начин је попуњавање вредности ред по ред.\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": [
    "**ЕНКОДИРАЊЕ ЈЕДНОГ ВРУЋЕГ**\n",
    "\n",
    "Још један тип енкодирања је енкодирање једног врућег (One Hot Encoding). Код овог типа енкодирања, свака категорија из колоне се додаје као посебна колона, а свака тачка података добија 0 или 1 у зависности од тога да ли садржи ту категорију. Дакле, ако постоји *n* различитих категорија, *n* колона ће бити додато у оквир података.\n",
    "\n",
    "На пример, узмимо исти пример класа у авиону. Категорије су биле: ['бизнис класа', 'економска класа', 'прва класа']. Дакле, ако извршимо енкодирање једног врућег, следеће три колоне ће бити додате у скуп података: ['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": [
    "Хајде да извршимо one hot encoding на првој колони\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. Постоје две врсте кодирања: кодирање етикета (Label encoding) и једнократно кодирање (One Hot encoding), а оба се могу применити у зависности од захтева скупа података.  \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": []
  },
  {
   "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": "8533b3a2230311943339963fc7f04c21",
   "translation_date": "2025-09-02T07:56:01+00:00",
   "source_file": "2-Working-With-Data/08-data-preparation/notebook.ipynb",
   "language_code": "sr"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}