LessonM43_Modules.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[![Google Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/PyGIS222/Fall2019/blob/master/LessonM43_Modules.ipynb)\n",
    "\n",
    "[![Binder](https://mybinder.org/badge_logo.svg)](https://mybinder.org/v2/gh/PyGIS222/Fall2019/master?filepath=LessonM43_Modules.ipynb)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Notebook Lesson 4.3\n",
    "\n",
    "# Python Modules\n",
    "\n",
    "This Jupyter Notebook is part of module 4 of the course GIS222 (Fall2019).\n",
    "\n",
    "This lesson discusses the use and creation of Python **modules**. Carefully study the content of this Notebook and use the chance to reflect the material through the interactive examples.\n",
    "\n",
    "<div class=\"alert alert-info\">\n",
    "\n",
    "**Note**\n",
    "\n",
    "Python *modules* should not be confused with the units of this course on canvas. To avoid confusion we will refer to canvas' units as *course modules* in the notebooks.\n",
    "\n",
    "</div>\n",
    "\n",
    "\n",
    "\n",
    "### Sources\n",
    "\n",
    "This lesson is inspired by Lessons 4 of the [Geo-Python 2018](https://geo-python.github.io/site/2018/notebooks/L4/modules.html), which is licensed under a Creative Commons Attribution-ShareAlike 4.0 International licence. The later part of this lesson is adapted from [How To Write Modules in Python 3](https://www.digitalocean.com/community/tutorials/how-to-write-modules-in-python-3) from the [Digital Ocean Community](https://www.digitalocean.com/community), which is licensed under a Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License.\n",
    "\n",
    "\n",
    "---\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Loading and using modules\n",
    "\n",
    "Before working on this notebook, make sure you have read the chapter *Modules: The Big Picture* from Lutz (2013).\n",
    "\n",
    "## What is a module?\n",
    "\n",
    "A *module* in Python is simply a Python `.py` file that contains a list of related functions that can be loaded and used. In Python's conceptual hierarchy **modules are the highest-level organization units that package code for reuse.**\n",
    "Modules are similar to what are more generally called libraries in programming languages, which again contain code related to a specific task such as mathematical operations. \n",
    "There are a *HUGE* number of Python modules, and many of them greatly extend what can be done in a normal Python program.\n",
    "In fact, the abundance of free Python modules is one of the best reasons to learn and start using Python.\n",
    "\n",
    "## How can modules be loaded?\n",
    "\n",
    "Python modules can be loaded in a number of different ways.\n",
    "\n",
    "### Loading a module\n",
    "    \n",
    "Let's start simple with the math module. We have used it briefly before. Now we will discuss how this actually worked.\n",
    "Here, we’ll load the math module using the `import` statement."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import math"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "9.0"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "math.sqrt(81)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here we have loaded the math module by typing `import math`, which tells Python to read in the functions in the math module and make them available for use.\n",
    "In our example, we see that we can use a function within the math library by typing the name of the module first, a period, and then the name of function we would like to use afterward (e.g., `math.sqrt()`).\n",
    "Built-in functions such as `print()` do not require the name of the module first since nothing is explicitly imported.\n",
    "\n",
    "Variables that are defined in the module can be accessed the same way. For example, the math module defines the natural constant `pi`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3.141592653589793"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "math.pi"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Renaming imported modules\n",
    "\n",
    "We can also rename modules when they are imported.\n",
    "This can be helpful when using modules with longer names."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "import math as m"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7.0"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "m.sqrt(49)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "module"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(m)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this example we now see that when the math module is imported, it is imported to be usable with the name `m` instead of `math`.\n",
    "It doesn't matter much in our toy example here since math is not a long module name, but we will see other examples later in the course where renaming the modules is very helpful (e.g., matplotlib).\n",
    "\n",
    "\n",
    "### Importing a single function\n",
    "\n",
    "It is also possible to import only a single function from a module, rather than the entire module.\n",
    "This is sometimes useful when using large modules that have much more available than the desired use."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "from math import sqrt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "11.0"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sqrt(121)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Though this can be useful, it has the drawback that the imported function could conflict with other built-in or imported function names, and you lose the information about which module contains the function.\n",
    "You should only do this when you truly need to.\n",
    "\n",
    "### Importing part of a module\n",
    "\n",
    "Some modules have sub-modules that can also be imported without importing the entire module.\n",
    "We may see examples of this later when making data plots using the pyplot sub-module of the [Matplotlib module](http://matplotlib.org/).\n",
    "In case you're curious, here is an example."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<Figure size 432x288 with 0 Axes>"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 432x288 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This creates a new figure window for a pyplot figure.\n",
    "Again, we'll see how this works and what it means later in the course."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## How can modules be used?\n",
    "\n",
    "As we see above, the easiest way to use a module is to import it an then use its functions by typing `modulename.functionname()` and providing the necessary arguments.\n",
    "Yes, it is that simple.\n",
    "\n",
    "However, there are times you may not know the names of all of the functions in a given module, or which are part of a module.\n",
    "You can view the list of functions that are part of a module by using the `dir()` function. If you pass the name of a module as an argument, you receive all names that exist in that module, including it's functions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__', 'acos', 'acosh', 'asin', 'asinh', 'atan', 'atan2', 'atanh', 'ceil', 'copysign', 'cos', 'cosh', 'degrees', 'e', 'erf', 'erfc', 'exp', 'expm1', 'fabs', 'factorial', 'floor', 'fmod', 'frexp', 'fsum', 'gamma', 'gcd', 'hypot', 'inf', 'isclose', 'isfinite', 'isinf', 'isnan', 'ldexp', 'lgamma', 'log', 'log10', 'log1p', 'log2', 'modf', 'nan', 'pi', 'pow', 'radians', 'remainder', 'sin', 'sinh', 'sqrt', 'tan', 'tanh', 'tau', 'trunc']\n"
     ]
    }
   ],
   "source": [
    "print(dir(math))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Given this list of names in the module `math`, you can also look up their content. For example, the name `__name__` is an attribute that saves the name of the module. And `__file__` contains the location of the math module file. In fact, the following names with double trailing and leading underscores are built-in attributes, that are defined for all modules:\n",
    "\n",
    "Table 1: *Python module's Built-in Attribute Names and their Content*\n",
    "\n",
    "| Built-in Attribute Name |  Content|\n",
    "|:-:| :- |\n",
    "| `__name__`\t\t| Module name|\n",
    "| `__file__`\t\t| Full name of the module file|\n",
    "| `__doc__`\t\t| Documentation string|\n",
    "| `__package__`\t| Package name, empty for top-level module|\n",
    "\n",
    "Let's peak into the content of these built-in attributes for the module math:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "math.__name__ returns:  math\n",
      "math.__file__ returns:  /anaconda3/lib/python3.7/lib-dynload/math.cpython-37m-darwin.so\n",
      "math.__doc__  returns:  This module provides access to the mathematical functions\n",
      "defined by the C standard.\n"
     ]
    }
   ],
   "source": [
    "import math\n",
    "print(\"math.__name__ returns: \", math.__name__)\n",
    "print(\"math.__file__ returns: \", math.__file__)\n",
    "print(\"math.__doc__  returns: \", math.__doc__)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Most of the other names returned by `dir(math)` are functions of the module math.\n",
    "\n",
    "So that's helpful, but what about when you don't know what a given function does?\n",
    "The easiest solution is to use the `help()` function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on built-in function sin in module math:\n",
      "\n",
      "sin(x, /)\n",
      "    Return the sine of x (measured in radians).\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(math.sin)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "(Note that you'll need to press `q` to exit the help viewer in a terminal or command window.)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## What should I not do?\n",
    "\n",
    "Here are a few things to avoid.\n",
    "\n",
    "### from X import *\n",
    "\n",
    "Don't use `from X import *`.\n",
    "This may be easier to understand by way of an example, but assuming `X` above is a Python module, `from X import *` will import all of the functions in module X and then using them without referencing the module with the `.` operator.\n",
    "Though you might think this is helpful. But it is more likely to encounter conflicting names when using `from X import *`. That means you risk overwriting any existing variables, attributes or functions living in your current namespace. Therefore, it is much better to simply `import X` or `import X as Y` to keep the connection between the functions and their module.\n",
    "\n",
    "\n",
    "### Poor names when renaming on import\n",
    "\n",
    "Don't use confusing names when renaming on import.\n",
    "Be smart when you import modules.\n",
    "If you want to make the module name shorter on import, pick a reasonable abbreviation.\n",
    "For instance, `import matplotlib as m` could be confusing, especially if you're also using `import math as m` in other Jupyter notebooks or script files.\n",
    "Similarly, `import matplotlib as math` is perfectly OK syntax in Python, but bound to cause a world of trouble.\n",
    "Remember, people need to be able to read and understand the code you write, keep it simple and logical."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Writing and Importing Modules\n",
    "\n",
    "Modules can contain definitions of functions, classes, and variables that can then be utilized in other Python programs. Some modules are available through the Python Standard Library and are therefore installed with your Python installation. Others can be installed with Python’s package manager pip. Additionally, you can create your own Python modules since modules are comprised of Python .py files. This means, creating a new *.py*-files that package our own library of functions. This will allow you to import and use them in any Python interpreter, e.g. that of the jupyter Notebook, as well as within other programming files. \n",
    "\n",
    "So let's begin with a very simple example. We want to write a Python module `hello`, which contains one function of the name `world` that simply prints the string \"Hello, World!\" to the screen, like this:\n",
    "\n",
    "```python\n",
    "def world():\n",
    "    print(\"Hello, World!\")\n",
    "```\n",
    "\n",
    "We will leave out any other fancy code elements, like parameter passing, user input, file reading etc and just focus on how to create our own module. Later you can use this recipy to package more complex code. Now, go to the file browser of the JupyterHub, create a new textfile of the name `hello.py` and copy the function above into that file. Save and close it.\n",
    "\n",
    "If you run the program on the command line with python hello.py nothing will happen since we have not told the program to do anything. It just defines a function. If you now try to run the function in the command cell below, you will receive a `NameError`, because the function is not defined in this environment."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'world' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-14-ed0b15a8181f>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mworld\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m: name 'world' is not defined"
     ]
    }
   ],
   "source": [
    "world()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you want to use the function `world()` that is defined in the file `hello.py`, you have to look at the file as a module that packages the function. Now, it should get more clear, what we have to do?! Yes, import the module! Then we can access the function, by referencing it with the module name and the `.` operator:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "ename": "ModuleNotFoundError",
     "evalue": "No module named 'hello'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mModuleNotFoundError\u001b[0m                       Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-15-97c38e313c76>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0;32mimport\u001b[0m \u001b[0mhello\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      2\u001b[0m \u001b[0mhello\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mworld\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mModuleNotFoundError\u001b[0m: No module named 'hello'"
     ]
    }
   ],
   "source": [
    "import hello\n",
    "hello.world()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Congratulations, you have just successfully written your first own Python module. \n",
    "\n",
    "Now expand your module with further variables, function. You could for example request the name of a user through `input()` and then print `Hello <name>!` on the screen! If you need some inspiration, refer back to the previous notebook lesson on functions. Copy some of the functions into the `hello.py` file and then practice accessing the functions through the module import and referencing.\n",
    "\n",
    "More details on writing modules can be found on the following page: https://www.digitalocean.com/community/tutorials/how-to-write-modules-in-python-3."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Standard Python Modules\n",
    "\n",
    "Let's briefly discuss a few standard modules of Python. Standard modules come with the installation of the Python compiler on a computer (or a server like the JupyterHub). They do not require any extra installation and simply have to be imported, using the `import` statement. The Python documentation are very recourceful for information on standard modules. For example, ther you can find a [Python Module Index](https://docs.python.org/3/py-modindex.html). Below a brief overview of the most commonly used standard modules.\n",
    "\n",
    "Table 2: *Commonly Used Python Standard Library Modules*\n",
    "\n",
    "| Module | Description| Example|\n",
    "| :-: | :- | :- |\n",
    "|math|Floating point math functions|math.pow()\n",
    "|string|constants and variables for processing strings (most available as methods)|string.capwords()\n",
    "|os|Interactions with the operating system|os.system(command)\n",
    "|sys|Interpreter-related tools|sys.path, sys.exit()\n",
    "|shutil|High-level file operations|shutil.copyfile(), shutil.move()\n",
    "|re|Regular expression pattern matching tools for advanced string processing|re.match(‘c’, ‘abcdef’)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We have already imported the math module above and used its function `sqrt()`. The module widely expands Pythons built-in functions for numbers. A complete list of functions in the math module can be found on the [Python's documentation pages for the module math](https://docs.python.org/3/library/math.html).\n",
    "\n",
    "The module `string` contains some constants, utility function, and classes for string manipulation. Look up some examples in the [Python's documentation pages for the module string](https://docs.python.org/3/library/string.html#module-string).\n",
    "\n",
    "The Python module `os` provides various operating system interfaces and it contains also more sophisticated functions for file handling, including `rename()`, `remove()`, `mkdir()`, `chdir()` or `rmdir()`. Study syntax for the methods of the os module for file handling on the second half of this website: https://www.tutorialspoint.com/python/python_files_io.htm. \n",
    "\n",
    "Even more sophisticated file operations are packaged in the module [`shutil`](https://docs.python.org/3/library/shutil.html?highlight=shutil#module-shutil).\n",
    "\n",
    "The `sys` module provides access to some variables used or maintained by the interpreter and to functions that interact strongly with the interpreter. For example, the function `sys.path()` provides you a list of folders, where the Python interpreter searches for module files. And the function `sys.path.append()` can add paths to this list.\n",
    "\n",
    "The package `importlib` has handles everything related to module import. It also provides the function `.reload()`, which reloads a previously imported module. The argument must be a module object, so it must have been successfully imported before. For example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import importlib\n",
    "importlib.reload(math)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is useful if you have edited the module source file using an external editor and want to try out the new version without leaving the Python interpreter. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Third-party Python Modules\n",
    "\n",
    "Third-party modules are non-standard in the sense that they are not maintained and supported by the [Python Software Foundation](https://en.wikipedia.org/wiki/Python_Software_Foundation), a nonprofit organization devoted to the Python programming language. \n",
    "\n",
    "Some of these libraries, however, have become so important, nowadays they come with a python installation. Examples for that are the packages **NumPy**, **Matplotlib** and **Pandas**, which we will discussin the upcoming notebooks. \n",
    "\n",
    "Many more available modules exist, that have to be installed before using them. There is not enough time in this course to provide you with a tutorial on that. If you like some more information, we suggest to start looking at the two following sites:\n",
    "\n",
    "* [Python Package Index (pip)](https://pypi.org/): A open-source Python package library provided by the Python Software Foundation.\n",
    "* [Pythons documentation pages on installing packages](https://packaging.python.org/tutorials/installing-packages/): Basics of how to install Python using pip.\n",
    "* [Anaconda Distribution (anaconda)](https://www.anaconda.com/distribution/): An alternative Python open-source package library, provided by the software development company [Anaconda, Inc](https://en.wikipedia.org/wiki/Anaconda_(Python_distribution)).\n",
    "\n",
    "On this JupyterHub, we have separately installed the modules geopandas, shapely, cartopy and netCDF4 relying on the anaconda distribution. However these are just a few examples for a vast universe of open-source Python libraries. Below a brief overview of larger Python packages for data sciences and GIS applications that might be relevant to you now or in the future. \n",
    "\n",
    "Table 3: *Larger Third-party Python Modules*\n",
    "\n",
    "| Module Package | Brief Description |\n",
    "| :-: | :- |\n",
    "|[IPython](https://ipython.org/) | Python prompt on steroids, fundament of Jupyter Notebooks|\n",
    "|[NumPy](https://numpy.org/)   | Advance math functionalities, matrix operations|\n",
    "|[Matplotlib](https://matplotlib.org/) | Numerical 2D plotting library|\n",
    "|[Pandas](https://pandas.pydata.org/) | High-performance data structures and data analysis tools|\n",
    "|[GeoPandas](http://geopandas.org/) | Pandas data structures for geospatial applications |\n",
    "|[SciPy](https://www.scipy.org/)   | Library of algorithms and mathematical tools|\n",
    "|[ArcPy](https://desktop.arcgis.com/en/arcmap/10.3/analyze/arcpy/what-is-arcpy-.htm) | ArcGIS geographic data analyses, map automation, ...|\n",
    "|[ArcGIS API](https://developers.arcgis.com/python/) | Working with maps and geospatial data powered by web GIS|\n",
    "|[Scikit-learn](http://scikit-learn.org/) | Classification, regression and clustering algorithms, machine Learning, interoperates with NumPy and SciPy|\n",
    "\n",
    "The list is far from complete. In the following notebooks of this and the course module 6, we will discuss the packages NumPy, Matplotlib, Pandas and a few smaller packages that are not listed here. \n",
    "\n",
    "The three packages NumPy, Matplotlib and Pandas are very useful in any kind of data sciences and for data processing. During the upcoming notebooks, you will be introducted to all three. We also want to recommend to check the **Python Data Science Handbook** by Jake VanderPlas  (2017). This book is entirely written as Jupyter Notebooks, which are published with an open source license. Click on the book's cover image below to access them. (You can also download them on [GitHub](https://github.com/jakevdp/PythonDataScienceHandbook) and from there launch them on Google Colab or Binder.)\n",
    "\n",
    "[</div>\n",
    "<img src=\"./img/M43_PDSH-cover.png\" title=\"Python Data Science Handbook by Jake VanderPlas\" width=\"100\" />](https://jakevdp.github.io/PythonDataScienceHandbook/)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Those who are interested getting to know about more useful Python packages may refer to these interesting online articles:\n",
    "\n",
    "* [Top 15 Python Libraries for Data Science in 2017](https://medium.com/activewizards-machine-learning-company/top-15-python-libraries-for-data-science-in-in-2017-ab61b4f9b4a7)\n",
    "* [20 Python libraries you can’t live without](https://pythontips.com/2013/07/30/20-python-libraries-you-cant-live-without/)\n",
    "* [65 Handy Third-Party Modules](https://www.djangospin.com/60-plus-handy-third-party-modules/)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}