new_modular_programming.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Modular programming\n",
    "\n",
    "Modular programming refers to the process of breaking a large, unwieldy programming task into separate, smaller, more manageable subtasks or modules. Individual modules can then be cobbled together like building blocks to create a larger application.\n",
    "\n",
    "There are several advantages to modularizing code in a large application:\n",
    "\n",
    "- **Simplicity:** Rather than focusing on the entire problem at hand, a module typically focuses on one relatively small portion of the problem. If you’re working on a single module, you’ll have a smaller problem domain to wrap your head around. This makes development easier and less error-prone.\n",
    "\n",
    "- **Maintainability:** Modules are typically designed so that they enforce logical boundaries between different problem domains. If modules are written in a way that minimizes interdependency, there is decreased likelihood that modifications to a single module will have an impact on other parts of the program. (You may even be able to make changes to a module without having any knowledge of the application outside that module.) This makes it more viable for a team of many programmers to work collaboratively on a large application.\n",
    "\n",
    "- **Reusability:** Functionality defined in a single module can be easily reused (through an appropriately defined interface) by other parts of the application. This eliminates the need to duplicate code.\n",
    "\n",
    "- **Scoping:** Modules typically define a separate namespace, which helps avoid collisions between identifiers in different areas of a program. (One of the tenets in the Zen of Python is Namespaces are one honking great idea—let’s do more of those!)\n",
    "\n",
    "Functions, modules and packages are all constructs in Python that promote code modularization."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Modules\n",
    "\n",
    "In Python, modules are \".py\" files containing Python code that can be imported inside another Python Program. A module is basically a code library or a file that contains a set of functions that you want to include in your application.\n",
    "\n",
    "### Importing a module\n",
    "\n",
    "Modules are imported with the import statement:\n",
    "```python\n",
    "import module\n",
    "```\n",
    "When the interpreter executes the above import statement, it searches for module.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 if the interpreter is being run interactively\n",
    "- The list of directories contained in the PYTHONPATH environment variable, if it is set. (The format for PYTHONPATH is OS-dependent but should mimic the PATH environment variable.)\n",
    "- An installation-dependent list of directories configured at the time Python is installed\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['/Users/elenadelahoz/Documents/Doctorado/Docencia/Programacion/Object_Oriented_Programming',\n",
       " '/Users/my_user/code',\n",
       " '/Users/elenadelahoz/opt/anaconda3/lib/python38.zip',\n",
       " '/Users/elenadelahoz/opt/anaconda3/lib/python3.8',\n",
       " '/Users/elenadelahoz/opt/anaconda3/lib/python3.8/lib-dynload',\n",
       " '',\n",
       " '/Users/elenadelahoz/opt/anaconda3/lib/python3.8/site-packages',\n",
       " '/Users/elenadelahoz/opt/anaconda3/lib/python3.8/site-packages/aeosa',\n",
       " '/Users/elenadelahoz/opt/anaconda3/lib/python3.8/site-packages/IPython/extensions',\n",
       " '/Users/elenadelahoz/.ipython']"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import sys\n",
    "\n",
    "# PYTHONPATH\n",
    "sys.path"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's see the objectes inside the file module.py."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on module module:\n",
      "\n",
      "NAME\n",
      "    module\n",
      "\n",
      "FUNCTIONS\n",
      "    add1(x)\n",
      "    \n",
      "    hello()\n",
      "\n",
      "DATA\n",
      "    docs = 'Example python module to show main concepts.'\n",
      "\n",
      "FILE\n",
      "    /Users/elenadelahoz/Documents/Doctorado/Docencia/Programacion/Object_Oriented_Programming/module.py\n",
      "\n",
      "\n"
     ]
    }
   ],
   "source": [
    "import module\n",
    "\n",
    "help(module)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we can access the function, variables, etc. defined in module.py using dot notation:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Example python module to show main concepts.'"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "module.docs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello world!\n"
     ]
    }
   ],
   "source": [
    "module.hello()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello world!\n"
     ]
    }
   ],
   "source": [
    "# We can import only certain pieces of code from module\n",
    "from module import hello\n",
    "\n",
    "hello()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# We can use shorthands\n",
    "import module as mod\n",
    "\n",
    "mod.add1(2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "One can import all the contents of a module using the star import:\n",
    "```python\n",
    "from module import *\n",
    "```\n",
    "However, this is not recommended since we can override already assigned variables without noticing it."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Executing a module as a script\n",
    "\n",
    "Let's consider the following file `example.py`.\n",
    "```python\n",
    "#!/usr/bin/env python3\n",
    "\n",
    "def hello():\n",
    "    print('Hello world!')\n",
    "    \n",
    "hello()\n",
    "```\n",
    "One can run the lines of code of a module as a regular script. Interactively:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello world!\n"
     ]
    }
   ],
   "source": [
    "%run -i example.py"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Or from the terminal it can be run as \n",
    "\n",
    "    >>python3 module.py\n",
    "    \n",
    "Notice that also when a module is imported all the lines of code within it are executed."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello world!\n"
     ]
    }
   ],
   "source": [
    "import example"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The hello() function is called and executed when example is imported. To execute several lines of code only when the module is called as a script there should be included in the following the conditional statement that checks whether the module is being run directly.\n",
    "\n",
    "```python\n",
    "if __name__ == \"__main__\":\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Running the module.py script\n",
      "Hello world!\n"
     ]
    }
   ],
   "source": [
    "%run -i module.py"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Packages\n",
    "\n",
    "A directory that contains many modules is called a package. A package is a module with submodules (which can have submodules themselves, etc.). A special file called `__init__.py` (which may be empty) tells Python that the directory is a Python package, from which modules can be imported. "
   ]
  }
 ],
 "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.8.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}