010_Python_Type_Conversion.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<small><small><i>\n",
    "All the IPython Notebooks in **Python Introduction** lecture series by **[Dr. Milaan Parmar](https://www.linkedin.com/in/milaanparmar/)** are available @ **[GitHub](https://github.com/milaan9/01_Python_Introduction)**\n",
    "</i></small></small>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Python Type Conversion and Type Casting\n",
    "\n",
    "In this class, you will learn about the Type conversion and uses of type conversion.\n",
    "\n",
    "Before learning Type Conversion in Python, you should have knowledge about **[Python Data Types](https://github.com/milaan9/01_Python_Introduction/blob/main/009_Python_Data_Types.ipynb)**."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Type Conversion\n",
    "\n",
    "The process of converting the value of one data type (integer, string, float, etc.) to another data type is called type conversion. Python has two types of type conversion.\n",
    "\n",
    "1. **Implicit Type Conversion**\n",
    "2. **Explicit Type Conversion**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1. Implicit Type Conversion\n",
    "\n",
    "In Implicit type conversion, Python automatically converts one data type to another data type. This process doesn't need any user involvement.\n",
    "\n",
    "Let's see an example where Python promotes the conversion of the lower data type (integer) to the higher data type (float) to avoid data loss."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-02T07:51:48.467278Z",
     "start_time": "2021-10-02T07:51:48.451655Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "datatype of num_int: <class 'int'>\n",
      "datatype of num_flo: <class 'float'>\n",
      "Value of num_new: 124.23\n",
      "datatype of num_new: <class 'float'>\n"
     ]
    }
   ],
   "source": [
    "# Example 1: Converting integer to float\n",
    "\n",
    "num_int = 123\n",
    "num_flo = 1.23\n",
    "\n",
    "num_new = num_int + num_flo\n",
    "\n",
    "print(\"datatype of num_int:\",type(num_int))\n",
    "print(\"datatype of num_flo:\",type(num_flo))\n",
    "\n",
    "print(\"Value of num_new:\",num_new)\n",
    "print(\"datatype of num_new:\",type(num_new))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Explanation**:\n",
    "\n",
    "In the above program,\n",
    "\n",
    "1. We add two variables **`num_int`** and **`num_flo`**, storing the value in **`num_new`**.\n",
    "2. We will look at the data type of all three objects respectively.\n",
    "3. In the output, we can see the data type of **`num_int`** is an **`integer`** while the data type of **`num_flo`** is a **`float`**.\n",
    "4. Also, we can see the **`num_new`** has a **`float`** data type because Python always converts smaller data types to larger data types to avoid the loss of data."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, let's try adding a string and an integer, and see how Python deals with it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-02T07:51:48.928212Z",
     "start_time": "2021-10-02T07:51:48.472161Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Data type of num_int: <class 'int'>\n",
      "Data type of num_str: <class 'str'>\n"
     ]
    },
    {
     "ename": "TypeError",
     "evalue": "unsupported operand type(s) for +: 'int' and 'str'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-2-49e421f2057c>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      7\u001b[0m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m\"Data type of num_str:\"\u001b[0m\u001b[1;33m,\u001b[0m\u001b[0mtype\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mnum_str\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      8\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 9\u001b[1;33m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mnum_int\u001b[0m\u001b[1;33m+\u001b[0m\u001b[0mnum_str\u001b[0m\u001b[1;33m)\u001b[0m  \u001b[1;31m# ERROR! cannot add two different data types (int and string)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m: unsupported operand type(s) for +: 'int' and 'str'"
     ]
    }
   ],
   "source": [
    "# Example 2: Addition of string(higher) data type and integer(lower) datatype\n",
    "\n",
    "num_int = 123\n",
    "num_str = \"456\"\n",
    "\n",
    "print(\"Data type of num_int:\",type(num_int))\n",
    "print(\"Data type of num_str:\",type(num_str))\n",
    "\n",
    "print(num_int+num_str)  # ERROR! cannot add two different data types (int and string)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Explanation**:\n",
    "\n",
    "In the above program,\n",
    "\n",
    "1. We add two variables **`num_int`** and **`num_str`**.\n",
    "2. As we can see from the output, we got **`TypeError`**. Python is not able to use Implicit Conversion in such conditions.\n",
    "3. However, Python has a solution for these types of situations which is known as Explicit Conversion."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2. Explicit Type Conversion\n",
    "\n",
    "In Explicit Type Conversion, users convert the data type of an object to required data type. We use the predefined functions like **`int()`**, **`float()`**, **`str()`**, etc to perform explicit type conversion.\n",
    "\n",
    "This type of conversion is also called typecasting because the user casts (changes) the data type of the objects.\n",
    "\n",
    "**Syntax:**\n",
    "\n",
    "```python\n",
    "<required_datatype>(expression)\n",
    "```\n",
    "\n",
    "Typecasting can be done by assigning the required data type function to the expression."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-02T07:51:58.860822Z",
     "start_time": "2021-10-02T07:51:58.840318Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "num_int 10\n",
      "num_float: 10.0\n"
     ]
    }
   ],
   "source": [
    "# int to float\n",
    "num_int = 10\n",
    "print('num_int',num_int)         # 10\n",
    "num_float = float(num_int)\n",
    "print('num_float:', num_float)   # 10.0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-02T07:51:59.387189Z",
     "start_time": "2021-10-02T07:51:59.366686Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "9\n"
     ]
    }
   ],
   "source": [
    "# float to int\n",
    "gravity = 9.81\n",
    "print(int(gravity))             # 9"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-02T07:51:59.927227Z",
     "start_time": "2021-10-02T07:51:59.903795Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Data type of num_int: <class 'int'>\n",
      "Data type of num_str before Type Casting: <class 'str'>\n",
      "Data type of num_str after Type Casting: <class 'int'>\n",
      "Sum of num_int and num_str: 579\n",
      "Data type of the sum: <class 'int'>\n"
     ]
    }
   ],
   "source": [
    "# Example 3: Addition of string and integer using explicit conversion\n",
    "\n",
    "num_int = 123\n",
    "num_str = \"456\"       # there is a number inside \" \" so I CAN change it to integer\n",
    "#num_str = \"jason\"    # there is a name inside \" \" so I cannot change to integer\n",
    "\n",
    "print(\"Data type of num_int:\",type(num_int))\n",
    "print(\"Data type of num_str before Type Casting:\",type(num_str))\n",
    "\n",
    "num_str = int(num_str) # change from \"string\" data type to integer datatype\n",
    "print(\"Data type of num_str after Type Casting:\",type(num_str))\n",
    "\n",
    "num_sum = num_int + num_str  # Now we can add two same data types (int and int)\n",
    "\n",
    "print(\"Sum of num_int and num_str:\",num_sum)\n",
    "print(\"Data type of the sum:\",type(num_sum))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Explanation**:\n",
    "\n",
    "In the above program,\n",
    "\n",
    "1. We add **`num_str`** and **`num_int`** variable.\n",
    "2. We converted **`num_str`** from string(higher) to integer(lower) type using **`int()`** function to perform the addition.\n",
    "3. After converting **`num_str`** to an integer value, Python is able to add these two variables.\n",
    "4. We got the **`num_sum`** value and data type to be an integer."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-02T07:52:00.959457Z",
     "start_time": "2021-10-02T07:52:00.936997Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6.0"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "float(6)  # means converting interger 6 to a float value"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Conversion from **`float`** to **`int`** will truncate the value (make it closer to zero)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-02T07:52:01.897933Z",
     "start_time": "2021-10-02T07:52:01.887192Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "33"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "int(33.6)  # means converting float 33.6 to a integer value\n",
    "\n",
    "# When you change from FLOAT to INTEGER it will round-up the number"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-02T07:52:02.267071Z",
     "start_time": "2021-10-02T07:52:02.250475Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-33"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "int(-33.6)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Conversion to and from **`string`** must contain compatible values."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-02T07:52:02.805645Z",
     "start_time": "2021-10-02T07:52:02.784163Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n",
      "10\n"
     ]
    }
   ],
   "source": [
    "# int to str\n",
    "num_int = 10\n",
    "print(num_int)                  # 10\n",
    "num_str = str(num_int)\n",
    "print(num_str)                  # '10'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-02T07:52:03.037577Z",
     "start_time": "2021-10-02T07:52:03.026839Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7.5"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "float('7.5')  # means converting string '7.5' to a float value"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-02T07:52:03.407209Z",
     "start_time": "2021-10-02T07:52:03.395491Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "num_float 10.6\n"
     ]
    }
   ],
   "source": [
    "# str to int or float\n",
    "num_str = '10.6' #or '10'\n",
    "# print('num_int', int(num_str))      # 10\n",
    "print('num_float', float(num_str))  # 10.6"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-02T07:52:03.651834Z",
     "start_time": "2021-10-02T07:52:03.634258Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'65'"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "str(65)  # means converting integer 65 to a string value"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-02T07:52:04.499979Z",
     "start_time": "2021-10-02T07:52:04.447248Z"
    }
   },
   "outputs": [
    {
     "ename": "ValueError",
     "evalue": "invalid literal for int() with base 10: '1p'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-13-bcaaeab6bf17>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m'1p'\u001b[0m\u001b[1;33m)\u001b[0m  \u001b[1;31m# means converting string '1p' to a integer value\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mValueError\u001b[0m: invalid literal for int() with base 10: '1p'"
     ]
    }
   ],
   "source": [
    "int('1p')  # means converting string '1p' to a integer value"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-02T07:52:04.993145Z",
     "start_time": "2021-10-02T07:52:04.983380Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'1p'"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "str(\"1p\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can even convert one sequence to another."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-02T07:52:08.777317Z",
     "start_time": "2021-10-02T07:52:08.758769Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1, 2, 3}"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "set([1,2,3])  # [1,2,3] is tuple and now converting to a set {}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-02T07:52:09.223608Z",
     "start_time": "2021-10-02T07:52:09.199197Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(5, 6, 7)"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tuple({5,6,7})  # {1,2,3} is set and now converting to a tuple ()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-02T07:52:09.439431Z",
     "start_time": "2021-10-02T07:52:09.425760Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['h', 'e', 'l', 'l', 'o']"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list('hello')  # (\"hello\") is string and now converting to a list []"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-02T07:52:09.669899Z",
     "start_time": "2021-10-02T07:52:09.664039Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Milaan\n",
      "['M', 'i', 'l', 'a', 'a', 'n']\n"
     ]
    }
   ],
   "source": [
    "# str to list\n",
    "first_name = 'Milaan'\n",
    "print(first_name)               # 'Milaan'\n",
    "first_name_to_list = list(first_name)\n",
    "print(first_name_to_list)            # ['M', 'i', 'l', 'a', 'a', 'n']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To convert to dictionary, each element must be a pair:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-02T07:52:10.179175Z",
     "start_time": "2021-10-02T07:52:10.167460Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1: 2, 3: 4}"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dict([[1,2],[3,4]])  # [[1,2],[3,4]] is tuple and now converting to a dictionary"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-02T07:52:10.718728Z",
     "start_time": "2021-10-02T07:52:10.711892Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{3: 63, 7: 91}"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dict([(3,63),(7,91)])  # [(3,63),(7,91)] is tuple and now converting to a dictionary"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Key Points to Remember\n",
    "\n",
    "1. Type Conversion is the conversion of object from one data type to another data type.\n",
    "2. Implicit Type Conversion is automatically performed by the Python interpreter.\n",
    "3. Python avoids the loss of data in Implicit Type Conversion.\n",
    "4. Explicit Type Conversion is also called Type Casting, the data types of objects are converted using predefined functions by the user.\n",
    "5. In Type Casting, loss of data may occur as we enforce the object to a specific data type."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "hide_input": false,
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.10.9"
  },
  "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
}