notebooks/6_imports_module_packages.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Understanding \\__name\\__ built in\n",
    "\n",
    "The \\__name\\__ is a special built-in variable which evaluates to the name of the current module. However, if a module is being run directly (from command line), then \\__name\\__ instead is set to the string “\\__main\\__”."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "foo.__name__ set to  __main__\n"
     ]
    }
   ],
   "source": [
    "# foo.py\n",
    "import bar\n",
    "\n",
    "print(\"foo.__name__ set to \", __name__)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "bar.__name__ set to  __main__\n"
     ]
    }
   ],
   "source": [
    "# bar.py\n",
    "\n",
    "print(\"bar.__name__ set to \", __name__)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Use of \\__name\\__ == \"\\__main__\\\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Using <b>\\__name\\__ == \"\\__main\\__\"</b> we can find out whether the value of \"\\__name\\__\" built in is equals to \"\\__main\\__\" or not. If it is equivalent it means module is directly being called form the terminal itself. If not then means it is being called form some other module."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# let's look at some of the examples"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "top-level in person module\n",
      "person mod is run directly\n"
     ]
    }
   ],
   "source": [
    "v edf"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# module utils.py\n",
    "import person\n",
    "\n",
    "person.creds()\n",
    "\n",
    "if __name__ == \"__main__\":\n",
    "    print(\"utils mod is run directly\")\n",
    "else:\n",
    "    print(\"utils mod is imported into another module\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Modules and Packages"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python modules and Python packages, two mechanisms that facilitate modular programming."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Modular Programming\n",
    "\n",
    "It refers to the process of breaking a large, unwieldy programming task into separate, smaller, more manageable subtasks or modules. Advantages are below - \n",
    "\n",
    "- Simplicity\n",
    "- Maintainability\n",
    "- Reusability\n",
    "- Scoping"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### What are modules in Python?\n",
    "\n",
    "Modules refer to a file containing Python statements and definitions.\n",
    "\n",
    "A file containing Python code, for example: example.py, is called a module, and its module name would be example."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "# example.py\n",
    "# Python Module example\n",
    "\n",
    "def add(a, b):\n",
    "   \"\"\"This program adds two\n",
    "   numbers and return the result\"\"\"\n",
    "\n",
    "   result = a + b\n",
    "   return result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "# let's try and import this in Python terminal\n",
    "# call function add()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The value of pi is 3.141592653589793\n"
     ]
    }
   ],
   "source": [
    "# import some native libraies\n",
    "# standard module math\n",
    "\n",
    "import math\n",
    "print(\"The value of pi is\", math.pi)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### The Module Search Path"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import example"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When the interpreter executes the above import statement, it searches for example.py in a list of directories assembled from the following sources:\n",
    "\n",
    "- The directory from which the input script was run or the current directory\n",
    "- The list of directories contained in the PYTHONPATH environment variable, if it is set.\n",
    "- An installation-dependent list of directories configured at the time Python is installed\n",
    "\n",
    "The resulting search path is accessible in the Python variable sys.path, which is obtained from a module named sys:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "C:\\cygwin64\\home\\Sanchit_Balchandani\\Workspace\\python-ws\\python-for-devops\\notebooks\n",
      "c:\\users\\sanchit_balchandani\\appdata\\local\\programs\\python\\python37\\python37.zip\n",
      "c:\\users\\sanchit_balchandani\\appdata\\local\\programs\\python\\python37\\DLLs\n",
      "c:\\users\\sanchit_balchandani\\appdata\\local\\programs\\python\\python37\\lib\n",
      "c:\\users\\sanchit_balchandani\\appdata\\local\\programs\\python\\python37\n",
      "\n",
      "C:\\Users\\Sanchit_Balchandani\\AppData\\Roaming\\Python\\Python37\\site-packages\n",
      "c:\\users\\sanchit_balchandani\\appdata\\local\\programs\\python\\python37\\lib\\site-packages\n",
      "c:\\users\\sanchit_balchandani\\appdata\\local\\programs\\python\\python37\\lib\\site-packages\\win32\n",
      "c:\\users\\sanchit_balchandani\\appdata\\local\\programs\\python\\python37\\lib\\site-packages\\win32\\lib\n",
      "c:\\users\\sanchit_balchandani\\appdata\\local\\programs\\python\\python37\\lib\\site-packages\\Pythonwin\n",
      "c:\\users\\sanchit_balchandani\\appdata\\local\\programs\\python\\python37\\lib\\site-packages\\IPython\\extensions\n",
      "C:\\cygwin64\\home\\Sanchit_Balchandani\\.ipython\n"
     ]
    }
   ],
   "source": [
    "import sys\n",
    "for i in sys.path: print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'c:\\\\users\\\\sanchit_balchandani\\\\appdata\\\\local\\\\programs\\\\python\\\\python37\\\\lib\\\\site-packages\\\\requests\\\\__init__.py'"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import requests\n",
    "\n",
    "requests.__file__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "C:\\cygwin64\\home\\Sanchit_Balchandani\\Workspace\\python-ws\\python-for-devops\\notebooks\\modules_and_packages\\math.py\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "1234"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# using from keyword to import \n",
    "\n",
    "import math\n",
    "from modules_and_packages import math\n",
    "\n",
    "print(math.__file__)\n",
    "\n",
    "math.pi"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Use of as keyword (renaming module)\n",
    "\n",
    "# let look an example on terminal\n",
    "\n",
    "# rom <module_name> import <name> as <alt_name>\n",
    "\n",
    "# import <module_name> as <alt_name>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Module not found\n"
     ]
    }
   ],
   "source": [
    "# Use of try and except for import validations\n",
    "\n",
    "try:\n",
    "    # Non-existent module\n",
    "    import baz\n",
    "except ImportError:\n",
    "    print('Module not found')\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### The dir() Function\n",
    "The built-in function dir() returns a list of defined names in a namespace. Without arguments, it produces an alphabetically sorted list of names in the current local symbol table:\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['In',\n",
       " 'Out',\n",
       " '_',\n",
       " '_23',\n",
       " '_27',\n",
       " '_28',\n",
       " '_29',\n",
       " '_30',\n",
       " '_31',\n",
       " '_32',\n",
       " '_34',\n",
       " '_35',\n",
       " '__',\n",
       " '___',\n",
       " '__builtin__',\n",
       " '__builtins__',\n",
       " '__doc__',\n",
       " '__loader__',\n",
       " '__name__',\n",
       " '__package__',\n",
       " '__spec__',\n",
       " '_dh',\n",
       " '_i',\n",
       " '_i1',\n",
       " '_i10',\n",
       " '_i11',\n",
       " '_i12',\n",
       " '_i13',\n",
       " '_i14',\n",
       " '_i15',\n",
       " '_i16',\n",
       " '_i17',\n",
       " '_i18',\n",
       " '_i19',\n",
       " '_i2',\n",
       " '_i20',\n",
       " '_i21',\n",
       " '_i22',\n",
       " '_i23',\n",
       " '_i24',\n",
       " '_i25',\n",
       " '_i26',\n",
       " '_i27',\n",
       " '_i28',\n",
       " '_i29',\n",
       " '_i3',\n",
       " '_i30',\n",
       " '_i31',\n",
       " '_i32',\n",
       " '_i33',\n",
       " '_i34',\n",
       " '_i35',\n",
       " '_i36',\n",
       " '_i37',\n",
       " '_i38',\n",
       " '_i39',\n",
       " '_i4',\n",
       " '_i40',\n",
       " '_i41',\n",
       " '_i5',\n",
       " '_i6',\n",
       " '_i7',\n",
       " '_i8',\n",
       " '_i9',\n",
       " '_ih',\n",
       " '_ii',\n",
       " '_iii',\n",
       " '_oh',\n",
       " 'add',\n",
       " 'creds',\n",
       " 'exit',\n",
       " 'get_ipython',\n",
       " 'i',\n",
       " 'math',\n",
       " 'proj',\n",
       " 'quit',\n",
       " 'requests',\n",
       " 'sys']"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dir()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_funny_randon_horrible_variable  = [\"Sanchit\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['In',\n",
       " 'Out',\n",
       " '_',\n",
       " '_23',\n",
       " '_27',\n",
       " '_28',\n",
       " '_29',\n",
       " '_30',\n",
       " '_31',\n",
       " '_32',\n",
       " '_34',\n",
       " '_35',\n",
       " '_41',\n",
       " '__',\n",
       " '___',\n",
       " '__builtin__',\n",
       " '__builtins__',\n",
       " '__doc__',\n",
       " '__loader__',\n",
       " '__name__',\n",
       " '__package__',\n",
       " '__spec__',\n",
       " '_dh',\n",
       " '_i',\n",
       " '_i1',\n",
       " '_i10',\n",
       " '_i11',\n",
       " '_i12',\n",
       " '_i13',\n",
       " '_i14',\n",
       " '_i15',\n",
       " '_i16',\n",
       " '_i17',\n",
       " '_i18',\n",
       " '_i19',\n",
       " '_i2',\n",
       " '_i20',\n",
       " '_i21',\n",
       " '_i22',\n",
       " '_i23',\n",
       " '_i24',\n",
       " '_i25',\n",
       " '_i26',\n",
       " '_i27',\n",
       " '_i28',\n",
       " '_i29',\n",
       " '_i3',\n",
       " '_i30',\n",
       " '_i31',\n",
       " '_i32',\n",
       " '_i33',\n",
       " '_i34',\n",
       " '_i35',\n",
       " '_i36',\n",
       " '_i37',\n",
       " '_i38',\n",
       " '_i39',\n",
       " '_i4',\n",
       " '_i40',\n",
       " '_i41',\n",
       " '_i42',\n",
       " '_i43',\n",
       " '_i5',\n",
       " '_i6',\n",
       " '_i7',\n",
       " '_i8',\n",
       " '_i9',\n",
       " '_ih',\n",
       " '_ii',\n",
       " '_iii',\n",
       " '_oh',\n",
       " 'add',\n",
       " 'creds',\n",
       " 'exit',\n",
       " 'get_ipython',\n",
       " 'i',\n",
       " 'math',\n",
       " 'my_funny_randon_horrible_variable',\n",
       " 'proj',\n",
       " 'quit',\n",
       " 'requests',\n",
       " 'sys']"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dir()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Reloading a Module"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For reasons of efficiency, a module is only loaded once per interpreter session. That is fine for function and class definitions, which typically make up the bulk of a module’s contents. But a module can contain executable statements as well, usually for initialization. Be aware that these statements will only be executed the first time a module is imported."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Let's try some examples on Terminal"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "ename": "ModuleNotFoundError",
     "evalue": "No module named 'mod'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mModuleNotFoundError\u001b[0m                       Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-48-9f88670d3539>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[1;32mimport\u001b[0m \u001b[0mmod\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m      2\u001b[0m \u001b[0ma\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;33m[\u001b[0m\u001b[1;36m100\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;36m200\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;36m300\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      3\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      4\u001b[0m \u001b[1;32mimport\u001b[0m \u001b[0mmod\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      5\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;31mModuleNotFoundError\u001b[0m: No module named 'mod'"
     ]
    }
   ],
   "source": [
    "# Sample Example, will not work here\n",
    "\n",
    "import mod\n",
    "a = [100, 200, 300]\n",
    "\n",
    "import mod\n",
    "\n",
    "import importlib\n",
    "importlib.reload(mod)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### What are packages?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Package Initialization\n",
    "If a file named \\__init\\__.py is present in a package directory, it is invoked when the package or a module in the package is imported. This can be used for execution of package initialization code, such as initialization of package-level data.\n",
    "\n",
    "For example, consider the following \\__init\\__.py file:"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"../media/imports.png\">"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Let's try some examples on terminal"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Subpackages\n",
    "\n",
    "<img src=\"../media/subpackages.png\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Absolute Import\n",
    "In this type of import, we specify the full path of the package/module/function to be imported. A dot(.) is used in pace of slash(/) for the directory structure.\n",
    "\n",
    "Consider the following directory structure for a package.\n",
    "\n",
    "python_project_name/packageA/moduleA1.py\n",
    "python_project_name/packageA/moduleA2.py"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [],
   "source": [
    "# from packageA.moduleA2 import myfunc"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Relative Import\n",
    "In relative import, we mention the path of the imported package as relative to the location of the current script which is using the imported module.\n",
    "\n",
    "A dot indicates one directory up from the current location and two dots indicates two directories up and so on.\n",
    "\n",
    "Consider the following directory structure for a package.\n",
    "\n",
    "python_project_name/packageA/moduleA1.py \n",
    "\n",
    "\n",
    "python_project_name/packageB/moduleB1.py"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from ..packageA import moduleA1"
   ]
  }
 ],
 "metadata": {
  "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.7.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}