Python Course Lecture 4 Functions, Scripts, and Modules.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "from IPython.display import HTML"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Introduction to Scientific Programming in Python\n",
    "\n",
    "## Python Course Lecture 4: Functions Scripts, and Modules"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Review\n",
    "  - What is the DRY Principle, and why is it important?\n",
    "  - What are some ways you can implement the DRY Principle in your code?\n",
    "  - How do you run Python functions, modules, and scripts?  How do you create them?\n",
    "  - What are side effects?  What are some ways to avoid them in your functions?\n",
    "  - What is scope?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# The DRY Principle"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "source": [
    "### Don't Repeat Yourself."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "### Don't Repeat Yourself."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "### Don't Repeat Yourself."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## DRY: Variable Creation\n",
    "\n",
    "Using the same number multiple times?  Put it in a variable, and call that instead!\n",
    "  - Decreases Typos\n",
    "  - Makes code easier to understand\n",
    "  - Decreases number of places needed to change code"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.mean([1, 3])\n",
    "np.std([1, 3])\n",
    "len([1, 3])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## DRY: Iteration"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "a = 2 + 5\n",
    "b = 2 + 6\n",
    "c = 2 + 7\n",
    "d = 2 + 8\n",
    "e = 2 + 9"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## DRY: Abstraction\n",
    "\n",
    "**Abstraction** is a key principle of computer science.  When you **abstract** something, you take some complex things and summarize it as a simple thing.  The **Function** is an important tool for abstraction in programming.  Besides shortening code, they make a programmer's intention easier to understand for other programmers.\n",
    "\n",
    "**output = function_name(input)**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3.3333333333333335"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(3 + 2 + 5) / 3."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3.3333333333333335"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.mean([3, 2, 5])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Making Your Own Functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "my_mean() missing 1 required positional argument: 'c'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-22-a2c864d337a9>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m()\u001b[0m\n\u001b[0;32m      2\u001b[0m     \u001b[1;32mreturn\u001b[0m \u001b[1;33m(\u001b[0m\u001b[0ma\u001b[0m \u001b[1;33m+\u001b[0m \u001b[0mb\u001b[0m \u001b[1;33m+\u001b[0m \u001b[0mc\u001b[0m\u001b[1;33m)\u001b[0m \u001b[1;33m/\u001b[0m \u001b[1;36m3.\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      3\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 4\u001b[1;33m \u001b[0mvv\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mmy_mean\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;36m3\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;36m2\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m      5\u001b[0m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mvv\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;31mTypeError\u001b[0m: my_mean() missing 1 required positional argument: 'c'"
     ]
    }
   ],
   "source": [
    "def my_mean(a, b, c):\n",
    "    return (a + b + c) / 3. \n",
    "\n",
    "vv = my_mean(3, 2)\n",
    "print(vv)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "**Important:** Functions should be **simple abstractions**.  Try to make sure a function does as little as possible, while working on as general a range of inputs as possible!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Keyword Arguments\n",
    "\n",
    "By default, all **arguments** (inputs to a function) are required.  However, you can insert **keyword arguments** (optional arguments) by giving them a default value:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "'bool' object is not iterable",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-30-e1f8368ad8c5>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m()\u001b[0m\n\u001b[0;32m      3\u001b[0m     \u001b[1;32mreturn\u001b[0m \u001b[0mdata_mean\u001b[0m \u001b[1;33m**\u001b[0m \u001b[1;36m2\u001b[0m \u001b[1;32mif\u001b[0m \u001b[0msquared\u001b[0m \u001b[1;32melse\u001b[0m \u001b[0mdata_mean\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      4\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 5\u001b[1;33m \u001b[0mmy_mean2\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;32mTrue\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;33m[\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;36m2.5\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;36m3.5\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;32m<ipython-input-30-e1f8368ad8c5>\u001b[0m in \u001b[0;36mmy_mean2\u001b[1;34m(data, squared)\u001b[0m\n\u001b[0;32m      1\u001b[0m \u001b[1;32mdef\u001b[0m \u001b[0mmy_mean2\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mdata\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0msquared\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;32mFalse\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 2\u001b[1;33m     \u001b[0mdata_mean\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0msum\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mdata\u001b[0m\u001b[1;33m)\u001b[0m \u001b[1;33m/\u001b[0m \u001b[0mlen\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mdata\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m      3\u001b[0m     \u001b[1;32mreturn\u001b[0m \u001b[0mdata_mean\u001b[0m \u001b[1;33m**\u001b[0m \u001b[1;36m2\u001b[0m \u001b[1;32mif\u001b[0m \u001b[0msquared\u001b[0m \u001b[1;32melse\u001b[0m \u001b[0mdata_mean\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      4\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      5\u001b[0m \u001b[0mmy_mean2\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;32mTrue\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;33m[\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;36m2.5\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;36m3.5\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;31mTypeError\u001b[0m: 'bool' object is not iterable"
     ]
    }
   ],
   "source": [
    "def my_mean2(data, squared=False):\n",
    "    data_mean = sum(data) / len(data)\n",
    "    return data_mean ** 2 if squared else data_mean\n",
    "\n",
    "my_mean2(True, [1, 2.5, 3.5])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## \\*args and \\*\\*kwargs\n",
    "\n",
    "Sometimes, people don't know how many arguments will be given to a function, or what the names of the arguments will be.  Python has no problem with this!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### \\*args becomes a tuple in the function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Values given: (1, 2, 4, 7, 8, 9)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "5.166666666666667"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def my_mean2(*values):\n",
    "    print('Values given: {}'.format(values))\n",
    "    return float(sum(values)) / len(values)\n",
    "\n",
    "my_mean2(1, 2, 4, 7, 8, 9)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Values given: (1, 5, 8)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "4.666666666666667"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data = (1, 5, 8)\n",
    "my_mean2(*data)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## \\*\\*kwargs becomes a dictionary of keyword arguments in the function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Values given: {'third': 4, 'second': 2, 'first': 1}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "2.3333333333333335"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def my_mean3(**values):\n",
    "    print('Values given: {}'.format(values))\n",
    "    return float(sum(values.values())) / len(values.values())\n",
    "\n",
    "my_mean3(first=1, second=2, third=4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Values given: {'mice': 9, 'rats': 6, 'zebrafish': 100}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "38.333333333333336"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data = {'rats': 6, 'mice': 9, 'zebrafish': 100}\n",
    "my_mean3(**data)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## You can mix and match these tools in your functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "def my_mean4(data,  *add_data, show_data=False, **kwargs):\n",
    "    all_data = tuple(data) + add_data + tuple(kwargs.values())\n",
    "    \n",
    "    if show_data:\n",
    "        print('data: {}'.format(all_data))\n",
    "    mean_data = np.mean(all_data)\n",
    "    \n",
    "    return mean_data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "data: (1, 2, 3, 5, 7, 20)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "6.333333333333333"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_mean4([1, 2, 3], 5, 7, final_point=20, show_data=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Takeaway: If you see that a function takes \\*args or **kwargs, it may have more functionality than it seems at first glance."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Aside: \\*args and zip()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[(1, 'a'), (2, 'b'), (3, 'c')]"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list1 = [1, 2, 3]\n",
    "list2 = ['a', 'b', 'c']\n",
    "\n",
    "list(zip(list1, list2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[(1, 2, 3), ('a', 'b', 'c')]"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(zip(*zip(list1, list2)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## \"Side Effects\" in Functions\n",
    "\n",
    "A good function only does one thing: it outputs data.  That said, often functions do more things..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "NoneType"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_output = print('Hello')\n",
    "type(my_output)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5.4000000000000004"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def my_mean5(list1, list2):\n",
    "    list1 = list1 + list2\n",
    "    return np.mean(list1)\n",
    "\n",
    "my_list = [1, 2, 3]\n",
    "my_mean5(my_list, [10, 11])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3]"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Takeaway: Avoid mutable arguments inside arguments"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Scope"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "  - Variables created inside a function are not accessible to code outside the function, unless that data is **returned**.  This data is said to be inside the function's **scope**, a concept similar to namespaces."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hello\n",
      "Hi\n"
     ]
    }
   ],
   "source": [
    "my_message = 'Hi'\n",
    "def say_hello():\n",
    "    my_message = 'hello'\n",
    "    print(my_message)\n",
    "\n",
    "say_hello()\n",
    "print(my_message)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "  - If a variable is called that is not inside the current scope, Python will automatically search for it in **outer scopes.**\n",
    "    - Try to avoid doing this whenever possible--it can easily lead to problems in your code."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello, Mary\n"
     ]
    }
   ],
   "source": [
    "my_name = 'Nick'\n",
    "def say_hello(my_name='Mary'):\n",
    "    print('Hello, {}'.format(my_name))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Global variables\n",
    "You can explicitly make a variable available to all scopes by using the **global** keyword.  You can also use it to declare that you are using a variable in an outer scope."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "'hi!'"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "hello = 5\n",
    "def change_hello():\n",
    "    global hello\n",
    "    hello = 'hi!'\n",
    "    \n",
    "print(hello)\n",
    "change_hello()\n",
    "hello"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Mixing Scopes, Global Variables, and \"Code Smell\"\n",
    "\n",
    "Extensive use of global varialbes and calling outer scopes considered bad coding practice?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<iFrame src=\"https://en.wikipedia.org/wiki/Code_smell\" height=400 width=900></iFrame>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "HTML('<iFrame src=\"https://en.wikipedia.org/wiki/Code_smell\" height=400 width=900></iFrame>')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Python Modules: .py files that are Imported"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "A **module** is any text file with python code in it. If you **import** it, that code will run, and you can access its functions and data!\n",
    "\n",
    "  - Python scripts are given the **.py** file extension: example_script.py\n",
    "  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## .pyc Files\n",
    "\n",
    "  - The Python interpreter will generate a **.pyc** file automatically when it runs it.  This is a \"compiled\" version of the script.  It will be regenerated automatically whenever you make changes to the .py file.\n",
    "  - You can safely ignore these files--you don't need to interact with them.\n",
    "  - Side effect: Running a script will be faster the second time you run it, since the .pyc file won't be generated twice."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Exercise: Make a Sample Module"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Python Scripts: .py files that are Run.\n",
    "\n",
    "A **Script** is any text file with code in it, meant to be run/interpreted/compiled as code.  These scripts are usually meant to be run from **outside** the programming language, which makes them different from functions.\n",
    "\n",
    "  - Python scripts are given the **.py** file extension: example_script.py\n",
    "  - The Python interpreter will generate a **.pyc** file automatically when it runs it.  This is a \"compiled\" version of the script.  It will be regenerated automatically whenever you make changes to the .py file.\n",
    "    - You can safely ignore these files--you don't need to interact with them.\n",
    "    - Side effect: Running a script will be faster the second time you run it, since the .pyc file won't be generated twice.\n",
    "    \n",
    "### A File can be both a script and a module! Super Useful!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Why Scripts?\n",
    "\n",
    "  - Easy for others to use--they don't have to know Python!\n",
    "  - Easy to chain different tools together\n",
    "     - ex) Bash Script to copy Files -> Matlab to Read Them -> Python Analysis Script to Compute Statistics -> Python Makes Plots -> Latex Puts them into a PDF -> Bash emails the pdf to you"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## How to Run a Script: Many Options\n",
    "  - navigate to the file from your terminal, and type **python script_name.py**.\n",
    "  - associate .py files with the Python interpreter, and just double-click the file.\n",
    "  - use the **%run** magick from with IPython:  **%run script_name.py**."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Script-Only Code\n",
    "\n",
    "Sometimes, you want some code to run only if it's in the script: That is, if it's in the **main** namespace.  To find out what namespace you're in, check the built-in **\\_\\_name\\_\\_** variable.  If it is **'\\_\\_main\\_\\_'**, you're in the main namespace!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "__name__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "np.__name__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "if __name__ == '__main__':\n",
    "    print('This code only runs in a script, or in the interpreter!')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## The argparse package: Adding Arguments to Scripts\n",
    "https://docs.python.org/3/howto/argparse.html"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "if __name__ == '__main__':\n",
    "    \n",
    "    import argparse\n",
    "    parser = argparse.ArgumentParser()\n",
    "\n",
    "    parser.add_argument(\"msg\", help='a message to display', type=str)\n",
    "    parser.add_argument(\"--repeat\", help='number of times to print the message', default=1, type=int)\n",
    "    parser.add_argument(\"--capitalize\", help='make the message capitalized.', action=\"store_true\")\n",
    "    \n",
    "    args = parser.parse_args()\n",
    "    \n",
    "    for rep in range(args.repeat):\n",
    "        message = args.msg.capitalize() if args.capitalize else args.msg\n",
    "        print(message)\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## (Aside) Advanced Tool Tip: Workflow Automation Tools\n",
    "\n",
    "You can easily string together the inputs and outputs of functions and scripts using an **automation tool**.  The best one I've found for scientific research is **doit** http://pydoit.org/\n",
    "\n",
    "This has many benefits:\n",
    "  - Your Analysis Pipeline is made **Explicit**\n",
    "  - The Analysis Pipeline is kept **Flexible**\n",
    "  - The automator knows which files and scripts still need to be run, or re-run.\n",
    "  - The automator can determine which tasks can be run in **parallel**.\n",
    "  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Review\n",
    "  - What is the DRY Principle, and why is it important?\n",
    "  - What are some ways you can implement the DRY Principle in your code?\n",
    "  - How do you run Python functions, modules, and scripts?  How do you create them?\n",
    "  - What are side effects?  What are some ways to avoid them in your functions?\n",
    "  - What is scope?"
   ]
  }
 ],
 "metadata": {
  "celltoolbar": "Slideshow",
  "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.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}