PythonTour/13-Modules-and-Packages.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Modules and Packages"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "One feature of Python that makes it useful for a wide range of tasks is the fact that \n",
    "- it comes \"batteries included\" – that is, \n",
    "    - the Python standard library contains useful tools for a wide range of tasks.\n",
    "    - the broad ecosystem of third-party tools and packages that offer more specialized functionality.\n",
    "    \n",
    "Here we'll take a look at \n",
    "- importing standard library modules, \n",
    "- tools for installing third-party modules, and \n",
    "- a description of how you can make your own modules."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "<!--BOOK_INFORMATION-->\n",
    "<img align=\"left\" style=\"padding-right:10px;\" src=\"fig/cover-small.jpg\">\n",
    "*This notebook contains an excerpt from the [Whirlwind Tour of Python](http://www.oreilly.com/programming/free/a-whirlwind-tour-of-python.csp) by Jake VanderPlas; the content is available [on GitHub](https://github.com/jakevdp/WhirlwindTourOfPython).*\n",
    "\n",
    "*The text and code are released under the [CC0](https://github.com/jakevdp/WhirlwindTourOfPython/blob/master/LICENSE) license; see also the companion project, the [Python Data Science Handbook](https://github.com/jakevdp/PythonDataScienceHandbook).*\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "<!--NAVIGATION-->\n",
    "< [Generators](12-Generators.ipynb) | [Contents](Index.ipynb) | [String Manipulation and Regular Expressions](14-Strings-and-Regular-Expressions.ipynb) >"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Loading Modules: the ``import`` Statement\n",
    "\n",
    "For loading built-in and third-party modules, \n",
    "- Python provides the ``import`` statement.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Explicit module import\n",
    "\n",
    "Explicit import of a module \n",
    "- preserves the module's content in a namespace.\n",
    "- The namespace is then used to refer to its contents with a \"``.``\" between them.\n",
    "\n",
    "For example, here we'll import the built-in ``math`` module and compute the cosine of pi:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-04-25T06:03:40.515820Z",
     "start_time": "2018-04-25T06:03:40.499974Z"
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "import math\n",
    "math.cos(math.pi)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Explicit module import by alias\n",
    "\n",
    "For longer module names, it's not convenient to use the full module name each time you access some element.\n",
    "\n",
    "For this reason, we'll commonly use the \"``import ... as ...``\" pattern to create a shorter alias for the namespace.\n",
    "\n",
    "For example, the NumPy (Numerical Python) package, a popular third-party package useful for data science, is by convention imported under the alias ``np``:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-04-25T06:03:40.845129Z",
     "start_time": "2018-04-25T06:03:40.517762Z"
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-1.0"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import numpy as np\n",
    "np.cos(np.pi)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Explicit import of module contents\n",
    "\n",
    "Sometimes rather than importing the module namespace, you would just like to \n",
    "- import a few particular items from the module.\n",
    "- This can be done with the \"``from ... import ...``\" pattern.\n",
    "\n",
    "For example, we can import just the ``cos`` function and the ``pi`` constant from the ``math`` module:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-04-25T06:03:40.852883Z",
     "start_time": "2018-04-25T06:03:40.847635Z"
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-1.0"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from math import cos, pi\n",
    "cos(pi)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Implicit import of module contents\n",
    "\n",
    "Finally, it is sometimes useful to \n",
    "- import the entirety of the module contents into the local namespace.\n",
    "- This can be done with the \"``from ... import *``\" pattern:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-04-25T06:03:40.859749Z",
     "start_time": "2018-04-25T06:03:40.854908Z"
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.0"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from math import *\n",
    "sin(pi) ** 2 + cos(pi) ** 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "This pattern should be used sparingly, if at all.\n",
    "- The problem is that such imports can sometimes overwrite function names that you do not intend to overwrite, and \n",
    "- the implicitness of the statement makes it difficult to determine what has changed.\n",
    "\n",
    "For example, Python has a built-in ``sum`` function that can be used for various operations:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-04-25T06:03:40.865041Z",
     "start_time": "2018-04-25T06:03:40.861580Z"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on built-in function sum in module builtins:\n",
      "\n",
      "sum(iterable, start=0, /)\n",
      "    Return the sum of a 'start' value (default: 0) plus an iterable of numbers\n",
      "    \n",
      "    When the iterable is empty, return the start value.\n",
      "    This function is intended specifically for use with numeric values and may\n",
      "    reject non-numeric types.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(sum)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "We can use this to compute the sum of a sequence, starting with a certain value (here, we'll start with ``-1``):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-04-25T06:03:40.871595Z",
     "start_time": "2018-04-25T06:03:40.866892Z"
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#sum(range(5), 0)\n",
    "sum(range(5))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-04-25T06:03:40.878296Z",
     "start_time": "2018-04-25T06:03:40.873932Z"
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "9"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sum(range(5), -1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-04-25T06:03:40.884066Z",
     "start_time": "2018-04-25T06:03:40.880121Z"
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sum(range(5), -2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Now observe what happens if we make the *exact same function call* after importing ``*`` from ``numpy``:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-04-25T06:03:40.888696Z",
     "start_time": "2018-04-25T06:03:40.886075Z"
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "from numpy import *"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-04-25T06:03:40.894737Z",
     "start_time": "2018-04-25T06:03:40.890598Z"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sum(range(5))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-04-25T06:03:40.900760Z",
     "start_time": "2018-04-25T06:03:40.896522Z"
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sum(range(5), -1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-04-25T06:03:40.906483Z",
     "start_time": "2018-04-25T06:03:40.902464Z"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sum(range(5), 0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "The result is off by one!\n",
    "\n",
    "The reason for this is that the ``import *`` statement *replaces* the built-in ``sum`` function with the ``numpy.sum`` function, \n",
    "\n",
    "- in the built-in ``sum`` function, we're summing ``range(5)`` starting at ``-1``; \n",
    "- in the ``numpy.sum`` function, we're summing ``range(5)`` along the last axis (indicated by ``-1``).\n",
    "\n",
    "This is the type of situation that may arise if care is not taken when using \"``import *``\" \n",
    "- for this reason, it is best to avoid this unless you know exactly what you are doing."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Importing from Python's Standard Library\n",
    "\n",
    "Python's standard library contains many useful built-in modules [Python's documentation](https://docs.python.org/3/library/).\n",
    "\n",
    "- import with the ``import`` statement, and then \n",
    "- explore using the help function."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Importing from Python's Standard Library\n",
    "\n",
    "\n",
    "Here is an extremely incomplete list of some of the modules you might wish to explore and learn about:\n",
    "\n",
    "- ``os`` and ``sys``: Tools for interfacing with the operating system, including navigating file directory structures and executing shell commands\n",
    "- ``math`` and ``cmath``: Mathematical functions and operations on real and complex numbers\n",
    "- ``itertools``: Tools for constructing and interacting with iterators and generators\n",
    "- ``functools``: Tools that assist with functional programming\n",
    "- ``random``: Tools for generating pseudorandom numbers\n",
    "- ``pickle``: Tools for object persistence: saving objects to and loading objects from disk\n",
    "- ``json`` and ``csv``: Tools for reading JSON-formatted and CSV-formatted files.\n",
    "- ``urllib``: Tools for doing HTTP and other web requests.\n",
    "\n",
    "You can find information on these, and many more, in the Python standard library documentation: https://docs.python.org/3/library/."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Importing from Third-Party Modules\n",
    "\n",
    "One of the things that makes Python useful, especially within the world of data science, is its ecosystem of third-party modules.\n",
    "\n",
    "- These can be imported just as the built-in modules, but first \n",
    "- the modules must be installed on your system.\n",
    "\n",
    "The standard registry for such modules is the Python Package Index (*PyPI* for short), found on the Web at http://pypi.python.org/.\n",
    "\n",
    "For convenience, Python comes with a program called ``pip``\n",
    "- a recursive acronym meaning \"pip install packages\"\n",
    "    - automatically fetch packages released and listed on PyPI \n",
    "- if you use Python version 2, ``pip`` must be installed separately\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Importing from Third-Party Modules\n",
    "\n",
    "For example, if you'd like to install the ``supersmoother`` package that I wrote, all that is required is to type the following at the command line:\n",
    "```\n",
    "$ pip install supersmoother\n",
    "```\n",
    "The source code for the package will be automatically downloaded from the PyPI repository, and the package installed in the standard Python path (assuming you have permission to do so on the computer you're using).\n",
    "\n",
    "For more information about PyPI and the ``pip`` installer, refer to the documentation at http://pypi.python.org/."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-04-25T06:10:54.784689Z",
     "start_time": "2018-04-25T06:10:54.775655Z"
    }
   },
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "invalid syntax (flownetwork.py, line 105)",
     "output_type": "error",
     "traceback": [
      "Traceback \u001b[0;36m(most recent call last)\u001b[0m:\n",
      "  File \u001b[1;32m\"/Users/datalab/Applications/anaconda/lib/python3.5/site-packages/IPython/core/interactiveshell.py\"\u001b[0m, line \u001b[1;32m2910\u001b[0m, in \u001b[1;35mrun_code\u001b[0m\n    exec(code_obj, self.user_global_ns, self.user_ns)\n",
      "\u001b[0;36m  File \u001b[0;32m\"<ipython-input-14-98400cf7b9f8>\"\u001b[0;36m, line \u001b[0;32m1\u001b[0;36m, in \u001b[0;35m<module>\u001b[0;36m\u001b[0m\n\u001b[0;31m    from flownetwork import flownetwork as fn\u001b[0m\n",
      "\u001b[0;36m  File \u001b[0;32m\"/Users/datalab/Applications/anaconda/lib/python3.5/site-packages/flownetwork/flownetwork.py\"\u001b[0;36m, line \u001b[0;32m105\u001b[0m\n\u001b[0;31m    except Exception, e:\u001b[0m\n\u001b[0m                    ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m invalid syntax\n"
     ]
    }
   ],
   "source": [
    "from flownetwork import flownetwork as fn"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print fn.__version__\n",
    "demo = fn.attention_data\n",
    "gd = fn.constructFlowNetwork(demo)\n",
    "gh = fn.flowBalancing(gd)\n",
    "fn.flowDistanceFromSource(gh)\n",
    "fn.networkDissipate(gh)\n",
    "fn.getAICI(gh)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "<!--NAVIGATION-->\n",
    "< [Generators](12-Generators.ipynb) | [Contents](Index.ipynb) | [String Manipulation and Regular Expressions](14-Strings-and-Regular-Expressions.ipynb) >"
   ]
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "celltoolbar": "Slideshow",
  "kernelspec": {
   "display_name": "Python [default]",
   "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.5.4"
  },
  "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
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}