(01) Intro to Python/.ipynb_checkpoints/(16) Importing Modules-checkpoint.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Importing Modules"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this lesson we're going to learn how to import different code libraries and how to use functions from those libraries. This is vital knowledge for this course; Plotly itself is an external code library and there are many different functions which we'll need to use.\n",
    "\n",
    "## How to import a module\n",
    "\n",
    "We'll start by importing the Python builtin library called <code>random</code> - this library allows us to create different random numbers. \n",
    "\n",
    "It's as easy as typing <code>import</code>, then the module name into the cell. When the Python interpreter finds an <code>import</code> statement, it searches through a list of directories in which it expects to find modules to be imported."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "import random"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When we try to import a module that doesn't yet exist, we get an <code>ImportError</code>:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "import bananas"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can test to see that the module has been imported by typing the module name, then a <code> . </code>, then pressing <code>tab</code> to see what functions are available to us from the module. We can scroll through these options using the arrow keys:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "random."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "We're going to use the <code>random.randint</code> function to get a random integer. Remember to press <code>shift + tab</code> after opening the brackets to see what arguments the function takes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "random.randint(5, 10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "But imagine that we had to use <code>random.randint()</code> a lot in whatever program we are writing. It would become very time consuming to write <code>random.randint()</code> every time.\n",
    "\n",
    "Luckily, we can create a shorthand to reference the <code>random</code> module:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "import random as r"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can now use <code>random.randint()</code> by typing <code>r.randint()</code>:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "r.randint(5, 10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We could go one step further, and import the <code>randint</code> module directly from <code>random</code>. This will let us use <code>randint</code> without having to reference the <code>random</code> module at all:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "from random import randint\n",
    "\n",
    "randint(5, 10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can also import multiple modules at the same time. In this example, <code>random()</code> creates a random number between 0 and 1:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "from random import randint, random\n",
    "\n",
    "print(random())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Finally, we can choose to import all of the functions in a module:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "from random import *"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This option should be used sparingly. Python uses 'namespaces' to keep track of object and function names; if you had created your own function called <code>randint</code>, and then imported the <code>random.randint()</code> function, you might experience some unwanted and unexpected behaviour in your program."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Importing the modules we'll use in the course\n",
    "\n",
    "From now on, we'll use the same modules in almost every lesson - we may add a few more modules, or utilise some different functions from these libraries, but we will always use at least these imports.\n",
    "\n",
    "<code>plotly.offline</code> allows us to use plotly's <code>plot</code> function to create our charts without pushing them to the Plotly cloud. This is handy when we develop a chart and don't want multiple beta versions being displayed publicly. I've imported this as <code>pyo</code>,\n",
    "\n",
    "The <code>plotly.graph_objs</code> library contains many functions which help us to create different kinds of charts; I've decided to import them all throughout the course.\n",
    "\n",
    "On the other hand, <code>plotly.plotly</code> makes the chart and pushes it to your plotly account in the cloud. We'll use this when we're happy with the chart we've made. I've imported this as <code>py</code>\n",
    "\n",
    "<code>pandas</code> is a great library for data analysis and manipulation. It's very powerful and very complex; a full tutorial on how to use it is far beyond the scope of this course, but there are a few functions that we'll use repeatedly, one of these being a Pandas DataFrame, which I've imported separately as we'll use it that often! We'll learn about Pandas very soon!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "#plotly.offline doesn't push your charts to the clouds\n",
    "import plotly.offline as pyo\n",
    "#allows us to create the Data and Figure objects\n",
    "from plotly.graph_objs import *\n",
    "#plotly.plotly pushes your charts to the cloud  \n",
    "import plotly.plotly as py\n",
    "\n",
    "#pandas is a data analysis library\n",
    "import pandas as pd\n",
    "from pandas import DataFrame"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### What have we learnt this lesson?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this lesson we have learnt how to import modules into our program. We have seen how to import the whole module which allows us to access each of the functions within that module and we've also learnt that we can create shorthand 'nickname' for the module when we import it. We've seen how to import a specific function or functions from a module, and that it's possible to import all of the functions in a module, but that this should be done sparingly.\n",
    "\n",
    "Finally, we've learnt which modules we'll be using in the course and have imported them for the first time."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you have any questions, please ask in the comments section or email <a href=\"mailto:me@richard-muir.com\">me@richard-muir.com</a>"
   ]
  }
 ],
 "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.4.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}