001_Python_Pandas_Methods/002_Python_Pandas_DataFrame_from_List.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<small><small><i>\n",
    "All the IPython Notebooks in this lecture series by Dr. Milan Parmar are available @ **[GitHub](https://github.com/milaan9/10_Python_Pandas_Module/tree/main/001_Python_Pandas_Methods)**\n",
    "</i></small></small>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Create Pandas DataFrame from Python List\n",
    "\n",
    "In this class, you will learn how to convert Python **[List](https://github.com/milaan9/02_Python_Datatypes/blob/main/003_Python_List.ipynb)** to a **[Pandas DataFrame](https://github.com/milaan9/10_Python_Pandas_Module/blob/main/001_Python_Pandas_DataFrame.ipynb)**. It covers creating DataFrame from different types of a list like single list, multiple lists, nested lists. It creates DataFame from a list where a list can be added as a row or a column.\n",
    "\n",
    "The List is a simple data structure in Python that stores the values as a List. The List can have heterogeneous elements, i.e., it can have values of different types. To analyze such a List, we can convert it into the pandas DataFrame. By converting the List into a 2-dimensional structure makes it efficient to process.\n",
    "\n",
    "DataFrame can be created from List using DataFrame constructor. In this class, we will discusses all the cases of it in detail."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Create DataFrame from list using constructor\n",
    "\n",
    "**DataFrame constructor** can create DataFrame from different data structures in python like **`dict`**, list, set, tuple, and **`ndarray`**.\n",
    "\n",
    "**Example:**\n",
    "\n",
    "Here we create a DataFrame object using a list of heterogeneous data. By default, all list elements are added as a row in the DataFrame. And row index is the range of numbers(starting at 0)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-06-17T11:49:41.778527Z",
     "start_time": "2021-06-17T11:49:41.209203Z"
    },
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Apple', 10, 'Orange', 55.5]\n",
      "        0\n",
      "0   Apple\n",
      "1      10\n",
      "2  Orange\n",
      "3    55.5\n"
     ]
    }
   ],
   "source": [
    "import pandas as pd\n",
    "\n",
    "# Create list\n",
    "fruits_list = ['Apple', 10, 'Orange', 55.50]\n",
    "print(fruits_list)\n",
    "\n",
    "# Create DataFrame from list\n",
    "fruits_df = pd.DataFrame(fruits_list)\n",
    "print(fruits_df)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Create DataFrame from list with a customized column name\n",
    "\n",
    "While creating a DataFrame from the list, we can give a customized column label in the resultant DataFrame. By default, it provides a range of integers as column labels, i.e., 0, 1, 2…n.\n",
    "\n",
    "We can specify column labels into the **`columns=[col_labels]`** parameter in the DataFrame constructor.\n",
    "\n",
    "**Example:**\n",
    "\n",
    "In the below example, we create DataFrame from a list of fruit names and provides a column label as **`Fruits`**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-06-17T11:49:44.302917Z",
     "start_time": "2021-06-17T11:49:44.289242Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Apple', 'Banana', 'Orange', 'Mango']\n",
      "   Fruits\n",
      "0   Apple\n",
      "1  Banana\n",
      "2  Orange\n",
      "3   Mango\n"
     ]
    }
   ],
   "source": [
    "import pandas as pd\n",
    "\n",
    "# Create list\n",
    "fruits_list = ['Apple', 'Banana', 'Orange','Mango']\n",
    "print(fruits_list)\n",
    "\n",
    "# Create DataFrame from list\n",
    "fruits_df = pd.DataFrame(fruits_list, columns=['Fruits'])\n",
    "print(fruits_df)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Create DataFrame from list with a customized index\n",
    "\n",
    "As we just discussed the changing column label, we can even customize the row index as well. We can give a meaningful row index to identify each row uniquely. It becomes easier to access the rows using the index label.\n",
    "\n",
    "We can specify row index into the **`index=[row_index1, row_index2]`** parameter in the DataFrame constructor. By default, it gives a range of integers as row index i.e. 0, 1, 2…n.\n",
    "\n",
    "**Example:**\n",
    "\n",
    "Let’s see how we can provide the custom row index while creating DataFrame from the List."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-06-17T11:49:48.028455Z",
     "start_time": "2021-06-17T11:49:48.008928Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Apple', 'Banana', 'Orange', 'Mango']\n",
      "             0\n",
      "Fruit1   Apple\n",
      "Fruit2  Banana\n",
      "Fruit3  Orange\n",
      "Fruit4   Mango\n"
     ]
    }
   ],
   "source": [
    "import pandas as pd\n",
    "\n",
    "# Create list\n",
    "fruits_list = ['Apple', 'Banana', 'Orange','Mango']\n",
    "print(fruits_list)\n",
    "\n",
    "# Create DataFrame from list\n",
    "fruits_df = pd.DataFrame(fruits_list, index=['Fruit1', 'Fruit2', 'Fruit3', 'Fruit4'])\n",
    "print(fruits_df)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Create DataFrame from list by changing data type\n",
    "\n",
    "While converting a Python List to the DataFrame, we may need to change the values’ data type.\n",
    "\n",
    "We can change the data type of the list elements using the **`dtype`** parameter of the DataFrame constructor.\n",
    "\n",
    "**Example:**\n",
    "\n",
    "Suppose we have a list of fruit’s prices of type **object**. But, while creating DataFrame we need to correct its data type to **float64**. In such case we use **`dtype`** parameter as shown below example."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-06-17T11:49:51.098244Z",
     "start_time": "2021-06-17T11:49:51.073834Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['50', '100', '60', '20']\n",
      "Data type before :  0    object\n",
      "dtype: object\n",
      "Data type after :  0    float64\n",
      "dtype: object\n",
      "       0\n",
      "0   50.0\n",
      "1  100.0\n",
      "2   60.0\n",
      "3   20.0\n"
     ]
    }
   ],
   "source": [
    "import pandas as pd\n",
    "\n",
    "# Create list\n",
    "price_list = ['50', '100', '60', '20']\n",
    "print(price_list)\n",
    "\n",
    "# Create DataFrame from list\n",
    "price_df = pd.DataFrame(price_list)\n",
    "print(\"Data type before : \", price_df.dtypes)\n",
    "\n",
    "# Create DataFrame from list with type change\n",
    "price_df = pd.DataFrame(price_list, dtype='float64')\n",
    "print(\"Data type after : \", price_df.dtypes)\n",
    "print(price_df)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Create DataFrame from hierarchical lists as rows\n",
    "\n",
    "It may be possible to have data scattered into multiple lists or in the list of lists, also called a **multi-dimensional list**. In such a case, We can pass such a list to the DataFrame constructor to convert it into the DataFrame. By default, it adds each list as a row in the resultant DataFrame.\n",
    "\n",
    "**Example:**\n",
    "\n",
    "In the below example, we have a list that has lists of fruit names and their prices. DataFrame constructor will add both the lists as a separate row in the resulting DataFrame."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-06-17T11:49:54.917049Z",
     "start_time": "2021-06-17T11:49:54.904842Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[['Apple', 'Banana', 'Orange', 'Mango'], [120, 40, 80, 500]]\n",
      "       0       1       2      3\n",
      "0  Apple  Banana  Orange  Mango\n",
      "1    120      40      80    500\n"
     ]
    }
   ],
   "source": [
    "import pandas as pd\n",
    "\n",
    "# Create list\n",
    "fruits_list = [['Apple', 'Banana', 'Orange', 'Mango'],[120, 40, 80, 500]]\n",
    "print(fruits_list)\n",
    "\n",
    "# Create DataFrame from list\n",
    "fruits_df = pd.DataFrame(fruits_list)\n",
    "print(fruits_df)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Create DataFrame from Hierarchical lists as columns\n",
    "\n",
    "As discussed in the above section, we have a multi-dimensional list, but we do not want them to add to the DataFrame as a row. Instead, we want to add each list as a separate column in the DataFrame. For that, we need to use the **`transpose()`** function.\n",
    "\n",
    "**Example:**\n",
    "\n",
    "Here we have a list of two lists, fruit names and another for the fruits’ price. And we want to add both the list as a separate column in the DataFrame."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-06-17T11:49:56.176800Z",
     "start_time": "2021-06-17T11:49:56.161174Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[['Apple', 'Banana', 'Orange', 'Mango'], [120, 40, 80, 500]]\n",
      "        0    1\n",
      "0   Apple  120\n",
      "1  Banana   40\n",
      "2  Orange   80\n",
      "3   Mango  500\n"
     ]
    }
   ],
   "source": [
    "import pandas as pd\n",
    "\n",
    "# Create list\n",
    "fruits_list = [['Apple', 'Banana', 'Orange', 'Mango'],[120, 40, 80, 500]]\n",
    "print(fruits_list)\n",
    "\n",
    "# Create DataFrame from list\n",
    "fruits_df = pd.DataFrame(fruits_list).transpose()\n",
    "print(fruits_df)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Create DataFrame from multiple lists\n",
    "\n",
    "It is the most common use case in the industry where you have multiple separate lists, and you need to add them as different columns in the DataFrame. This case can be resolved by using following two ways:\n",
    "\n",
    "1. **`zip(list1, list2...)`**\n",
    "2. **`dict { 'col1' : list1, 'col2' : list2}`**\n",
    "\n",
    "**Example:**\n",
    "\n",
    "The below example demonstrates the use of **`zip()`** function to combine multiple lists in one list and pass it to the DataFrame constructor."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-06-17T11:49:59.170416Z",
     "start_time": "2021-06-17T11:49:59.152839Z"
    },
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "     Name  Price\n",
      "0   Apple    120\n",
      "1  Banana     40\n",
      "2  Orange     80\n",
      "3   Mango    500\n"
     ]
    }
   ],
   "source": [
    "import pandas as pd\n",
    "\n",
    "# Create multiple lists\n",
    "fruits_list = ['Apple', 'Banana', 'Orange', 'Mango']\n",
    "price_list = [120, 40, 80, 500]\n",
    "\n",
    "# Create DataFrame\n",
    "fruits_df = pd.DataFrame(list(zip(fruits_list, price_list )), columns = ['Name', 'Price'])\n",
    "print(fruits_df)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The below example demonstrates the use of Python dictionary data structure to solve the purpose. Here, column names are keys of the dict and, lists are the values of dict which need to be added in the DataFrame."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-06-17T11:50:00.855453Z",
     "start_time": "2021-06-17T11:50:00.832994Z"
    },
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'Name': ['Apple', 'Banana', 'Orange', 'Mango'], 'Price': [120, 40, 80, 500]}\n",
      "     Name  Price\n",
      "0   Apple    120\n",
      "1  Banana     40\n",
      "2  Orange     80\n",
      "3   Mango    500\n"
     ]
    }
   ],
   "source": [
    "import pandas as pd\n",
    "\n",
    "# Create multiple lists\n",
    "fruits_list = ['Apple', 'Banana', 'Orange', 'Mango']\n",
    "price_list = [120, 40, 80, 500]\n",
    "\n",
    "# Create dict\n",
    "fruits_dict = {'Name': fruits_list,\n",
    "               'Price': price_list}\n",
    "print(fruits_dict)\n",
    "\n",
    "# Create DataFrame from dict\n",
    "fruits_df = pd.DataFrame(fruits_dict)\n",
    "print(fruits_df)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "hide_input": false,
  "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.8.8"
  },
  "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()) "
    }
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}