02.1_libraries.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![Practicum AI Logo image](https://github.com/PracticumAI/practicumai.github.io/blob/main/images/logo/PracticumAI_logo_250x50.png?raw=true)  <img src='https://github.com/PracticumAI/practicumai.github.io/blob/main/images/icons/practicumai_python.png?raw=true' align='right' width=50>\n",
    "\n",
    "# *Practicum AI Python*: Libraries\n",
    "\n",
    "***\n",
    "This exercise adapted from the <a href=\"https://github.com/swcarpentry/python-novice-gapminder\">Software Carpentries</a>\n",
    "\n",
    "(15 Minutes: Presentation)\n",
    "\n",
    "## 1. The power of a programming language is in its libraries\n",
    "\n",
    "* A *library* is a collection of files (called *modules*) that contains functions for use by other programs.\n",
    "    * May also contain data values (e.g., numerical constants) and other things.\n",
    "    * Library's contents are supposed to be related, but there's no way to enforce that.\n",
    "* The Python [standard library](https://docs.python.org/3/library/) is an extensive suite of modules that comes with Python itself.\n",
    "* Many additional libraries are available from [PyPI](https://pypi.python.org/pypi/) (the Python Package Index).\n",
    "* We will see later how to write new libraries.\n",
    "\n",
    "### 1.1 Libraries and modules\n",
    "\n",
    "A library is a collection of modules, but **the terms are often used interchangeably**, especially since many libraries only consist of a single module.\n",
    "\n",
    "### 1.2 A program must import a library module before using it\n",
    "\n",
    "* Use `import` to load a library module into a program's memory.\n",
    "* Then refer to things from the module as `module_name.thing_name`.\n",
    "    * Python uses `.` to mean \"part of\".\n",
    "* Here is an example of using the `math` library, one of the libraries in the standard library:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "pi is 3.141592653589793\n",
      "cos(pi) is -1.0\n"
     ]
    }
   ],
   "source": [
    "import math\n",
    "\n",
    "print('pi is', math.pi)\n",
    "print('cos(pi) is', math.cos(math.pi))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* You have to refer to each item using the containing module's name.\n",
    "    * `math.cos(pi)` won't work: the reference to `pi` doesn't somehow \"inherit\" the function's reference to `math`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1.3 Use `help` to learn about the contents of a library module.\n",
    "\n",
    "Works just like help for a function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "help(math)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1.4  Use `pip` to view kernel libraries"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "!pip list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2. Import specific items from a library module to shorten programs\n",
    "\n",
    "* >Use `from ______ import _____` to load only specific items from a library.\n",
    "* Then refer to them directly without library name as prefix.\n",
    "* It is not a good idea to import *everything* from a library this way...e.g. you may see examples that suggest something like `from math import *`. That is likely to create namespace problems and other issues and is not recommended. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from math import cos, pi\n",
    "\n",
    "print('cos(pi) is', cos(pi))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3. Create an alias for a library module when importing it to shorten programs\n",
    "\n",
    "* Use `import _____ as _____` to give a library a short *alias* while importing it.\n",
    "* Then refer to items in the library using that shortened name."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import math as m\n",
    "\n",
    "print('cos(pi) is', m.cos(m.pi))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Commonly used for libraries that are frequently used or have long names.\n",
    "    * E.g., The `pandas` library is often aliased as `pd`.\n",
    "* But can make programs harder to understand, since readers must learn your program's aliases.\n",
    "* While you *can* use anything for an alias, if there is a commonly used alias, like `pd`, use the convention! "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Questions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Q1: Exploring Math Module"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1. What function from the `math` module can you use to calculate a square root *without* using `sqrt`?\n",
    "2. Since the library contains this function, why does `sqrt` exist?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Solution**\n",
    "\n",
    "Click on the '...' below to show the solution."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "jupyter": {
     "source_hidden": true
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "# 1. Using the help(math) we see the we've got pow(x,y) in additon to sqrt(x)\n",
    "# 2. The sqrt(x) fucntion (like much of the `math` library) has it's origins \n",
    "#    in C's math library. Consequently, it might be somewhat faster than pow(x,y). \n",
    "#    Also, it might be more readable than pow(x, 0.5) when implementing equations. \n",
    "#    However, sqrt(x) doesn't support negative arguments."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Q2: Locating the Right Module"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You want to select a random character from a string:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "bases = 'ACTTGCTTGAC'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1. What standard library module could help you?\n",
    "2. Which function would you select from that module? Are there alternatives?\n",
    "3. Try to write a program that uses the function."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Solution**\n",
    "\n",
    "Click on the '...' below to show the solution."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "jupyter": {
     "source_hidden": true
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "# The [random module](randommod) seems like it could help you.\n",
    "\n",
    "# The string has 11 characters, each having a positional index from 0 to 10. You \n",
    "# could use `random.randrange` function (or the alias `random.randint`\n",
    "# if you find that easier to remember) to get a random integer between 0 and\n",
    "# 10, and then pick out the character at that position:\n",
    "\n",
    "from random import randrange\n",
    "random_index = randrange(len(bases))\n",
    "print(bases[random_index])\n",
    "\n",
    "# or more compactly:\n",
    "\n",
    "from random import randrange\n",
    "print(bases[randrange(len(bases))])\n",
    "\n",
    "# Perhaps you found the `random.sample` function? It allows for slightly \n",
    "# less typing:\n",
    "\n",
    "from random import sample\n",
    "print(sample(bases, 1)[0])\n",
    "\n",
    "# Note that this function returns a list of values. We will learn about lists \n",
    "# in episode 11.\n",
    "\n",
    "# There's also other functions you could use, but with more convoluted code as \n",
    "# a result."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Q3: Jigsaw Puzzle (Parson's Problem) Programming Example"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Rearrange the following statements so that random DNA base is printed and its index in the string. Not all statements may be needed. feel free to tuse/add intermediate variables."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "bases=\"ACTTGCTTGAC\"\n",
    "import math\n",
    "import random\n",
    "____ = random.randrange(n_bases)\n",
    "____ = len(bases)\n",
    "print(\"random base \", bases[___], \"base index\", ___)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Solution**\n",
    "\n",
    "Click on the '...' below to show the solution."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "import math\n",
    "import random\n",
    "\n",
    "bases = \"ACTTGCTTGAC\"\n",
    "n_bases = len(bases)\n",
    "idx = random.randrange(n_bases)\n",
    "\n",
    "print(\"random base\", bases[idx], \"base index\", idx)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Q4: When is help available?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When a colleague of yours types `help(math)`, Python reports an error:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`NameError: name 'math' is not defined`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "What has your colleague forgotten to do?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Solution**\n",
    "\n",
    "Click on the '...' below to show the solution."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "jupyter": {
     "source_hidden": true
    }
   },
   "outputs": [],
   "source": [
    "import math"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Q5: Importing with Aliases"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1. Fill in the blanks so that the program below prints `90.0`\n",
    "2. Rewrite the program so that is ueses `import` *without* `as`.\n",
    "3. Which form do you find easier to read."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import math as m\n",
    "angle = ___.degrees(___.pi / 2)\n",
    "print(___)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Solution**\n",
    "\n",
    "Click on the '...' below to show the solution."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "jupyter": {
     "source_hidden": true
    }
   },
   "outputs": [],
   "source": [
    "# 1. ------------------------------------------\n",
    "import math as m\n",
    "angle = m.degrees(m.pi / 2)\n",
    "print(angle)\n",
    "\n",
    "# 2. ------------------------------------------\n",
    "import math\n",
    "angle = math.degrees(math.pi / 2)\n",
    "print(angle)\n",
    "\n",
    "# Since you just wrote the code and are familiar with it, you might actually \n",
    "# find the first version easier to read. But when trying to read a huge piece \n",
    "# of code written by someone else, or when getting back to your huge piece of \n",
    "# code after several months, non-abbreviated names are often easier except \n",
    "# when there are clear abbreviation conventions."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Q6: There are many Ways to Import Libraries"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Match the following print statements with the appropriate library calls. Print commands:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1. `print(\"sin(pi/2) = \", sin(pi/2))`\n",
    "2. `print(\"sin(pi/2) =\", m.sin(m.pi/2))`\n",
    "3. `print(\"sin(pi/2) =\", math.sin(math.pi/2))`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Library calls:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1. `from math import sin,pi`\n",
    "2. `import math`\n",
    "3. `import math as m`\n",
    "4. `from math import`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Solution**\n",
    "\n",
    "Click on the '...' below to show the solution."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "jupyter": {
     "source_hidden": true
    }
   },
   "outputs": [],
   "source": [
    "# 1. Library calls 1 and 4. In order to directly refer to `sin` and `pi` \n",
    "#    without the library name as prefix, tyou need to use the `from \n",
    "#    ... import ...` statement. Whereas library call 4 imports all functions \n",
    "#    in the `math` module.\n",
    "# 2. Library call 3. Here `sin` and `pi` are referred to with a shortened \n",
    "#    library name `m` instead of `math`. Library call 3 does exactly that using \n",
    "#    the `import ... as ...` syntax - it creates an alias for `math` in the \n",
    "#    form of the shortened name `m`.\n",
    "# 3. Library call 2. Here `sin` and `pi` are referred to with the regular \n",
    "#    library name `math`, so the regular `import ...` call suffices."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Q7: Importing Specific Items"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1. Fill in the blanks so that the program below prints 90.0\n",
    "2. Do you find this version easier to read than the preceding ones?\n",
    "3. Why *wouldn't* programmers always use this form of `import`?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "___ math import ___, ___\n",
    "angle = degrees(pi / 2)\n",
    "print(angle)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Solution**\n",
    "\n",
    "Click on the '...' below to show the solution."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "from math import degrees, pi\n",
    "angle = degrees(pi / 2)\n",
    "print(angle)\n",
    "\n",
    "# Most likely you find this version easier to read since it's less dense.\n",
    "# The main reason not to use this form of import is to avoid name clashes.\n",
    "# For instance, you wouldn't import `degrees` this way if you also wanted to \n",
    "# use the name `degrees` for a variable or function of your own. Or if you \n",
    "# were to also import a function named `degrees` from another library. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Q8: Reading Error Messages"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1. Read the code below and try to identify what the errors are without running it.\n",
    "2. Run the code, read the error message. What type of error is it?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from math import log\n",
    "log(0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Solution**\n",
    "\n",
    "Click on the '...' below to show the solution."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "jupyter": {
     "source_hidden": true
    }
   },
   "outputs": [],
   "source": [
    "# 1. The logarithm of `x` is only defined for `x > 0`, so 0 is outside of the \n",
    "#    domain of the function.\n",
    "# 2. You get an error of type \"ValueError\", indicating that the function received \n",
    "#    an inappropriate argument value. The additional message \"math domain error\" \n",
    "#    makes it clearer what the problem is."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "UFRC Python-3.8",
   "language": "python",
   "name": "python3-3.8-ufrc"
  },
  "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
}