Workshop.ipynb

{
 "metadata": {
  "name": ""
 },
 "nbformat": 3,
 "nbformat_minor": 0,
 "worksheets": [
  {
   "cells": [
    {
     "cell_type": "heading",
     "level": 1,
     "metadata": {},
     "source": [
      "An Introduction to Python for new Programmers"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Welcome to _An Introduction to Python for new Programmers_! This iPython notebook serves as an instructor-led guide to the Python programming language, particularly for those who are new to programming or have very limited programming experience. iPython notebooks are a novel form of communicating about programming; creating an environment where both text and live code can be executed in an explanatory fashion. Parts of this document will contain live Python code that is interpreted by the notebook and whose output will be rendered directly to the screen. If you would like to follow along on your laptop, you can install iPython and download this workbook from [github/intro-to-python](https://github.com/bbengfort/intro-to-python)."
     ]
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "Before we get Started"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Although this is an introductory course, some prerequisites are required. In particular, the student must have Python installed and be familiar with using Python on his or her operating system. They must also have familiarity with the command line. The following are suggested tasks to perform before this course:\n",
      "\n",
      "* [Install Python](https://wiki.python.org/moin/BeginnersGuide/Download)\n",
      "* [Install virtualenv and virtualenvwrapper](http://docs.python-guide.org/en/latest/dev/virtualenvs/)\n",
      "* [Get a Github account](https://github.com/) \n",
      "* [Python Hello World](http://www.learnpython.org/en/Hello,_World!)\n",
      "* [Using the terminal](http://cli.learncodethehardway.org/book/)\n",
      "* [Python Basics](http://www.codecademy.com/tracks/python)\n",
      "\n",
      "If you can open up an interpreter and have the words \"Hello World\" print to the screen, then we're ready to go!\n"
     ]
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "Learning how to Learn how to Code"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "So, let's be clear- what can we accomplish in a two to three hour session? Obviously we're not going to make you an expert programmer in this time, nor are we going to impart a comprehensive theory of programming. However, there is one fundamental concept about programming that I would like ensure you all take away: **programming isn't about knowing syntax it's about learning**. Therefore, what were going to try to enable you to do today is help you learn how to learn how to code. \n",
      "\n",
      "Programming is a creative discipline, and thanks to the wide applicability of programming to a variety of domains, true innovation happens often. Programmers stand on the shoulders of giants, and in order to continually improve his or her craft, a programmer must constantly be in a state of education. From reading about new programming paradigms, languages, or frameworks to experimental approaches to reading other' code- programming is is a community activity that encourages the sharing of ideas. \n",
      "\n",
      "In particular we'll focus on clear expression of code and readability. By ensuring you can write code in a readable form, it will help you to read other's code as well!"
     ]
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "What is Programming?"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Programming is the act of creating a set of instructions to transform input data to some kind of output. \n",
      "\n",
      "Yeh- it's that simple. We're making recipes of ingredients and instructions.\n",
      "\n",
      "However, instead of food, we cook with numbers and strings. The instructions are defined as a formal language.\n",
      "\n",
      "The instructions are interpreted and executed from top to bottom, and when the interpreter runs out of instructions, the program is done!\n",
      "\n",
      "Consider the following simple program:"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": true,
     "input": [
      "# Compute the area of a triangle\n",
      "\n",
      "# Ingredients\n",
      "base   = 4\n",
      "height = 7\n",
      "\n",
      "# Instructions\n",
      "area = 0.5 * base * height\n",
      "print area"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "This small program includes quite a few components:\n",
      "\n",
      "* Comments\n",
      "* Assignment\n",
      "* Variables\n",
      "* Multiplication\n",
      "* Output"
     ]
    },
    {
     "cell_type": "heading",
     "level": 3,
     "metadata": {},
     "source": [
      "Interactivity"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "But why is this idea so powerful? It's because variables are meant to be... variable."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# The area of a circle\n",
      "# Must input a number or a decimal\n",
      "radius = input(\"Enter radius: \")\n",
      "area = 3.14 * radius * radius\n",
      "print area"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Here we create a variable called radius. Note that the name of the variable is expressive (much better than x or y). The value of variable is assigned using the `=` operator. In this case it is assigned the value of the return value from the `input` function. We can run this program over and over again and by changing the input we have changed the ouput- thus making our program dynamic. We can then use the variable throughout the program and even modify its value through code during runtime. And through this very simple concept, very complex programs from web servers to self-driving cars are built from just a few simple building blocks!"
     ]
    },
    {
     "cell_type": "heading",
     "level": 3,
     "metadata": {},
     "source": [
      "Calculation"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "So let's look at what computers do best- compute things!"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "a = 2    # Integer\n",
      "b = 3.4  # Float\n",
      "\n",
      "print a + b    # Addition\n",
      "print b - a    # Subtraction\n",
      "print a * b    # Multiplication\n",
      "print 5 % a    # Modulus\n"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "a = 10\n",
      "b = 3\n",
      "c = 3.0\n",
      "\n",
      "# Division?\n",
      "print a / b    \n",
      "print a / c"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "a = \"Hello\"  # String\n",
      "b = \" World\" # Another string\n",
      "\n",
      "print a + b  # Concatenation\n",
      "\n",
      "name = \"Jonesey\"\n",
      "print \"Hello, %s!\" % name # String format"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "heading",
     "level": 3,
     "metadata": {},
     "source": [
      "Comparison"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "True and False are booleans in Python and are used to express truth. Let's explore some comparision operators. \n",
      "\n",
      "**Note:** Don't confuse assignment `=` with is equal to `==`; this is one of the most common programmer errors."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "a = 10\n",
      "b = 20\n",
      "\n",
      "print a > b   # Greater than\n",
      "print b >= a  # Greater than or equal to\n",
      "print a == b  # is equal to\n",
      "print b < a   # Less than\n",
      "print a <= b   # Less than or equal to"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "heading",
     "level": 3,
     "metadata": {},
     "source": [
      "Conditionality"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Programs can make choices based on particular values of variables using conditional execution. Conditionality forks the flow of execution so that some parts of the program may be executed but others will not.\n",
      "\n",
      "This brings up a crucial point about Python in particular- blocks of code are grouped by indentation. Every time you get to a place where you have to define a contiguous block of code (usually following a `:`) then everything under must be indented with the same amount of space (usually 4 space). Dedented code does not belong to the indented block.\n",
      "\n",
      "TODO: Logic"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# Evaluate Temperature\n",
      "temperature = input(\"What is today's temperature?  \")\n",
      "temperature = int(temperature)\n",
      "\n",
      "if temperature > 82:\n",
      "   print \"It's too hot, %i degrees will melt you.\" % temperature\n",
      "elif temperature < 45:\n",
      "   print \"Are you crazy? You'll freeze at %i degrees\" % temperature\n",
      "else:\n",
      "    print \"Perfect weather! Let's go for a picnic!\""
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "a = True\n",
      "b = True\n",
      "c = False\n",
      "d = False\n",
      "\n",
      "if a and b:\n",
      "    print \"a and b == True\"\n",
      "    \n",
      "if b or c:\n",
      "    print \"b and c == True\"\n",
      "    \n",
      "if c or not d:\n",
      "    print \"d and c == True\""
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "if 1: \n",
      "    print \"1\"\n",
      "\n",
      "if None:\n",
      "    print \"None\"\n",
      "\n",
      "if not None:\n",
      "    print \"Not None\"\n",
      "\n",
      "print None == False\n",
      "\n",
      "a = None\n",
      "b = 0\n",
      "\n",
      "print a is None\n",
      "print b is None"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "heading",
     "level": 3,
     "metadata": {},
     "source": [
      "Repetition"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "The power of computers is their ability to do a repetitive task over and over again without tiring. Most programs don't just shut down on you have executing their instructions- they wait for input from the user and respond. In order to accomplish this some mechanism is required to continually execute a chunk of code."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "for letter in \"a\", \"b\", \"c\", \"d\", \"e\":\n",
      "    print letter"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "for number in range(1,10):\n",
      "    if number % 2 == 0:\n",
      "        print \"number \" + str(number) + \" is even\""
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# an import statement\n",
      "from time import sleep\n",
      "\n",
      "print \"Cooking the spam.\"\n",
      "\n",
      "hot_enough  = 180\n",
      "temperature = 62\n",
      "\n",
      "while temperature < hot_enough:\n",
      "    print \"Not hot enough...\"\n",
      "    sleep(1)\n",
      "    temperature = temperature + 15\n",
      "\n",
      "print \"Spam is done!\""
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "heading",
     "level": 3,
     "metadata": {},
     "source": [
      "Functions"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Functions allow you to define proceedures that happen over and over again in your code, almost like mini-programs that take input and `return` an output. Consider the following proceedural code:"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# Compute 8! - 4!\n",
      "\n",
      "num     = 8\n",
      "result  = 1\n",
      "while num > 0:\n",
      "    result = result * num\n",
      "    num = num -1\n",
      "\n",
      "num     = 4\n",
      "result2 = 1\n",
      "while num > 0:\n",
      "    result2 = result2 + num\n",
      "    num = num - 1\n",
      "    \n",
      "print \"8! - 4! is \" + str(result - result2)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Let's create a reusable chunk of code to perform the computation just once. This is far better than copy and paste; it reduces the complexity of code, makes it more readable, and makes it more maintainable. "
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "def fact(num):\n",
      "    result = 1\n",
      "    while num > 0:\n",
      "        result = result * num\n",
      "        num = num - 1\n",
      "    return result\n",
      "\n",
      "print \"8! - 4! is \" + str(fact(8) - fact(4))"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Arguments to functions are named buckets that can have defaults associated with them. Positional arguments (arguments without a default) must be specified in the order of the arguments. Keyword arguments (those with a default) can be specified in any order, so long as they come after the positional arguments."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# postional and keyword arguments\n",
      "def writer(name, color=\"blue\"):\n",
      "    print name + \"'s favorite color is \" + color\n",
      "    \n",
      "writer(\"Samantha\")\n",
      "writer(\"Sarah\", \"red\")\n",
      "writer(\"Susan\", color=\"green\")\n",
      "\n",
      "# A stub function that does nothing\n",
      "def stub():\n",
      "    pass\n",
      "\n",
      "# Generic Arguments\n",
      "def generic(*args, **kwargs):\n",
      "    print args\n",
      "    print kwargs    "
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "heading",
     "level": 3,
     "metadata": {},
     "source": [
      "Data Structures"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Programmers can't live on numbers and strings alone. The currency of programming is data (information), therefore we need more significant structures to represent information. The last two primitive data structures are `dict` and `list`."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      " # A new list\n",
      " groceries = []\n",
      "\n",
      " # Add to list\n",
      " groceries.append(\"Apples\")\n",
      " groceries.append(\"Oranges\")\n",
      " print groceries.append(\"Cactus\")\n",
      "\n",
      " # Access by index\n",
      " print groceries[2]\n",
      "\n",
      " # Find number of things in list\n",
      " print len(groceries)\n",
      "\n",
      " # Remove from list\n",
      " groceries.remove(\"Oranges\")\n",
      " print groceries"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# A dictionary of days in months\n",
      "months = {\n",
      "    'January': 31,\n",
      "    'February': 28,\n",
      "    'March': 30,\n",
      "    # ...\n",
      "}\n",
      "\n",
      "# Access by key\n",
      "print months['March']\n",
      "\n",
      "# Add new item\n",
      "print 'December' in months\n",
      "months['December'] = 31\n",
      "print months['December']"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# Complex Data structures\n",
      "\n",
      "employees = {\n",
      "    \"eid0001\": {\n",
      "        \"name\": \"Bob Jones\",\n",
      "        \"department\": \"Marketing\",\n",
      "        \"interests\": [\"fishing\", \"deep breathing\", \"gatorade\",]\n",
      "    },\n",
      "    \"eid0002\": {\n",
      "        \"name\": \"Sherry Lorenzo\",\n",
      "        \"department\": \"Human Resources\",\n",
      "        \"interests\": [\"cooking\", \"steganography\", \"cycling\",],\n",
      "    }\n",
      "}\n",
      "\n",
      "for employee in employees:\n",
      "    print employees[employee][\"name\"]"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "Object Oriented Programming"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Now that we have covered the basic building blocks of a Python program, let's discuss a programming paradigm called Object-Oriented Programming (OOP). OOP gives programmers a framework for modeling the real world by using classes - templates that describe an object's methods and attributes. Using this methodology, a programmer simply has to imagine the component interactions of the structure they're trying to model, then translate that into the executional components described above. \n",
      "\n",
      "**Some Terminology**:\n",
      "\n",
      "* **Class**: A user-defined prototype for an object that defines a set of attributes that characterize any object of the class. The attributes are data members (class variables and instance variables) and methods, accessed via dot notation.\n",
      "* **Class variable**: A variable that is shared by all instances of a class. Class variables are defined within a class but outside any of the class's methods. Class variables aren't used as frequently as instance variables are.\n",
      "* **Data member**: A class variable or instance variable that holds data associated with a class and its objects.\n",
      "* **Function overloading**: The assignment of more than one behavior to a particular function. The operation performed varies by the types of objects (arguments) involved.\n",
      "* **Instance variable**: A variable that is defined inside a method and belongs only to the current instance of a class.\n",
      "* **Inheritance** : The transfer of the characteristics of a class to other classes that are derived from it.\n",
      "* **Instance**: An individual object of a certain class. An object obj that belongs to a class Circle, for example, is an instance of the class Circle.\n",
      "* **Instantiation** : The creation of an instance of a class.\n",
      "* **Method** : A special kind of function that is defined in a class definition.\n",
      "* **Object** : A unique instance of a data structure that's defined by its class. An object comprises both data members (class variables and instance variables) and methods.\n",
      "* **Operator overloading**: The assignment of more than one function to a particular operator."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "class Person(object):\n",
      "    \"\"\"\n",
      "    Base class for all employees\n",
      "    \"\"\"\n",
      "    \n",
      "    population = 0\n",
      "    \n",
      "    def __init__(self, name, age):\n",
      "        self.name = name\n",
      "        self.age = age\n",
      "        Person.population += 1\n",
      "    \n",
      "    def displayCount(self):\n",
      "        print \"Total people: %d\" % Person.population\n",
      "    \n",
      "    def displayPerson(self):\n",
      "        print \"Name: \", self.name, \", Age: \", self.age\n",
      "        "
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# Creating instances\n",
      "bob = Person(\"Bob\", 35)\n",
      "bob.displayCount()\n",
      "bob.displayPerson()\n",
      "sue = Person(\"Sue\", 42)\n",
      "bob.displayCount()"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "heading",
     "level": 3,
     "metadata": {},
     "source": [
      "Inheritance"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "class Employee(Person):\n",
      "    \n",
      "    def __init__(self, name, age, salary):\n",
      "        self.salary = salary\n",
      "        super(Employee, self).__init__(name, age)\n",
      "    \n",
      "    def displayPerson(self):\n",
      "        print \"Name: \", self.name, \", Salary: \", self.salary"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "bob = Employee(\"Bob\", 42, 768500)\n",
      "bob.displayPerson()\n",
      "bob.displayCount()"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "A Time Formatter"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "In order to get a feel for how simple programs can be constructed, let's take a look at simple program that I wrote and use every single day. We'll walk through each line of code together and discover how this code works. This exercise will be common as you continue to learn how to program."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "#!/usr/bin/env python\n",
      "\n",
      "import sys\n",
      "from datetime import datetime\n",
      "from dateutil.tz import tzlocal\n",
      "\n",
      "class Clock(object):\n",
      "    \n",
      "    FORMATS = {\n",
      "        \"code\":\"%a %b %d %H:%M:%S %Y %z\",\n",
      "        \"json\":\"%Y-%m-%dT%H:%M:%S.%fZ\",\n",
      "        \"cute\":\"%b %d, %Y\", \n",
      "    }\n",
      "\n",
      "    @classmethod\n",
      "    def local_now(klass):\n",
      "        return datetime.now(tzlocal())\n",
      "\n",
      "    @classmethod\n",
      "    def utc_now(klass):\n",
      "        return datetime.utcnow()\n",
      "\n",
      "    def __init__(self, formats={}):\n",
      "        self.formats = self.FORMATS.copy()\n",
      "        self.formats.update(formats)\n",
      "     \n",
      "    def _local_format(self, fmt):\n",
      "        return Clock.local_now().strftime(fmt)\n",
      "\n",
      "    def _utc_format(self, fmt):\n",
      "        return Clock.utc_now().strftime(fmt)\n",
      "\n",
      "    def get_stamp(self, name):\n",
      "        name  = name.strip(\"-\")\n",
      "        mname = name + \"_stamp\"\n",
      "\n",
      "        # Try to find method table first\n",
      "        if hasattr(self, mname):\n",
      "            method = getattr(self, mname)\n",
      "            return method()\n",
      "\n",
      "        # Try to use the format string with local timezone\n",
      "        if name in self.formats:\n",
      "            return self._local_format(self.formats[name])\n",
      "\n",
      "        return None\n",
      "\n",
      "    def print_stamp(self, name):\n",
      "            stamp = self.get_stamp(name)\n",
      "            if stamp:\n",
      "                print stamp\n",
      "            else:\n",
      "                print \"No stamp format for name %s\" % name\n",
      "\n",
      "    def help_stamp(self):\n",
      "\n",
      "        output = [\"Prints a timestamp represented with a format.\",\n",
      "                  \"\",\n",
      "                  \"The formats are stored in a lookup table with names, that\",\n",
      "                  \"you can pass to the function. For instance, if you pass the\",\n",
      "                  \"following arguments, you'll get the following results:\",\n",
      "                  \"\"]\n",
      "\n",
      "        for name in ('--code', '--json'):\n",
      "            output.append(\"\\t%s: %s\" % (name, self.get_stamp(name)))\n",
      "    \n",
      "        output.append(\"\")\n",
      "        output.append(\"The current formats are:\")\n",
      "        output.append(\"\")\n",
      "\n",
      "        for item in self.formats.items():\n",
      "            output.append(\"\\t%s: \\\"%s\\\"\" % item)\n",
      "        output.append(\"\")\n",
      "\n",
      "        output.append(\"Note that the timezone will default to the system timezone unless\")\n",
      "        output.append(\"The format requires a UTC or other timezone (like JSON)\")\n",
      "        output.append(\"\")\n",
      "\n",
      "        return \"\\n\".join(output)\n",
      "\n",
      "    def json_stamp(self):\n",
      "        return self._utc_format(self.formats['json'])\n",
      "\n",
      "\n",
      "if __name__ == \"__main__\":\n",
      "\n",
      "    clock = Clock()\n",
      "    clock.print_stamp(\"code\")\n"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [],
     "language": "python",
     "metadata": {},
     "outputs": []
    }
   ],
   "metadata": {}
  }
 ]
}