Programming-Concepts.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Part 1:  Programming Concepts"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Installation\n",
    "\n",
    "We're going to be installing several things that will give you a standard Python development envirionment, but use applications on top of it that are suitable for beginners.  This means you're set for exploration and experimentation, but you'll have something that will be appropriate if you continue on.\n",
    "\n",
    "## Step 1: Download and install this stuff\n",
    "\n",
    "* Download and install the Python 3.6 graphical installer of Anaconda from here: https://www.continuum.io/downloads\n",
    "* Download and install the PyCharm Education Edition:  https://www.jetbrains.com/pycharm-edu/download\n",
    "\n",
    "The Anaconda package will install Python and other helper packages.  It'll also place in some hooks/aliases in your computer to make working with Python easier (particularly for Windows users).  You will not directly interact with Anaconda.  You will use PyCharm to write and execute your scripts, but have it hooked to your Anaconda installation.  We'll walk you through this.\n",
    "\n",
    "## Step 2: Test Anaconda\n",
    "\n",
    "After Anaconda has finished installing, restart your computer.  Now we’ll test that everything worked.  You’ll be using anaconda the entire class, but it’ll be somewhat invisible to you.\n",
    "\n",
    "**Open your command line**\n",
    "\n",
    "* Windows users:  open up your Command Prompt application (in your system search bar, type in ‘cmd’ and an application will open up.  Youtube has videos explaining this more if you need it.\n",
    "\n",
    "* Mac users:  open your Terminal application. Either search via spotlight for ‘terminal’ or open it from Applications -> Utilities -> Terminal.  \n",
    "\n",
    "**Attempt to launch Python**\n",
    "\n",
    "Within your command line application, type in ‘python’ (without quotes) and press return.  \n",
    "* Windows users:  you should not get an error that it doesn’t know what Python is.\n",
    "* Mac users:  it should state it is Python 3.6 and not Python 2.7.\n",
    "\n",
    "Put up your help flag and halt progress here if you hit either error condition.  Otherwise, just close the window after this.  Everything has worked and you can move on to installing PyCharm Education edition.\n",
    "\n",
    "**Open PyCharm Education edition**\n",
    "\n",
    "* When you open it for the first time it’ll ask you what sort of project you want.  Select Create New Project.\n",
    "* On the next screen you’ll want change a few things:\n",
    "    1.\tSelect the Location where you want your project folder to exist on your computer.  I suggest putting it in your Documents folder.\n",
    "    2.\tChange Untitled to Humanities Data (or some other name of choice).\n",
    "    3.\tFor interpreter, this is where it gets weird.  \n",
    "        * Windows users, the drop down should show something like C:\\Anaconda\\python.exe.  Which you should select.  \n",
    "        * For mac users, you might see several.  You want the one that has anaconda in the file path.  E.g. ~/anaconda/bin/python.  Choose the one that has Python 3.6.x _Do not choose one that states Python 2.6 or 2.7_. You may need to click the … button and manually add where your ~/anaconda/bin/python exists.  \n",
    "\n",
    "**Make a Python script in PyCharm and try to run it**\n",
    "\n",
    "Don’t worry; you don’t need to know python yet. We’re just testing to see if everything is working.\n",
    "\n",
    "1. Right click on the name of your project on the left.  Select New -> Python file\n",
    "2. Name is something like ‘testing’\n",
    "3. You’ll now see an empty file in the main part of the PyCharm window\n",
    "4. Type in the following into that screen: `print(\"Hello world\")`\n",
    "5. A green \"play\" arrow should appear next to line 1 next to that text.  It may take a moment or two for the green button to appear.  That is completely normal and just PyCharm connecting to your anaconda installation.\n",
    "6. Click that green button!\n",
    "7. A new panel at the bottom of the program should appear, with text that starts with \"Hello world\". \"Process finished with exit code 0\" means that everything worked and is not something to worry about.  Looks weird, though, I know.\n",
    "\n",
    "**Mac Users:  test to be sure you've got the right version of Python installed**\n",
    "\n",
    "Sometimes it's possible to get PyCharm going on a mac with 2.7 rather than 3.6.  This is a simple test:\n",
    "\n",
    "1. Go back into your testing.py file that you just used.\n",
    "2. Change your line of test to `print 1 + 1`.\n",
    "3. Attempt to run it.\n",
    "4. In the bottom screen where the output is, you should either get:\n",
    "    * An error that says \n",
    "\n",
    "python\n",
    "File \"<ipython-input-1-28aa8a406b63>\", line 1\n",
    "    print 1 + 1\n",
    "          ^\n",
    "SyntaxError: Missing parentheses in call to 'print'\n",
    "\n",
    "**The error means that you have hooked PyCharm to the right version of Python and you're done!**\n",
    "\n",
    "**If you got the number 2, then you need to go back to the step where you are connecting Anaconda to the right interpreter.**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Programming languages versus software\n",
    "\n",
    "We're used to opening up software for specific tasks.  We work inside of highly stylized digital files that remove many traces of the digital-ness of these files and the computers. This makes sense.  We just want to get our jobs done.\n",
    "\n",
    "Software programs are all written by humans via programming languages.  Software packages are usually written to be a tool to solve a need or serve a purpose.  You can't usually hack something to do anything you want (although sometimes things are flexible enough that you can get away with it).  \n",
    "\n",
    "Programming languages are similar in this way, they are tools written out of other programming languages to solve a need or serve a purpose.  Some languages are designed for very specialized tasks, while others are more general purpose.  These languages are also written languages, so they each have their own linguistic style.\n",
    "\n",
    "\n",
    "## Programming languages can be classified into groups\n",
    "\n",
    "_Very_ roughly, programming languages can be described by their purpose and their style.\n",
    "\n",
    "Purpose:\n",
    "* Web languages (HTML, PHP, JavaScript, etc...)\n",
    "* Scripting (Python, Perl, R, etc...)\n",
    "* Software languages (Java, C++, etc...)\n",
    "\n",
    "Style:\n",
    "* Language syntax\n",
    "* Abstraction level\n",
    "* Methodological approach\n",
    "* etc...\n",
    "\n",
    "\n",
    "## That's neat, but what about Python?\n",
    "\n",
    "In this description universe, we can describe Python as:\n",
    "* A general purpose programming language, most commonly used for scripting\n",
    "* But with growing web and software design usage\n",
    "* A very high level language designed for clarity of expression\n",
    "\n",
    "![title](grid.png)\n",
    "\n",
    "\n",
    "## Points of interest in the Python biography\n",
    "\n",
    "* Created by Guido van Rossum\n",
    "    * Who is now the Benevolent Dictator for Life (BDFL)\n",
    "* Is open source\n",
    "    * Community maintained\n",
    "    * Features created by its users\n",
    "    * Adapts quickly to industry needs\n",
    "    * Free to use\n",
    "    * Consensus based development\n",
    "* Written the C language\n",
    "    * Everything written in Python is translated to C before being executed.\n",
    "    * This does make execution technically slower than in C, but this is rarely a problem unless you're doing computationally intensive scientific computing.\n",
    "* Was designed with a philosophy\n",
    "    * And this design philosophy is maintained by the community, with Guido's dictatorship.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# you can run this in PyCharm\n",
    "\n",
    "import this"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "🐦🐦🐦🐦🐦🐦🐦🐦🐦\n"
     ]
    }
   ],
   "source": [
    "# print(u'\\U0001F4D6')\n",
    "\n",
    "print(len(\"Elizabeth\") * u'\\U0001F426')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Python and why we are learning it"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## How the history of computing impacts programming languages"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![title](US-ASCII_code_chart.png)\n",
    "\n",
    "* Everything is numbers\n",
    "* Some of those numbers are displayed as letters.\n",
    "    * Those letters become words, and somtimes collected as documents.\n",
    "* Some of those numbers become the values for pixel colors.\n",
    "    * Those pixels become images, and some of those images are part of video.\n",
    "* Some of those numbers represent frequencies and sounds.\n",
    "    * Those sounds become audio recordings.\n",
    "* Meanwhile, computers need to have more messages than just letters.  Before we had the computers we understand as them now, there were Teletype machines.  These machines neded commands that controlled the physical printing process, so there are a series of [control characters](https://en.wikipedia.org/wiki/Control_character) that direct the machine how to work.\n",
    "* These control characters still exist and some are still used and impact processing. For the curious, you can read abotu the history of the newline character: https://en.wikipedia.org/wiki/Newline.  \n",
    "   \n",
    "![title](Teletype-IMG_7287.jpg)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": false,
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Counts of 'bird'/'Raven'/'fowl' as 🐦, Lenore as 👒,\n'chamber' as 🏠, and door as 🚪 in stanzas of The Raven\n\n00: 🏠🏠🚪🚪\n01: 👒👒\n02: 🏠🏠🚪🚪\n03: 🏠🚪🚪\n04: 👒👒\n05: 🏠\n06: 🏠🏠🚪🚪🐦\n07: 🐦🐦🐦\n08: 🏠🏠🚪🚪🐦🐦\n09: 🐦🐦\n10: \n11: 🚪🐦🐦🐦🐦\n12: 🐦\n13: 🐦👒👒\n14: 🐦🐦\n15: 🐦🐦👒👒\n16: 🚪🚪🐦🐦\n17: 🏠🚪🐦\n"
     ]
    }
   ],
   "source": [
    "with open('raven.txt', 'r') as file_in:\n",
    "    poem = file_in.read()\n",
    "    \n",
    "stanzas = poem.split(\"\\n\\n\")\n",
    "\n",
    "raven_count = [s.count(\"Raven\") + s.count(\"bird\") + s.count(\"fowl\") for s in stanzas]\n",
    "lenore_count = [s.count(\"Lenore\") for s in stanzas]\n",
    "chamber_count = [s.count(\"chamber\") for s in stanzas]\n",
    "door_count= [s.count(\"door\") for s in stanzas]\n",
    "\n",
    "print(\"Counts of 'bird'/'Raven'/'fowl' as \\U0001F426, Lenore as \\U0001F452,\\n\"\n",
    "      \"'chamber' as \\U0001F3E0, and door as \\U0001F6AA in stanzas of The Raven\")\n",
    "print()\n",
    "for stanza_num, bird_count in enumerate(raven_count):\n",
    "    print(str(stanza_num).zfill(2) + \": \", end = \"\") \n",
    "    print(u'\\U0001F3E0' * chamber_count[stanza_num], end = \"\")\n",
    "    print(u'\\U0001F6AA' * door_count[stanza_num], end = \"\")\n",
    "    print(u'\\U0001F426' * bird_count, end = \"\")\n",
    "    print(u'\\U0001F452' * lenore_count[stanza_num])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "# Data Types\n",
    "\n",
    "There parts of speech in a Python expression.  Informally and generally, these are:\n",
    "\n",
    "* Nouns -> objects\n",
    "* Verbs -> functions and operators\n",
    "* Prepositions/Conjunctions -> keywords that provide more structure and direction\n",
    "\n",
    "You use combinations of prepositions/conjunctions to form a structure that contains verbs and actions that operate on objects. (Don't angry tweet me because you disagree with this, we're talking very generally here, not scientific classifications).\n",
    "\n",
    "Just like with writing, there are types of programs.  Essays and poems have very different structures even though they might be written using the same language.  Writing programs is no different.  Sometimes these programs require a lot of introduction and prepapration, other times they need a lot of definitions and rule creation, and other times you can just bust in and write a few powerpoint slides.\n",
    "\n",
    "Here's a crappy poem that describes the Raven program:\n",
    "\n",
    "* Read in the raven\n",
    "* Separate the stanza text\n",
    "* Count the words I want\n",
    "\n",
    "\n",
    "* Print the chart title\n",
    "* Looping over the stanzas\n",
    "* Print the emoji\n",
    "\n",
    "\n",
    "* Joy\n",
    "\n",
    "\n",
    "But you may have a more complex problem where you need to more systematically approach it and tease some initial things out:\n",
    "\n",
    "* Given a set of documents, where we can test that there indeed is one chapter per file, and all files are stripped of header and tail information, we can then begin to look at the content.\n",
    "* The content is then a series of lines of text, which should be broken down into consituant words.  However, the relationship between these words and the lines they came from needs to be retained in some fasion such that the lines can be stitched back together after processing each word.\n",
    "\n",
    "The data types are what the bits and pieces that we work with, and and manipulated to craft the narrative of accomplishments within these descriptions."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "## Numbers\n",
    "\n",
    "Computers represent and store numbers differently than humans. Languages like Java actually have five different numerical data types. Python (at least in everyday use) only requires programmers to deal with two numerical datatypes. Why would we need more than one way to store numbers in the first place?\n",
    "\n",
    "This has to do with the legacy of early computing and how computers store data in memory. The key fact is that storing some kinds of numbers takes up less memory than other types of numbers. With 64 units of memory space, practically any number can be stored. However, not all numbers need that much space. The vast majority of numbers only need 16 units of memory space.\n",
    "\n",
    "Recall our earlier discussion about how early computer languages were closer to the computer's internal structure. When memory was very limited and expensive, allowing a number to take up more memory than necessary could render a project impossible from an engineering or budgetary perspective. Programmers gained a real benefit from the variety of numerical data types that allowed them fine control over how much memory to allocate for each number they needed to store.\n",
    "\n",
    "Compared to the early days of computing, the amount of memory available in today's computers is incredibly huge and cheap (though not infinite!) Programmers can afford to be more relaxed when it comes to managing memory. Python is also better than early languages at automatically deciding how much memory is needed to store a given number and so takes care of much of this in the background for us. However, there are still two different numerical data types that we need to remember:\n",
    "\n",
    "* integers (whole numbers)\n",
    "* floating point number (decimal numbers)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "### Integers:  Whole numbers\n",
    "\n",
    "The `int` type, short for integer, is used for whole numbers, numbers without any decimal points.  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n"
     ]
    }
   ],
   "source": [
    "print(1 + 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "int"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "int"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(1 + 1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Floating point numbers:  Numbers with decimal values\n",
    "\n",
    "The `float` type, short for floating point number, is any number with a decimal value."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4.0\n"
     ]
    }
   ],
   "source": [
    "print(1.5 + 2.5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.8\n"
     ]
    }
   ],
   "source": [
    "print(1.5 + .3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'float'>\n"
     ]
    }
   ],
   "source": [
    "print(type(1.5))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'float'>\n"
     ]
    }
   ],
   "source": [
    "print(type(10/2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Interaction of `int` and `float`\n",
    "\n",
    "`int` and `float` numbers get along pretty well, but there are some aspects which you might find surprising. We'll go into more detail about this later.  (You haven't met some of these operators yet, but you can understand the basics!)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.4\n"
     ]
    }
   ],
   "source": [
    "print(1 + 0.4) # int + float == float"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3.9\n"
     ]
    }
   ],
   "source": [
    "print(4 - .1) # int - float == float"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'float'>\n"
     ]
    }
   ],
   "source": [
    "print(type(1.0)) # whole numbers can be represnted as floats as well"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "print(1 == 1.0) # different data type, but equal the same value"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Words\n",
    "\n",
    "Words are pretty simple here.  All the basic characters you see, the ones you can see and type on your keyboard, are represented as characters.  These characters can be strung together as strings! (pun intended)\n",
    "\n",
    "### Strings\n",
    "\n",
    "The `str` type, short for string, contains character data.  There are three ways to indicate that something is a string.\n",
    "\n",
    "\n",
    "`\"like this, with double quotes\"`\n",
    "\n",
    "`'or like this, with single quotes'`\n",
    "\n",
    "`\"\"\" or use`<br>\n",
    "`three double quotes`<br>\n",
    "`together to make`<br>\n",
    "`a multi-line string\"\"\"`\n",
    "\n",
    "Feel free to use either ' or \", but try to be consistent.  The multi-line string is generally used either for certain types of documentation modes.\n",
    "\n",
    "### Why do we need three different ways to write strings?\n",
    "\n",
    "Why do you not want choice, human?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Feel free to use either single or double quotes\nYou just need to make them match.\nYou can escape it out, like this: \" see the backslash?\nI am a meat popsicle.\nI live to be eaten.\nMy soul is frozen.\nThere is a stick.\n"
     ]
    }
   ],
   "source": [
    "print(\"Feel free to use either single or double quotes\")\n",
    "\n",
    "print('You just need to make them match.')\n",
    "\n",
    "# BUT I NEED THAT SWEET SWEET DOUBLE QUOTE INSIDE OF DOUBLE QUOTES\n",
    "# you're covered\n",
    "\n",
    "print(\"You can escape it out, like this: \\\" see the backslash?\")\n",
    "\n",
    "# and now I have a long chunk of text that I don't want to parse\n",
    "\n",
    "print(\"\"\"I am a meat popsicle.\n",
    "I live to be eaten.\n",
    "My soul is frozen.\n",
    "There is a stick.\"\"\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# What can you do with the essentials?\n",
    "\n",
    "Now that we've talked about the two essential data types for storing content (numbers and words), we'll start exploring what you can do with these essential data types."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Numerical operators\n",
    "\n",
    "Numbers are the core of computing, so naturally there are a ton of things you can do with them.  \n",
    "\n",
    "### The basic operators\n",
    "\n",
    "\n",
    "| Operator |                       Numeric Operation                       | Example |\n",
    "|:--------:|:-------------------------------------------------------------:|:----------------:|\n",
    "| +        | Addition                                                      | `>>> 2 + 5` <br> `7` | \n",
    "| -        | Subtraction                                                   | `>>> 2 - 5` <br> `-3` | \n",
    "| *        | Multiplication                                                | `>>> 2 * 5` <br> `10` | \n",
    "| **       | Exponent                                                      | `>>> 2 ** 5` <br> `32` | \n",
    "| /        | division <br>Python2.\\*: floor division<br>Python 3.\\*: true division | `>>> 2 / 5` <br> `0`<br>`>>> 2. / 5.` <br> `0.4` | \n",
    "| //       | floor division<br>both 2.\\* and 3.\\*                            | `>>> 2 // 5` <br> `0`<br>`>>> 2. // 5.` <br> `0.0` | \n",
    "| %        | modulo<br>(returns the remainder)                                | `>>> 2 % 5` <br> `2`<br>`>>> 4 % 2` <br> `0` | \n",
    "\n",
    "### Modulo?\n",
    "\n",
    "Referred to as 'mod', modulo returns the remainder of your division value.\n",
    "\n",
    "Remember the parts of a division calculation:\n",
    "\n",
    "* Quotient\n",
    "    * The 'whole number' value\n",
    "* Remainder\n",
    "    * What is 'left over'\n",
    "    \n",
    "What is returned from modulo is not the decimal value!\n",
    "\n",
    "Modulo is most valuable for checking if a number is divisible by another number (e.g. checking if a number is even or odd)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2.5\n"
     ]
    }
   ],
   "source": [
    "print(5. / 2.)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n"
     ]
    }
   ],
   "source": [
    "print(5 % 2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## String operations\n",
    "\n",
    "\n",
    "Strings can be sliced, meaning that subsections can be accessed.  The slicing notation is:\n",
    "\n",
    "`string[start:stop:step]`\n",
    "\n",
    "* `start` is the index position to start at\n",
    "    * Assumes start if omitted\n",
    "* `stop` is the index position to stop at\n",
    "    * Assumes end if omitted\n",
    "* `step` is how many positions to move over\n",
    "    * Assumes 1 if omitted\n",
    "    \n",
    "Let's open up your interactive session and test this out.\n",
    "\n",
    "Most of the cleverness you'll find in Python relate to this start:stop:step notation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hello\nhello\nhlo\nhe\n"
     ]
    }
   ],
   "source": [
    "print(\"hello\"[:]) # everything\n",
    "print(\"hello\"[0:len(\"hello\")]) # also everything\n",
    "print(\"hello\"[::2]) # skip every other letter\n",
    "print(\"hello\"[0:2]) # yup, indexing starts at 0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You try a few on your own:\n",
    "\n",
    "* get just the l's\n",
    "* skip every three letters\n",
    "\n",
    "Anything else neat?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Numerical-looking operations on strings\n",
    "\n",
    "Some of the numerical operators are overloaded to work on strings and other data types in Python.\n",
    "\n",
    "Strings can also be:\n",
    "\n",
    "* Added via `+`\n",
    "    * `'a' + 'b' == 'ab'`\n",
    "* Multiplied by integers for repetition\n",
    "    * `'hello' * 4 == 'hellohellohellohello'`\n",
    "* Or combined!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "oh ***** this ****\n"
     ]
    }
   ],
   "source": [
    "print(\"oh \" + len(\"screw\") * \"*\" + \" this \" + len(\"crap\") * \"*\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Can you create a concatenation of the first and last letters of `\"hello\"`?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## One more quick data type: the boolean"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Conditional testing\n",
    "\n",
    "The bulk of your creative design in programming will be making conditional checks on content.  These are boolean tests, or logical tests.  There are only two values things can be:\n",
    "\n",
    "* `True`\n",
    "* `False`\n",
    "\n",
    "We use the `==` operator to initiate one of these checks.\n",
    "\n",
    "Some examples:\n",
    "\n",
    "* Is this a title that I have seen already?\n",
    "* Was this word found more than 100 times?\n",
    "* Is the length of the word longer than 10 characters?\n",
    "\n",
    "There are a variety of ways to construct these tests, but the goal is to produce a boolean answer."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "print(1 == 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "print(5 < 10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n"
     ]
    }
   ],
   "source": [
    "print(len(\"foo\") > 5) # len() checks the length of whatever you pass it"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'a' in 'abcdefg'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n"
     ]
    }
   ],
   "source": [
    "print('i' in 'team')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Variables\n",
    "\n",
    "Now that we're making more and bigger stuff, we need to store those things with memorable (hopefully?) names.  This allows us to reference things where the content might change, or avoid having to type the same info multiple times.\n",
    "\n",
    "We use a single `=` sign to create assignments. The basic syntax is `variable = value`, so to the left of the `=` is the variable name, and the stuff on the right is the value you want to store with that name."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "x = 4\n",
    "name = \"Elizabeth\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello Hello Hello Hello  Elizabeth!\n"
     ]
    }
   ],
   "source": [
    "print(\"Hello \" * x, name + \"!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# The most basic container: the list\n",
    "\n",
    "Lists are:\n",
    "\n",
    "* ordered\n",
    "* flat hierarchy \n",
    "* present in nearly every program you'll ever write\n",
    "* designated by square brackets:  `[]`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "colors = ['red', 'yellow', 'green', 'blue']\n",
    "nouns = ['cat', 'dog', 'shark']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Containers in context\n",
    "\n",
    "Can we automatically generate madlibs using this base?\n",
    "\n",
    "* A list of many colors to choose from\n",
    "* a number\n",
    "* A list of several nouns to choose from\n",
    "\n",
    "## Pair activity:  constructing madlibs\n",
    "\n",
    "1. Pair up with someone near you!\n",
    "2. One you constructs a list with:\n",
    "    * an integer number\n",
    "    * a color\n",
    "    * a animal name\n",
    "3. The other constructs a sentence that uses a number, a color, and an animal name.\n",
    "\n",
    "Use your knowledge of list index positions and string concatenation to write a madlib sentence that utilizes those values.  Knowing that the item at position `0` is the number, `1` is the color, and `2` is the animal name. TIP!  You'll need to recast the number to a string via `str()`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![title](singleton_party_parrot.png)\n",
    "![title](parrot_2.png)\n",
    "![title](parrot_3.png)\n",
    "![title](parrot_4.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "I'd have to work for 2 years to save for a gecko with red eyes.\n"
     ]
    }
   ],
   "source": [
    "my_list = [2, 'red', 'gecko']\n",
    "\n",
    "print(\"I'd have to work for \" + str(my_list[0]) + \" years to save for a \" + my_list[2] + \" with \" + my_list[1] + \" eyes.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "# Functions\n",
    "\n",
    "Funtions are structures to modularize specific sections of code.  These are most useful when you are doing a task that is pretty repetitive, meaning that you can call a function repeatedly rather than having to write out all that code over and over.\n",
    "\n",
    "We've been working with functions this whole time, for example `type()` and `print()`.  We call them by using their names, and sometimes we pass values to them.  Example:  in `type(1)` the function is `type` and you're passing it an object of `1`.  `type` then returns a value to us that we can store or print out.  \n",
    "\n",
    "## Function vocabulary\n",
    "\n",
    "* function\n",
    "    * a piece of code that has been compartmentalized and named\n",
    "* name\n",
    "    * not really a vocabulary piece, but functions all have names, e.g. 'type' is the name of `type()`\n",
    "* call\n",
    "    * when you want to make a function do its thing, you have to call it by name.  Otherwise it just sits there ready to go but sitting there dormant until executed.  I call `type()` but executing the code `type(1)`.\n",
    "* pass values\n",
    "    * functions are little semi-independent buckets that sit in a corner and wait to do their work.  They often need to act on variables and values but because they are usually independent of when/how they're used in a larger context, they won't always know the variable names in question.  So when you stick values or variables inside of the `()` when you call a function, you're passing that function a little bundle of data to crunch on.\n",
    "* return something\n",
    "    * We're used to printing out values to our screen, but we sometimes we need to capture those values for reuse.  So when I print `2 + 2` I see `4` on my screen, but what if I need to use that calculated value later on?  This is where `return` comes into play.  \n",
    "    \n",
    "## Function scope\n",
    "\n",
    "Very generally, functions can 'see' variables outside of them, but variables inside a function cannot be 'seen' by any other portion of the program.  This is why we have to `return` values back out of a function.\n",
    "\n",
    "## Defining functions\n",
    "\n",
    "When defining a function, that code is both executed and not excuted.  Sort of an interstitial state.  When a function is defined, that code belonging to it is **learned** but not actually run.  The code within a function is only run when the function itself is called.  This means you can have errors in your code within a function but your script will run just fine unless you actually call that function.\n",
    "\n",
    "## Stop talking, how do I do it?\n",
    "\n",
    "The basic syntax of making functions is:\n",
    "\n",
    "```python\n",
    "def function_name(parameter_variables):\n",
    "    return \"the stuff you want to do\"\n",
    "```\n",
    "\n",
    "Let's adapt this for our madlibs."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def my_mad_lib(number, color, animal):\n",
    "    result = \"I'd have to work for \" + str(number) + \\\n",
    "             \" years to save for a \" + animal + \" with \" + color + \" eyes.\"\n",
    "    return result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "I'd have to work for 2 years to save for a gecko with red eyes.\n"
     ]
    }
   ],
   "source": [
    "print(my_mad_lib(2, \"red\", \"gecko\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Pair activity!\n",
    "\n",
    "Within your pairs, each of you independently come up with a new madlib function. It should ask for certain parameters and print out a new creation.  Without sharing what the madlib is, ask eachother for the appropriate inputs.  Test and share!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "# Lunch break"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    ""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    ""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    ""
   ]
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "kernelspec": {
   "display_name": "Python [default]",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3.0
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.5.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}