007_Python_Function_Module.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<small><small><i>\n",
    "All the IPython Notebooks in **Python Functions** lecture series by Dr. Milaan Parmar are available @ **[GitHub](https://github.com/milaan9/04_Python_Functions)**\n",
    "</i></small></small>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Python Modules\n",
    "\n",
    "In this class, you will learn to create and import custom modules in Python. Also, you will find different techniques to import and use custom and built-in modules in Python."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## What are modules in Python?\n",
    "\n",
    "Module containing a set of codes or a set of functions which can be included to an application. Modules refer to the Python file, which contains Python code like Python statements, classes, functions, variables, etc. A file with Python code is defined with extension**`.py`**\n",
    "\n",
    "For example: In **`main.py`**, where the **`main`** is the module name.\n",
    "\n",
    "In Python, large code is divided into small modules. The benefit of modules is, it provides a way to share reusable functions."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Advantage\n",
    "\n",
    "* **Reusability**: Module can be used in some other python code. Hence it provides the facility of code reusability.\n",
    "* **Categorization**: Similar type of attributes can be placed in one module."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Creating a module in Python\n",
    "\n",
    "A file containing Python code, for example: **`example.py`**, is called a module, and its module name would be **`example`**.\n",
    "\n",
    "We use modules to break down large programs into small manageable and organized files. Furthermore, modules provide reusability of code.\n",
    "\n",
    "We can define our most used functions in a module and import it, instead of copying their definitions into different programs.\n",
    "\n",
    "The module contains Python code like classes, functions, methods, but it also has variables. A variable can list, tuple, dict, etc.\n",
    "\n",
    "Let us create a module. Type the following and save it as **`example.py`**.\n",
    "\n",
    "```python\n",
    "# Python Module example\n",
    "\n",
    ">>> def add(a, b):\n",
    ">>>     \"\"\"This program adds two numbers and return the result\"\"\"\n",
    ">>>     result = a + b\n",
    ">>>     return result\n",
    "```\n",
    "\n",
    "Here, we have defined a **[function](https://github.com/milaan9/04_Python_Functions/blob/main/001_Python_Functions.ipynb)** **`add()`** inside a module named **`example`**. The function takes in two numbers and returns their sum."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## How to import modules in Python?\n",
    "\n",
    "We can import the definitions inside a module to another module or the interactive interpreter in Python.\n",
    "\n",
    "We use the **`import`** keyword to do this. To import our previously defined module example, we type the following in the Python prompt."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```python\n",
    ">>> import example\n",
    "```\n",
    "This does not import the names of the functions defined in **`example`** directly in the current symbol table. It only imports the module name **`example`** there.\n",
    "\n",
    "Using the module name we can access the function using the dot **`.`** operator. For example:\n",
    "\n",
    "**# Example 1:**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-12T14:02:26.910409Z",
     "start_time": "2021-10-12T14:02:26.835984Z"
    },
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "9.6"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import example\n",
    "example.add(3,6.6)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python has tons of standard modules. You can check out the full list of **[Python standard modules](https://docs.python.org/3/py-modindex.html)** and their use cases. These files are in the Lib directory inside the location where you installed Python.\n",
    "\n",
    "Standard modules can be imported the same way as we import our user-defined modules.\n",
    "\n",
    "There are various ways to import modules. They are listed below:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**# Example 2:**\n",
    "\n",
    "The Python code for a module named a name normally resides in a file **main.py**. But first create a function in **test.py**. Here is an example of a simple module,\n",
    "\n",
    "**test.py** - \n",
    "\n",
    "```python\n",
    ">>> def fun():\n",
    ">>>     print(\"something here inside fun()\")\n",
    "```\n",
    "**main.py** −\n",
    "\n",
    "```python\n",
    ">>> import test\n",
    ">>> from test import fun\n",
    ">>> fun()\n",
    "```\n",
    "\n",
    "Output of above example: Run **main.py**\n",
    "\n",
    "`something here inside fun()`\n",
    "\n",
    "----------------------------------------------------------------\n",
    "For **test.ipynb** or **test1.ipynb** and **main.ipynb**\n",
    "\n",
    "Open anaconda prompt and type **`pip install import-ipynb`**\n",
    "\n",
    "see:\n",
    "Downloading import-ipynb-0.1.3.tar.gz (4.0 kB)\n",
    "\n",
    "**test.py** or **test1.ipynb** - \n",
    "\n",
    "```python\n",
    ">>> def fun():\n",
    ">>>     print(\"something here inside fun()\")\n",
    "```\n",
    "**main.ipynb** −\n",
    "\n",
    "```python\n",
    ">>> import import_ipynb\n",
    "\n",
    ">>> import test1\n",
    ">>> from test1 import fun\n",
    ">>> fun()\n",
    "```\n",
    "\n",
    "Output of above example: Run **main.ipynb**\n",
    "\n",
    "`something here inside fun()`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**# Example 3:**\n",
    "\n",
    "**fibo.py** - \n",
    "\n",
    "```python\n",
    "# Fibonacci numbers module\n",
    ">>> def fib(n): # return Fibonacci series up to n\n",
    ">>>     result = []\n",
    ">>>     a, b = 0, 1\n",
    ">>>     while b < n:\n",
    ">>>         result.append(b)\n",
    ">>>         a, b = b, a + b\n",
    ">>>     return result\n",
    "```\n",
    "**main.py** −\n",
    "\n",
    "```python\n",
    ">>> import fibo\n",
    ">>> from fibo import fib\n",
    ">>> print(fib(100))\n",
    "```\n",
    "\n",
    "Output of above example: Run **main.py**\n",
    "\n",
    "`[1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]`\n",
    "\n",
    "----------------------------------------------------------------\n",
    "For **test.ipynb** or **test1.ipynb** and **main.ipynb**\n",
    "\n",
    "Open anaconda prompt and type **`pip install import-ipynb`**\n",
    "\n",
    "see:\n",
    "Downloading import-ipynb-0.1.3.tar.gz (4.0 kB)\n",
    "\n",
    "**fibo1.ipynb** or **fibo.py** - \n",
    "\n",
    "```python\n",
    "# Fibonacci numbers module\n",
    ">>> def fib(n): # return Fibonacci series up to n\n",
    ">>>     result = []\n",
    ">>>     a, b = 0, 1\n",
    ">>>     while b < n:\n",
    ">>>         result.append(b)\n",
    ">>>         a, b = b, a + b\n",
    ">>>     return result\n",
    "```\n",
    "**main.ipynb** −\n",
    "\n",
    "```python\n",
    ">>> import import_ipynb\n",
    "\n",
    ">>> import fibo1\n",
    ">>> from fibo1 import fib\n",
    ">>> print(fib(100))\n",
    "```\n",
    "\n",
    "Output of above example: Run **main.ipynb**\n",
    "\n",
    "`[1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**# Example 4:**\n",
    "\n",
    "**equal.py** - \n",
    "\n",
    "```python\n",
    "#function definition\n",
    ">>> def equal(a, b):\n",
    ">>>     if(a == b):\n",
    ">>>         return True\n",
    "```\n",
    "**main.py** −\n",
    "\n",
    "```python\n",
    ">>> from equal import *\n",
    ">>> a, b = 10, 10\n",
    ">>> print(equal(a, b))\n",
    "```\n",
    "\n",
    "Output of above example: Run **main.py**\n",
    "\n",
    "`True`\n",
    "\n",
    "----------------------------------------------------------------\n",
    "For **equal.ipynb** or **equal1.ipynb** and **main.ipynb**\n",
    "\n",
    "Open anaconda prompt and type **`pip install import-ipynb`**\n",
    "\n",
    "see:\n",
    "Downloading import-ipynb-0.1.3.tar.gz (4.0 kB)\n",
    "\n",
    "**equal.ipynb** or **equal1.ipynb** - \n",
    "\n",
    "```python\n",
    "#function definition\n",
    ">>> def equal(a, b):\n",
    ">>>     if(a == b):\n",
    ">>>         return True\n",
    "```\n",
    "**main.ipynb** −\n",
    "\n",
    "```python\n",
    ">>> import import_ipynb\n",
    "\n",
    ">>> from equal1 import *\n",
    ">>> a, b = 10, 10\n",
    ">>> print(equal(a, b))\n",
    "```\n",
    "\n",
    "Output of above example: Run **main.ipynb**\n",
    "\n",
    "`True`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In Python, each and every built-in module has a large number of predefined functions to perform specific tasks. For instance, Python has a built-in module named **`operator`**, inside which the function called **`eq()`** is defined. This function returns the boolean value of **`True`** if the given two input values are equal. Else, returns **`False`**.\n",
    "\n",
    "So now, we can make use of this operator module in our **`main()`** program to check if two numbers are equal. This means we would no longer need that **`equal.py`** module."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-12T14:02:27.045065Z",
     "start_time": "2021-10-12T14:02:26.913837Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "# Example 5: \n",
    "\n",
    "#main function\n",
    "from operator import *\n",
    "a, b = 10, 10\n",
    "print(eq(a, b))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Python `import` statement\n",
    "\n",
    "We can import a module using the **`import`** statement and access the definitions inside it using the dot operator **`.`** as described above. Here is an example."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-12T14:02:27.248271Z",
     "start_time": "2021-10-12T14:02:27.048983Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The value of pi is 3.141592653589793\n"
     ]
    }
   ],
   "source": [
    "# Example 1: \n",
    "\n",
    "# import statement example to import standard module math\n",
    "import math\n",
    "print(\"The value of pi is\", math.pi)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-12T14:02:27.381949Z",
     "start_time": "2021-10-12T14:02:27.261984Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2.449489742783178\n"
     ]
    }
   ],
   "source": [
    "# Example 2:\n",
    "\n",
    "import math\n",
    "\n",
    "# use math module functions\n",
    "print(math.sqrt(6))    # Output 2.449489742783178"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### `import` multiple modules\n",
    "\n",
    "If we want to use more than one module, then we can import multiple modules. This is the simplest form of **`import`** a keyword that we already use in the above example."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-12T14:02:27.501912Z",
     "start_time": "2021-10-12T14:02:27.389783Z"
    },
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "720\n",
      "28\n"
     ]
    }
   ],
   "source": [
    "# Example 1: Import two modules\n",
    "\n",
    "import math, random\n",
    "\n",
    "print(math.factorial(6))\n",
    "print(random.randint(10, 30))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Python `from-import` statement\n",
    "\n",
    "To import particular classes or functions, we can use the **`from-import`** statement. It is an alternate way to **`import`**. By using this form, we can import individual attributes and methods directly into the program.We can import specific names from a module without importing the module as a whole."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-12T14:02:27.623348Z",
     "start_time": "2021-10-12T14:02:27.505830Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "720\n"
     ]
    }
   ],
   "source": [
    "# Example 1: import only factorial function from math module\n",
    "from math import factorial\n",
    "\n",
    "print(factorial(6))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-12T14:02:27.772693Z",
     "start_time": "2021-10-12T14:02:27.627264Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2.718281828459045"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Example 2: \n",
    "\n",
    "from math import pi, e\n",
    "e"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-12T14:02:27.892167Z",
     "start_time": "2021-10-12T14:02:27.779549Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The value of pi is 3.141592653589793\n"
     ]
    }
   ],
   "source": [
    "# Example 3: \n",
    "\n",
    "# import only pi from math module\n",
    "from math import pi\n",
    "print(\"The value of pi is\", pi)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here, we imported only the **`pi`** attribute from the **`math`** module.\n",
    "\n",
    "In such cases, we don't use the dot operator. We can also import multiple attributes as follows:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-12T14:02:28.069912Z",
     "start_time": "2021-10-12T14:02:27.898045Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3.141592653589793"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Example 4: \n",
    "\n",
    "from math import pi, e\n",
    "pi"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### `import` with renaming\n",
    "\n",
    "We can import a module by renaming it as follows:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-12T14:02:28.190856Z",
     "start_time": "2021-10-12T14:02:28.072848Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The value of pi is 3.141592653589793\n"
     ]
    }
   ],
   "source": [
    "# Example 1: \n",
    "\n",
    "# import module by renaming it\n",
    "import math as m\n",
    "print(\"The value of pi is\", m.pi)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We have renamed the **`math`** module as **`m`**. This can save us typing time in some cases.\n",
    "\n",
    ">**Note:** that the name **`math`** is not recognized in our scope. Hence, **`math.pi`** is invalid, and **`m.pi`** is the correct implementation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-12T14:02:28.360765Z",
     "start_time": "2021-10-12T14:02:28.195755Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "12\n"
     ]
    }
   ],
   "source": [
    "# Example 2:  Import a module by renaming it\n",
    "\n",
    "import random as rand\n",
    "\n",
    "print(rand.randrange(10, 20, 2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-12T14:02:28.435682Z",
     "start_time": "2021-10-12T14:02:28.363705Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "49\n"
     ]
    }
   ],
   "source": [
    "# Example 3:  import a method by renaming it\n",
    "\n",
    "# rename randint as random_number\n",
    "from random import randint as random_number\n",
    "\n",
    "# Gives any random number from range(10, 50)\n",
    "print(random_number(30, 60))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### `import` all names\n",
    "\n",
    "We can **`import`** all functions and attributes of a specific module, then instead of writing all function names and attribute names, we can import all using an **asterisk** **`*`**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-12T14:02:28.557118Z",
     "start_time": "2021-10-12T14:02:28.438621Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The value of pi is 3.141592653589793\n"
     ]
    }
   ],
   "source": [
    "# Example 1: \n",
    "\n",
    "# import all names from the standard module math\n",
    "\n",
    "from math import *\n",
    "print(\"The value of pi is\", pi)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here, we have imported all the definitions from the **`math`** module. This includes all names visible in our scope except those beginning with an underscore(private definitions).\n",
    "\n",
    "Importing everything with the asterisk **`*`** symbol is not a good programming practice. This can lead to duplicate definitions for an identifier. It also hampers the readability of our code."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-12T14:02:28.666311Z",
     "start_time": "2021-10-12T14:02:28.562015Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "216.0\n",
      "720\n",
      "9.42477796076938\n",
      "10.0\n"
     ]
    }
   ],
   "source": [
    "# Example 2: \n",
    "\n",
    "from math import *\n",
    "print(pow(6,3))\n",
    "print(factorial(6))\n",
    "\n",
    "print(pi*3)\n",
    "print(sqrt(100))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Python Module Search Path\n",
    "\n",
    "While importing a module, Python looks at several places. Interpreter first looks for a built-in module. Then(if built-in module not found), Python looks into a list of directories defined in **`sys.path`**. The search is in this order.\n",
    "\n",
    "1. The current directory.\n",
    "2. **`PYTHONPATH`** (an environment variable with a list of directories).\n",
    "3. The installation-dependent default directory."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-12T14:02:28.804883Z",
     "start_time": "2021-10-12T14:02:28.670228Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['C:\\\\Users\\\\Deepak\\\\01_Learn_Python4Data\\\\04_Python_Functions',\n",
       " 'C:\\\\ProgramData\\\\Anaconda3\\\\python38.zip',\n",
       " 'C:\\\\ProgramData\\\\Anaconda3\\\\DLLs',\n",
       " 'C:\\\\ProgramData\\\\Anaconda3\\\\lib',\n",
       " 'C:\\\\ProgramData\\\\Anaconda3',\n",
       " '',\n",
       " 'C:\\\\Users\\\\Deepak\\\\AppData\\\\Roaming\\\\Python\\\\Python38\\\\site-packages',\n",
       " 'C:\\\\ProgramData\\\\Anaconda3\\\\lib\\\\site-packages',\n",
       " 'C:\\\\ProgramData\\\\Anaconda3\\\\lib\\\\site-packages\\\\locket-0.2.1-py3.8.egg',\n",
       " 'C:\\\\ProgramData\\\\Anaconda3\\\\lib\\\\site-packages\\\\win32',\n",
       " 'C:\\\\ProgramData\\\\Anaconda3\\\\lib\\\\site-packages\\\\win32\\\\lib',\n",
       " 'C:\\\\ProgramData\\\\Anaconda3\\\\lib\\\\site-packages\\\\Pythonwin',\n",
       " 'C:\\\\ProgramData\\\\Anaconda3\\\\lib\\\\site-packages\\\\IPython\\\\extensions',\n",
       " 'C:\\\\Users\\\\Deepak\\\\.ipython']"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import sys\n",
    "sys.path"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can add and modify this list to add our own path."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Reloading a module\n",
    "\n",
    "The Python interpreter imports a module only once during a session. This makes things more efficient. Foe example:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**# Example 1:**\n",
    "\n",
    "Suppose we have the following code in a module named **`my_module`**.\n",
    "\n",
    "```python\n",
    "# This module shows the effect of\n",
    "#  multiple imports and reload\n",
    "\n",
    "print(\"This code got executed\")\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-12T14:02:28.929252Z",
     "start_time": "2021-10-12T14:02:28.807820Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "This code got executed\n"
     ]
    }
   ],
   "source": [
    "import my_module"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can see that our code got executed only once. This goes to say that our module was imported only once.\n",
    "\n",
    "Now if our module changed during the course of the program, we would have to reload it.One way to do this is to restart the interpreter. But this does not help much.\n",
    "\n",
    "Python provides a more efficient way of doing this. We can use the **`reload()`** function inside the **`imp`** module to reload a module. We can do it in the following ways:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-12T14:02:29.020820Z",
     "start_time": "2021-10-12T14:02:28.932192Z"
    }
   },
   "outputs": [],
   "source": [
    "import imp\n",
    "import my_module"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-12T14:02:29.114344Z",
     "start_time": "2021-10-12T14:02:29.023756Z"
    },
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "This code got executed\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<module 'my_module' from 'C:\\\\Users\\\\Deepak\\\\01_Learn_Python4Data\\\\04_Python_Functions\\\\my_module.py'>"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import my_module\n",
    "imp.reload(my_module)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**# Example 2:**\n",
    "\n",
    "First, create a Python module with the name **`greet_module.pynb`**\n",
    "and write the below code in that file.\n",
    "\n",
    "```python\n",
    ">>> print(\"Welcome to Dr Parmar's Python4DataScience class\")\n",
    "```\n",
    "\n",
    "Now, create a Python file with the name, **main.py** and write the below code in it and import the module test_module.py. See the following code.\n",
    "\n",
    "```python\n",
    ">>> import import_ipynb\n",
    ">>> import time\n",
    ">>> from importlib import reload\n",
    "\n",
    ">>> # load 1st time\n",
    ">>> import test_module\n",
    ">>> time.sleep(25)\n",
    ">>> # reload \n",
    ">>> reload(test_module)\n",
    ">>> time.sleep(25) \n",
    "\n",
    ">>> # reload again  \n",
    ">>> reload(test_module)\n",
    ">>> print(\"This is test file..\")\n",
    "```\n",
    "\n",
    "Output of above example: Run **main.py** \n",
    "\n",
    "```python\n",
    "Welcome to Dr Parmar's Python4DataScience class\n",
    "Welcome to Dr Parmar's Python4DataScience class\n",
    "Welcome to Dr Parmar's Python4DataScience class\n",
    "This is test file..\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## The `dir()` built-in function\n",
    "\n",
    "We can use the **`dir()`** function to find out names that are defined inside a module. When we use this function with any object (an object can be sequence like list, tuple, set, dict or can be class, function, module, etc. ), it returns properties, attributes, and method.\n",
    "\n",
    "For example, we have defined a function **`add()`** in the module example that we had in the beginning.\n",
    "\n",
    "We can use dir in example module in the following way:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-12T14:02:29.223046Z",
     "start_time": "2021-10-12T14:02:29.117282Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['__builtins__',\n",
       " '__cached__',\n",
       " '__doc__',\n",
       " '__file__',\n",
       " '__loader__',\n",
       " '__name__',\n",
       " '__package__',\n",
       " '__spec__',\n",
       " 'add']"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Example 1:\n",
    "\n",
    "dir(example)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here, we can see a sorted list of names (along with **`add`**). All other names that begin with an underscore are default Python attributes associated with the module (not user-defined).\n",
    "\n",
    "For example, the **`__name__`** attribute contains the name of the module."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-12T14:02:29.332241Z",
     "start_time": "2021-10-12T14:02:29.227944Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'example'"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Example 2:\n",
    "\n",
    "import example\n",
    "example.__name__"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "All the names defined in our current namespace can be found out using the **`dir()`** function without any arguments."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-12T14:02:29.473261Z",
     "start_time": "2021-10-12T14:02:29.335177Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['__builtins__', '__doc__', '__name__', 'a', 'b', 'math', 'pyscripter']"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Example 3:\n",
    "\n",
    "a = 1\n",
    "b = \"hello\"\n",
    "import math\n",
    "dir()\n",
    "['__builtins__', '__doc__', '__name__', 'a', 'b', 'math', 'pyscripter']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-12T14:02:29.566785Z",
     "start_time": "2021-10-12T14:02:29.476197Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['__doc__', '__loader__', '__name__', '__package__', '__spec__', 'acos', 'acosh', 'asin', 'asinh', 'atan', 'atan2', 'atanh', 'ceil', 'comb', 'copysign', 'cos', 'cosh', 'degrees', 'dist', 'e', 'erf', 'erfc', 'exp', 'expm1', 'fabs', 'factorial', 'floor', 'fmod', 'frexp', 'fsum', 'gamma', 'gcd', 'hypot', 'inf', 'isclose', 'isfinite', 'isinf', 'isnan', 'isqrt', 'ldexp', 'lgamma', 'log', 'log10', 'log1p', 'log2', 'modf', 'nan', 'perm', 'pi', 'pow', 'prod', 'radians', 'remainder', 'sin', 'sinh', 'sqrt', 'tan', 'tanh', 'tau', 'trunc']\n"
     ]
    }
   ],
   "source": [
    "# Example 4:\n",
    "\n",
    "import math\n",
    "\n",
    "print(dir(math))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Python Modules List\n",
    "\n",
    "Using Python built-in function **`help()`**, we can obtain the list of built-in modules available in Python. On executing the line help ('modules') in Python IDE, you can see all the Python built-in modules. Some of the frequently used ones are discussed below.\n",
    "\n",
    "| Module | Description |\n",
    "|:----| :--- |\n",
    "| **`Operator`** |   This module provides a set of pre-defined functions corresponding to operators in Python.  | \n",
    "| **`decimal`** |   This module is used to print the complete decimal value when one number is divided by another number.  | \n",
    "| **[random](https://github.com/milaan9/04_Python_Functions/blob/main/008_Python_Function_random_Module.ipynb)** |   random module is used to generate random numbers. Some of the pre-defined functions of this module are **`randint()`**, **`choice()`**, **`uniform`**, etc.  | \n",
    "| **`string`** |   string module provides a set of functions that are used to perform certain operations on characters. This module has pre-defined functions like capwords, ascii_letters, etc.  | \n",
    "| **[math](https://github.com/milaan9/04_Python_Functions/blob/main/009_Python_Function_math_Module.ipynb.ipynb)** |   math module is used to perform mathematical operations. This module provides some pre-defined mathematical functions like sqrt, factorial, etc.  | "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Python Built-In Modules Examples\n",
    "\n",
    "There are many **built-in** modules in Python. Some of the common built-in modules: **`os`**, **[sys](https://docs.python.org/3/library/sys.html)**, **`operator`**, **`string`**, **`decimal`**, **[random](https://github.com/milaan9/04_Python_Functions/blob/main/008_Python_Function_random_Module.ipynb)** , **[math](https://github.com/milaan9/04_Python_Functions/blob/main/009_Python_Function_math_Module.ipynb.ipynb)**, **`statistics`**, **`datetime`**, **`time`**, **`collections`**, **`threading`**, **`mailbox`**, **`tkinter`**, **`json`**, **`re`**, etc."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Example Using `os` Module\n",
    "\n",
    "Using python **`os`** module it is possible to automatically perform many operating system tasks. The **`os`** module in Python provides functions for creating, changing current working directory, and removing a directory (folder), fetching its contents, changing and identifying the current directory."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-12T14:02:30.283151Z",
     "start_time": "2021-10-12T14:02:29.576580Z"
    },
    "scrolled": true
   },
   "outputs": [
    {
     "ename": "FileExistsError",
     "evalue": "[WinError 183] Cannot create a file when that file already exists: 'directory_name'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mFileExistsError\u001b[0m                           Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-23-5aa728677edf>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      4\u001b[0m \u001b[1;32mimport\u001b[0m \u001b[0mos\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      5\u001b[0m \u001b[1;31m# Creating a directory\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 6\u001b[1;33m \u001b[0mos\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mmkdir\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m'directory_name'\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m      7\u001b[0m \u001b[1;31m# Changing the current directory\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[0mos\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mchdir\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m'path'\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;31mFileExistsError\u001b[0m: [WinError 183] Cannot create a file when that file already exists: 'directory_name'"
     ]
    }
   ],
   "source": [
    "# Example 1:\n",
    "\n",
    "# import the module\n",
    "import os\n",
    "# Creating a directory\n",
    "os.mkdir('directory_name')\n",
    "# Changing the current directory\n",
    "os.chdir('path')\n",
    "# Getting current working directory\n",
    "os.getcwd()\n",
    "# Removing directory\n",
    "os.rmdir()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Example Using `sys` Module\n",
    "\n",
    "The **[sys](https://docs.python.org/3/library/sys.html)** module provides functions and variables used to manipulate different parts of the Python runtime environment."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**`sys.argv`** function returns a list of command line arguments passed to a Python script. The item at index 0 in this list is always the name of the script, at index 1 is the argument passed from the command line."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-12T14:02:39.796140Z",
     "start_time": "2021-10-12T14:02:39.781456Z"
    },
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['C:\\\\Users\\\\Deepak\\\\01_Learn_Python4Data\\\\04_Python_Functions',\n",
       " 'C:\\\\ProgramData\\\\Anaconda3\\\\python38.zip',\n",
       " 'C:\\\\ProgramData\\\\Anaconda3\\\\DLLs',\n",
       " 'C:\\\\ProgramData\\\\Anaconda3\\\\lib',\n",
       " 'C:\\\\ProgramData\\\\Anaconda3',\n",
       " '',\n",
       " 'C:\\\\Users\\\\Deepak\\\\AppData\\\\Roaming\\\\Python\\\\Python38\\\\site-packages',\n",
       " 'C:\\\\ProgramData\\\\Anaconda3\\\\lib\\\\site-packages',\n",
       " 'C:\\\\ProgramData\\\\Anaconda3\\\\lib\\\\site-packages\\\\locket-0.2.1-py3.8.egg',\n",
       " 'C:\\\\ProgramData\\\\Anaconda3\\\\lib\\\\site-packages\\\\win32',\n",
       " 'C:\\\\ProgramData\\\\Anaconda3\\\\lib\\\\site-packages\\\\win32\\\\lib',\n",
       " 'C:\\\\ProgramData\\\\Anaconda3\\\\lib\\\\site-packages\\\\Pythonwin',\n",
       " 'C:\\\\ProgramData\\\\Anaconda3\\\\lib\\\\site-packages\\\\IPython\\\\extensions',\n",
       " 'C:\\\\Users\\\\Deepak\\\\.ipython']"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import sys\n",
    "sys.path"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**First**, create a Python module with the name **`script.py`** and write the below code in that file.\n",
    "\n",
    "```py\n",
    ">>> import sys\n",
    ">>> # print(sys.argv[0], argv[1],sys.argv[2])  # this line would print out: filename argument1 argument2\n",
    ">>> print('Welcome {}. Enjoy  {} for Data Science ^_^'.format(sys.argv[1], sys.argv[2]))\n",
    "```\n",
    "**Second**, open **`Anaconda Prompt (Anaconda3)`**\n",
    "\n",
    "**Third**, type system path after **`cd`**\n",
    "\n",
    "```sy\n",
    "cd C:\\\\Users\\\\Deepak\\\\01_Learn_Python4Data\\\\04_Python_Functions\n",
    "```\n",
    "\n",
    "**Forth**, type\n",
    "\n",
    "```sy\n",
    "python script.py Milaan Python\n",
    "```\n",
    "\n",
    "**Output:**\n",
    "\n",
    "```sy\n",
    "Welcome Milaan. Enjoy  Python for Data Science ^_^\n",
    "```\n",
    "\n",
    "<div>\n",
    "<img src=\"img/anaconda_prompt.png\" width=\"1000\"/>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Some useful **`sys`** commands to type in:\n",
    "\n",
    "```py\n",
    "# to exit sys\n",
    "sys.exit()\n",
    "# To know the largest integer variable it takes\n",
    "sys.maxsize\n",
    "# To know environment path\n",
    "sys.path\n",
    "# To know the version of python you are using\n",
    "sys.version\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Example Using `operator` Module"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-12T14:02:42.304149Z",
     "start_time": "2021-10-12T14:02:42.287505Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "200\n",
      "False\n",
      "10\n",
      "Hello World\n"
     ]
    }
   ],
   "source": [
    "# Example 1:\n",
    "\n",
    "from operator import *\n",
    "a, b = 10, 20\n",
    "#prints the product of the values 'a' and 'b'\n",
    "print(mul(a, b))\n",
    "#prints True if the value of 'a' is greater than 'b'. Else, False\n",
    "print(gt(a, b))\n",
    "#prints the remainder value, when the value of 'a' is divided by 'b'\n",
    "print(mod(a, b))\n",
    "#concatenates and prints the given two strings\n",
    "print(concat(\"Hello \", \"World\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Example Using `string` Module\n",
    "\n",
    "A **[string](https://github.com/milaan9/02_Python_Datatypes/blob/main/002_Python_String.ipynb)** module is a useful module for many purposes. The example below shows some use of the string module."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-12T14:02:43.381879Z",
     "start_time": "2021-10-12T14:02:43.369152Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello World\n",
      "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ\n"
     ]
    }
   ],
   "source": [
    "# Example 1:\n",
    "\n",
    "from string import *\n",
    "print(capwords(\"hello world\")) #capitalizes the first letter of each words\n",
    "print(ascii_letters) #prints all lowercase and uppercase letters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-12T14:02:43.805435Z",
     "start_time": "2021-10-12T14:02:43.793679Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ\n",
      "0123456789\n",
      "!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~\n"
     ]
    }
   ],
   "source": [
    "# Example 2:\n",
    "\n",
    "import string\n",
    "print(string.ascii_letters) # abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ\n",
    "print(string.digits)        # 0123456789\n",
    "print(string.punctuation)   # !\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Example Using `decimal` Module"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-12T14:02:45.249910Z",
     "start_time": "2021-10-12T14:02:45.199966Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3.3333333333333335\n",
      "3.333333333333333481363069950020872056484222412109375\n"
     ]
    }
   ],
   "source": [
    "# Example 1:\n",
    "\n",
    "from decimal import *\n",
    "a, b = 10, 3\n",
    "c = a / b\n",
    "print(c)\n",
    "print(Decimal(c)) #prints the complete decimal value of c"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Example Using `random` Module\n",
    "\n",
    "The **[random](https://github.com/milaan9/04_Python_Functions/blob/main/008_Python_Function_random_Module.ipynb)** module is used to generate the random numbers. It provides the following two built in functions:\n",
    "\n",
    "#### Comparision operators in Python\n",
    "\n",
    "| Function | Description |\n",
    "|:----| :--- |\n",
    "| **`random()`** |   It returns a random number between 0.0 and 1.0 where 1.0 is exclusive.  | \n",
    "| **`randint(x,y)`** |   It returns a random number between x and y where both the numbers are inclusive.  | "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-12T14:02:46.106312Z",
     "start_time": "2021-10-12T14:02:46.097503Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n",
      "16\n",
      "13.03505598723366\n"
     ]
    }
   ],
   "source": [
    "# Example 1:\n",
    "\n",
    "from random import *\n",
    "print(randint(10, 20)) #prints a random number between the given range\n",
    "\n",
    "list1 = [30, 23, 45, 16, 89, 56]\n",
    "print(choice(list1)) #prints a random element from the given iterator\n",
    "\n",
    "print(uniform(10, 20)) #prints a random float number between two given values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-12T14:02:46.586662Z",
     "start_time": "2021-10-12T14:02:46.570998Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.2946014910624595\n",
      "8\n"
     ]
    }
   ],
   "source": [
    "# Example 2:\n",
    "\n",
    "import random\n",
    "\n",
    "print(random.random())\n",
    "print(random.randint(2,8))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-12T14:02:46.953905Z",
     "start_time": "2021-10-12T14:02:46.897105Z"
    }
   },
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "'module' object is not callable",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-31-92fab552c144>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      3\u001b[0m \u001b[1;32mfrom\u001b[0m \u001b[0mrandom\u001b[0m \u001b[1;32mimport\u001b[0m \u001b[0mrandint\u001b[0m   \u001b[1;31m# import randint function\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      4\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 5\u001b[1;33m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mrandom\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m   \u001b[1;31m# it doesn't take any arguments; it returns a value between 0 and 0.9999\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m      6\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      7\u001b[0m \u001b[1;31m# call randint function to get random number\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;31mTypeError\u001b[0m: 'module' object is not callable"
     ]
    }
   ],
   "source": [
    "# Example 3:\n",
    "\n",
    "from random import randint   # import randint function\n",
    "\n",
    "print(random())   # it doesn't take any arguments; it returns a value between 0 and 0.9999\n",
    "\n",
    "# call randint function to get random number\n",
    "print(randint(10, 30))  # it returns a random integer number between [10, 30] inclusive"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Example Using `math` Module\n",
    "\n",
    "Using **[math](https://github.com/milaan9/04_Python_Functions/blob/main/009_Python_Function_math_Module.ipynb.ipynb)** module, you can use different built in mathematical functions.\n",
    "\n",
    "#### math module Functions:\n",
    "\n",
    "| Function | Description |\n",
    "|:----| :--- |\n",
    "| **`ceil(n)`** |   It returns the next integer number of the given number.  | \n",
    "| **`sqrt(n)`** |   It returns the Square root of the given number.  | \n",
    "| **`exp(n)`** |   It returns the natural logarithm e raised to the given number.  | \n",
    "| **`floor(n)`** |   It returns the previous integer number of the given number.  | \n",
    "| **`log(n,baseto)`** |   It returns the previous integer number of the given number.  | \n",
    "| **`pow(baseto, exp)`** |   It returns baseto raised to the exp power.  | \n",
    "| **`sin(n)`** |   It returns sine of the given radian.  | \n",
    "| **`cos(n)`** |   It returns cosine of the given radian.  | \n",
    "| **`tan(n)`** |   It returns tangent of the given radian.  | "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-12T14:02:48.223575Z",
     "start_time": "2021-10-12T14:02:48.206931Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4.0\n",
      "120\n"
     ]
    }
   ],
   "source": [
    "# Example 1:\n",
    "\n",
    "from math import *\n",
    "print(sqrt(16)) # prints the square root of the value 16 in the form of a floating-point value\n",
    "print(factorial(5)) # prints the factorial of the value 5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-12T14:02:49.064312Z",
     "start_time": "2021-10-12T14:02:49.042770Z"
    },
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n",
      "4\n",
      "3.0\n",
      "20.085536923187668\n",
      "0.6931471805599453\n",
      "8.0\n",
      "0.0\n",
      "1.0\n",
      "1.6197751905438615\n",
      "2.0\n"
     ]
    }
   ],
   "source": [
    "# Example 2:\n",
    "\n",
    "import math\n",
    "\n",
    "a=4.6\n",
    "print(math.ceil(a))       # 5, rounding to the highest\n",
    "print(math.floor(a))      # 4, rounding to the lowest\n",
    "b=9\n",
    "print(math.sqrt(b))       # 3.0, square root\n",
    "print(math.exp(3.0))      # 20.085536923187668\n",
    "print(math.log(2.0))      # 0.6931471805599453\n",
    "print(math.pow(2.0,3.0))  # 8.0, exponential function\n",
    "print(math.sin(0))        # 0.0\n",
    "print(math.cos(0))        # 1.0\n",
    "print (math.tan(45))      # 1.6197751905438615\n",
    "print(math.log10(100))    # 2.0, logarithm with 10 as base "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Constants  -  \n",
    "\n",
    "The math module provides two constants for mathematical Operations:\n",
    "\n",
    "* **`math.pi`** : Returns constant Pi = 3.14159...\n",
    "* **`math.e`** : Returns constant e= 2.71828..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-12T14:02:50.965636Z",
     "start_time": "2021-10-12T14:02:50.945076Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "math.pi :  3.141592653589793\n",
      "math.e :  2.718281828459045\n"
     ]
    }
   ],
   "source": [
    "# Example 3:\n",
    "\n",
    "import math \n",
    "\n",
    "print(\"math.pi : \",math.pi)  # 3.141592653589793, pi constant\n",
    "print(\"math.e : \",math.e)    # 2.718281828459045, e  constant"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Example Using `statistics` Module\n",
    "\n",
    "The statistics module provides functions for mathematical statistics of numeric data. The popular statistical functions which are defined in this module: **`mean`**, **`median`**, **`mode`**, **`stdev`** etc."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-12T14:02:52.744549Z",
     "start_time": "2021-10-12T14:02:52.645153Z"
    },
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "21.09090909090909\n",
      "22\n",
      "20\n",
      "6.106628291529549\n"
     ]
    }
   ],
   "source": [
    "# Example 1:\n",
    "\n",
    "from statistics import * # importing all the statistics modules\n",
    "ages = [20, 20, 4, 24, 25, 22, 26, 20, 23, 22, 26]\n",
    "print(mean(ages))       # ~22.9\n",
    "print(median(ages))     # 23\n",
    "print(mode(ages))       # 20\n",
    "print(stdev(ages))      # ~2.3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Wrap up\n",
    "\n",
    "Since Python provides a lot of built-in modules, it is advisable to use built-in modules rather than user-created modules to perform basic operations."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 💻 Exercises ➞ <span class='label label-default'>Module</span>\n",
    "\n",
    "### Exercises ➞ <span class='label label-default'>Level 1</span>\n",
    "\n",
    "1. Writ a function which generates a six digit/character **`random_user_id`**.\n",
    "    - ```py\n",
    "     print(random_user_id());\n",
    "     '1ee33d'\n",
    "    ```\n",
    "2. Modify the previous task. Declare a function named **`user_id_gen_by_user`**. It doesn’t take any parameters but it takes two inputs using **`input()`**. One of the inputs is the number of characters and the second input is the number of IDs which are supposed to be generated.\n",
    "   \n",
    "    - ```py\n",
    "print(user_id_gen_by_user()) # user input: 5 5\n",
    "#output:\n",
    "#kcsy2\n",
    "#SMFYb\n",
    "#bWmeq\n",
    "#ZXOYh\n",
    "#2Rgxf\n",
    "    ``` \n",
    " \n",
    "    - ```py\n",
    "print(user_id_gen_by_user()) # 16 5\n",
    "#1GCSgPLMaBAVQZ26\n",
    "#YD7eFwNQKNs7qXaT\n",
    "#ycArC5yrRupyG00S\n",
    "#UbGxOFI7UXSWAyKN\n",
    "#dIV0SSUTgAdKwStr\n",
    "    ```\n",
    "\n",
    "3. Write a function named **`rgb_color_gen`**. It will generate rgb colors (3 values ranging from 0 to 255 each).\n",
    "   \n",
    "    - ```py\n",
    "print(rgb_color_gen()) \n",
    "#rgb(125,244,255) - the output should be in this form\n",
    "    ```\n",
    " \n",
    "### Exercises ➞ <span class='label label-default'>Level 2</span>\n",
    "\n",
    "1. Write a function **`list_of_hexa_colors`** which returns any number of hexadecimal colors in an array (six hexadecimal numbers written after **`#`**. Hexadecimal numeral system is made out of 16 symbols, 0-9 and first 6 letters of the alphabet, a-f. Check the task 6 for output examples).\n",
    "2. Write a function **`list_of_rgb_colors`** which returns any number of RGB colors in an array.\n",
    "3. Write a function **`generate_colors`** which can generate any number of hexa or rgb colors.\n",
    "\n",
    "    - ```py\n",
    "   generate_colors('hexa', 3) # ['#a3e12f','#03ed55','#eb3d2b'] \n",
    "   generate_colors('hexa', 1) # ['#b334ef']\n",
    "   generate_colors('rgb', 3)  # ['rgb(5, 55, 175','rgb(50, 105, 100','rgb(15, 26, 80'] \n",
    "   generate_colors('rgb', 1)  # ['rgb(33,79, 176)']\n",
    "    ```\n",
    "   \n",
    "### Exercises ➞ <span class='label label-default'>Level 3</span>\n",
    "\n",
    "1. Call your function **`shuffle_list`**, it takes a list as a parameter and it returns a shuffled list\n",
    "2. Write a function which returns an array of seven random numbers in a range of 0-9. All the numbers must be unique."
   ]
  },
  {
   "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": {
    "height": "calc(100% - 180px)",
    "left": "10px",
    "top": "150px",
    "width": "204.797px"
   },
   "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
}