2. The Basics of Programming (with Python).ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# The Basics of Programming"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Objectives"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "By the end of this lesson you will:\n",
    "- Be able to understand and implement basic concepts in programming, including boolean logic, control flow, and for/while loops\n",
    "- Be able to create functions\n",
    "- Understand what it means that Python is a multi-paradigm language\n",
    "- Understand the basics of Object-Oriented Programming (OOP)\n",
    "- Start to grasp some of the nuances in language and various programming concepts"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id='toc'></a>\n",
    "## Table of Contents"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- [Boolean Logic](#boolean)\n",
    "- [Control Flow](#control)\n",
    "- [Loops](#loops)\n",
    "- [Python as a Multi-Paradigm Language](#multiparadigm)\n",
    "- [Functions](#functions)\n",
    "- [Object-Oriented Programming](#oop)\n",
    "- [Appendix](#appendix)\n",
    "- [Citations and Resources](#citations)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id='boolean'></a>\n",
    "## Boolean Logic\n",
    "([Back to the Table of Contents](#toc))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Computers are built on top of bits. Each bit is binary. That is, it can express one of two states: it can be either \"on\" or \"off\".\n",
    "\n",
    "All of programming is built on this principle. That is, all code is a sequence of statements, and each statement can be evaluated to one of two states: True or False (which can be represented as 1 or 0).\n",
    "\n",
    "To evaluate a statement, we use a double equal sign (==). Note, this is a convention because Python (and most languages) use a single equal sign to store data in a name (e.g., x = 5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "5 == 5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "0 == 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "You can also use this in math since True is represented by 1 and False is represented by 0."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(5 == 5) + 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "bool"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# But notice the data type is not a numeric type\n",
    "type(True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Comparison Operators"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There are six comparison operators in Python:  \n",
    "== (equal to)  \n",
    "`>` (greater than)  \n",
    "`<` (less than)  \n",
    "`>`= (greater than or equal to)  \n",
    "`<`= (less than or equal to)  \n",
    "`!=` (not equal to)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "5 > 4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "5!= 5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = 15\n",
    "x < 10"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Logical Operators"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In addition to comparison operators, there are three logical operators: *and*, *or*, and *not*.\n",
    "\n",
    "If you are familiar with logic in math, these should be intuitive. If not, you should know that an *and* statement is true if and only if all conditions in the statement are individually true. An *or* statement is true if at least one condition in the statement is individually true. *not* negates whatever follows."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "True and True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "True and False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "False and False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "True or True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "True or False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "False or False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "not True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "True and not True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "True and (False and not True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# More practically:\n",
    "1 == 1 and 5 == 5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1 == 2 or 5 == 5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id='control'></a>\n",
    "## Control Flow\n",
    "([Back to the Table of Contents](#toc))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now that you have grasped boolean logic, we can use this in implementing code.\n",
    "\n",
    "Say that you want something to happen *if* a condition is met. You can implement this with an *if-else* construction."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello\n"
     ]
    }
   ],
   "source": [
    "if 5 == 5:\n",
    "    # make sure to indent (an indent can be a tab or, \n",
    "    # preferably, four spaces)\n",
    "    print(\"Hello\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# This won't print anything because the condition is not true\n",
    "if 1 == 2:\n",
    "    print(\"Hello\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello\n"
     ]
    }
   ],
   "source": [
    "# But this will\n",
    "if 1 == 2 or 5 == 5:\n",
    "    print(\"Hello\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Goodbye\n"
     ]
    }
   ],
   "source": [
    "# Okay, so this won't be true, so we'll add an \"else\" statement -- \n",
    "# something for the code to do in case of failure\n",
    "if 1 == 2:\n",
    "    print(\"Hello\")\n",
    "# You can write as many statements after the \"if\" condition as you'd \n",
    "# like. once you're done, delete the indent\n",
    "else:\n",
    "    print(\"Goodbye\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x is 1\n"
     ]
    }
   ],
   "source": [
    "# Finally, let's add an \"elif\" statement. This allows our code the \n",
    "# option to do more than two things (because there may be more than \n",
    "# two outcomes!)\n",
    "x = 1\n",
    "if x == 0:\n",
    "    print (\"x is 0\")\n",
    "elif x == 1:\n",
    "    print(\"x is 1\")\n",
    "elif x > 1:\n",
    "    print(\"x is greater than 1\")\n",
    "else:\n",
    "    print(\"x is less than 0\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id='loops'></a>\n",
    "## Loops\n",
    "([Back to the Table of Contents](#toc))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Loops are the first thing people learn when programming where they really appreciate for the first time what concrete tasks a little bit of code can do to make their life immediately easier. They help us easily complete tasks that are otherwise routine and would take humans much longer to complete on his or her own.\n",
    "\n",
    "A loop executes a line of code until a condition is met. The genius of loops is that while the predicate or \"verb\" is the same (you are running the same function or set of functions), you can change the \"noun\" that those \"verbs\" are acting on."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### For Loops"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's say we want to print the first 10 letters of the alphabet, with one letter on each line. This is a repetitive task. We are doing the same thing over and over again (printing), but we are changing the thing we want to print (a letter).\n",
    "\n",
    "One option is to write 10 lines of code:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A\n",
      "B\n",
      "C\n",
      "D\n",
      "E\n",
      "F\n",
      "G\n",
      "H\n",
      "I\n",
      "J\n"
     ]
    }
   ],
   "source": [
    "print(\"A\")\n",
    "print(\"B\")\n",
    "print(\"C\")\n",
    "print(\"D\")\n",
    "print(\"E\")\n",
    "print(\"F\")\n",
    "print(\"G\")\n",
    "print(\"H\")\n",
    "print(\"I\")\n",
    "print(\"J\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "However, you can greatly simplify this by writing a for loop as follows:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A\n",
      "B\n",
      "C\n",
      "D\n",
      "E\n",
      "F\n",
      "G\n",
      "H\n",
      "I\n",
      "J\n"
     ]
    }
   ],
   "source": [
    "letters = [\"A\", \"B\", \"C\", \"D\", \"E\", \"F\", \"G\", \"H\", \"I\", \"J\"]\n",
    "for letter in letters:\n",
    "    # Like if-statements, you must indent after the for-condition \n",
    "    # and you can write as many statements as you'd like\n",
    "    print(letter)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**NOTE:**  \n",
    "A lot of beginners have trouble with this syntax: **for letter in letters**.  \n",
    "What this is saying is that for every element in the object \"letters\", do something. I didn't have to use the word **letter**. I could have picked **element** or **foo** or **i**. It doesn't matter. But once I pick a specific name, I can use that name to call the element. \n",
    "\n",
    "So once I've said that we are going to call each element in the list \"letter\", printing \"letter\" will print the current element that we are iterating over in the list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n",
      "6\n",
      "7\n",
      "8\n",
      "9\n"
     ]
    }
   ],
   "source": [
    "# Here's another neat trick. \"range\" is a built-in function that \n",
    "# creates a list starting with and going up to (but not including) \n",
    "# two numbers you pass to the function\n",
    "for i in range(0, 10):\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "2\n",
      "4\n",
      "6\n",
      "8\n"
     ]
    }
   ],
   "source": [
    "# You can even combine for-loops and if-statements\n",
    "for i in range(0,10):\n",
    "    # If the remainder of i divided by 2 is 0 (i.e., if i is even), \n",
    "    # then print\n",
    "    if i%2 == 0:\n",
    "        print(i)\n",
    "    else:\n",
    "        pass"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### While loops"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "While loops are very dangerous. A lot of programmers dislike them since you can usually do what you want with a for loop if you're smart, which makes them needlessly dangerous as you can really break things with a while loop.\n",
    "\n",
    "While loops go on until the condition is met. So, if you write a while loop, you better *know* that the condition will be met. Else, your computer might crash."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n",
      "6\n",
      "7\n",
      "8\n",
      "9\n"
     ]
    }
   ],
   "source": [
    "# Here's the classic example: print i while i is less than some \n",
    "# number, then increment up\n",
    "# Note that we define i *before* the loop begins, and within the \n",
    "# loop we create a condition that will ensure that the loop will \n",
    "# eventually end\n",
    "i = 0\n",
    "while i < 10:\n",
    "    print(i)\n",
    "    i = i + 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n",
      "6\n",
      "7\n",
      "8\n",
      "9\n"
     ]
    }
   ],
   "source": [
    "# Incrementing is very common so there's an easier way to do it:\n",
    "i = 0\n",
    "while i < 10:\n",
    "    print(i)\n",
    "    i += 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id='multiparadigm'></a>\n",
    "## Python as a multi-paradigm language\n",
    "([Back to the Table of Contents](#toc))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As far as I can tell, there are three or four dominant programming paradigms, or theories for how computer programs should be structured. Many languages are built to advantage one paradigm over another. However, Python is a multi-paradigm language, meaning that programmers with different philosophies for building programs can build using methods most comfortable for them. \n",
    "\n",
    "[This](https://blog.newrelic.com/2015/04/01/python-programming-styles/) post is pretty great for understanding the four dominant paradigms Python supports, but I'll focus on three:\n",
    "\n",
    "1. **Imperative and Procedural Programming** When you first start programming, this feels like the most intutitive or natural way to code. Often, we start with some data, feed it to the algorithm, which in turn performs some series of steps on that data, and, finally, returns a result. Imperative programming is clean and extremely easy to follow, but it can be slower and, to some extent, less generalizable than programs built using other paradigms (Procedural is similar but modulizes much of these algorithms).\n",
    "2. **Object-Oriented Programming** OOP is one of the first things you learn in Python, primarily because everything in Python (lists, dictionaries, classes, etc) are objects. These objects have their own characteristics and we can take advantage of these fixed characteristics to produce generalizable code. More on this below.\n",
    "3. **Functional Programming** This is the one I'm least comfortable with, but I'm starting to see that it can be incredibly useful. Functional programming treats every statement like a mathematical functon. That is, each line tells the program *what* to do, not *how* to do it. More on this in the \"Intermediate Concepts in Python\" notebook.\n",
    "\n",
    "I would be lying if I said I really understood the difference between these four as well as I should, but these are terms I run into often and think it's important to understand the gist of what they mean."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id='functions'></a>\n",
    "## Functions\n",
    "([Back to the Table of Contents](#toc))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Functions are certainly the soul of procedural programming, but they are vital across all of the core paradigms we have discussed so far.\n",
    "\n",
    "We have primarily worked with a single function thus far: *print*. In practice, there are thousands of functions written by users that you have at your disposal. Furthermore, if you find yourself doing something over and over again, you can even write your own function.\n",
    "\n",
    "A function is a block of executable code. I think of it as a \"verb\". This block of code performs the same steps every time it is called. It is most useful when it causes *something* to be done to objects you have created and passed to the function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Just so that we get the syntax, let's write a simple function that \n",
    "# just prints \"Hello, world\". The first line creates a function of \n",
    "# some name and every subsequent, indented line says what to do.\n",
    "# This just defines the function, but it doesn't actually execute it\n",
    "def printHelloWorld():\n",
    "    print(\"Hello, world\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello, world\n"
     ]
    }
   ],
   "source": [
    "# You then call the function to actually execute\n",
    "printHelloWorld()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Okay, that was really simple. It's also not particularly useful. You could've just passed **print(\"Hello, world\")** directly to the console.\n",
    "\n",
    "Functions are powerful because you can pass different arguments to them and Python will then execute that function on whatever arguments you pass. Let's see this in action:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# This time, we are going to tell Python that the function should \n",
    "# take a single \"parameter\". This \"parameter\" will be known as \n",
    "# \"word\". So every time Python sees \"word\" inside of the function, \n",
    "# it knows that we are actually talking about whatever argument we \n",
    "# passed to printWord.\n",
    "def printWord(word):\n",
    "    print(word)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello\n"
     ]
    }
   ],
   "source": [
    "# We pass the argument \"Hello\" to the function printWord. As \n",
    "# mentioned above, printWord stores the value \"Hello\" in \n",
    "# the name \"word\". So, when Python is told to \"print(word)\" it reads \n",
    "# print(\"Hello\")\n",
    "printWord(\"Hello\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Goodbye\n"
     ]
    }
   ],
   "source": [
    "printWord(\"Goodbye\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Okay, let's move away from print. Let's do some arithmetic."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def addTwo(x, y):\n",
    "    # Below we have a docstring. It simply tells readers what the \n",
    "    # fuction does. That is, this line is not executed. More on \n",
    "    # this when we discuss classes.\n",
    "    \"\"\"This function sums two numbers together\"\"\"\n",
    "    # Well, we're not getting entirely away from printing...\n",
    "    print(x + y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "8\n"
     ]
    }
   ],
   "source": [
    "addTwo(5, 3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "74691789\n"
     ]
    }
   ],
   "source": [
    "addTwo(124324, 74567465)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Let's change our function slightly. Instead of printing, let's \n",
    "# just return the value.\n",
    "def addTwo(x, y):\n",
    "    return x + y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# This time, it would do nothing if we were working from the shell, \n",
    "# but Jupyter notebook displays the output anyway\n",
    "addTwo(3, 5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# But, this time, we can also store the value in a variable name\n",
    "result = addTwo(3, 5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "8\n"
     ]
    }
   ],
   "source": [
    "print(result)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2.0"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "result/4"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id='oop'></a>\n",
    "## Object-Oriented Programming\n",
    "([Back to the Table of Contents](#toc))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Overview"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Object-Oriented Programming is a programming paradigm where data are treated as \"objects\". These objects have attributes and can also \"do\" things (these things that they \"do\" are called \"methods\").\n",
    "\n",
    "OOP is useful because of its ability to tie the abstract and the concrete. In OOP, you often create a blueprint of an idea in a \"class.\" Then you can create specific instances of that class. In this way, you can have generalizable code that can be reused for specific tasks."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Classes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Classes as being the essence of OOP. But what is a class? It's hard for me to explain in the abstract, but I'll try before getting into concrete examples. A \"class\" is some [\"logical grouping of data and functions.\"](https://jeffknupp.com/blog/2014/06/18/improve-your-python-python-classes-and-object-oriented-programming/)\n",
    "\n",
    "Classes are generic blueprints that you can use to create objects. Within these classes, you can assign attributes to each *instance* of an object (instance is the technical term and something I'll try and flesh out below; for now, I think you can understand what I mean from the way the word is used in this sentence).\n",
    "\n",
    "Okay, that was vague and abstract. Let's start with some examples."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Our first class"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is a bit complicated, so unlike everything we've done up to this point, I'm going to do some explaining before sharing the (commented) code. \n",
    "\n",
    "Below, we will create a class generically called \"Dog\". \n",
    "\n",
    "We want to give this class some *data attributes*, like name, breed, and weight.\n",
    "\n",
    "We also want to give this class some *method attributes*, like the ability to bark. More on these attributes in a moment.\n",
    "\n",
    "Below, you'll see the same set of code twice, but once without and once with comments.\n",
    "\n",
    "Note: some people like introducing classes and other concepts by using generic words like \"foo\" or \"bar\" for the class and function names. I think this is useful, but I think it's important to think of some concrete examples when seeing classes for the first time (though I recognize this can be limiting and may give you the impression that classes are more limited than they are)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "class Dog(object):\n",
    "    \"\"\"Creates a dog with a some attributes\"\"\"\n",
    "    \n",
    "    def __init__(self, name, breed, weight):\n",
    "        self.name = name\n",
    "        self.breed = breed\n",
    "        self.weight = weight\n",
    "        \n",
    "    def bark(self):\n",
    "        print(\"Woof!\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Assert that we are creating a class called \"Dog\", \n",
    "# which is an object; more on the stuff instide the parentheses later\n",
    "class Dog(object):\n",
    "    # It is good practice to include some notes (called a docstring) \n",
    "    # on what the class is. This is good practice when creating \n",
    "    # functions, too. Triple quotes allow you to span multiple \n",
    "    # lines (single quotes have to take place on the same line)\n",
    "    # Even in cases where the comment can be written in one line, \n",
    "    # it's convention to use triple quotes for docstrings\n",
    "    \"\"\"Creates a dog with a some attributes\"\"\"\n",
    "    \n",
    "    # This initializes the class. When you do this, you must pass \n",
    "    # the name, breed, and weight of the dog\n",
    "    # \"self\" is the instance of \"Dog\" you invoke (explained further below)\n",
    "    def __init__(self, name, breed, weight):\n",
    "        self.name = name\n",
    "        self.breed = breed\n",
    "        self.weight = weight\n",
    "    \n",
    "    # Create a method (a function defined within a class), \n",
    "    # basically some verb performed on or by the class\n",
    "    def bark(self):\n",
    "        print(\"Woof!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "First, note that nothing happened. All we've done is create a blueprint for Dog -- we have not created a Dog (capitalizing it to make clear that this is a class; we could substitute anything for the word \"Dog\").\n",
    "\n",
    "Second, note that when we create a function inside a class, we call it a method attribute (almost always referred to simply as a method). More on this soon, but for now just know that a method is just a function. \n",
    "\n",
    "Okay, let's go ahead and create an *instance* of Dog."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# We can create an instance by passing the name, breed, and \n",
    "# weight of a specific Dog\n",
    "mydog = Dog(\"Spot\", \"Dalmation\", 60.0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<__main__.Dog object at 0x0000000005588C50>\n"
     ]
    }
   ],
   "source": [
    "# See that mydog is a Dog object, or an instance of Dog\n",
    "print(mydog)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Attributes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Attributes are, well, attributes of a class. You can identify them because they follow the syntax [object name].[attribute name].\n",
    "\n",
    "Data attributes come from __init__, while method attributes come from functions defined within classes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Spot'"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Call a data attribute\n",
    "mydog.name"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Woof!\n"
     ]
    }
   ],
   "source": [
    "# Call a method attribute\n",
    "mydog.bark()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### More on self"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Okay, so what is the deal with \"self\"? It's just a substitute for the instance (e.g., \"mydog\") of the class. To wrap your head around this, first notice the connection between the line to create an instance of mydog\n",
    "\n",
    ">**mydog = Dog(\"Spot\", \"Dalmation\", 60.0)**\n",
    "\n",
    "and the code we write to initialize the class\n",
    "\n",
    ">**def `__init`__ (self, name, breed, weight):**\n",
    "\n",
    "The first item we pass (\"Spot\") is stored in the name \"name\", the second item (\"Dalmation\") is stored in the name \"breed\", and so on.\n",
    "\n",
    "Where does \"self\" come from? Python implicitly passes it. Imagine that the following is actually happening:\n",
    "\n",
    ">**mydog = Dog(mydog, \"Spot\", \"Dalmation\", 60.0)**\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "So, whenever Python reads \"self\" in the class definition, it understands that we are talking about the specific instance of the class. Now, this line of code makes a lot more sense:\n",
    "\n",
    ">**self.name = name**\n",
    "\n",
    "In other words, whenever we call \"instance.name\" (in this case, \"mydog.name\"), we should get whatever it is we passed to the name when instantiating the object mydog."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### A few other notes on the basics"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "I wrote the code above in the hopes that you could generalize the concept by looking at a specific example, rooted in real world relationships between objects. I do want to abstract a little, however.\n",
    "\n",
    "Let's change how the class stores the items we pass to it. Instead of calling the first item \"name\", let's call it \"foo\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "class Dog(object):\n",
    "    \"\"\"Creates a dog with a some attributes\"\"\"\n",
    "    \n",
    "    def __init__(self, foo, bar, foobar):\n",
    "        self.name = foo\n",
    "        self.breed = bar\n",
    "        self.weight = foobar\n",
    "        \n",
    "    def bark(self):\n",
    "        print(\"Woof!\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Spot'"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Observe that it works exactly the same way\n",
    "mydog = Dog(\"Spot\", \"Dalmation\", 60.0)\n",
    "mydog.name"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "So, what happened? The first item we passed is now called \"foo\", but we are still storing whatever is in \"foo\" as self.name (which, as we mentioned, is just mydog.name)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Class Inheritance"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Often, you will want to create a new class that shares much of the behavior of one class, and deviates or adds to it in other ways.\n",
    "\n",
    "Consider the case where we want a class for Animal, but we also want subclasses for Dog or Cat. Dog and Cat can \"inherit\" attributes or methods from Animal, while also having their own attributes and methods."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# Animal is an object...\n",
    "class Animal(object):\n",
    "    def __init__(self, name, weight):\n",
    "        self.name = name\n",
    "        self.weight = weight\n",
    "\n",
    "# But Dog is not just any object -- it is an Animal object       \n",
    "# We are creating a new function unique to Dog, but it will also\n",
    "# have Animal attributes\n",
    "class Dog(Animal):\n",
    "    def bark(self):\n",
    "        print(\"Woof!\")\n",
    "\n",
    "# Same with Cat\n",
    "class Cat(Animal):\n",
    "    def meow(self):\n",
    "        print(\"Meow!\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Spot'"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Create an instance of Animal and get name attribute\n",
    "myanimal = Animal(\"Spot\", 80)\n",
    "myanimal.name"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Spot\n",
      "80\n"
     ]
    }
   ],
   "source": [
    "# Now create a Dog instance and see if it has the same attributes\n",
    "mydog = Dog(\"Spot\", 80)\n",
    "print(mydog.name)\n",
    "print(mydog.weight)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Woof!\n"
     ]
    },
    {
     "ename": "AttributeError",
     "evalue": "'Animal' object has no attribute 'bark'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mAttributeError\u001b[0m                            Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-54-9d8557d636ae>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[1;31m# But the method **bark** is unique to Dog\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m      2\u001b[0m \u001b[0mmydog\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mbark\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[0;31m \u001b[0mmyanimal\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mbark\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mAttributeError\u001b[0m: 'Animal' object has no attribute 'bark'"
     ]
    }
   ],
   "source": [
    "# But the method **bark** is unique to Dog\n",
    "mydog.bark()\n",
    "myanimal.bark()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Garfield\n",
      "Meow!\n"
     ]
    },
    {
     "ename": "AttributeError",
     "evalue": "'Dog' object has no attribute 'meow'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mAttributeError\u001b[0m                            Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-55-6c6fec642bd7>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      3\u001b[0m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mmycat\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mname\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m      4\u001b[0m \u001b[0mmycat\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mmeow\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m----> 5\u001b[0;31m \u001b[0mmydog\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mmeow\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mAttributeError\u001b[0m: 'Dog' object has no attribute 'meow'"
     ]
    }
   ],
   "source": [
    "# Same with Cat and meowing\n",
    "mycat = Cat(\"Garfield\", 30)\n",
    "print(mycat.name)\n",
    "mycat.meow()\n",
    "mydog.meow()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id='appendix'></a>\n",
    "## Appendix\n",
    "([Back to the Table of Contents](#toc))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Functions and Methods"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A function is a block of code that allows you to execute the same lines of code every time the function is invoked.\n",
    "\n",
    "This is helpful because you usually want to do the same verb to different *things*. For example, you may want to sum one set of numbers, and later sum a different set of numbers. So you want a function that easily sums whatever you pass to the function.\n",
    "\n",
    "A method is simply a function, but it is one defined within a class.\n",
    "\n",
    "So, given everything we've done so far, passing \n",
    "\n",
    "> **bark()**\n",
    "\n",
    "won't do anything since bark is not a built-in function (i.e., one that is in the local environment for all Python scripts) or one we've defined ourselves, but passing \n",
    "\n",
    ">**mydog.bark()**\n",
    "\n",
    "will since bark was defined as a method of Dog (and mydog is an instance of Dog).\n",
    "\n",
    "For more on this, see the discussion of scope below."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Classes and Instances"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A class is a blueprint for some logical grouping of ideas. While we have gone over examples that make sense in real life (e.g., animal, dog), this could be something that does not map to a concept in the physical world.\n",
    "\n",
    "An instance is the specific *thing* created using the blueprint. I.e., using the blueprint, we created a specific object called \"mydog\" that represented an instance of a Dog."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Scripts, Modules, Packages, and Libraries"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A **script** should be straightforward. This is a single .py file that you execute to do some thing. The HelloWorld.py file we created would be an example of a script.\n",
    "\n",
    "A **module** is a single Python script that contains class and function definitions. For example, you might create a module called math.py which creates functions that sum, substract, multiply, and divide (but doesn't actually execute any of these functions).\n",
    "\n",
    "We *import* modules at the top of our scripts so we can use whatever it is (typically classes and functions) defined in those modules.\n",
    "\n",
    "A **package** is a collection of modules that share a namespace (more on this below). The rough analogy: if you think of a folder that contains a bunch of files, a folder would be a package, and all the files would be modules.\n",
    "\n",
    "**Library** is not a clearly defined term; rather, it is one that is commonly and casually used. People tend to use \"library\" to refer to published packages or a collection of packages that share some common purpose (I think pandas is technically a package, but people often refer to it as a library)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Arguments and Parameters"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "People tend to use these interchangeably, but let's be precise here.\n",
    "\n",
    "A *parameter* is a variable in the function or method declaration.\n",
    "\n",
    "> ** def foo (a, b, c):**\n",
    "\n",
    "Here, a, b, and c are parameters.\n",
    "\n",
    "An *argument* is a variable we pass to the function.\n",
    "\n",
    "> **foo(d, e, f)**\n",
    "\n",
    "When we call **foo**, we pass d, e, and f as arguments.\n",
    "\n",
    "So, **foo** takes three parameters. And we can pass three arguments to foo."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Namespaces and Scope"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Namespaces"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Think of a namespace as a (Python) dictionary. This is not an analogy: namespaces are implemented as dictionaries.\n",
    "\n",
    "A namespace maps names to objects. So, when you invoke a name in a namespace, you can access a specific object. For instance, **sum** maybe be a function in a certain namespace. Invoking **sum** will give you access to that function.\n",
    "\n",
    "(In your head so far, you should have a picture of something like **a_namespace_dictionary = {\"name\":object}**\n",
    "\n",
    "There can be many namespaces. Each namespace can have the same name mapped to different objects. **Multiply** can do one thing in one namespace, and something completely different in another (e.g., you can imagine how it would act differently in an arithmetic package and one that deals with matrices).\n",
    "\n",
    "This is important: the same name in different namespaces are completely unrelated."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Scope"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This brings us to scope. Namespaces have hierarchy: when the Python interpreter sees a name, it starts looking for the name you have invoked in some specific namespace and moves on to others when trying to map a name to an object.\n",
    "\n",
    "Let's think of a couple of examples. Let's extend the example we made above. \n",
    "\n",
    "Say we have a built-in function called multiply so that:\n",
    "\n",
    "> **multiply(2, 3)**  \n",
    "> **\\> 6**\n",
    "\n",
    "But let's say there is a linear algebra library called **linearalgebra** (completely made up package) that multiplies two matrices together. In the following example we have two 3 x 3 matrices stored as *matrix1* and *matrix2*. In order to perform matrix multiplication we would have to do something like:\n",
    "\n",
    "> **import linearalgebra**  \n",
    "> **linearalgebra.multiply(matrix1, matrix2)**\n",
    "\n",
    "There are a lot of ways where this can go wrong. While I was reviewing this tutorial, I stumbled across this tweet:\n",
    "\n",
    "<img src=\"Screenshots/scope.png\" alt=\"Terminal\" style=\"width: 400px;\"/>\n",
    "\n",
    "Essentially Python had access to two sum functions and got confused about which one it should use (which is why you should always **import numpy** or **from numpy import sum** and then invoke the specific method using **numpy.sum**)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Other concepts"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the appendix for the \"Intermediate Concepts in Python\" notebook, I will also go over:\n",
    "* Underscores in certain names\n",
    "* Compiled vs Interpreted languages\n",
    "* High vs low level languages\n",
    "* Lazy evaluation"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "<a id='citations'></a>\n",
    "## Citations and Resources\n",
    "([Back to the Table of Contents](#toc))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To ensure that I was using the most accurate language (and to help me better wrap my head around these ideas), I often consulted with Python's official [tutorial](https://docs.python.org/3/tutorial/index.html). This is an invaluable resource and you should regularly refer to it!\n",
    "\n",
    "I also relied a lot on the following answers:\n",
    "\n",
    "- Different programming paradigms: [The New Relic blog](https://blog.newrelic.com/2015/04/01/python-programming-styles/)\n",
    "- Help clarifying various elements throughout OOP introduction: [Jeff Knup's blog](https://jeffknupp.com/blog/2014/06/18/improve-your-python-python-classes-and-object-oriented-programming/)\n",
    "- Clarifying between modules and packages: [StackOverflow](https://stackoverflow.com/questions/19198166/whats-the-difference-between-a-module-and-a-library-in-python)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# END OF FILE"
   ]
  }
 ],
 "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.6.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}