Introduction to Python.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Introduction to Python"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python is an awesome, powerful, and easy to learn programming language. We're going to start from some basic concepts, and within a half hour you will know enough Python to code your own simulations!\n",
    "\n",
    "This course definitely isn't intended to be a comprehensive tutorial on Python (we'd need a LOT more than 2 hours for that), but it will teach you enough to jump right into the thick of things!\n",
    "\n",
    "For those of you that have no programming experience, have no fear! Everything we will teach you will not be difficult to grasp every for complete beginners. If you've already had experience with Python before, feel free to skip this section and play around with the exercises."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Variables"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "All the work you do in programming will rely on variables. In math, a variable can stand for any number. \n",
    "\n",
    "This is similar in Python, but a variable in Python can be more than *x* or *y*: in fact, a variable name can be almost any word. Plus, variables can represent more than numbers: they can hold many different types of data, including *integers*, *floats* (noninteger numbers!), *booleans* (true/false), *strings* (words), *lists*, and other arbitrary objects.\n",
    "\n",
    "We can create a variable and assign a value to it by typing in \"*var_name* = *value*\".\n",
    "\n",
    "Let's try it out below!\n",
    "\n",
    "Put your cursor in the code blocks below and press \"Ctrl-Enter\" to run the code. You can also change the code in the block and rerun it to see how your changes affect the output!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The value of foo is 5\n"
     ]
    }
   ],
   "source": [
    "#This is a comment. Code on commented lines doesn't run, so you can type whatever you want here!\n",
    "\n",
    "#Let's create a variable called \"foo\" and assign it the value 5\n",
    "foo = 5\n",
    "\n",
    "#Let's check that five is telling the truth about it's value\n",
    "#In python, you can use \"print var\" to output the value of \"var\"\n",
    "print \"The value of foo is\", 5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### The Print Statement\n",
    "Before we continue, let's talk a bit more about **print**.\n",
    "The **print** statement in Python lets you output stuff to the console so you can see what your program is doing! As you can imagine, this can be pretty useful.\n",
    "\n",
    "To print a string, just type **print \"Your string here\"**\n",
    "\n",
    "To print the value of a variable, type **print var_name**\n",
    "\n",
    "To print the value of a variable along with a string like we did above, you should separate the string(s) and variable(s) with commas: \n",
    "**print \"String part\",var_name1,\"String part 2\", var_name2 **\n",
    "\n",
    "Now let's create a few more variables with different types"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "i_am_a_float: 0.333333333333\n",
      "i_am_a_string: Hello World!\n",
      "i_am_a_boolean: True\n",
      "i_am_a_list: [1, 2, 3]\n",
      "The third element of i_am_a_list: 3\n"
     ]
    }
   ],
   "source": [
    "#Create a variable with a noninteger number\n",
    "i_am_a_float = 1.0/3.0\n",
    "#Create a variable with a string\n",
    "i_am_a_string = \"Hello World!\"\n",
    "#Create a variable that holds a boolean\n",
    "i_am_a_boolean = True\n",
    "#Create a variable that holds a list\n",
    "i_am_a_list = [1,2,3]\n",
    "\n",
    "print \"i_am_a_float:\", i_am_a_float\n",
    "print \"i_am_a_string:\", i_am_a_string\n",
    "print \"i_am_a_boolean:\", i_am_a_boolean\n",
    "print \"i_am_a_list:\", i_am_a_list\n",
    "\n",
    "#Let's also get the third element of the list we created. We can access\n",
    "#list elements by using bracket notation: the number in the bracket\n",
    "#is the index of the element we want to access, starting from zero.\n",
    "#Thus the first element is list[0], the second list[1], the third list[2], etc . . .\n",
    "print \"The third element of i_am_a_list:\", i_am_a_list[2]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also reassign variables to hold different values: the new value might even be a completely different type!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": false,
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "foo has value 5\n",
      "foo now has value 7\n",
      "foo finally has value I am a string!\n"
     ]
    }
   ],
   "source": [
    "#Create a variable foo with the value 5\n",
    "foo = 5\n",
    "#Check foo's value\n",
    "print \"foo has value\", foo\n",
    "#Reassign foo to hold a different number\n",
    "foo = 7\n",
    "#Check foo's value again\n",
    "print \"foo now has value\", foo\n",
    "#Let's make foo hold a string instead!\n",
    "foo = \"I am a string!\"\n",
    "print \"foo finally has value\", foo"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also reassign individual list elements using the same bracket notation we used to access them."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Hi', 'Hello', 'Hola', 'Oi', 'Ni Hao']\n",
      "['Hi', \"What's up\", 'Hola', 'Oi', 'Ni Hao']\n"
     ]
    }
   ],
   "source": [
    "my_list = [\"Hi\", \"Hello\", \"Hola\", \"Oi\", \"Ni Hao\"]\n",
    "print my_list\n",
    "my_list[1] = \"What's up\"\n",
    "print my_list\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Your Turn\n",
    "Now you should try it out. Create, reassign, and print a few variables to get a feel for how it works."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "foo = 5\n",
    "bar = True\n",
    "baz = [\"One\",\"Two\",\"Three\"]\n",
    "\n",
    "#Try printing the values of foo and bar and changing the values in baz\n",
    "#Also try adding values to baz by calling \"baz.append(value)\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Control Flow\n",
    "\n",
    "To do anything more complicated than just moving around variables, we need a way to control our program's execution. We can do this with control flow statements: if-else blocks and loops.\n",
    "\n",
    "### Conditional Execution\n",
    "If-else statements allow you to execute some code (which is indented, pushed to the right) if a condition is met, and other code if it is not.\n",
    "\n",
    "Note that in a single if-else block, the first condition that is met is executed, but the rest are skipped!\n",
    "\n",
    "In the following code blocks, try changing the values (True/False) of the variables and seeing what gets printed"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Control flow starts here\n",
      "The sky is blue!\n",
      "It doesn't matter if the sky is blue or not, we will always get here since it is outside of the if-else!\n"
     ]
    }
   ],
   "source": [
    "print \"Control flow starts here\"\n",
    "\n",
    "sky_is_blue = True\n",
    "\n",
    "if sky_is_blue:\n",
    "    #Only indented code is executed!\n",
    "    print \"The sky is blue!\"\n",
    "else:\n",
    "    print \"The sky isn't blue (knowing Boston, it's probably because it's snowing)\"\n",
    "\n",
    "print \"It doesn't matter if the sky is blue or not, we will always get here since it is outside of the if-else!\"\n",
    "    \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Things are as they should be ;)\n"
     ]
    }
   ],
   "source": [
    "sky_is_blue = True\n",
    "harvard_is_better_than_mit = False\n",
    "\n",
    "if harvard_is_better_than_mit:\n",
    "    #If we execute this block, we won't execute the else-if or the else that follows it\n",
    "    print \"Wrong!\"\n",
    "elif sky_is_blue:\n",
    "    #This only gets executed if harvard is not better than MIT AND the sky is blue\n",
    "    print \"Things are as they should be ;)\"\n",
    "else:\n",
    "    #This executes if neither of the above are true\n",
    "    print \"Neither of the conditions were true\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "collapsed": false,
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Bar was not equal to foo!\n",
      "Foo was 20 and bar was 5\n",
      "Foo was 20 and bar was 5\n"
     ]
    }
   ],
   "source": [
    "#We don't have to use Boolean variables in our conditions either! \n",
    "#We can use anything that evaluates to a boolean\n",
    "\n",
    "bar = 5\n",
    "foo = 20\n",
    "\n",
    "if bar == foo:\n",
    "    print \"Bar was equal to foo!\"\n",
    "else:\n",
    "    print \"Bar was not equal to foo!\"\n",
    "\n",
    "#We can also nest if statements: the print statement will only get executed if both conditions are met\n",
    "if bar == 5:\n",
    "    if foo == 20:\n",
    "        print \"Foo was 20 and bar was 5\"\n",
    "#We can accomplish the same thing as the nested print statement using \"and\"\n",
    "if bar == 5 and foo == 20:\n",
    "    print \"Foo was 20 and bar was 5\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Loops\n",
    "\n",
    "This is a super quick primer on loops\n",
    "\n",
    "##### For Loops\n",
    "for loops can be used to iterate over lists or for a fixed number of times"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "On iteration 0\n",
      "On iteration 1\n",
      "On iteration 2\n",
      "On iteration 3\n",
      "On iteration 4\n",
      "Checking One\n",
      "Checking Two\n",
      "Checking Three\n",
      "Found it!\n"
     ]
    }
   ],
   "source": [
    "number_of_iterations = 5\n",
    "list = ['One', 'Two', 'Three', 'Four']\n",
    "\n",
    "#Loop for a fixed number of iterations\n",
    "for i in range(number_of_iterations):\n",
    "    print \"On iteration\", i\n",
    "\n",
    "#Let's use a for loop to find a certain entry in the list, and exit the loop when it's found\n",
    "for entry in list:\n",
    "    print \"Checking\",entry\n",
    "    if entry == 'Three':\n",
    "        print \"Found it!\"\n",
    "        #Exit the loop\n",
    "        break"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### While Loops\n",
    "\n",
    "While loops will continue to run until the condition is no longer met: this can be dangerous! If your condition never stops being true (For example, your loop looks like *while True*), your loop will never end and your program will stall."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "126 is divisible by 42\n"
     ]
    }
   ],
   "source": [
    "#Let's a while loop to find the first number divisible by 42 over 100\n",
    "\n",
    "current = 100\n",
    "\n",
    "while not current % 42 == 0:\n",
    "    current = current + 1\n",
    "\n",
    "#This happens after we exit the loop\n",
    "print current, \"is divisible by 42\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Functions\n",
    "\n",
    "The last major concept you need to know about before we unleash you on problems is the function. Again, you may have heard of functions in math class: a function takes one or more numbers and turns them into a different number.\n",
    "\n",
    "Similarly, a Python function takes zero, one, or many inputs called **arguments**; performs some operation on them; and sometimes **returns** a value. Of course, these inputs and the return value don't have to be numbers! You can think of it as a building block of your program, sometimes because you use a lot, while others because it makes the code more readable.\n",
    "\n",
    "We can invoke or call a function by using its name: if the function returns a value, that value will replace the function call when the code is evaluated.\n",
    "\n",
    "Let's try defining and using a few functions in Python."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 + 2 = 3\n",
      "5 + -3 = 2\n",
      "1 + 2 + 3 = 6\n"
     ]
    }
   ],
   "source": [
    "#Let's create a function that adds two numbers together\n",
    "\n",
    "#This line names the function and how many inputs it has\n",
    "def add_numbers(number1, number2):\n",
    "    #Perform the operation\n",
    "    answer = number1 + number2\n",
    "    #Return the value\n",
    "    return answer\n",
    "\n",
    "#Let's try out the function\n",
    "print \"1 + 2 =\", add_numbers(1,2)\n",
    "print \"5 + -3 =\", add_numbers(5, -3)\n",
    "\n",
    "#We can nest function calls. Note that the inner function call is evaluated\n",
    "#Then the values are passed to the outer calls\n",
    "print \"1 + 2 + 3 =\", add_numbers(1, add_numbers(2,3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n",
      "None\n"
     ]
    }
   ],
   "source": [
    "#Some functions don't have to return anything!\n",
    "#We can create a function that just prints out an array on separate lines, for instance\n",
    "\n",
    "def print_array(arr1):\n",
    "    for entry in arr1:\n",
    "        print entry\n",
    "\n",
    "my_array = [1,2,3]\n",
    "        \n",
    "value = print_array(my_array)\n",
    "\n",
    "#value is None, since print_array doesn't return anything!\n",
    "print value"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 4, 3, 5]\n"
     ]
    }
   ],
   "source": [
    "#Finally, functions that are passed lists can modify the list that they are passed!\n",
    "#This is because lists are *mutable* data types (if you don't know what this means, don't worry! It won't be important today)\n",
    "\n",
    "def swap_indices(arr, index1, index2):\n",
    "    temp = arr[index1]\n",
    "    arr[index1] = arr[index2]\n",
    "    arr[index2] = temp\n",
    "    #We don't return anything here!\n",
    "\n",
    "my_array = [1,2,3,4,5]\n",
    "\n",
    "swap_indices(my_array, 2,3)\n",
    "#my_array has changed!\n",
    "print my_array"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here's an important point about functions and Python in general. Let's go back to our first function: add_numbers.\n",
    "\n",
    "We called the function **add_numbers** and called its arguments **number1** and **number2**, but we had no way of making sure they were actually numbers! In fact, this is one of the fundamental design decisions of Python. Variables are *not typed*, that is we have no way of knowing what kinds of data they actually hold beside being extra careful never to reassign them to a different type ourselves unless we mean to! This can cause big problems if we aren't careful.\n",
    "\n",
    "To make this specific, let's look back at the add_numbers function. This time, we'll try to break things."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "8\n"
     ]
    },
    {
     "ename": "TypeError",
     "evalue": "unsupported operand type(s) for +: 'int' and 'str'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-4-cc70978a0c44>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m()\u001b[0m\n\u001b[0;32m     10\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     11\u001b[0m \u001b[1;31m#What happens if we make one of the arguments a string instead?\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m---> 12\u001b[1;33m \u001b[1;32mprint\u001b[0m \u001b[0madd_numbers\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;36m5\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;34m\"3\"\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m     13\u001b[0m \u001b[1;31m#This throws an error! That's pretty bad.\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32m<ipython-input-4-cc70978a0c44>\u001b[0m in \u001b[0;36madd_numbers\u001b[1;34m(number1, number2)\u001b[0m\n\u001b[0;32m      2\u001b[0m \u001b[1;32mdef\u001b[0m \u001b[0madd_numbers\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mnumber1\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mnumber2\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      3\u001b[0m     \u001b[1;31m#Perform the operation\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 4\u001b[1;33m     \u001b[0manswer\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mnumber1\u001b[0m \u001b[1;33m+\u001b[0m \u001b[0mnumber2\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m      5\u001b[0m     \u001b[1;31m#Return the value\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      6\u001b[0m     \u001b[1;32mreturn\u001b[0m \u001b[0manswer\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;31mTypeError\u001b[0m: unsupported operand type(s) for +: 'int' and 'str'"
     ]
    }
   ],
   "source": [
    "#This line names the function and how many inputs it has\n",
    "def add_numbers(number1, number2):\n",
    "    #Perform the operation\n",
    "    answer = number1 + number2\n",
    "    #Return the value\n",
    "    return answer\n",
    "\n",
    "#This works as expected\n",
    "print add_numbers(5,3)\n",
    "\n",
    "#What happens if we make one of the arguments a string instead?\n",
    "print add_numbers(5, \"3\")\n",
    "#This throws an error! That's pretty bad.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "23\n"
     ]
    },
    {
     "ename": "TypeError",
     "evalue": "unsupported operand type(s) for /: 'str' and 'int'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-5-c48edeb56ba1>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m()\u001b[0m\n\u001b[0;32m      7\u001b[0m \u001b[1;31m#This could happen hundreds or thousands of lines later, and this WILL throw an error\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      8\u001b[0m \u001b[0mcount\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;36m10\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 9\u001b[1;33m \u001b[0maverage\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0msum\u001b[0m \u001b[1;33m/\u001b[0m \u001b[0mcount\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m     10\u001b[0m \u001b[1;31m#This can make troubleshooting very difficult!\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;31mTypeError\u001b[0m: unsupported operand type(s) for /: 'str' and 'int'"
     ]
    }
   ],
   "source": [
    "#But things could be even worse! What if we accidentaly pass in TWO strings?\n",
    "sum = add_numbers(\"2\",\"3\")\n",
    "#This isn't what we want!\n",
    "print sum\n",
    "\n",
    "#Even worse, we don't get an error. What if we use this sum somewhere else in the program\n",
    "#This could happen hundreds or thousands of lines later, and this WILL throw an error\n",
    "count = 10\n",
    "average = sum / count\n",
    "#This can make troubleshooting very difficult!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The takeaway here is that you should be careful about what datatypes you are assigning to each variable! Python won't check these things for you, so your program can appear to work fine until it suddenly explodes :)\n",
    "\n",
    "That wraps up our crash course in Python! If you have a little more time or already knew this stuff, go ahead and play around with the programs in the Gravity section while you wait."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 2",
   "language": "python",
   "name": "python2"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}