module_import.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Analysis 2: Foundations of modeling 2\n",
    "## Module import\n",
    "\n",
    "Python is one of the most popular programming languages (in the November 2020 TIOBE index it is ranked\n",
    "\\#2, right behind C - arguably the two most important programming languages to master).\n",
    "One of the reasons is an enormous number of libraries.  Besides the built-in libraries, Python\n",
    "has a very active community that regularly develops new modules, for almost any general\n",
    "problem.\n",
    "\n",
    "Python libraries are files that contain pre-written code that can be easily imported in our\n",
    "program(s), significantly reducing the development and debugging time, and increasing the\n",
    "code reusability.  For example, in Analysis 1 and Analysis 2 exercises, some problems required\n",
    "finding the minimum or the maximum value.  Instead of developing such subroutines every\n",
    "time, it is much more efficient to use already proven functions such as `min()` and `max()`.\n",
    "\n",
    "By default, Python stores libraries / modules in the Lib folder where Python is installed. \n",
    "To use a library / module, it has to be imported.  If the import was successful, imported functions\n",
    "from those modules can be called from the program.\n",
    "\n",
    "This document contains:\n",
    "- [Import](#import)\n",
    "- [From ... import ...](#from)\n",
    "- [Import ... as ...](#as)\n",
    "\n",
    "---\n",
    "\n",
    "<a id='import'></a>\n",
    "### Import\n",
    "The straightforward way of importing modules is using the `import` command. \n",
    "Typically at the\n",
    "beginning of the program, but it can be in any other place.  Just keep in mind that functions\n",
    "from that module become available only after they are imported.\n",
    "To import a module that is already in the Lib folder, type `import` and then the module name. \n",
    "\n",
    "Let’s\n",
    "assume that we want to write a program where we need random values.  We need function(s)\n",
    "to generate such values, and Python provides them as part of the `random` module.  First, run:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dir()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next, let’s import the `random` module."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import random"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Try using `dir()` again:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dir()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You should see `random` if everything went smoothly.\n",
    "Let’s inspect the module. Use `dir()` again, but this time pass module `random` as the argument."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dir(random)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You should see all functions that are part of the `random` module.  For now, ignore elements\n",
    "starting with `_ ` or `__`.  Let’s assume we are interested in using the function `random()` and/or\n",
    "`randint()`, but we are not sure what they do exactly.  Built-in modules and\n",
    "functions are well documented; therefore, just obtain the docstring using `help`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "help(random.random)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "help(random.randint)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In Analysis 2 we will simulate coin tosses and dice rolls often.  For the sake of illustration, we will\n",
    "use `random()` to simulate 6-sided dice, although, `randint()` is the more convenient\n",
    "choice.\n",
    "##### Example – random die:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import random  #  We start by importing the `random` module\n",
    "\n",
    "def d6():  # Define d6 function, takes no param., returns value\n",
    "    value = random.random() * 6 + 1\n",
    "    return int(value)\n",
    "\n",
    "print(d6())  # Let's call the function several times ...\n",
    "a = d6()\n",
    "print(a)\n",
    "b = d6()\n",
    "print(b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Testing d6() function # let's test if d6 returns numbers in range [1-6]\n",
    "x = [d6() for i in range(100)]  # A simple way is to call it 100 times, and ...\n",
    "print(x)  # Store values in a list; then print it\n",
    "\n",
    "print(min(x))  # check what was the minimum\n",
    "print(max(x))  # and the maximum"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Experiment\n",
    "- In exercises for OP1 you asked a user to input a list of numbers.  This can be \n",
    "time-consuming when testing programs.  Automate this task by writing a piece of code that\n",
    "generates a list of N elements from range \\[a, b\\].\n",
    "- Follow the link docs.python.org/3/py-modindex.html to the official page with Python\n",
    "modules. Experiment importing a few modules that you choose. Use `dir()` and `help()` to\n",
    "investigate some of their functions."
   ]
  },
  {
   "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": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "<a id='from'></a>\n",
    "### From ... import ...\n",
    "If you want to import only specific functions and not an entire module, you can use the following syntax:\n",
    "```Python\n",
    "from module_name import function_name\n",
    "```\n",
    "Restart this kernel by clicking on \"Restart Kernel\" in the \"Kernel\" menu (to ensure our previous import is discarded). \n",
    "Let’s experiment with the same module, but this time we only want to import `random()` and\n",
    "`randint()`. Start again with `dir()`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dir()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next, import the `randint()` function from the `random` module:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from random import randint\n",
    "\n",
    "dir()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You should see the `randint()` function imported.  Now you can call it directly:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "r = randint(1,6)\n",
    "print(r)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To import more than one function, separate them with commas:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from random import random, randint\n",
    "dir()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you want to import all functions use asterisk (not recommended!):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from random import *"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note: if different modules have functions with the same name you will have to state the name\n",
    "of the module first (example: `random.randint()`) when calling a function.\n",
    "\n",
    "---\n",
    "<a id='as'></a>\n",
    "### Import ... as ...\n",
    "Modules can also be imported as objects. This is accomplished using the following syntax:\n",
    "```Python\n",
    "import module_name as object_name\n",
    "```\n",
    "##### Example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import random as r\n",
    "print(r.randint(1,6))"
   ]
  },
  {
   "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.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}