Data Analysis with Pandas.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "G3vV_ag-Ak1q"
   },
   "source": [
    "# Data Analysis and manipulation with Pandas\n",
    "\n",
    "## Pandas Introduction"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "wZ0UHb2eAk1v"
   },
   "source": [
    "``Pandas`` is an open source Python library for data analysis. It gives Python the\n",
    "ability to work with spreadsheet-like data for fast data loading, manipulating,\n",
    "aligning, merging, etc. To give Python these enhanced features, Pandas\n",
    "introduces two new data types to Python: ``Series`` and ``DataFrame``. The\n",
    "DataFrame will represent your entire spreadsheet or rectangular data, whereas\n",
    "the Series is a single column of the DataFrame. A Pandas DataFrame can also\n",
    "be thought of as a dictionary or collection of Series.\n",
    "\n",
    "While NumPy and its ndarray object, which provides efficient storage and manipulation \n",
    "of dense typed arrays in Python. Pandas is a package built on top of NumPy, and provides an\n",
    "efficient implementation of a DataFrame. DataFrames are essentially multidimensional\n",
    "arrays with attached row and column labels, and often with heterogeneous\n",
    "types and/or missing data. As well as offering a convenient storage interface for\n",
    "labeled data, Pandas implements a number of powerful data operations familiar to\n",
    "users of both database frameworks and spreadsheet programs.\n",
    "\n",
    "NumPy’s ndarray data structure provides essential features for the type of\n",
    "clean, well-organized data typically seen in numerical computing tasks. While it\n",
    "serves this purpose very well, its limitations become clear when we need more flexibility\n",
    "(attaching labels to data, working with missing data, etc.) and when attempting\n",
    "operations that do not map well to element-wise broadcasting (groupings, pivots,\n",
    "etc.), each of which is an important piece of analyzing the less structured data available\n",
    "in many forms in the world around us. Pandas, and in particular its Series and\n",
    "DataFrame objects, builds on the NumPy array structure and provides efficient access\n",
    "to these sorts of “data munging” tasks that occupy much of a data scientist’s time."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "dY7dGeLdAk1x"
   },
   "source": [
    "Import ``pandas`` under the alias pd and check the version:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "id": "gd3rVV52Ak1y",
    "outputId": "7c68b4a5-dcba-40dc-a3be-e500b99ea1db"
   },
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "pd.__version__"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "PBL9Ls-1Ak15"
   },
   "source": [
    "***Reminder About Built-In Documentation***\n",
    "\n",
    "Remember, IPython gives you the ability to quickly explore the contents of a package \n",
    "(by using the tab-completion feature) as well as the documentation of various functions \n",
    "(using the ? character)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "S6NRaPVUAk16"
   },
   "source": [
    "For example, to display all the contents of the pandas namespace, you can type this:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "raw",
    "id": "YFomHniFAk18"
   },
   "source": [
    "pd.<TAB>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "xLqREs2XAk19"
   },
   "source": [
    "And to display the built-in Pandas documentation, you can use this:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "raw",
    "id": "y-uD-Jl5Ak1-"
   },
   "source": [
    "pd?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "EUFwvLkBAk1_"
   },
   "source": [
    "More detailed documentation, along with tutorials and other resources, can be found\n",
    "at [Pandas](http://pandas.pydata.org/.)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "wj76hKWrAk2B"
   },
   "source": [
    "### Pandas Objects\n",
    "\n",
    "At the very basic level, Pandas objects can be thought of as enhanced versions of\n",
    "NumPy structured arrays in which the rows and columns are identified with labels\n",
    "rather than simple integer indices. \n",
    "\n",
    "To get started with pandas, we will need to get comfortable with its two workhorse\n",
    "data structures: Series and DataFrame."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "8Ts3iZDWAk2C"
   },
   "source": [
    "#### Series\n",
    "\n",
    "A Series is a one-dimensional array-like object containing a sequence of values (of\n",
    "similar types to NumPy types) and an associated array of data labels, called its index.\n",
    "The simplest Series is formed from only an array of data:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "XrsCQ2P9Ak2D"
   },
   "source": [
    "Numpy and Pandas imports under the aliases np and pd:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "_JRkkn5HAk2E"
   },
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import pandas as pd"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 119
    },
    "colab_type": "code",
    "id": "JeR4o4H3Ak2I",
    "outputId": "205e0cb2-425d-41e5-89ea-77a0fa6dd4ac"
   },
   "outputs": [],
   "source": [
    "series_data = pd.Series([0.0, 0.25, 0.5, 0.75, 1.0])\n",
    "series_data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "tOM8EGVvAk2N"
   },
   "source": [
    "The Series wraps both a sequence of values and a\n",
    "sequence of indices, which we can access with the values and index attributes. The\n",
    "values are simply a familiar NumPy array:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "id": "zi10wwiPAk2Q",
    "outputId": "7135eeaf-7380-4f3d-c9e6-c1915271463e"
   },
   "outputs": [],
   "source": [
    "series_data.values"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "DbYMkfU3Ak2T"
   },
   "source": [
    "The index is an array-like object of type pd.Index."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "id": "43fEwGOfAk2U",
    "outputId": "b44960bc-27f2-42d9-cecb-761960e8f2eb"
   },
   "outputs": [],
   "source": [
    "series_data.index"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "gDyQrMEWAk2a"
   },
   "source": [
    "Like with a NumPy array, data can be accessed by the associated index via the familiar\n",
    "Python square-bracket notation:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "series_data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "id": "ktkO6ML8Ak2g",
    "outputId": "fd31b6f1-b32b-4077-9747-6daf558ae7df"
   },
   "outputs": [],
   "source": [
    "series_data[2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 102
    },
    "colab_type": "code",
    "id": "PDKVdKFQAk2n",
    "outputId": "ddd4f564-1f53-4dea-b5dd-54b3aa84c147"
   },
   "outputs": [],
   "source": [
    "series_data[1:5]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "S9ZgOTbDAk2q"
   },
   "source": [
    "**Series as generalized NumPy array**\n",
    "\n",
    "From what we’ve seen so far, it may look like the Series object is basically interchangeable\n",
    "with a one-dimensional NumPy array. The essential difference is the presence\n",
    "of the index: while the NumPy array has an implicitly defined integer index used\n",
    "to access the values, the Pandas Series has an explicitly defined index associated with\n",
    "the values."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "1QIrKvzRAk2r"
   },
   "source": [
    "This explicit index definition gives the Series object additional capabilities. For\n",
    "example, the index need not be an integer, but can consist of values of any desired\n",
    "type. For example, if we wish, we can use strings as an index:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "JXwd-AQgAk2t"
   },
   "outputs": [],
   "source": [
    "gdp_per_capita = pd.Series([113196,83716, 81151, 77975, 77771, 69687, 67037, 65111, 63987, 2171],\n",
    "index=['Luxembourg', 'Switzerland', 'Macau', 'Norway', 'Ireland', 'Qatar', 'Iceland', 'United States', 'Singapore', 'India'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 204
    },
    "colab_type": "code",
    "id": "RBmeXVmGAk2x",
    "outputId": "b8561d17-f46a-4790-82ef-cf7ee96eb28e"
   },
   "outputs": [],
   "source": [
    "gdp_per_capita"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "gdp_per_capita['Norway']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "gdp_per_capita[3]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "TOUTvIYlAk21"
   },
   "source": [
    "And the item access works as expected:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "id": "KwB7_CQlAk24",
    "outputId": "f7d6c6b3-dc5d-4855-f9e1-e8df71676545"
   },
   "outputs": [],
   "source": [
    "gdp_per_capita['United States']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "34XKv5cyveJd"
   },
   "source": [
    "**Task**\n",
    "\n",
    "Find the gdp_per_capita for `India` as gdp_India"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "deletable": false,
    "id": "Uw0vQO74veJf",
    "nbgrader": {
     "cell_type": "code",
     "checksum": "c64a1293ea38482d486231c0b53e11e9",
     "grade": false,
     "grade_id": "Task_5_1",
     "locked": false,
     "schema_version": 3,
     "solution": true,
     "task": false
    },
    "outputId": "1380917b-7706-4140-a0e0-130bb55d1cd2"
   },
   "outputs": [],
   "source": [
    "## Write 1 line of code.\n",
    "\n",
    "#YOUR CODE HERE\n",
    "\n",
    "print(gdp_India)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "ZbXM_95kveJj"
   },
   "source": [
    "#### DataFrame\n",
    "\n",
    "A DataFrame represents a rectangular table of data and contains an ordered collection\n",
    "of columns, each of which can be a different value type (numeric, string,\n",
    "boolean, etc.). The DataFrame has both a row and column index; it can be thought of\n",
    "as a dict of Series all sharing the same index. Under the hood, the data is stored as one\n",
    "or more two-dimensional blocks rather than a list, dict, or some other collection of\n",
    "one-dimensional arrays."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dict1 = {'name':['john'],'age':[20]}\n",
    "df1 = pd.DataFrame(dict1,columns=['name','NAME','age'])\n",
    "df1\n",
    "# How to create a dataframe from dictionary"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df1.columns = ['name1', 'NAME1', 'age1']\n",
    "df1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "list1 = [['john',20],['xavier',30]]\n",
    "pd.DataFrame(list1,columns=['name','age'],index=['R1','R2'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# How to create a dataframe from list\n",
    "\n",
    "stu_name = ['jhon','xavier','chris','kristien']\n",
    "age = [18,19,20,18]\n",
    "stu_id = [101,102,103,104]\n",
    "\n",
    "stu_data = {'stu_name':stu_name,'age':age,'stu_id':stu_id}\n",
    "pd.DataFrame(stu_data)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "oKE_4is1Ak2-"
   },
   "source": [
    "There are many ways to construct a DataFrame, though one of the most common is\n",
    "from a dict of equal-length lists or NumPy arrays:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Indexing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "wRryVWLXAk2_"
   },
   "outputs": [],
   "source": [
    "dense_pop_data = {'country': ['India', 'Pakistan', 'Bangladesh', 'Japan', 'Philippines', 'Vietnam', 'United Kingdom', 'South Korea', 'Taiwan', 'Sri Lanka'],\n",
    "'population': [1360780000, 219210000, 168410000, 126010000, 108510000, 96208984, 66435600, 51780579, 23604265, 21803000],\n",
    "'area_in_sq_km': [3287240, 803940, 143998, 377873, 300000, 331689, 243610, 99538, 36193, 65610],\n",
    "'density_pop_per_sq_km':[414, 273, 1170, 333, 362, 290, 273, 520, 652, 332],\n",
    "'notes':['Growing population', 'Growing population', 'Rapidly growing population', 'Declining population', 'Growing population', \n",
    "         'Growing population', 'Steady population', 'Steady population', 'Steady population', 'Growing population']}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 359
    },
    "colab_type": "code",
    "id": "6NhTy3ILAk3I",
    "outputId": "038fe974-9379-4b1b-f24d-176b46694bdd"
   },
   "outputs": [],
   "source": [
    "dense_df = pd.DataFrame(dense_pop_data)\n",
    "dense_df"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "GyIhOP1mAk3L"
   },
   "source": [
    "The resulting DataFrame will have its index assigned automatically as with Series."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "Kkp8AehJAk3Y"
   },
   "source": [
    "A column in a DataFrame can be retrieved as a Series either by dict-like notation or\n",
    "by attribute:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 204
    },
    "colab_type": "code",
    "id": "VZFZnXG2Ak3Z",
    "outputId": "fa931d1b-c7a1-4548-cf64-2a6ba83a4633"
   },
   "outputs": [],
   "source": [
    "dense_df['population']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 204
    },
    "colab_type": "code",
    "id": "k2UMwYyhAk3d",
    "outputId": "c09e0f97-d9f4-4c9d-ce34-514ad9e046ae"
   },
   "outputs": [],
   "source": [
    "dense_df.area_in_sq_km"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "8WR6fvTHAk3h"
   },
   "source": [
    "``df[column]`` works for any column name, but ``df.column`` only works when the column name is a valid Python variable\n",
    "name."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "gUWJa4inAk3i"
   },
   "source": [
    "### Data Indexing and Selection\n",
    "\n",
    "#### Series\n",
    "##### Data Selection in Series"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 119
    },
    "colab_type": "code",
    "id": "Y2I2dEeDAk3i",
    "outputId": "2b39c5b7-04da-452a-be41-ba0c7ee2998b"
   },
   "outputs": [],
   "source": [
    "series_data = pd.Series([0.0, 0.25, 0.5, 0.75, 1.0], index=['a', 'b', 'c', 'd', 'e'])\n",
    "print(series_data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# numpyarray = np.array(series_data)\n",
    "# numpyarray[1]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dict(series_data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "id": "EnFlOTagAk3l",
    "outputId": "4a1acff7-8c22-49ae-b6c6-be61e97f379a"
   },
   "outputs": [],
   "source": [
    "series_data['b']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "73iJkuEjAk3o"
   },
   "source": [
    "We can also use dictionary-like Python expressions and methods to examine the\n",
    "keys/indices and values:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "id": "s8VHGEnuAk3p",
    "outputId": "d8e0c4d1-d943-4202-86de-8a9139724adc"
   },
   "outputs": [],
   "source": [
    "'a' in series_data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "id": "F1q6zU4PAk3s",
    "outputId": "75a81c1e-2956-43a8-ad3a-486b03d56295"
   },
   "outputs": [],
   "source": [
    "series_data.keys()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "id": "7JCzZjBBAk3v",
    "outputId": "b04d7ae1-6fb5-47d8-b655-16d22566a053"
   },
   "outputs": [],
   "source": [
    "list(series_data.items())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "elqWLpkUAk3y"
   },
   "source": [
    "Series objects can even be modified with a dictionary-like syntax. Just as you can\n",
    "extend a dictionary by assigning to a new key, you can extend a Series by assigning\n",
    "to a new index value:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "Oi7Jet_-Ak3z"
   },
   "outputs": [],
   "source": [
    "series_data['f'] = 1.25"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 136
    },
    "colab_type": "code",
    "id": "zleZeizyAk32",
    "outputId": "1e8f74ed-ab49-42c2-fba6-b2b515d179b0"
   },
   "outputs": [],
   "source": [
    "series_data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 85
    },
    "colab_type": "code",
    "id": "4SDkbdNXAk36",
    "outputId": "044ff0d2-8cb8-492e-ea8b-7847725e9d94"
   },
   "outputs": [],
   "source": [
    "# slicing by explicit index\n",
    "series_data['a':'c']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 68
    },
    "colab_type": "code",
    "id": "9HJ6jCSdAk3-",
    "outputId": "20751133-63f1-469c-ba94-7f3d6f896373"
   },
   "outputs": [],
   "source": [
    "# slicing by implicit integer index\n",
    "series_data[0:2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 68
    },
    "colab_type": "code",
    "id": "ABdefRIkAk4D",
    "outputId": "e0ecbfb5-d343-46b1-988f-30a23e0910c4"
   },
   "outputs": [],
   "source": [
    "# masking\n",
    "series_data[(series_data > 0.3) & (series_data < 0.8)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 68
    },
    "colab_type": "code",
    "id": "MIT7pu9GAk4G",
    "outputId": "13c8336d-d7d3-465a-840a-ebb6f9fb264e"
   },
   "outputs": [],
   "source": [
    "# fancy indexing\n",
    "series_data[['a', 'e']]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "aGxipiZaAk4J"
   },
   "source": [
    "*Notice that when you are  slicing with an explicit index (i.e., series_data['a':'c']), the final index is included in the slice, while when you’re slicing with an implicit index (i.e., series_data[0:2]), the final index is excluded from the slice.*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "tOe933dmAk4K"
   },
   "source": [
    "##### Indexers: loc, iloc, and ix\n",
    "These slicing and indexing conventions can be a source of confusion. For example, if\n",
    "your Series has an explicit integer index, an indexing operation such as data[1] will\n",
    "use the explicit indices, while a slicing operation like data[1:3] will use the implicit\n",
    "Python-style index."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 119
    },
    "colab_type": "code",
    "id": "1r1zah33Ak4K",
    "outputId": "f8ddc1ac-25ca-4d4a-f2c5-14186666184e"
   },
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "\n",
    "data = pd.Series(['a', 'b', 'c', 'd', 'e'], index = [1, 3, 5, 7, 9])\n",
    "data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "id": "qKglB2WBAk4O",
    "outputId": "0cac6133-5bb0-4685-d205-b49bdf7f2356"
   },
   "outputs": [],
   "source": [
    "# explicit index when indexing\n",
    "data[1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 68
    },
    "colab_type": "code",
    "id": "cUR6ds4CAk4R",
    "outputId": "c748d1c7-9151-4944-a356-3d429169cfdc"
   },
   "outputs": [],
   "source": [
    "# implicit index when slicing\n",
    "data[1:3]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "RGpJKs96Ak4U"
   },
   "source": [
    "Because of this potential confusion in the case of integer indexes, Pandas provides\n",
    "some special indexer attributes that explicitly expose certain indexing schemes. These\n",
    "are not functional methods, but attributes that expose a particular slicing interface to\n",
    "the data in the Series."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "WpJdvbmEAk4V"
   },
   "source": [
    "First, the ``loc`` attribute allows indexing and slicing that always references the explicit\n",
    "index:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "id": "tbBmg6-jAk4W",
    "outputId": "7824c270-51ee-4322-d46a-8f865d065ac3"
   },
   "outputs": [],
   "source": [
    "data.loc[1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 68
    },
    "colab_type": "code",
    "id": "tG9TIl-YAk4Z",
    "outputId": "ca393c6e-f381-464e-c1cf-d896d54825ec"
   },
   "outputs": [],
   "source": [
    "data.loc[1:5]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "Z1uxMfMmAk4d"
   },
   "source": [
    "The ``iloc`` attribute allows indexing and slicing that always references the implicit\n",
    "Python-style index:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "id": "uPxtg9cUAk4e",
    "outputId": "0b0623a2-0ecc-4f79-9cd5-3e5c8fdd262a"
   },
   "outputs": [],
   "source": [
    "data.iloc[1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 68
    },
    "colab_type": "code",
    "id": "B-KEXkTvAk4m",
    "outputId": "aa2f982b-867a-45be-cf13-e992dbff8e07"
   },
   "outputs": [],
   "source": [
    "data.iloc[1:3]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "ed3h7yGoveMi"
   },
   "source": [
    "**Task**\n",
    "\n",
    "Find the first 4 series values from beginning into `part_series`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "deletable": false,
    "id": "iTxpkbJ8veMj",
    "nbgrader": {
     "cell_type": "code",
     "checksum": "2728a5277a4bb672614456941ce866aa",
     "grade": false,
     "grade_id": "Task_5_2",
     "locked": false,
     "schema_version": 3,
     "solution": true,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "## Write 1 line of code.\n",
    "\n",
    "# YOUR CODE HERE\n",
    "\n",
    "print(part_series)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "part_series_sol =  data.iloc[0:4]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "CAypq7PGveMs"
   },
   "source": [
    "**Task**\n",
    "\n",
    "Add a new data item `f` to the series at index `11`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "deletable": false,
    "id": "eszqphZVveMy",
    "nbgrader": {
     "cell_type": "code",
     "checksum": "769d7774686696400d522fe609699673",
     "grade": false,
     "grade_id": "Task_5_3",
     "locked": false,
     "schema_version": 3,
     "solution": true,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "# YOUR CODE HERE\n",
    "data.loc[11] = 'f'\n",
    "print(data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "deletable": false,
    "editable": false,
    "id": "vmIz2HeZveM2",
    "nbgrader": {
     "cell_type": "code",
     "checksum": "ec51b09b834613fcdbabbd3ec7b85f2a",
     "grade": true,
     "grade_id": "Task_5_3_Ans",
     "locked": true,
     "points": 0,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "assert data[11] == 'flop'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "heading_collapsed": true,
    "id": "WiMWpXaCAk4q"
   },
   "source": [
    "#### Data Selection in DataFrame"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "hidden": true,
    "id": "G6JSDAe9Ak4q"
   },
   "outputs": [],
   "source": [
    "dense_pop_data = {'country': ['India', 'Pakistan', 'Bangladesh', 'Japan', 'Philippines', 'Vietnam', 'United Kingdom', 'South Korea', 'Taiwan', 'Sri Lanka'],\n",
    "'population': [1360780000, 219210000, 168410000, 126010000, 108510000, 96208984, 66435600, 51780579, 23604265, 21803000],\n",
    "'area_in_sq_km': [3287240, 803940, 143998, 377873, 300000, 331689, 243610, 99538, 36193, 65610],\n",
    "'density_pop_per_sq_km':[414, 273, 1170, 333, 362, 290, 273, 520, 652, 332],\n",
    "'notes':['Growing population', 'Growing population', 'Rapidly growing population', 'Declining population', 'Growing population', \n",
    "         'Growing population', 'Steady population', 'Steady population', 'Steady population', 'Growing population']}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "hidden": true,
    "id": "q5Cp1_JTAk4v"
   },
   "outputs": [],
   "source": [
    "dense_df = pd.DataFrame(dense_pop_data)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "hidden": true,
    "id": "lW45KvNzAk42"
   },
   "source": [
    "The individual Series that make up the columns of the DataFrame can be accessed\n",
    "via dictionary-style indexing of the column name:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 204
    },
    "colab_type": "code",
    "hidden": true,
    "id": "LAWb3FtjAk42",
    "outputId": "b2892a24-9d3c-4d66-bf35-6884621cfb13"
   },
   "outputs": [],
   "source": [
    "dense_df['country']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "hidden": true,
    "id": "WOMaQzl_Ak45"
   },
   "source": [
    "Equivalently, we can use attribute-style access with column names that are strings:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 204
    },
    "colab_type": "code",
    "hidden": true,
    "id": "zrhMfMHTAk48",
    "outputId": "bbc1da03-a92c-4c9f-ed7b-7ad84493f799"
   },
   "outputs": [],
   "source": [
    "dense_df.country"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "hidden": true,
    "id": "YXH32I4TAk5D"
   },
   "source": [
    "**DataFrame as two-dimensional array**\n",
    "\n",
    "DataFrame as an enhanced twodimensional array. We can examine the raw underlying data array using the values\n",
    "attribute:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 187
    },
    "colab_type": "code",
    "hidden": true,
    "id": "mi9hyhJmAk5E",
    "outputId": "1c97b97d-2ae7-47de-ba80-c09fa07ba4d8"
   },
   "outputs": [],
   "source": [
    "dense_df.values"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "hidden": true,
    "id": "Pw7bb2zKAk5H"
   },
   "source": [
    "Transpose the full DataFrame to swap rows and columns:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 173
    },
    "colab_type": "code",
    "hidden": true,
    "id": "4g5vxLdxAk5I",
    "outputId": "aab00648-c479-4697-97c7-3128a5a67207"
   },
   "outputs": [],
   "source": [
    "dense_df.T"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "hidden": true,
    "id": "AAfGWPz0Ak5M"
   },
   "source": [
    "Using indexers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 359
    },
    "colab_type": "code",
    "hidden": true,
    "id": "pdCNJbh_Ak5N",
    "outputId": "4ded27ec-f1e8-43cf-8c2b-37b9dba80b78"
   },
   "outputs": [],
   "source": [
    "dense_df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 80
    },
    "colab_type": "code",
    "hidden": true,
    "id": "WYFCgsRSAk5P",
    "outputId": "8e682b54-c8b2-4af0-fbe9-d9998a7d4d9f"
   },
   "outputs": [],
   "source": [
    "dense_df[1:2]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "hidden": true,
    "id": "F6CF0hggAk5S"
   },
   "source": [
    "**Selection with ``loc`` and ``iloc``**\n",
    "\n",
    "For DataFrame label-indexing on the rows, the special indexing operators\n",
    "``loc`` and ``iloc`` enable us to select a subset of the rows and columns from a\n",
    "DataFrame with NumPy-like notation using either ``axis labels (loc)`` or ``integers (iloc)``."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 173
    },
    "colab_type": "code",
    "hidden": true,
    "id": "4y-B3aWaAk5S",
    "outputId": "5365d81e-09fc-4d48-e764-f50e5ff96b65"
   },
   "outputs": [],
   "source": [
    "dense_df.loc[1:4,['country', 'notes']]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 142
    },
    "colab_type": "code",
    "hidden": true,
    "id": "C7CvPcbbAk5U",
    "outputId": "39f5dacb-7bc0-42f6-9022-5bb5fc02834c"
   },
   "outputs": [],
   "source": [
    "dense_df.iloc[1:4,0:2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 111
    },
    "colab_type": "code",
    "hidden": true,
    "id": "Sw1V9hCGAk5W",
    "outputId": "6bdfabd7-a76f-48a8-eaa4-b4dcfa3835e8"
   },
   "outputs": [],
   "source": [
    "dense_df.iloc[[1, 0], [0, 2, 1]]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "hidden": true,
    "id": "7Y-qvab4Ak5Y",
    "outputId": "e18c3c1f-4fab-4402-a14f-3db0f95d169b"
   },
   "outputs": [],
   "source": [
    "dense_df.iloc[2, 1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 111
    },
    "colab_type": "code",
    "hidden": true,
    "id": "CdXjnnqPAk5a",
    "outputId": "d4bba5e5-1b64-4ccc-e022-1829e08881c4"
   },
   "outputs": [],
   "source": [
    "dense_df.iloc[:, :3][dense_df.density_pop_per_sq_km > 400]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "hidden": true,
    "id": "D7WQj5zwAk5c"
   },
   "source": [
    "``Indexing operations with datafrmaes``\n",
    "- ``df[val]``: Select single column or sequence of columns from the DataFrame; special case\n",
    "conveniences: boolean array (filter rows), slice (slice rows), or boolean DataFrame\n",
    "- ``df.loc[val]``: Selects single row or subset of rows from the DataFrame by label\n",
    "- ``df.loc[:, val]``: Selects single column or subset of columns by label\n",
    "- ``df.loc[val1, val2]``: Select both rows and columns by label\n",
    "- ``df.iloc[where]``: Selects single row or subset of rows from the DataFrame by integer position\n",
    "- ``df.iloc[:, where]``: Selects single column or subset of columns by integer position\n",
    "- ``df.iloc``: [where_i, where_j] Select both rows and columns by integer position"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "hidden": true,
    "id": "HrPw3sD9Ak5f"
   },
   "source": [
    "The ``iloc`` method is used to select rows and columns by integer position. \n",
    "\n",
    "You can pass it:\n",
    "- A single integer position\n",
    "- A list of integer positions\n",
    "- A slice of integer positions\n",
    "- A colon (which indicates \"all integer positions\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "hidden": true,
    "id": "vwP5MsOyAk5g"
   },
   "source": [
    "The ``loc`` method is used to select rows and columns by label. \n",
    "\n",
    "You can pass it:\n",
    "- A single label\n",
    "- A list of labels\n",
    "- A slice of labels\n",
    "- A boolean Series\n",
    "- A colon (which indicates \"all labels\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "Xfn3J66AAk5h"
   },
   "source": [
    "### Indexing ###\n",
    "\n",
    "An important method on pandas objects is reindex, which means to create a new\n",
    "object with the data conformed to a new index."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 359
    },
    "colab_type": "code",
    "id": "vq5cfDDiAk5k",
    "outputId": "d2f66625-2942-4c06-97cd-a25083b54fd7"
   },
   "outputs": [],
   "source": [
    "dense_df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "WeJjO4s3Ak5n"
   },
   "outputs": [],
   "source": [
    "# Set country as index\n",
    "dense_df.set_index('country', inplace = True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 390
    },
    "colab_type": "code",
    "id": "7gCrsCp5Ak5u",
    "outputId": "0f7ea48b-26f7-4b66-934c-2cb18a50b404"
   },
   "outputs": [],
   "source": [
    "dense_df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 85
    },
    "colab_type": "code",
    "id": "phDalJ0FAk5w",
    "outputId": "ecfca3a3-03ae-4c6e-a47a-9b368989491b"
   },
   "outputs": [],
   "source": [
    "dense_df.loc['United Kingdom']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 85
    },
    "colab_type": "code",
    "id": "l96e2iYNAk50",
    "outputId": "718c09c3-235d-4501-9614-a9b3a26d8f52"
   },
   "outputs": [],
   "source": [
    "dense_df.iloc[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 266
    },
    "colab_type": "code",
    "id": "cJw6vO6DAk53",
    "outputId": "6d585b5b-54d0-4e13-ba2f-47d44078baf4"
   },
   "outputs": [],
   "source": [
    "dense_df.loc['Japan':'Sri Lanka']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 235
    },
    "colab_type": "code",
    "id": "uV82JaibAk56",
    "outputId": "d179bf9d-64b2-4689-abd3-9d567cbd3f3b"
   },
   "outputs": [],
   "source": [
    "dense_df[0:5]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 390
    },
    "colab_type": "code",
    "id": "gBms4ouRAk58",
    "outputId": "ac48d326-c2ad-4e26-f1ab-a5727068532c"
   },
   "outputs": [],
   "source": [
    "dense_df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 390
    },
    "colab_type": "code",
    "id": "f0-g2o2GAk5-",
    "outputId": "2a5995d9-f528-4392-f3e2-fa7f25a3e52f"
   },
   "outputs": [],
   "source": [
    "dense_df = dense_df.sort_index()\n",
    "dense_df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dense_df.sort_values(['population'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Merge and concat"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df1 = pd.DataFrame({\n",
    "'A':[1,2,3,4],\n",
    "'B':[True,False,True,True],\n",
    "'C':['C1','C2','C3','C4']\n",
    "})\n",
    "df2 = pd.DataFrame({\n",
    "'A':[5,7,8,5],\n",
    "'B':[False,False,True,False],\n",
    "'D':['D1','D2','D3','D4']\n",
    "})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(df1)\n",
    "print(df2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Concat"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "pd.concat([df1,df2],axis=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "pd.concat([df1,df2],axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "pd.concat([df1,df2],axis=0,ignore_index=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df1 = pd.DataFrame({\n",
    "'A':[1,2,3,4],\n",
    "'B':[True,False,True,True],\n",
    "'C':['C1','C2','C3','C4']\n",
    "})\n",
    "df2 = pd.DataFrame({\n",
    "'A':[5,7,8,'NULL'],\n",
    "'B':[False,False,True,False],\n",
    "'D':['D1','D2','D3','NULL']\n",
    "})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "print(df1)\n",
    "print(df2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "pd.concat([df1,df2],axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "pd.concat([df1,df2],axis=0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Merge"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df1 = pd.DataFrame({\n",
    "'A':[1,2,3,4],\n",
    "'B':[True,False,True,True],\n",
    "'C':['C1','C2','C3','C4']\n",
    "})\n",
    "df2 = pd.DataFrame({\n",
    "'A':[4,7,8,'NULL'],\n",
    "'B':[True,False,True,False],\n",
    "'D':['D1','D2','D3','NULL']\n",
    "})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(df1)\n",
    "print(df2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "?pd.merge"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "colab": {
   "collapsed_sections": [],
   "name": "Pandas_Basics.ipynb",
   "provenance": []
  },
  "interpreter": {
   "hash": "d76a6713ea065ccca64d993c02c6b9e279dcce4f62a99101c64210a1216fb1dc"
  },
  "kernelspec": {
   "display_name": "Python 3.8.5 64-bit ('anaconda3': conda)",
   "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.8.5"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": false
  },
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "metadata": {
    "deletable": true,
    "editable": true,
    "trusted": true
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}