Intro To Pandas 2.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Pandas 2\n",
    "In the previous section we briefly went over how to read a csv file into a dataframe and look at different columns, row, and cells within the dataframe. Here we will continue to explore dataframes and use some standard statistical operations on them. Instead of reading a csv file into a dataframe, let's create one manually by passing a dictionary to pd.DataFrame:\n",
    "\n",
    "    dataframe = pd.DataFrame({Column1 Name: [row1 value, row2 value, etc.],\n",
    "                              Column2 Name: [row1 value, row2 value, etc.],\n",
    "                              etc.}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# import pandas\n",
    "import pandas as pd\n",
    "\n",
    "# create a dataframe called df\n",
    "df = pd.DataFrame({'Column 1':[1, 2, 3],\n",
    "                   'Column 2':[4, 5, 6],\n",
    "                   'Column 3':[7, 8, 9]})"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "Using the pandas dataframe structure, you pass a dictionary with the column names as the keys and the column data as the keys."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "   Column 1  Column 2  Column 3\n",
      "0         1         4         7\n",
      "1         2         5         8\n",
      "2         3         6         9\n"
     ]
    }
   ],
   "source": [
    "print(df)"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "A dataframe has two axes:\n",
    "    0: refers to the row/index\n",
    "    1: refers to the columns\n",
    "\n",
    "A lot of dataframe operations take an axis as a parameter, so you may need to commit to memory 0 is row and 1 is column."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "axis 0 refers to: RangeIndex(start=0, stop=3, step=1)\n",
      "axis 1 refers to: Index(['Column 1', 'Column 2', 'Column 3'], dtype='object')\n"
     ]
    }
   ],
   "source": [
    "print('axis 0 refers to: ' + str(df.axes[0]))\n",
    "print('axis 1 refers to: ' + str(df.axes[1]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Adding Rows\n",
    "If we had another dataframe and we wanted to it to our existing data we would use the .concat function or the append method:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "   Column 1  Column 2  Column 3\n",
      "0         1         4         7\n",
      "1         2         5         8\n",
      "2         3         6         9\n",
      "   Column 1  Column 2  Column 3\n",
      "0        11        12        13\n"
     ]
    }
   ],
   "source": [
    "# create another dataframe\n",
    "df1 = pd.DataFrame({'Column 1': [11],\n",
    "                    'Column 2': [12],\n",
    "                    'Column 3': [13]})\n",
    "print(df)\n",
    "print(df1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "   Column 1  Column 2  Column 3\n",
      "0         1         4         7\n",
      "1         2         5         8\n",
      "2         3         6         9\n",
      "0        11        12        13\n"
     ]
    }
   ],
   "source": [
    "# create a new dataframe by concatenating df and df1\n",
    "df3 = pd.concat([df, df1])\n",
    "# print df3\n",
    "print(df3)"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "Notice how df2 was added to df but the index number is zero, rather than three. Usually, we would want the index continued and can specify this by using the 'ignore_index=True' argument:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "   Column 1  Column 2  Column 3\n",
      "0         1         4         7\n",
      "1         2         5         8\n",
      "2         3         6         9\n",
      "3        11        12        13\n"
     ]
    }
   ],
   "source": [
    "df3 = pd.concat([df, df1], ignore_index=True)\n",
    "# print df3\n",
    "print(df3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Adding Columns\n",
    "If you want to add a column you simply assign it like so:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "   Column 1  Column 2  Column 3  My New Column\n",
      "0         1         4         7             14\n",
      "1         2         5         8             15\n",
      "2         3         6         9             16\n",
      "3        11        12        13             17\n"
     ]
    }
   ],
   "source": [
    "# create a new column with values listed in a series\n",
    "df3['My New Column'] = [14, 15, 16, 17]\n",
    "\n",
    "# print df3\n",
    "print(df3)"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "Here we see that a new column has been added, but it is automatically added as the right-most column. To assign a new column in a specified position, use the .insert method:\n",
    "\n",
    "    dataframe.insert(column position starting from 0, column name, column values)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "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>insert method</th>\n",
       "      <th>Column 1</th>\n",
       "      <th>Column 2</th>\n",
       "      <th>Column 3</th>\n",
       "      <th>My New Column</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>missing</td>\n",
       "      <td>1</td>\n",
       "      <td>4</td>\n",
       "      <td>7</td>\n",
       "      <td>14</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>missing</td>\n",
       "      <td>2</td>\n",
       "      <td>5</td>\n",
       "      <td>8</td>\n",
       "      <td>15</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>missing</td>\n",
       "      <td>3</td>\n",
       "      <td>6</td>\n",
       "      <td>9</td>\n",
       "      <td>16</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>missing</td>\n",
       "      <td>11</td>\n",
       "      <td>12</td>\n",
       "      <td>13</td>\n",
       "      <td>17</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "  insert method  Column 1  Column 2  Column 3  My New Column\n",
       "0       missing         1         4         7             14\n",
       "1       missing         2         5         8             15\n",
       "2       missing         3         6         9             16\n",
       "3       missing        11        12        13             17"
      ]
     },
     "execution_count": 103,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df3.insert(0, 'insert method', 'missing')\n",
    "\n",
    "df3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Deleting Rows\n",
    "You can use the .drop method to return a new dataframe without the index of the rows specified:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "  insert method  Column 1  Column 2  Column 3  My New Column\n",
      "0       missing         1         4         7             14\n",
      "1       missing         2         5         8             15\n",
      "2       missing         3         6         9             16\n"
     ]
    }
   ],
   "source": [
    "# drop the fourth row, which is given by index 3 as the index starts from zero\n",
    "df_drop_row = df3.drop([3])\n",
    "print(df_drop_row)"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "You can also use slicing to drop rows by slicing the .index attribute as well:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "  insert method  Column 1  Column 2  Column 3  My New Column\n",
      "0       missing         1         4         7             14\n",
      "3       missing        11        12        13             17\n"
     ]
    }
   ],
   "source": [
    "df_drop_slice_row = df3.drop(df3.index[1:3])\n",
    "print(df_drop_slice_row)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Deleting Columns\n",
    "You can delete a column using the .pop method, the .drop method and including axis=1, or the del statement:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "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>insert method</th>\n",
       "      <th>Column 1</th>\n",
       "      <th>Column 2</th>\n",
       "      <th>Column 3</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>missing</td>\n",
       "      <td>1</td>\n",
       "      <td>4</td>\n",
       "      <td>7</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>missing</td>\n",
       "      <td>2</td>\n",
       "      <td>5</td>\n",
       "      <td>8</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>missing</td>\n",
       "      <td>3</td>\n",
       "      <td>6</td>\n",
       "      <td>9</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>missing</td>\n",
       "      <td>11</td>\n",
       "      <td>12</td>\n",
       "      <td>13</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "  insert method  Column 1  Column 2  Column 3\n",
       "0       missing         1         4         7\n",
       "1       missing         2         5         8\n",
       "2       missing         3         6         9\n",
       "3       missing        11        12        13"
      ]
     },
     "execution_count": 106,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# here we create a new dataframe frome df3 by using .drop\n",
    "df_drop = df3.drop(['My New Column'], axis=1)\n",
    "df_drop"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "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>insert method</th>\n",
       "      <th>Column 1</th>\n",
       "      <th>Column 2</th>\n",
       "      <th>Column 3</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>missing</td>\n",
       "      <td>1</td>\n",
       "      <td>4</td>\n",
       "      <td>7</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>missing</td>\n",
       "      <td>2</td>\n",
       "      <td>5</td>\n",
       "      <td>8</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>missing</td>\n",
       "      <td>3</td>\n",
       "      <td>6</td>\n",
       "      <td>9</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>missing</td>\n",
       "      <td>11</td>\n",
       "      <td>12</td>\n",
       "      <td>13</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "  insert method  Column 1  Column 2  Column 3\n",
       "0       missing         1         4         7\n",
       "1       missing         2         5         8\n",
       "2       missing         3         6         9\n",
       "3       missing        11        12        13"
      ]
     },
     "execution_count": 107,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# using .pop to remove a column from df3\n",
    "df3.pop('My New Column')\n",
    "df3"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "df3 no longer has 'My New Column'. Let's add it back again and remove it using the .drop method"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "  insert method  Column 1  Column 2  Column 3  My New Column\n",
      "0       missing         1         4         7             14\n",
      "1       missing         2         5         8             15\n",
      "2       missing         3         6         9             16\n",
      "3       missing        11        12        13             17\n"
     ]
    }
   ],
   "source": [
    "# create a new column with values listed in a series\n",
    "df3['My New Column'] = [14, 15, 16, 17]\n",
    "\n",
    "# print df3\n",
    "print(df3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "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>insert method</th>\n",
       "      <th>Column 1</th>\n",
       "      <th>Column 2</th>\n",
       "      <th>Column 3</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>missing</td>\n",
       "      <td>1</td>\n",
       "      <td>4</td>\n",
       "      <td>7</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>missing</td>\n",
       "      <td>2</td>\n",
       "      <td>5</td>\n",
       "      <td>8</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>missing</td>\n",
       "      <td>3</td>\n",
       "      <td>6</td>\n",
       "      <td>9</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>missing</td>\n",
       "      <td>11</td>\n",
       "      <td>12</td>\n",
       "      <td>13</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "  insert method  Column 1  Column 2  Column 3\n",
       "0       missing         1         4         7\n",
       "1       missing         2         5         8\n",
       "2       missing         3         6         9\n",
       "3       missing        11        12        13"
      ]
     },
     "execution_count": 109,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# using .drop\n",
    "df_drop = df3.drop(['My New Column'], axis=1)\n",
    "df_drop"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "Finally, we will use the del method"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 110,
   "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>Column 1</th>\n",
       "      <th>Column 2</th>\n",
       "      <th>Column 3</th>\n",
       "      <th>My New Column</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>1</td>\n",
       "      <td>4</td>\n",
       "      <td>7</td>\n",
       "      <td>14</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>2</td>\n",
       "      <td>5</td>\n",
       "      <td>8</td>\n",
       "      <td>15</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>3</td>\n",
       "      <td>6</td>\n",
       "      <td>9</td>\n",
       "      <td>16</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>11</td>\n",
       "      <td>12</td>\n",
       "      <td>13</td>\n",
       "      <td>17</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   Column 1  Column 2  Column 3  My New Column\n",
       "0         1         4         7             14\n",
       "1         2         5         8             15\n",
       "2         3         6         9             16\n",
       "3        11        12        13             17"
      ]
     },
     "execution_count": 110,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# using del\n",
    "del df3['insert method']\n",
    "df3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Iteration\n",
    "Iteration over a dataframe by default is made over the column names:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Column 1\n",
      "Column 2\n",
      "Column 3\n",
      "My New Column\n"
     ]
    }
   ],
   "source": [
    "for columns in df3:\n",
    "    print(columns)"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "The .iteritems() method returns a pair of column names and the values in that column series:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Column 1\n",
      " 0     1\n",
      "1     2\n",
      "2     3\n",
      "3    11\n",
      "Name: Column 1, dtype: int64\n",
      "Column 2\n",
      " 0     4\n",
      "1     5\n",
      "2     6\n",
      "3    12\n",
      "Name: Column 2, dtype: int64\n",
      "Column 3\n",
      " 0     7\n",
      "1     8\n",
      "2     9\n",
      "3    13\n",
      "Name: Column 3, dtype: int64\n",
      "My New Column\n",
      " 0    14\n",
      "1    15\n",
      "2    16\n",
      "3    17\n",
      "Name: My New Column, dtype: int64\n"
     ]
    }
   ],
   "source": [
    "for col, index in df3.iteritems():\n",
    "    print(col+'\\n',index)"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "The .iterrows method returns a tuple for every row in the dataframe:\n",
    "\n",
    "    index value, row values converted into a series object"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(0, Column 1          1\n",
      "Column 2          4\n",
      "Column 3          7\n",
      "My New Column    14\n",
      "Name: 0, dtype: int64)\n",
      "(1, Column 1          2\n",
      "Column 2          5\n",
      "Column 3          8\n",
      "My New Column    15\n",
      "Name: 1, dtype: int64)\n",
      "(2, Column 1          3\n",
      "Column 2          6\n",
      "Column 3          9\n",
      "My New Column    16\n",
      "Name: 2, dtype: int64)\n",
      "(3, Column 1         11\n",
      "Column 2         12\n",
      "Column 3         13\n",
      "My New Column    17\n",
      "Name: 3, dtype: int64)\n"
     ]
    }
   ],
   "source": [
    "for row in df3.iterrows():\n",
    "    print(row)"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "You can get the size of a dataframe using the .shape attribute, which will return:\n",
    "\n",
    "    (number of rows, number of columns)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 114,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(4, 4)"
      ]
     },
     "execution_count": 114,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df3.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Index Operations\n",
    "There are various operations that can be performed with a dataframe, one of the most common is to reindex a dataframe using one of its columns. To make a column the index, use .set_index:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "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>Column 2</th>\n",
       "      <th>Column 3</th>\n",
       "      <th>My New Column</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Column 1</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>4</td>\n",
       "      <td>7</td>\n",
       "      <td>14</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>5</td>\n",
       "      <td>8</td>\n",
       "      <td>15</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>6</td>\n",
       "      <td>9</td>\n",
       "      <td>16</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>11</th>\n",
       "      <td>12</td>\n",
       "      <td>13</td>\n",
       "      <td>17</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "          Column 2  Column 3  My New Column\n",
       "Column 1                                   \n",
       "1                4         7             14\n",
       "2                5         8             15\n",
       "3                6         9             16\n",
       "11              12        13             17"
      ]
     },
     "execution_count": 115,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# create a new dataframe based on df3 but with 'Column 1' as the index\n",
    "col_1_df = df3.set_index('Column 1')\n",
    "\n",
    "col_1_df"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "A point to note is that unlike the previous index (0, 1, 2, ...) the newly assigned index may contain duplicate values. You can use the verify_integrity parameter to check that the assigned index has a unique set of entries:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "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>Column 1</th>\n",
       "      <th>Column 2</th>\n",
       "      <th>Column 3</th>\n",
       "      <th>My New Column</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>2</td>\n",
       "      <td>4</td>\n",
       "      <td>7</td>\n",
       "      <td>14</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>2</td>\n",
       "      <td>5</td>\n",
       "      <td>8</td>\n",
       "      <td>15</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>3</td>\n",
       "      <td>6</td>\n",
       "      <td>9</td>\n",
       "      <td>16</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>11</td>\n",
       "      <td>12</td>\n",
       "      <td>13</td>\n",
       "      <td>17</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   Column 1  Column 2  Column 3  My New Column\n",
       "0         2         4         7             14\n",
       "1         2         5         8             15\n",
       "2         3         6         9             16\n",
       "3        11        12        13             17"
      ]
     },
     "execution_count": 116,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# create a duplicate value in df3\n",
    "df3['Column 1'][0] = 2\n",
    "\n",
    "df3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 117,
   "metadata": {},
   "outputs": [
    {
     "ename": "ValueError",
     "evalue": "Index has duplicate keys: Int64Index([2], dtype='int64', name='Column 1')",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-117-8b8a67c6b752>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      1\u001b[0m \u001b[1;31m# create a new dataframe based on df3 but with 'Column 1' as the index\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 2\u001b[1;33m \u001b[0mcol_1_df\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mdf3\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mset_index\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m'Column 1'\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mverify_integrity\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;32mTrue\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m      3\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      4\u001b[0m \u001b[0mcol_1_df\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32mC:\\Anaconda3\\lib\\site-packages\\pandas\\core\\frame.py\u001b[0m in \u001b[0;36mset_index\u001b[1;34m(self, keys, drop, append, inplace, verify_integrity)\u001b[0m\n\u001b[0;32m   3918\u001b[0m             \u001b[0mduplicates\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mindex\u001b[0m\u001b[1;33m[\u001b[0m\u001b[0mindex\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mduplicated\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0munique\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m   3919\u001b[0m             raise ValueError('Index has duplicate keys: {dup}'.format(\n\u001b[1;32m-> 3920\u001b[1;33m                 dup=duplicates))\n\u001b[0m\u001b[0;32m   3921\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m   3922\u001b[0m         \u001b[1;32mfor\u001b[0m \u001b[0mc\u001b[0m \u001b[1;32min\u001b[0m \u001b[0mto_remove\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;31mValueError\u001b[0m: Index has duplicate keys: Int64Index([2], dtype='int64', name='Column 1')"
     ]
    }
   ],
   "source": [
    "# create a new dataframe based on df3 but with 'Column 1' as the index\n",
    "col_1_df = df3.set_index('Column 1', verify_integrity=True)\n",
    "\n",
    "col_1_df"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "Now an error is thrown when trying to set the index using column 1 as a duplicate value exists."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Accessing And Setting Values\n",
    "There are two methods to access and/or set values, the first is the .iat which uses an index based notation:\n",
    "\n",
    "    dataframe.iat[row, column]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 118,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The value of cell (0,0) in df3 is: 2\n"
     ]
    }
   ],
   "source": [
    "print('The value of cell (0,0) in df3 is: ' + str(df3.iat[0,0]))"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "The other method is the .get_value which uses an index name and a column name:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 119,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 119,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df3.at[0, 'Column 1']"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "To set a value, you state the cell to be accessed and assign it a value:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 120,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The current value of df3 cell (0,0) is: 2\n",
      "The new value of df3 cell (0,0) is: 5\n"
     ]
    }
   ],
   "source": [
    "print('The current value of df3 cell (0,0) is: ' + str(df3.iat[0,0]))\n",
    "\n",
    "df3.iat[0,0] = 5\n",
    "\n",
    "print('The new value of df3 cell (0,0) is: ' + str(df3.iat[0,0]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Replacing Values\n",
    "If you want to update all values in a dataframe you can use the .replace method"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 149,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "   Column 1  Column 2  Column 3  My New Column\n",
      "0         5         4         7             14\n",
      "1         2         5         8             15\n",
      "2         3         6         9             16\n",
      "3        11        12        13             17\n",
      "\n",
      "Replacing all values of 5 with 99\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>Column 1</th>\n",
       "      <th>Column 2</th>\n",
       "      <th>Column 3</th>\n",
       "      <th>My New Column</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>99</td>\n",
       "      <td>4</td>\n",
       "      <td>7</td>\n",
       "      <td>14</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>2</td>\n",
       "      <td>99</td>\n",
       "      <td>8</td>\n",
       "      <td>15</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>3</td>\n",
       "      <td>6</td>\n",
       "      <td>9</td>\n",
       "      <td>16</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>11</td>\n",
       "      <td>12</td>\n",
       "      <td>13</td>\n",
       "      <td>17</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   Column 1  Column 2  Column 3  My New Column\n",
       "0        99         4         7             14\n",
       "1         2        99         8             15\n",
       "2         3         6         9             16\n",
       "3        11        12        13             17"
      ]
     },
     "execution_count": 149,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "print(df3)\n",
    "\n",
    "print('\\nReplacing all values of 5 with 99')\n",
    "      \n",
    "df4 = df3.replace(5,99)\n",
    "df4"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "If you only wanted to replace values in a particular column you would pass in a dictionary with the key as the column name, and a dictionary of old value : new value:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 150,
   "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>Column 1</th>\n",
       "      <th>Column 2</th>\n",
       "      <th>Column 3</th>\n",
       "      <th>My New Column</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>99</td>\n",
       "      <td>4</td>\n",
       "      <td>7</td>\n",
       "      <td>14</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>2</td>\n",
       "      <td>5</td>\n",
       "      <td>8</td>\n",
       "      <td>15</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>3</td>\n",
       "      <td>6</td>\n",
       "      <td>9</td>\n",
       "      <td>16</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>11</td>\n",
       "      <td>12</td>\n",
       "      <td>13</td>\n",
       "      <td>17</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   Column 1  Column 2  Column 3  My New Column\n",
       "0        99         4         7             14\n",
       "1         2         5         8             15\n",
       "2         3         6         9             16\n",
       "3        11        12        13             17"
      ]
     },
     "execution_count": 150,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df4 = df3.replace({'Column 1': {5:99}})\n",
    "\n",
    "df4"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Sorting\n",
    "You can sort a dataframe either by it's index or column values using:\n",
    "\n",
    "    dataframe.sort_values(column name)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 151,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Current arrangement of df3: \n",
      "\n",
      "   Column 1  Column 2  Column 3  My New Column\n",
      "0         5         4         7             14\n",
      "1         2         5         8             15\n",
      "2         3         6         9             16\n",
      "3        11        12        13             17\n",
      "\n",
      "After sorting by column 1: \n",
      "\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>Column 1</th>\n",
       "      <th>Column 2</th>\n",
       "      <th>Column 3</th>\n",
       "      <th>My New Column</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>2</td>\n",
       "      <td>5</td>\n",
       "      <td>8</td>\n",
       "      <td>15</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>3</td>\n",
       "      <td>6</td>\n",
       "      <td>9</td>\n",
       "      <td>16</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>5</td>\n",
       "      <td>4</td>\n",
       "      <td>7</td>\n",
       "      <td>14</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>11</td>\n",
       "      <td>12</td>\n",
       "      <td>13</td>\n",
       "      <td>17</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   Column 1  Column 2  Column 3  My New Column\n",
       "1         2         5         8             15\n",
       "2         3         6         9             16\n",
       "0         5         4         7             14\n",
       "3        11        12        13             17"
      ]
     },
     "execution_count": 151,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "print('Current arrangement of df3: \\n')\n",
    "print(df3)\n",
    "print('\\nAfter sorting by column 1: \\n')\n",
    "df3.sort_values('Column 1')"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "To sort by the index use the .sort_index method, and to sort by the index in reverse order pass the argument 'ascending=False':"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 152,
   "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>Column 1</th>\n",
       "      <th>Column 2</th>\n",
       "      <th>Column 3</th>\n",
       "      <th>My New Column</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>11</td>\n",
       "      <td>12</td>\n",
       "      <td>13</td>\n",
       "      <td>17</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>3</td>\n",
       "      <td>6</td>\n",
       "      <td>9</td>\n",
       "      <td>16</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>2</td>\n",
       "      <td>5</td>\n",
       "      <td>8</td>\n",
       "      <td>15</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>5</td>\n",
       "      <td>4</td>\n",
       "      <td>7</td>\n",
       "      <td>14</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   Column 1  Column 2  Column 3  My New Column\n",
       "3        11        12        13             17\n",
       "2         3         6         9             16\n",
       "1         2         5         8             15\n",
       "0         5         4         7             14"
      ]
     },
     "execution_count": 152,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df3.sort_index(ascending=False)"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "You can sort by more than one column by passing a list of column names to .sort_values and it will sort the left-most column first, then proceed right. Using a dataframe with different values will make this process clearer and we will sort column 1 in reverse order, then for each grouping in column 1 we will sort column 2 in ascending order"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 153,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Current arrangement of df: \n",
      "\n",
      "   Column 1  Column 2  Column 3\n",
      "0         1         1         1\n",
      "1         1         2         2\n",
      "2         1         3         3\n",
      "3         2         3         4\n",
      "4         2         2         5\n",
      "5         2         1         6\n",
      "\n",
      "After sorting by Column 1 then Column 2: \n",
      "\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>Column 1</th>\n",
       "      <th>Column 2</th>\n",
       "      <th>Column 3</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>2</td>\n",
       "      <td>1</td>\n",
       "      <td>6</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>2</td>\n",
       "      <td>2</td>\n",
       "      <td>5</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>2</td>\n",
       "      <td>3</td>\n",
       "      <td>4</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>1</td>\n",
       "      <td>2</td>\n",
       "      <td>2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>1</td>\n",
       "      <td>3</td>\n",
       "      <td>3</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   Column 1  Column 2  Column 3\n",
       "5         2         1         6\n",
       "4         2         2         5\n",
       "3         2         3         4\n",
       "0         1         1         1\n",
       "1         1         2         2\n",
       "2         1         3         3"
      ]
     },
     "execution_count": 153,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# create a dataframe called df\n",
    "df = pd.DataFrame({'Column 1':[1, 1, 1, 2, 2, 2],\n",
    "                   'Column 2':[1, 2, 3, 3, 2, 1],\n",
    "                   'Column 3':[1, 2, 3, 4, 5, 6]})\n",
    "print('Current arrangement of df: \\n')\n",
    "print(df)\n",
    "print('\\nAfter sorting by Column 1 then Column 2: \\n')\n",
    "df.sort_values(['Column 1', 'Column 2'], ascending=[False, True])"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "We've covered a lot of information regarding dataframes and by now you should have a good handle on how to access a dataframe to do most common operations. In the next tutorial we'll cover some of the more advanced operations of dataframes."
   ]
  }
 ],
 "metadata": {
  "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.7.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}