DSPD0102EN-Pandas Series,Data Frame and Index.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Introducing Pandas Data Structure"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "At the very basic level, Pandas objects can be thought of as enhanced versions of NumPy structured arrays in which the rows and columns are identified with labels rather than simple integer indices.\n",
    "As we will see during the course of this chapter, Pandas provides a host of useful tools, methods, and functionality on top of the basic data structures, but nearly everything that follows will require an understanding of what these structures are.\n",
    "Thus, before we go any further, let's introduce these three fundamental Pandas data structures: the ``Series``, ``DataFrame``, and ``Index``.\n",
    "\n",
    "We will start our code sessions with the standard NumPy and Pandas imports:\n",
    "\n",
    "![image](https://lh3.googleusercontent.com/-hWtJzm7U4l8/XPdm8Te_bpI/AAAAAAAAdFE/xIfnVx8jD58FEb-NWfGiLWFeDWD3xnU8ACK8BGAs/s0/2019-06-04.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Magic Funcation\n",
    "1. %matplotlib inline\n",
    "2. %history"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Names'"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = ('Names',1,True,2.5,2j+3)\n",
    "a[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0     Names\n",
       "1         1\n",
       "2      True\n",
       "3       2.5\n",
       "4    (3+2j)\n",
       "dtype: object"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Se= pd.Series(a)\n",
    "Se"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "collapsed": true,
    "jupyter": {
     "outputs_hidden": true
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0    10\n",
       "1    11\n",
       "2    12\n",
       "3    13\n",
       "4    14\n",
       "5    15\n",
       "6    16\n",
       "7    17\n",
       "8    18\n",
       "9    19\n",
       "dtype: int64"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "li = list(range(10,20))\n",
    "Se1 = pd.Series(li)\n",
    "Se1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "A    [1, 2, 3]\n",
       "dtype: object"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dic = dict({'A':[1,2,3]})\n",
    "pd.Series(dic)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## The Pandas Series Object\n",
    "\n",
    "A Pandas ``Series`` is a one-dimensional array of indexed data.\n",
    "It can be created from a list or array as follows:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0    0.25\n",
       "1    0.50\n",
       "2    0.75\n",
       "3    1.00\n",
       "dtype: float64"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data = pd.Series([0.25, 0.5, 0.75, 1.0])\n",
    "data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As we see in the output, the ``Series`` wraps both a sequence of values and a sequence of indices, which we can access with the ``values`` and ``index`` attributes.\n",
    "The ``values`` are simply a familiar NumPy array:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.25, 0.5 , 0.75, 1.  ])"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data.values"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The ``index`` is an array-like object of type ``pd.Index``, which we'll discuss in more detail momentarily."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "RangeIndex(start=0, stop=4, step=1)"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data.index"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Like with a NumPy array, data can be accessed by the associated index via the familiar Python square-bracket notation:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.5"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data[1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1    0.50\n",
       "2    0.75\n",
       "dtype: float64"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data[1:3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0    0.25\n",
       "2    0.75\n",
       "dtype: float64"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data[0:3:2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "collapsed": true,
    "jupyter": {
     "outputs_hidden": true
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "count    4.000000\n",
       "mean     0.625000\n",
       "std      0.322749\n",
       "min      0.250000\n",
       "25%      0.437500\n",
       "50%      0.625000\n",
       "75%      0.812500\n",
       "max      1.000000\n",
       "dtype: float64"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data.describe() # Descriptive Stast"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0    0.25\n",
       "1    0.50\n",
       "2    0.75\n",
       "3    1.00\n",
       "dtype: float64"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data.head()  # top Five Rows"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0    0.25\n",
       "1    0.50\n",
       "2    0.75\n",
       "3    1.00\n",
       "dtype: float64"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data.tail() # to get last five rows"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.625"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data.mean()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data.ndim"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(4,)"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dtype('float64')"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data.dtype"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "collapsed": true,
    "jupyter": {
     "outputs_hidden": true
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.axes._subplots.AxesSubplot at 0x1b9467e0160>"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "data.plot()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As we will see, though, the Pandas ``Series`` is much more general and flexible than the one-dimensional NumPy array that it emulates."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### ``Series`` as generalized NumPy array"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "From what we've seen so far, it may look like the ``Series`` object is basically interchangeable with a one-dimensional NumPy array.\n",
    "The essential difference is the presence of the index: while the Numpy Array has an *implicitly defined* integer index used to access the values, the Pandas ``Series`` has an *explicitly defined* index associated with the values.\n",
    "\n",
    "This explicit index definition gives the ``Series`` object additional capabilities. For example, the index need not be an integer, but can consist of values of any desired type.\n",
    "For example, if we wish, we can use strings as an index:"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "pd.Series(\n",
    "    data=None,\n",
    "    index=None,\n",
    "    dtype=None,\n",
    "    name=None,\n",
    "    copy=False,\n",
    "    fastpath=False,\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "collapsed": true,
    "jupyter": {
     "outputs_hidden": true
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "a    0.25\n",
       "b    0.50\n",
       "c    0.75\n",
       "d    1.00\n",
       "dtype: float64"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data = pd.Series([0.25, 0.5, 0.75, 1.0],\n",
    "                 index=['a', 'b', 'c', 'd'])\n",
    "data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And the item access works as expected:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.5"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data['b']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.5"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data[1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can even use non-contiguous or non-sequential indices:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2    0.25\n",
       "5    0.50\n",
       "3    0.75\n",
       "7    1.00\n",
       "dtype: float64"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data = pd.Series([0.25, 0.5, 0.75, 1.0],\n",
    "                 index=[2, 5, 3, 7])\n",
    "data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.5"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data[5]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.25"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data[2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Int64Index([2, 5, 3, 7], dtype='int64')"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data.index"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.25, 0.5 , 0.75, 1.  ])"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data.values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2    0.25\n",
       "3    0.75\n",
       "5    0.50\n",
       "7    1.00\n",
       "dtype: float64"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data.sort_index() # Sorting only index"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2    0.25\n",
       "5    0.50\n",
       "3    0.75\n",
       "7    1.00\n",
       "dtype: float64"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data.sort_values() # Sorting the Elements or Values "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.15571276, 0.96261259, 0.85006244, 0.79737387, 0.82038473,\n",
       "       0.23580132, 0.51299528, 0.83690543, 0.93793253, 0.40387883,\n",
       "       0.1866805 , 0.0344703 , 0.62229916, 0.27626546, 0.31817543,\n",
       "       0.36854876, 0.14940836, 0.08415681, 0.80675646, 0.44637815])"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Array = np.random.rand(20)\n",
    "Array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {
    "collapsed": true,
    "jupyter": {
     "outputs_hidden": true
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0     0.155713\n",
       "1     0.962613\n",
       "2     0.850062\n",
       "3     0.797374\n",
       "4     0.820385\n",
       "5     0.235801\n",
       "6     0.512995\n",
       "7     0.836905\n",
       "8     0.937933\n",
       "9     0.403879\n",
       "10    0.186681\n",
       "11    0.034470\n",
       "12    0.622299\n",
       "13    0.276265\n",
       "14    0.318175\n",
       "15    0.368549\n",
       "16    0.149408\n",
       "17    0.084157\n",
       "18    0.806756\n",
       "19    0.446378\n",
       "dtype: float64"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Se = pd.Series(Array)\n",
    "Se"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Series as specialized dictionary\n",
    "\n",
    "In this way, you can think of a Pandas ``Series`` a bit like a specialization of a Python dictionary.\n",
    "A dictionary is a structure that maps arbitrary keys to a set of arbitrary values, and a ``Series`` is a structure which maps typed keys to a set of typed values.\n",
    "This typing is important: just as the type-specific compiled code behind a NumPy array makes it more efficient than a Python list for certain operations, the type information of a Pandas ``Series`` makes it much more efficient than Python dictionaries for certain operations.\n",
    "\n",
    "The ``Series``-as-dictionary analogy can be made even more clear by constructing a ``Series`` object directly from a Python dictionary:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "California    38332521\n",
       "Texas         26448193\n",
       "New York      19651127\n",
       "Florida       19552860\n",
       "Illinois      12882135\n",
       "dtype: int64"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "population_dict = {'California': 38332521,\n",
    "                   'Texas': 26448193,\n",
    "                   'New York': 19651127,\n",
    "                   'Florida': 19552860,\n",
    "                   'Illinois': 12882135}\n",
    "population = pd.Series(population_dict)\n",
    "population"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([38332521, 26448193, 19651127, 19552860, 12882135], dtype=int64)"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "population.values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<bound method Series.keys of California    38332521\n",
       "Texas         26448193\n",
       "New York      19651127\n",
       "Florida       19552860\n",
       "Illinois      12882135\n",
       "dtype: int64>"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "population.keys"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Index(['California', 'Texas', 'New York', 'Florida', 'Illinois'], dtype='object')"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "population.index"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "count    5.000000e+00\n",
       "mean     2.337337e+07\n",
       "std      9.640386e+06\n",
       "min      1.288214e+07\n",
       "25%      1.955286e+07\n",
       "50%      1.965113e+07\n",
       "75%      2.644819e+07\n",
       "max      3.833252e+07\n",
       "dtype: float64"
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "population.describe()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "California    38332521\n",
       "Texas         26448193\n",
       "New York      19651127\n",
       "Florida       19552860\n",
       "Illinois      12882135\n",
       "dtype: int64"
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "population.tail()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "California    38332521\n",
       "Texas         26448193\n",
       "New York      19651127\n",
       "Florida       19552860\n",
       "Illinois      12882135\n",
       "dtype: int64"
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "population.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "19651127    1\n",
       "12882135    1\n",
       "19552860    1\n",
       "26448193    1\n",
       "38332521    1\n",
       "dtype: int64"
      ]
     },
     "execution_count": 66,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "population.value_counts()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "California    38332521\n",
       "Florida       19552860\n",
       "Illinois      12882135\n",
       "New York      19651127\n",
       "Texas         26448193\n",
       "dtype: int64"
      ]
     },
     "execution_count": 68,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "population.sort_index()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Illinois      12882135\n",
       "Florida       19552860\n",
       "New York      19651127\n",
       "Texas         26448193\n",
       "California    38332521\n",
       "dtype: int64"
      ]
     },
     "execution_count": 69,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "population.sort_values()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "By default, a ``Series`` will be created where the index is drawn from the sorted keys.\n",
    "From here, typical dictionary-style item access can be performed:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "38332521"
      ]
     },
     "execution_count": 70,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "population['California']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Unlike a dictionary, though, the ``Series`` also supports array-style operations such as slicing:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "California    38332521\n",
       "Texas         26448193\n",
       "New York      19651127\n",
       "Florida       19552860\n",
       "Illinois      12882135\n",
       "dtype: int64"
      ]
     },
     "execution_count": 71,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "population['California':'Illinois']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "38332521"
      ]
     },
     "execution_count": 72,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "population[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We'll discuss some of the quirks of Pandas indexing and slicing in [Data Indexing and Selection](03.02-Data-Indexing-and-Selection.ipynb)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Constructing Series objects\n",
    "\n",
    "We've already seen a few ways of constructing a Pandas ``Series`` from scratch; all of them are some version of the following:\n",
    "\n",
    "```python\n",
    ">>> pd.Series(data, index=index)\n",
    "```\n",
    "\n",
    "where ``index`` is an optional argument, and ``data`` can be one of many entities.\n",
    "\n",
    "For example, ``data`` can be a list or NumPy array, in which case ``index`` defaults to an integer sequence:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0    2\n",
       "1    4\n",
       "2    6\n",
       "dtype: int64"
      ]
     },
     "execution_count": 73,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pd.Series([2, 4, 6])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "``data`` can be a scalar, which is repeated to fill the specified index:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "100    5\n",
       "200    5\n",
       "300    5\n",
       "dtype: int64"
      ]
     },
     "execution_count": 74,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pd.Series(5, index=[100, 200, 300])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "``data`` can be a dictionary, in which ``index`` defaults to the sorted dictionary keys:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2    a\n",
       "1    b\n",
       "3    c\n",
       "dtype: object"
      ]
     },
     "execution_count": 75,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pd.Series({2:'a', 1:'b', 3:'c'})"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In each case, the index can be explicitly set if a different result is preferred:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1    b\n",
       "3    c\n",
       "dtype: object"
      ]
     },
     "execution_count": 76,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pd.Series({2:'a', 1:'b', 3:'c'}, index=[1,3])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notice that in this case, the ``Series`` is populated only with the explicitly identified keys."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## The Pandas DataFrame Object\n",
    "\n",
    "The next fundamental structure in Pandas is the ``DataFrame``.\n",
    "Like the ``Series`` object discussed in the previous section, the ``DataFrame`` can be thought of either as a generalization of a NumPy array, or as a specialization of a Python dictionary.\n",
    "We'll now take a look at each of these perspectives."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### DataFrame as a generalized NumPy array\n",
    "If a ``Series`` is an analog of a one-dimensional array with flexible indices, a ``DataFrame`` is an analog of a two-dimensional array with both flexible row indices and flexible column names.\n",
    "Just as you might think of a two-dimensional array as an ordered sequence of aligned one-dimensional columns, you can think of a ``DataFrame`` as a sequence of aligned ``Series`` objects.\n",
    "Here, by \"aligned\" we mean that they share the same index.\n",
    "\n",
    "To demonstrate this, let's first construct a new ``Series`` listing the area of each of the five states discussed in the previous section:\n",
    "![](https://lh3.googleusercontent.com/-6uBGxST5W9M/Xspx_djUQ3I/AAAAAAAAoOI/EgyLSCDnRKMVGzQv1S8y10CuxTeUQx4cACK8BGAsYHg/s0/2020-05-24.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0,  1,  2],\n",
       "       [ 3,  4,  5],\n",
       "       [ 6,  7,  8],\n",
       "       [ 9, 10, 11]])"
      ]
     },
     "execution_count": 77,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Ar = np.arange(12).reshape(4,3)\n",
    "Ar"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {
    "collapsed": true,
    "jupyter": {
     "outputs_hidden": true
    }
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>0</th>\n",
       "      <th>1</th>\n",
       "      <th>2</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>3</td>\n",
       "      <td>4</td>\n",
       "      <td>5</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>6</td>\n",
       "      <td>7</td>\n",
       "      <td>8</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>9</td>\n",
       "      <td>10</td>\n",
       "      <td>11</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   0   1   2\n",
       "0  0   1   2\n",
       "1  3   4   5\n",
       "2  6   7   8\n",
       "3  9  10  11"
      ]
     },
     "execution_count": 78,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d = pd.DataFrame(Ar)\n",
    "d"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "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",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "Empty DataFrame\n",
       "Columns: []\n",
       "Index: []"
      ]
     },
     "execution_count": 79,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df = pd.DataFrame() # Empty Data Frame \n",
    "df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {},
   "outputs": [],
   "source": [
    "df['Height']=[10,20,30]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {},
   "outputs": [],
   "source": [
    "df['Weight'] = (1.5,2.5,3.5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "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>A</th>\n",
       "      <th>Data</th>\n",
       "      <th>Height</th>\n",
       "      <th>Weight</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>10</td>\n",
       "      <td>1.5</td>\n",
       "      <td>10</td>\n",
       "      <td>1.5</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>20</td>\n",
       "      <td>2.5</td>\n",
       "      <td>20</td>\n",
       "      <td>2.5</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>30</td>\n",
       "      <td>3.5</td>\n",
       "      <td>30</td>\n",
       "      <td>3.5</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "    A  Data  Height  Weight\n",
       "0  10   1.5      10     1.5\n",
       "1  20   2.5      20     2.5\n",
       "2  30   3.5      30     3.5"
      ]
     },
     "execution_count": 86,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 83,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df.ndim"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "area_dict = {'California': 423967, 'Texas': 695662, 'New York': 141297,\n",
    "             'Florida': 170312, 'Illinois': 149995}\n",
    "area = pd.Series(area_dict)\n",
    "area"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now that we have this along with the ``population`` Series from before, we can use a dictionary to construct a single two-dimensional object containing this information:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "population"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "states = pd.DataFrame({'population': population,\n",
    "                       'area': area})\n",
    "states"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Like the ``Series`` object, the ``DataFrame`` has an ``index`` attribute that gives access to the index labels:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "states.index"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Additionally, the ``DataFrame`` has a ``columns`` attribute, which is an ``Index`` object holding the column labels:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "states.columns"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "states.keys()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "states.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "states.ndim"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "states.describe()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "states.info()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "states.head(2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "states.tail(2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Thus the ``DataFrame`` can be thought of as a generalization of a two-dimensional NumPy array, where both the rows and columns have a generalized index for accessing the data."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### DataFrame as specialized dictionary\n",
    "\n",
    "Similarly, we can also think of a ``DataFrame`` as a specialization of a dictionary.\n",
    "Where a dictionary maps a key to a value, a ``DataFrame`` maps a column name to a ``Series`` of column data.\n",
    "For example, asking for the ``'area'`` attribute returns the ``Series`` object containing the areas we saw earlier:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "states['area']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "states['area'][0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "states['area'][1:3]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notice the potential point of confusion here: in a two-dimesnional NumPy array, ``data[0]`` will return the first *row*. For a ``DataFrame``, ``data['col0']`` will return the first *column*.\n",
    "Because of this, it is probably better to think about ``DataFrame``s as generalized dictionaries rather than generalized arrays, though both ways of looking at the situation can be useful.\n",
    "We'll explore more flexible means of indexing ``DataFrame``s in [Data Indexing and Selection](03.02-Data-Indexing-and-Selection.ipynb)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Constructing DataFrame objects\n",
    "\n",
    "A Pandas ``DataFrame`` can be constructed in a variety of ways.\n",
    "Here we'll give several examples."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### From a single Series object\n",
    "\n",
    "A ``DataFrame`` is a collection of ``Series`` objects, and a single-column ``DataFrame`` can be constructed from a single ``Series``:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "pd.DataFrame(population, columns=['population'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### From a list comprehension of dicts\n",
    "\n",
    "Any list of dictionaries can be made into a ``DataFrame``.\n",
    "We'll use a simple list comprehension to create some data:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "data = [{'a': i, 'b': 2 * i,'c':2**i+2 }\n",
    "        for i in range(1,4)]\n",
    "pd.DataFrame(data)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Even if some keys in the dictionary are missing, Pandas will fill them in with ``NaN`` (i.e., \"not a number\") values:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "pd.DataFrame([{'a': 1, 'b': 2}, {'b': 3, 'c': 4}])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### From a dictionary of Series objects\n",
    "\n",
    "As we saw before, a ``DataFrame`` can be constructed from a dictionary of ``Series`` objects as well:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "pd.DataFrame({'population': population,\n",
    "              'area': area})"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### From a two-dimensional NumPy array\n",
    "\n",
    "Given a two-dimensional array of data, we can create a ``DataFrame`` with any specified column and index names.\n",
    "If omitted, an integer index will be used for each:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "pd.DataFrame(np.random.rand(3, 2),\n",
    "             columns=['foo', 'bar'],\n",
    "             index=['a', 'b', 'c'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### From a NumPy structured array\n",
    "\n",
    "We covered structured arrays in  Numpy,\n",
    "A Pandas ``DataFrame`` operates much like a structured array, and can be created directly from one:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "A = np.zeros(5, dtype=[('A', 'i8'), ('B', 'c8')])\n",
    "A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "pd.DataFrame(A)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## The Pandas Index Object\n",
    "\n",
    "We have seen here that both the ``Series`` and ``DataFrame`` objects contain an explicit *index* that lets you reference and modify data.\n",
    "This ``Index`` object is an interesting structure in itself, and it can be thought of either as an *immutable array* or as an *ordered set* (technically a multi-set, as ``Index`` objects may contain repeated values).\n",
    "Those views have some interesting consequences in the operations available on ``Index`` objects.\n",
    "As a simple example, let's construct an ``Index`` from a list of integers:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ind = pd.Index([2, 3, 5, 7, 11])\n",
    "ind"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Index as immutable array\n",
    "\n",
    "The ``Index`` in many ways operates like an array.\n",
    "\n",
    "For example, we can use standard Python indexing notation to retrieve values or slices:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ind[1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ind[::2]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "``Index`` objects also have many of the attributes familiar from NumPy arrays:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(ind.size, ind.shape, ind.ndim, ind.dtype)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "One difference between ``Index`` objects and NumPy arrays is that indices are immutable–that is, they cannot be modified via the normal means:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This immutability makes it safer to share indices between multiple ``DataFrame``s and arrays, without the potential for side effects from inadvertent index modification."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Index as ordered set\n",
    "\n",
    "Pandas objects are designed to facilitate operations such as joins across datasets, which depend on many aspects of set arithmetic.\n",
    "The ``Index`` object follows many of the conventions used by Python's built-in ``set`` data structure, so that unions, intersections, differences, and other combinations can be computed in a familiar way:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "indA = pd.Index([1, 3, 5, 7, 9])\n",
    "indB = pd.Index([2, 3, 5, 7, 11])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "indA & indB  # intersection (Commen Elemeant in the Both the Sets)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "indA | indB  # union(Combine all the elements)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "indA ^ indB  # symmetric difference"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "These operations may also be accessed via object methods, for example ``indA.intersection(indB)``."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Series and DataFrame to File Format"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "Se = pd.Series([10,20,30,40,50,60,40,25,60])\n",
    "Se"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "Data =Se.to_csv('Data.csv',sep=',',header=True)\n",
    "Data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "Se.to_frame('Datajson')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "Df = pd.DataFrame({'Age':np.arange(25,30),\n",
    "                  'Gender':['M','F','M','F','M'],\n",
    "                  'Data_types':('int','Float','Complex','String','bool')\n",
    "                  })\n",
    "Df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "Df['Data_Structures']= ['list','tuple','dict','set','array'] # Col name and Values\n",
    "Df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "Df.columns"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "Df['Age', 'Gender', 'Data_types', 'Data_Structures'] = [30,'m','None Type','None','IEEE']  # Col names and Values to add the row"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "Df"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Data Converting To files"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "Df.to_html('Df.html')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "Df.to_csv('Df.csv')"
   ]
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "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.6.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}