Pandas/Basic pandas.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Chapter 4 Basic Pandas"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Pandas series\n",
    "\n",
    "### pandas.Series(data,index)\n",
    "**important poitnts**\n",
    "1. one-dimensional array-like object\n",
    "2. can hold data of different data types(but in numpy arrays all data types are converted into one)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "eggs       30\n",
       "apples      6\n",
       "milk      Yes\n",
       "bread      No\n",
       "dtype: object"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import pandas as pd\n",
    "\n",
    "groceries = pd.Series(data = [30, 6, 'Yes', 'No'], index = ['eggs', 'apples', 'milk', 'bread'])\n",
    "\n",
    "groceries"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Groceries has shape: (4,)\n",
      "Groceries has dimension: 1\n",
      "Groceries has a total of 4 elements\n",
      "\n",
      "The data in Groceries is: [30 6 'Yes' 'No']\n",
      "The index of Groceries is: Index(['eggs', 'apples', 'milk', 'bread'], dtype='object')\n"
     ]
    }
   ],
   "source": [
    "# We print some information about Groceries\n",
    "print('Groceries has shape:', groceries.shape)\n",
    "print('Groceries has dimension:', groceries.ndim)\n",
    "print('Groceries has a total of', groceries.size, 'elements')\n",
    "print()\n",
    "# We print the index and data of Groceries\n",
    "print('The data in Groceries is:', groceries.values)\n",
    "print('The index of Groceries is:', groceries.index)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "# We check whether bread is a food item (an index) in Groceries\n",
    "print('bread' in groceries)#check index not data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Manipulating pandas series"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "30\n",
      "\n",
      "eggs     30\n",
      "milk    Yes\n",
      "dtype: object\n",
      "\n",
      "eggs      30\n",
      "apples     6\n",
      "dtype: object\n",
      "\n",
      "30\n",
      "\n",
      "eggs     30\n",
      "milk    Yes\n",
      "dtype: object\n",
      "\n",
      "eggs      30\n",
      "apples     6\n",
      "dtype: object\n"
     ]
    }
   ],
   "source": [
    "#Accessing elements using labes\n",
    "print(groceries['eggs'])\n",
    "print()\n",
    "print(groceries[['eggs','milk']])\n",
    "print()\n",
    "print(groceries.loc[['eggs','apples']])\n",
    "print()\n",
    "#Accessing elemts using integer index\n",
    "print(groceries[0])\n",
    "print()\n",
    "print(groceries[[0,2]])\n",
    "print()\n",
    "print(groceries.iloc[[0,1]])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**to remove any ambiguity to whether we are referring to an index label or numerical index use loc and iloc**\n",
    "\n",
    "### pandas series are mutable and hence can be modified"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Original Grocery List:\n",
      " eggs       30\n",
      "apples      6\n",
      "milk      Yes\n",
      "bread      No\n",
      "dtype: object\n",
      "\n",
      "Modified Grocery List:\n",
      " eggs        2\n",
      "apples      6\n",
      "milk      Yes\n",
      "bread      No\n",
      "dtype: object\n"
     ]
    }
   ],
   "source": [
    "# We display the original grocery list\n",
    "print('Original Grocery List:\\n', groceries)\n",
    "\n",
    "# We change the number of eggs to 2\n",
    "groceries['eggs'] = 2\n",
    "\n",
    "# We display the changed grocery list\n",
    "print()\n",
    "print('Modified Grocery List:\\n', groceries)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Series.drop(label, inplace=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Original Grocery List:\n",
      " eggs        2\n",
      "apples      6\n",
      "milk      Yes\n",
      "bread      No\n",
      "dtype: object\n",
      "\n",
      "We remove apples (out of place):\n",
      " eggs       2\n",
      "milk     Yes\n",
      "bread     No\n",
      "dtype: object\n",
      "\n",
      "Grocery List after removing apples out of place is still intact:\n",
      " eggs        2\n",
      "apples      6\n",
      "milk      Yes\n",
      "bread      No\n",
      "dtype: object\n"
     ]
    }
   ],
   "source": [
    "# We display the original grocery list\n",
    "print('Original Grocery List:\\n', groceries)\n",
    "\n",
    "# We remove apples from our grocery list. The drop function removes elements out of place\n",
    "print()\n",
    "print('We remove apples (out of place):\\n', groceries.drop('apples'))\n",
    "\n",
    "# When we remove elements out of place the original Series remains intact. To see this\n",
    "# we display our grocery list again\n",
    "print()\n",
    "print('Grocery List after removing apples out of place is still intact:\\n', groceries)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "if we set inplace to True than original list is also modified"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "eggs       2\n",
      "milk     Yes\n",
      "bread     No\n",
      "dtype: object\n"
     ]
    }
   ],
   "source": [
    "groceries.drop('apples', inplace = True)\n",
    "print(groceries)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Arithmetic operations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "apples     10\n",
       "oranges     6\n",
       "bananas     3\n",
       "dtype: int64"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fruits= pd.Series(data = [10, 6, 3,], index = ['apples', 'oranges', 'bananas'])\n",
    "fruits"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Original grocery list of fruits:\n",
      "  apples     10\n",
      "oranges     6\n",
      "bananas     3\n",
      "dtype: int64\n",
      "\n",
      "fruits + 2:\n",
      " apples     12\n",
      "oranges     8\n",
      "bananas     5\n",
      "dtype: int64\n",
      "\n",
      "fruits - 2:\n",
      " apples     8\n",
      "oranges    4\n",
      "bananas    1\n",
      "dtype: int64\n",
      "\n",
      "fruits * 2:\n",
      " apples     20\n",
      "oranges    12\n",
      "bananas     6\n",
      "dtype: int64\n",
      "\n",
      "fruits / 2:\n",
      " apples     5.0\n",
      "oranges    3.0\n",
      "bananas    1.5\n",
      "dtype: float64\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# We print fruits for reference\n",
    "print('Original grocery list of fruits:\\n ', fruits)\n",
    "\n",
    "# We perform basic element-wise operations using arithmetic symbols\n",
    "print()\n",
    "print('fruits + 2:\\n', fruits + 2) # We add 2 to each item in fruits\n",
    "print()\n",
    "print('fruits - 2:\\n', fruits - 2) # We subtract 2 to each item in fruits\n",
    "print()\n",
    "print('fruits * 2:\\n', fruits * 2) # We multiply each item in fruits by 2 \n",
    "print()\n",
    "print('fruits / 2:\\n', fruits / 2) # We divide each item in fruits by 2\n",
    "print()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Applying mathemetical functions from numpy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Original grocery list of fruits:\n",
      " apples     10\n",
      "oranges     6\n",
      "bananas     3\n",
      "dtype: int64\n",
      "\n",
      "EXP(X) = \n",
      " apples     22026.465795\n",
      "oranges      403.428793\n",
      "bananas       20.085537\n",
      "dtype: float64\n",
      "\n",
      "SQRT(X) =\n",
      " apples     3.162278\n",
      "oranges    2.449490\n",
      "bananas    1.732051\n",
      "dtype: float64\n",
      "\n",
      "POW(X,2) =\n",
      " apples     100\n",
      "oranges     36\n",
      "bananas      9\n",
      "dtype: int64\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "\n",
    "# We print fruits for reference\n",
    "print('Original grocery list of fruits:\\n', fruits)\n",
    "\n",
    "# We apply different mathematical functions to all elements of fruits\n",
    "print()\n",
    "print('EXP(X) = \\n', np.exp(fruits))\n",
    "print() \n",
    "print('SQRT(X) =\\n', np.sqrt(fruits))\n",
    "print()\n",
    "print('POW(X,2) =\\n',np.power(fruits,2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On single elements"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Original grocery list of fruits:\n",
      "  apples     10\n",
      "oranges     6\n",
      "bananas     3\n",
      "dtype: int64\n",
      "\n",
      "Amount of bananas + 2 =  5\n",
      "\n",
      "Amount of apples - 2 =  8\n",
      "\n",
      "We double the amount of apples and oranges:\n",
      " apples     20\n",
      "oranges    12\n",
      "dtype: int64\n",
      "\n",
      "We half the amount of apples and oranges:\n",
      " apples     5.0\n",
      "oranges    3.0\n",
      "dtype: float64\n"
     ]
    }
   ],
   "source": [
    "# We print fruits for reference\n",
    "print('Original grocery list of fruits:\\n ', fruits)\n",
    "print()\n",
    "\n",
    "# We add 2 only to the bananas\n",
    "print('Amount of bananas + 2 = ', fruits['bananas'] + 2)\n",
    "print()\n",
    "\n",
    "# We subtract 2 from apples\n",
    "print('Amount of apples - 2 = ', fruits.iloc[0] - 2)\n",
    "print()\n",
    "\n",
    "# We multiply apples and oranges by 2\n",
    "print('We double the amount of apples and oranges:\\n', fruits[['apples', 'oranges']] * 2)\n",
    "print()\n",
    "\n",
    "# We divide apples and oranges by 2\n",
    "print('We half the amount of apples and oranges:\\n', fruits.loc[['apples', 'oranges']] / 2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### operation on series with mixed data types\n",
    "be carefull to check whether the operator applies to all selected elements"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "eggs       2\n",
      "milk     Yes\n",
      "bread     No\n",
      "dtype: object\n",
      "\n",
      "eggs          4\n",
      "milk     YesYes\n",
      "bread      NoNo\n",
      "dtype: object\n"
     ]
    }
   ],
   "source": [
    "\n",
    "print(groceries)\n",
    "print()\n",
    "print(groceries*2)#multiplication on string doubles it \n",
    "#if we apply '/' than there will be error as string dont have '/' operator\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Pandas DataFrames\n",
    "\n",
    "1. think of Pandas DataFrames as being similar to a spreadsheet.\n",
    "2. two-dimensional data structures with labeled rows and columns.\n",
    "3. can hold many data types.\n",
    "\n",
    "\n",
    "### Creating By Dictionary\n",
    "\n",
    "#### using pandas series in dictionary"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'dict'>\n"
     ]
    }
   ],
   "source": [
    "# We import Pandas as pd into Python\n",
    "import pandas as pd\n",
    "\n",
    "# We create a dictionary of Pandas Series \n",
    "items = {'Bob' : pd.Series(data = [245, 25, 55], index = ['bike', 'pants', 'watch']),\n",
    "         'Alice' : pd.Series(data = [40, 110, 500, 45], index = ['book', 'glasses', 'bike', 'pants'])}\n",
    "\n",
    "# We print the type of items to see that it is a dictionary\n",
    "print(type(items))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "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>Bob</th>\n",
       "      <th>Alice</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>bike</th>\n",
       "      <td>245.0</td>\n",
       "      <td>500.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>book</th>\n",
       "      <td>NaN</td>\n",
       "      <td>40.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>glasses</th>\n",
       "      <td>NaN</td>\n",
       "      <td>110.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>pants</th>\n",
       "      <td>25.0</td>\n",
       "      <td>45.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>watch</th>\n",
       "      <td>55.0</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "           Bob  Alice\n",
       "bike     245.0  500.0\n",
       "book       NaN   40.0\n",
       "glasses    NaN  110.0\n",
       "pants     25.0   45.0\n",
       "watch     55.0    NaN"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# We create a Pandas DataFrame by passing it a dictionary of Pandas Series\n",
    "shopping_carts = pd.DataFrame(items)\n",
    "\n",
    "# We display the DataFrame rows are alphabetically arranged\n",
    "shopping_carts"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "shopping_carts has shape: (5, 2)\n",
      "shopping_carts has dimension: 2\n",
      "shopping_carts has a total of: 10 elements\n",
      "\n",
      "The data in shopping_carts is:\n",
      " [[245. 500.]\n",
      " [ nan  40.]\n",
      " [ nan 110.]\n",
      " [ 25.  45.]\n",
      " [ 55.  nan]]\n",
      "\n",
      "The row index in shopping_carts is: Index(['bike', 'book', 'glasses', 'pants', 'watch'], dtype='object')\n",
      "\n",
      "The column index in shopping_carts is: Index(['Bob', 'Alice'], dtype='object')\n"
     ]
    }
   ],
   "source": [
    "# We print some information about shopping_carts\n",
    "print('shopping_carts has shape:', shopping_carts.shape)\n",
    "print('shopping_carts has dimension:', shopping_carts.ndim)\n",
    "print('shopping_carts has a total of:', shopping_carts.size, 'elements')\n",
    "print()\n",
    "print('The data in shopping_carts is:\\n', shopping_carts.values)\n",
    "print()\n",
    "print('The row index in shopping_carts is:', shopping_carts.index)\n",
    "print()\n",
    "print('The column index in shopping_carts is:', shopping_carts.columns)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "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>Bob</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>bike</th>\n",
       "      <td>245</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>pants</th>\n",
       "      <td>25</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>watch</th>\n",
       "      <td>55</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "       Bob\n",
       "bike   245\n",
       "pants   25\n",
       "watch   55"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# We Create a DataFrame that only has Bob's data\n",
    "bob_shopping_cart = pd.DataFrame(items, columns=['Bob'])\n",
    "\n",
    "# We display bob_shopping_cart\n",
    "bob_shopping_cart"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "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>Bob</th>\n",
       "      <th>Alice</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>pants</th>\n",
       "      <td>25.0</td>\n",
       "      <td>45</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>book</th>\n",
       "      <td>NaN</td>\n",
       "      <td>40</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "        Bob  Alice\n",
       "pants  25.0     45\n",
       "book    NaN     40"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# We Create a DataFrame that only has selected items for both Alice and Bob\n",
    "sel_shopping_cart = pd.DataFrame(items, index = ['pants', 'book'])\n",
    "\n",
    "# We display sel_shopping_cart\n",
    "sel_shopping_cart"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "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>Alice</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>glasses</th>\n",
       "      <td>110</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>bike</th>\n",
       "      <td>500</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "         Alice\n",
       "glasses    110\n",
       "bike       500"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# We Create a DataFrame that only has selected items for Alice\n",
    "alice_sel_shopping_cart = pd.DataFrame(items, index = ['glasses', 'bike'], columns = ['Alice'])\n",
    "\n",
    "# We display alice_sel_shopping_cart\n",
    "alice_sel_shopping_cart"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can also manually create DataFrames from a dictionary of lists (arrays). The procedure is the same as before, we start by creating the dictionary and then passing the dictionary to the pd.DataFrame() function. In this case, however, all the lists (arrays) in the dictionary must be of the same length. Let' see an example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "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>Integers</th>\n",
       "      <th>Floats</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>1</td>\n",
       "      <td>4.5</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>2</td>\n",
       "      <td>8.2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>3</td>\n",
       "      <td>9.6</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   Integers  Floats\n",
       "0         1     4.5\n",
       "1         2     8.2\n",
       "2         3     9.6"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# We create a dictionary of lists (arrays)\n",
    "data = {'Integers' : [1,2,3],\n",
    "        'Floats' : [4.5, 8.2, 9.6]}\n",
    "\n",
    "# We create a DataFrame \n",
    "df = pd.DataFrame(data)\n",
    "\n",
    "# We display the DataFrame\n",
    "df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "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>Integers</th>\n",
       "      <th>Floats</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>label 1</th>\n",
       "      <td>1</td>\n",
       "      <td>4.5</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>label 2</th>\n",
       "      <td>2</td>\n",
       "      <td>8.2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>label 3</th>\n",
       "      <td>3</td>\n",
       "      <td>9.6</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "         Integers  Floats\n",
       "label 1         1     4.5\n",
       "label 2         2     8.2\n",
       "label 3         3     9.6"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# We create a dictionary of lists (arrays)\n",
    "data = {'Integers' : [1,2,3],\n",
    "        'Floats' : [4.5, 8.2, 9.6]}\n",
    "\n",
    "# We create a DataFrame and provide the row index\n",
    "df = pd.DataFrame(data, index = ['label 1', 'label 2', 'label 3'])\n",
    "\n",
    "# We display the DataFrame\n",
    "df"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "using list of dictionery"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "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>bikes</th>\n",
       "      <th>pants</th>\n",
       "      <th>watches</th>\n",
       "      <th>glasses</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>20</td>\n",
       "      <td>30</td>\n",
       "      <td>35</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>15</td>\n",
       "      <td>5</td>\n",
       "      <td>10</td>\n",
       "      <td>50.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   bikes  pants  watches  glasses\n",
       "0     20     30       35      NaN\n",
       "1     15      5       10     50.0"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# We create a list of Python dictionaries\n",
    "items2 = [{'bikes': 20, 'pants': 30, 'watches': 35}, \n",
    "          {'watches': 10, 'glasses': 50, 'bikes': 15, 'pants':5}]\n",
    "\n",
    "# We create a DataFrame \n",
    "store_items = pd.DataFrame(items2)\n",
    "\n",
    "# We display the DataFrame\n",
    "store_items"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "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>bikes</th>\n",
       "      <th>pants</th>\n",
       "      <th>watches</th>\n",
       "      <th>glasses</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>store 1</th>\n",
       "      <td>20</td>\n",
       "      <td>30</td>\n",
       "      <td>35</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>store 2</th>\n",
       "      <td>15</td>\n",
       "      <td>5</td>\n",
       "      <td>10</td>\n",
       "      <td>50.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "         bikes  pants  watches  glasses\n",
       "store 1     20     30       35      NaN\n",
       "store 2     15      5       10     50.0"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# We create a list of Python dictionaries\n",
    "items2 = [{'bikes': 20, 'pants': 30, 'watches': 35}, \n",
    "          {'watches': 10, 'glasses': 50, 'bikes': 15, 'pants':5}]\n",
    "\n",
    "# We create a DataFrame  and provide the row index\n",
    "store_items = pd.DataFrame(items2, index = ['store 1', 'store 2'])\n",
    "\n",
    "# We display the DataFrame\n",
    "store_items"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### anipulating elements\n",
    "####  dataframe[column][row]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "         bikes  pants  watches  glasses\n",
      "store 1     20     30       35      NaN\n",
      "store 2     15      5       10     50.0\n",
      "\n",
      "How many bikes are in each store:\n",
      "          bikes\n",
      "store 1     20\n",
      "store 2     15\n",
      "\n",
      "How many bikes and pants are in each store:\n",
      "          bikes  pants\n",
      "store 1     20     30\n",
      "store 2     15      5\n",
      "\n",
      "What items are in Store 1:\n",
      "          bikes  pants  watches  glasses\n",
      "store 1     20     30       35      NaN\n",
      "\n",
      "How many bikes are in Store 2: 15\n"
     ]
    }
   ],
   "source": [
    "# We print the store_items DataFrame\n",
    "print(store_items)\n",
    "\n",
    "# We access rows, columns and elements using labels\n",
    "print()\n",
    "print('How many bikes are in each store:\\n', store_items[['bikes']])\n",
    "print()\n",
    "print('How many bikes and pants are in each store:\\n', store_items[['bikes', 'pants']])\n",
    "print()\n",
    "print('What items are in Store 1:\\n', store_items.loc[['store 1']])\n",
    "print()\n",
    "print('How many bikes are in Store 2:', store_items['bikes']['store 2'])#[columns][rows]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "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>bikes</th>\n",
       "      <th>pants</th>\n",
       "      <th>watches</th>\n",
       "      <th>glasses</th>\n",
       "      <th>shirts</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>store 1</th>\n",
       "      <td>20</td>\n",
       "      <td>30</td>\n",
       "      <td>35</td>\n",
       "      <td>NaN</td>\n",
       "      <td>15</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>store 2</th>\n",
       "      <td>15</td>\n",
       "      <td>5</td>\n",
       "      <td>10</td>\n",
       "      <td>50.0</td>\n",
       "      <td>2</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "         bikes  pants  watches  glasses  shirts\n",
       "store 1     20     30       35      NaN      15\n",
       "store 2     15      5       10     50.0       2"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# We add a new column named shirts to our store_items DataFrame indicating the number of\n",
    "# shirts in stock at each store. We will put 15 shirts in store 1 and 2 shirts in store 2\n",
    "store_items['shirts'] = [15,2]\n",
    "\n",
    "# We display the modified DataFrame\n",
    "store_items"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "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>bikes</th>\n",
       "      <th>pants</th>\n",
       "      <th>watches</th>\n",
       "      <th>glasses</th>\n",
       "      <th>shirts</th>\n",
       "      <th>suits</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>store 1</th>\n",
       "      <td>20</td>\n",
       "      <td>30</td>\n",
       "      <td>35</td>\n",
       "      <td>NaN</td>\n",
       "      <td>15</td>\n",
       "      <td>45</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>store 2</th>\n",
       "      <td>15</td>\n",
       "      <td>5</td>\n",
       "      <td>10</td>\n",
       "      <td>50.0</td>\n",
       "      <td>2</td>\n",
       "      <td>7</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "         bikes  pants  watches  glasses  shirts  suits\n",
       "store 1     20     30       35      NaN      15     45\n",
       "store 2     15      5       10     50.0       2      7"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# We make a new column called suits by adding the number of shirts and pants\n",
    "store_items['suits'] = store_items['pants'] + store_items['shirts']\n",
    "\n",
    "# We display the modified DataFrame\n",
    "store_items"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Adding new row\n",
    "##### append()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "         bikes  pants  watches  glasses\n",
      "store 3     20     30       35        4\n"
     ]
    },
    {
     "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>bikes</th>\n",
       "      <th>pants</th>\n",
       "      <th>watches</th>\n",
       "      <th>glasses</th>\n",
       "      <th>shirts</th>\n",
       "      <th>suits</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>store 1</th>\n",
       "      <td>20</td>\n",
       "      <td>30</td>\n",
       "      <td>35</td>\n",
       "      <td>NaN</td>\n",
       "      <td>15.0</td>\n",
       "      <td>45.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>store 2</th>\n",
       "      <td>15</td>\n",
       "      <td>5</td>\n",
       "      <td>10</td>\n",
       "      <td>50.0</td>\n",
       "      <td>2.0</td>\n",
       "      <td>7.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>store 3</th>\n",
       "      <td>20</td>\n",
       "      <td>30</td>\n",
       "      <td>35</td>\n",
       "      <td>4.0</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "         bikes  pants  watches  glasses  shirts  suits\n",
       "store 1     20     30       35      NaN    15.0   45.0\n",
       "store 2     15      5       10     50.0     2.0    7.0\n",
       "store 3     20     30       35      4.0     NaN    NaN"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# We create a dictionary from a list of Python dictionaries that will number of items at the new store\n",
    "new_items = [{'bikes': 20, 'pants': 30, 'watches': 35, 'glasses': 4}]\n",
    "\n",
    "# We create new DataFrame with the new_items and provide and index labeled store 3\n",
    "new_store = pd.DataFrame(new_items, index = ['store 3'])\n",
    "\n",
    "# We display the items at the new store\n",
    "print(new_store)\n",
    "\n",
    "# We append store 3 to our store_items DataFrame\n",
    "store_items = store_items.append(new_store)\n",
    "\n",
    "# We display the modified DataFrame\n",
    "store_items"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Adding new column to specific rows"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "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>bikes</th>\n",
       "      <th>pants</th>\n",
       "      <th>watches</th>\n",
       "      <th>glasses</th>\n",
       "      <th>shirts</th>\n",
       "      <th>suits</th>\n",
       "      <th>new watches</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>store 1</th>\n",
       "      <td>20</td>\n",
       "      <td>30</td>\n",
       "      <td>35</td>\n",
       "      <td>NaN</td>\n",
       "      <td>15.0</td>\n",
       "      <td>45.0</td>\n",
       "      <td>35</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>store 2</th>\n",
       "      <td>15</td>\n",
       "      <td>5</td>\n",
       "      <td>10</td>\n",
       "      <td>50.0</td>\n",
       "      <td>2.0</td>\n",
       "      <td>7.0</td>\n",
       "      <td>10</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>store 3</th>\n",
       "      <td>20</td>\n",
       "      <td>30</td>\n",
       "      <td>35</td>\n",
       "      <td>4.0</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>35</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "         bikes  pants  watches  glasses  shirts  suits  new watches\n",
       "store 1     20     30       35      NaN    15.0   45.0           35\n",
       "store 2     15      5       10     50.0     2.0    7.0           10\n",
       "store 3     20     30       35      4.0     NaN    NaN           35"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# We add a new column using data from particular rows in the watches column\n",
    "# this adds watches to store  and store3\n",
    "store_items['new watches'] = store_items['watches']\n",
    "\n",
    "# We display the modified DataFrame\n",
    "store_items"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Adds a new column"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "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>bikes</th>\n",
       "      <th>pants</th>\n",
       "      <th>watches</th>\n",
       "      <th>glasses</th>\n",
       "      <th>shoes</th>\n",
       "      <th>shirts</th>\n",
       "      <th>suits</th>\n",
       "      <th>new watches</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>store 1</th>\n",
       "      <td>20</td>\n",
       "      <td>30</td>\n",
       "      <td>35</td>\n",
       "      <td>NaN</td>\n",
       "      <td>8</td>\n",
       "      <td>15.0</td>\n",
       "      <td>45.0</td>\n",
       "      <td>35</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>store 2</th>\n",
       "      <td>15</td>\n",
       "      <td>5</td>\n",
       "      <td>10</td>\n",
       "      <td>50.0</td>\n",
       "      <td>5</td>\n",
       "      <td>2.0</td>\n",
       "      <td>7.0</td>\n",
       "      <td>10</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>store 3</th>\n",
       "      <td>20</td>\n",
       "      <td>30</td>\n",
       "      <td>35</td>\n",
       "      <td>4.0</td>\n",
       "      <td>0</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>35</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "         bikes  pants  watches  glasses  shoes  shirts  suits  new watches\n",
       "store 1     20     30       35      NaN      8    15.0   45.0           35\n",
       "store 2     15      5       10     50.0      5     2.0    7.0           10\n",
       "store 3     20     30       35      4.0      0     NaN    NaN           35"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# We insert a new column with label shoes right before the column with numerical index 4\n",
    "store_items.insert(4, 'shoes', [8,5,0])\n",
    "\n",
    "# we display the modified DataFrame\n",
    "store_items"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Deleting elemets"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "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>bikes</th>\n",
       "      <th>pants</th>\n",
       "      <th>watches</th>\n",
       "      <th>glasses</th>\n",
       "      <th>shoes</th>\n",
       "      <th>shirts</th>\n",
       "      <th>suits</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>store 1</th>\n",
       "      <td>20</td>\n",
       "      <td>30</td>\n",
       "      <td>35</td>\n",
       "      <td>NaN</td>\n",
       "      <td>8</td>\n",
       "      <td>15.0</td>\n",
       "      <td>45.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>store 2</th>\n",
       "      <td>15</td>\n",
       "      <td>5</td>\n",
       "      <td>10</td>\n",
       "      <td>50.0</td>\n",
       "      <td>5</td>\n",
       "      <td>2.0</td>\n",
       "      <td>7.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>store 3</th>\n",
       "      <td>20</td>\n",
       "      <td>30</td>\n",
       "      <td>35</td>\n",
       "      <td>4.0</td>\n",
       "      <td>0</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "         bikes  pants  watches  glasses  shoes  shirts  suits\n",
       "store 1     20     30       35      NaN      8    15.0   45.0\n",
       "store 2     15      5       10     50.0      5     2.0    7.0\n",
       "store 3     20     30       35      4.0      0     NaN    NaN"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# We remove the new watches column\n",
    "store_items.pop('new watches')\n",
    "\n",
    "# we display the modified DataFrame\n",
    "store_items"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### .drop() can delete both rows or columns using axis keyword"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "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>bikes</th>\n",
       "      <th>pants</th>\n",
       "      <th>glasses</th>\n",
       "      <th>shirts</th>\n",
       "      <th>suits</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>store 1</th>\n",
       "      <td>20</td>\n",
       "      <td>30</td>\n",
       "      <td>NaN</td>\n",
       "      <td>15.0</td>\n",
       "      <td>45.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>store 2</th>\n",
       "      <td>15</td>\n",
       "      <td>5</td>\n",
       "      <td>50.0</td>\n",
       "      <td>2.0</td>\n",
       "      <td>7.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>store 3</th>\n",
       "      <td>20</td>\n",
       "      <td>30</td>\n",
       "      <td>4.0</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "         bikes  pants  glasses  shirts  suits\n",
       "store 1     20     30      NaN    15.0   45.0\n",
       "store 2     15      5     50.0     2.0    7.0\n",
       "store 3     20     30      4.0     NaN    NaN"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# We remove the watches and shoes columns\n",
    "store_items = store_items.drop(['watches', 'shoes'], axis = 1)\n",
    "\n",
    "# we display the modified DataFrame\n",
    "store_items"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "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>bikes</th>\n",
       "      <th>pants</th>\n",
       "      <th>glasses</th>\n",
       "      <th>shirts</th>\n",
       "      <th>suits</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>store 3</th>\n",
       "      <td>20</td>\n",
       "      <td>30</td>\n",
       "      <td>4.0</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "         bikes  pants  glasses  shirts  suits\n",
       "store 3     20     30      4.0     NaN    NaN"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# We remove the store 2 and store 1 rows\n",
    "store_items = store_items.drop(['store 2', 'store 1'], axis = 0)\n",
    "\n",
    "# we display the modified DataFrame\n",
    "store_items"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#### Renaming labels"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "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>hats</th>\n",
       "      <th>pants</th>\n",
       "      <th>glasses</th>\n",
       "      <th>shirts</th>\n",
       "      <th>suits</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>store 3</th>\n",
       "      <td>20</td>\n",
       "      <td>30</td>\n",
       "      <td>4.0</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "         hats  pants  glasses  shirts  suits\n",
       "store 3    20     30      4.0     NaN    NaN"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# We change the column label bikes to hats\n",
    "store_items = store_items.rename(columns = {'bikes': 'hats'})\n",
    "\n",
    "# we display the modified DataFrame\n",
    "store_items"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "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>hats</th>\n",
       "      <th>pants</th>\n",
       "      <th>glasses</th>\n",
       "      <th>shirts</th>\n",
       "      <th>suits</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>last store</th>\n",
       "      <td>20</td>\n",
       "      <td>30</td>\n",
       "      <td>4.0</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "            hats  pants  glasses  shirts  suits\n",
       "last store    20     30      4.0     NaN    NaN"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# We change the row label from store 3 to last store\n",
    "store_items = store_items.rename(index = {'store 3': 'last store'})\n",
    "\n",
    "# we display the modified DataFrame\n",
    "store_items"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "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>hats</th>\n",
       "      <th>glasses</th>\n",
       "      <th>shirts</th>\n",
       "      <th>suits</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>pants</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>30</th>\n",
       "      <td>20</td>\n",
       "      <td>4.0</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "       hats  glasses  shirts  suits\n",
       "pants                              \n",
       "30       20      4.0     NaN    NaN"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# We change the row index to be the data in the pants column\n",
    "store_items = store_items.set_index('pants')\n",
    "\n",
    "# we display the modified DataFrame\n",
    "store_items"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#### Dealing with NaN values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "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>bikes</th>\n",
       "      <th>pants</th>\n",
       "      <th>watches</th>\n",
       "      <th>shirts</th>\n",
       "      <th>shoes</th>\n",
       "      <th>suits</th>\n",
       "      <th>glasses</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>store 1</th>\n",
       "      <td>20</td>\n",
       "      <td>30</td>\n",
       "      <td>35</td>\n",
       "      <td>15.0</td>\n",
       "      <td>8</td>\n",
       "      <td>45.0</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>store 2</th>\n",
       "      <td>15</td>\n",
       "      <td>5</td>\n",
       "      <td>10</td>\n",
       "      <td>2.0</td>\n",
       "      <td>5</td>\n",
       "      <td>7.0</td>\n",
       "      <td>50.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>store 3</th>\n",
       "      <td>20</td>\n",
       "      <td>30</td>\n",
       "      <td>35</td>\n",
       "      <td>NaN</td>\n",
       "      <td>10</td>\n",
       "      <td>NaN</td>\n",
       "      <td>4.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "         bikes  pants  watches  shirts  shoes  suits  glasses\n",
       "store 1     20     30       35    15.0      8   45.0      NaN\n",
       "store 2     15      5       10     2.0      5    7.0     50.0\n",
       "store 3     20     30       35     NaN     10    NaN      4.0"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# We create a list of Python dictionaries\n",
    "items2 = [{'bikes': 20, 'pants': 30, 'watches': 35, 'shirts': 15, 'shoes':8, 'suits':45},\n",
    "{'watches': 10, 'glasses': 50, 'bikes': 15, 'pants':5, 'shirts': 2, 'shoes':5, 'suits':7},\n",
    "{'bikes': 20, 'pants': 30, 'watches': 35, 'glasses': 4, 'shoes':10}]\n",
    "\n",
    "# We create a DataFrame  and provide the row index\n",
    "store_items = pd.DataFrame(items2, index = ['store 1', 'store 2', 'store 3'])\n",
    "\n",
    "# We display the DataFrame\n",
    "store_items"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#### Counting NaN values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number of NaN values in our DataFrame: 3\n"
     ]
    }
   ],
   "source": [
    "# We count the number of NaN values in store_items\n",
    "# break it to see how it works\n",
    "x =  store_items.isnull().sum().sum()\n",
    "\n",
    "# We print x\n",
    "print('Number of NaN values in our DataFrame:', x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#### deleting NaN value\n",
    "\n",
    "The .dropna(axis) method eliminates any rows with NaN values when axis = 0 is used and will eliminate any columns with NaN values when axis = 1 is used. Let's see some examples"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "         bikes  pants  watches  shirts  shoes  suits  glasses\n",
      "store 1     20     30       35    15.0      8   45.0      NaN\n",
      "store 2     15      5       10     2.0      5    7.0     50.0\n",
      "store 3     20     30       35     NaN     10    NaN      4.0\n",
      "-----------------------------------------------------------------\n",
      "\n",
      "         bikes  pants  watches  shirts  shoes  suits  glasses\n",
      "store 2     15      5       10     2.0      5    7.0     50.0\n",
      "-----------------------------------------------------------------\n",
      "\n",
      "         bikes  pants  watches  shirts  shoes  suits  glasses\n",
      "store 1     20     30       35    15.0      8   45.0      NaN\n",
      "store 2     15      5       10     2.0      5    7.0     50.0\n",
      "store 3     20     30       35     NaN     10    NaN      4.0\n",
      "-----------------------------------------------------------------\n",
      "\n",
      "         bikes  pants  watches  shoes\n",
      "store 1     20     30       35      8\n",
      "store 2     15      5       10      5\n",
      "store 3     20     30       35     10\n"
     ]
    }
   ],
   "source": [
    "print(store_items)\n",
    "print('-'*65)\n",
    "print()\n",
    "print(store_items.dropna(axis=0))\n",
    "print('-'*65)\n",
    "print()\n",
    "print(store_items)\n",
    "print('-'*65)\n",
    "print()\n",
    "print(store_items.dropna(axis=1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "**Notice that the .dropna() method eliminates (drops) the rows or columns with NaN values out of place. This means that the original DataFrame is not modified. You can always remove the desired rows or columns in place by setting the keyword inplace = True inside the dropna() function.**\n",
    "\n",
    "### Filling NaN values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "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>bikes</th>\n",
       "      <th>pants</th>\n",
       "      <th>watches</th>\n",
       "      <th>shirts</th>\n",
       "      <th>shoes</th>\n",
       "      <th>suits</th>\n",
       "      <th>glasses</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>store 1</th>\n",
       "      <td>20</td>\n",
       "      <td>30</td>\n",
       "      <td>35</td>\n",
       "      <td>15.0</td>\n",
       "      <td>8</td>\n",
       "      <td>45.0</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>store 2</th>\n",
       "      <td>15</td>\n",
       "      <td>5</td>\n",
       "      <td>10</td>\n",
       "      <td>2.0</td>\n",
       "      <td>5</td>\n",
       "      <td>7.0</td>\n",
       "      <td>50.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>store 3</th>\n",
       "      <td>20</td>\n",
       "      <td>30</td>\n",
       "      <td>35</td>\n",
       "      <td>0.0</td>\n",
       "      <td>10</td>\n",
       "      <td>0.0</td>\n",
       "      <td>4.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "         bikes  pants  watches  shirts  shoes  suits  glasses\n",
       "store 1     20     30       35    15.0      8   45.0      0.0\n",
       "store 2     15      5       10     2.0      5    7.0     50.0\n",
       "store 3     20     30       35     0.0     10    0.0      4.0"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# We replace all NaN values with 0\n",
    "store_items.fillna(0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "##### .fillna(method = 'ffill', axis)\n",
    "ffill method to replace NaN values using the previous known value along the given axis"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "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>bikes</th>\n",
       "      <th>pants</th>\n",
       "      <th>watches</th>\n",
       "      <th>shirts</th>\n",
       "      <th>shoes</th>\n",
       "      <th>suits</th>\n",
       "      <th>glasses</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>store 1</th>\n",
       "      <td>20</td>\n",
       "      <td>30</td>\n",
       "      <td>35</td>\n",
       "      <td>15.0</td>\n",
       "      <td>8</td>\n",
       "      <td>45.0</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>store 2</th>\n",
       "      <td>15</td>\n",
       "      <td>5</td>\n",
       "      <td>10</td>\n",
       "      <td>2.0</td>\n",
       "      <td>5</td>\n",
       "      <td>7.0</td>\n",
       "      <td>50.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>store 3</th>\n",
       "      <td>20</td>\n",
       "      <td>30</td>\n",
       "      <td>35</td>\n",
       "      <td>NaN</td>\n",
       "      <td>10</td>\n",
       "      <td>NaN</td>\n",
       "      <td>4.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "         bikes  pants  watches  shirts  shoes  suits  glasses\n",
       "store 1     20     30       35    15.0      8   45.0      NaN\n",
       "store 2     15      5       10     2.0      5    7.0     50.0\n",
       "store 3     20     30       35     NaN     10    NaN      4.0"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "store_items"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "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>bikes</th>\n",
       "      <th>pants</th>\n",
       "      <th>watches</th>\n",
       "      <th>shirts</th>\n",
       "      <th>shoes</th>\n",
       "      <th>suits</th>\n",
       "      <th>glasses</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>store 1</th>\n",
       "      <td>20</td>\n",
       "      <td>30</td>\n",
       "      <td>35</td>\n",
       "      <td>15.0</td>\n",
       "      <td>8</td>\n",
       "      <td>45.0</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>store 2</th>\n",
       "      <td>15</td>\n",
       "      <td>5</td>\n",
       "      <td>10</td>\n",
       "      <td>2.0</td>\n",
       "      <td>5</td>\n",
       "      <td>7.0</td>\n",
       "      <td>50.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>store 3</th>\n",
       "      <td>20</td>\n",
       "      <td>30</td>\n",
       "      <td>35</td>\n",
       "      <td>2.0</td>\n",
       "      <td>10</td>\n",
       "      <td>7.0</td>\n",
       "      <td>4.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "         bikes  pants  watches  shirts  shoes  suits  glasses\n",
       "store 1     20     30       35    15.0      8   45.0      NaN\n",
       "store 2     15      5       10     2.0      5    7.0     50.0\n",
       "store 3     20     30       35     2.0     10    7.0      4.0"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "store_items.fillna(method = 'ffill', axis = 0)#replaces with prevoius rows"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "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>bikes</th>\n",
       "      <th>pants</th>\n",
       "      <th>watches</th>\n",
       "      <th>shirts</th>\n",
       "      <th>shoes</th>\n",
       "      <th>suits</th>\n",
       "      <th>glasses</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>store 1</th>\n",
       "      <td>20.0</td>\n",
       "      <td>30.0</td>\n",
       "      <td>35.0</td>\n",
       "      <td>15.0</td>\n",
       "      <td>8.0</td>\n",
       "      <td>45.0</td>\n",
       "      <td>45.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>store 2</th>\n",
       "      <td>15.0</td>\n",
       "      <td>5.0</td>\n",
       "      <td>10.0</td>\n",
       "      <td>2.0</td>\n",
       "      <td>5.0</td>\n",
       "      <td>7.0</td>\n",
       "      <td>50.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>store 3</th>\n",
       "      <td>20.0</td>\n",
       "      <td>30.0</td>\n",
       "      <td>35.0</td>\n",
       "      <td>35.0</td>\n",
       "      <td>10.0</td>\n",
       "      <td>10.0</td>\n",
       "      <td>4.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "         bikes  pants  watches  shirts  shoes  suits  glasses\n",
       "store 1   20.0   30.0     35.0    15.0    8.0   45.0     45.0\n",
       "store 2   15.0    5.0     10.0     2.0    5.0    7.0     50.0\n",
       "store 3   20.0   30.0     35.0    35.0   10.0   10.0      4.0"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "store_items.fillna(method = 'ffill', axis = 1)#replaces with previous columns"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "##### .fillna(method = 'backfill', axis)\n",
    "backfill method to replace NaN values using the next known value along the given axis\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "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>bikes</th>\n",
       "      <th>pants</th>\n",
       "      <th>watches</th>\n",
       "      <th>shirts</th>\n",
       "      <th>shoes</th>\n",
       "      <th>suits</th>\n",
       "      <th>glasses</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>store 1</th>\n",
       "      <td>20</td>\n",
       "      <td>30</td>\n",
       "      <td>35</td>\n",
       "      <td>15.0</td>\n",
       "      <td>8</td>\n",
       "      <td>45.0</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>store 2</th>\n",
       "      <td>15</td>\n",
       "      <td>5</td>\n",
       "      <td>10</td>\n",
       "      <td>2.0</td>\n",
       "      <td>5</td>\n",
       "      <td>7.0</td>\n",
       "      <td>50.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>store 3</th>\n",
       "      <td>20</td>\n",
       "      <td>30</td>\n",
       "      <td>35</td>\n",
       "      <td>NaN</td>\n",
       "      <td>10</td>\n",
       "      <td>NaN</td>\n",
       "      <td>4.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "         bikes  pants  watches  shirts  shoes  suits  glasses\n",
       "store 1     20     30       35    15.0      8   45.0      NaN\n",
       "store 2     15      5       10     2.0      5    7.0     50.0\n",
       "store 3     20     30       35     NaN     10    NaN      4.0"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "store_items"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "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>bikes</th>\n",
       "      <th>pants</th>\n",
       "      <th>watches</th>\n",
       "      <th>shirts</th>\n",
       "      <th>shoes</th>\n",
       "      <th>suits</th>\n",
       "      <th>glasses</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>store 1</th>\n",
       "      <td>20</td>\n",
       "      <td>30</td>\n",
       "      <td>35</td>\n",
       "      <td>15.0</td>\n",
       "      <td>8</td>\n",
       "      <td>45.0</td>\n",
       "      <td>50.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>store 2</th>\n",
       "      <td>15</td>\n",
       "      <td>5</td>\n",
       "      <td>10</td>\n",
       "      <td>2.0</td>\n",
       "      <td>5</td>\n",
       "      <td>7.0</td>\n",
       "      <td>50.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>store 3</th>\n",
       "      <td>20</td>\n",
       "      <td>30</td>\n",
       "      <td>35</td>\n",
       "      <td>NaN</td>\n",
       "      <td>10</td>\n",
       "      <td>NaN</td>\n",
       "      <td>4.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "         bikes  pants  watches  shirts  shoes  suits  glasses\n",
       "store 1     20     30       35    15.0      8   45.0     50.0\n",
       "store 2     15      5       10     2.0      5    7.0     50.0\n",
       "store 3     20     30       35     NaN     10    NaN      4.0"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# We replace NaN values with the next value in the column\n",
    "store_items.fillna(method = 'backfill', axis = 0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "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>bikes</th>\n",
       "      <th>pants</th>\n",
       "      <th>watches</th>\n",
       "      <th>shirts</th>\n",
       "      <th>shoes</th>\n",
       "      <th>suits</th>\n",
       "      <th>glasses</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>store 1</th>\n",
       "      <td>20.0</td>\n",
       "      <td>30.0</td>\n",
       "      <td>35.0</td>\n",
       "      <td>15.0</td>\n",
       "      <td>8.0</td>\n",
       "      <td>45.0</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>store 2</th>\n",
       "      <td>15.0</td>\n",
       "      <td>5.0</td>\n",
       "      <td>10.0</td>\n",
       "      <td>2.0</td>\n",
       "      <td>5.0</td>\n",
       "      <td>7.0</td>\n",
       "      <td>50.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>store 3</th>\n",
       "      <td>20.0</td>\n",
       "      <td>30.0</td>\n",
       "      <td>35.0</td>\n",
       "      <td>10.0</td>\n",
       "      <td>10.0</td>\n",
       "      <td>4.0</td>\n",
       "      <td>4.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "         bikes  pants  watches  shirts  shoes  suits  glasses\n",
       "store 1   20.0   30.0     35.0    15.0    8.0   45.0      NaN\n",
       "store 2   15.0    5.0     10.0     2.0    5.0    7.0     50.0\n",
       "store 3   20.0   30.0     35.0    10.0   10.0    4.0      4.0"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# We replace NaN values with the next value in the row\n",
    "store_items.fillna(method = 'backfill', axis = 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "Note we can always replace the NaN values in place by setting the keyword inplace = True inside the fillna() function.\n",
    "\n",
    "#### isnull().any()\n",
    "gives True or False if there are any NaN values in any rows"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "bikes      False\n",
       "pants      False\n",
       "watches    False\n",
       "shirts      True\n",
       "shoes      False\n",
       "suits       True\n",
       "glasses     True\n",
       "dtype: bool"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "store_items.isnull().any()"
   ]
  }
 ],
 "metadata": {
  "interpreter": {
   "hash": "e11a82443ab50bba9acfd7f1c4bf29437f87a746c9170b735da53de8dec5b943"
  },
  "kernelspec": {
   "display_name": "Python 3.9.7 64-bit ('base': conda)",
   "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.9.7"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}