book_notebooks/python_fundamentals_two.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Python Fundamentals 2 \n",
    "\n",
    "\n",
    "\n",
    "#### Review and Outline\n",
    "\n",
    "**Great Work!** We have made it this far...we know some basic calculations, data types and structures (lists, tuples, strings, dictionaries), we also know how to get help `?` and read `Error:` messages. Finally, we should be getting comfortable with the notebook and markdown.\n",
    "\n",
    "Where are we going? In this notebooke we will cover some key operations: Comparisons, `if else` conditional operations, `for` loops. In the end, we will learn the core concept of **object** in object oriented programming and how it is used in python to help us better understand the language.\n",
    "\n",
    "[This notebook largely follows the discussion in the Book.](https://nyudatabootcamp.gitbook.io/thebook/py-fun2) Note, in the book there are many more excercises to try. Pleast try them at home. \n",
    "\n",
    "#### Python  Tools\n",
    "\n",
    "Boolean variables, comparisons, conditionals (if, else), slicing, loops (for), tab completion, function definitions and objects.\n",
    "\n",
    "**Buzzwords.** Code block, data structures, list comprehension, PEP8.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "---\n",
    "## Booleans\n",
    "\n",
    "Basic idea, make a comparison and the result is a `true` or `false` value. We call these bools..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "test = 1 < 0 # This is a comparsition, value 1 versus zero....\n",
    "print(test) # What does it return a True or False value...\n",
    "print(type(test)) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**KEY** Note the type, it's a bool or short for Boolean.\n",
    "\n",
    "Here are some more operations...bools can be combined with integers and floats..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "print(2*test)\n",
    "\n",
    "# Now what if we had 1 < 0 above, what would the command return... note that it will\n",
    "# give a zero... so what is going on here is implicitly with a True is the value 1\n",
    "# and associated with the value False is a zero (note how in the background there is\n",
    "# probably a dictionary doing this....)\n",
    "\n",
    "test1 = 0.666666666666666666 # This is interesing, when are they equal...\n",
    "test2 = 2/3\n",
    "print(test1 == test2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Some more operations... == is equal, >= greater than or equals, <= less than\n",
    "or equals, != not equals. Keep these in mind. There are also other ways to take the oppisite value by using the `not` built-in"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "test = not 1 > 0 # this is not whatever 1 > 0 is, so not True which is FALSE\n",
    "print(test)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Then notice what happens when we print a statement..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "x = 2*3\n",
    "y = 2**3\n",
    "print('x greater than y is', x > y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercise.** What is 2 >= 1? 2 >= 2? not 2 >= 1? If you're not sure, \n",
    "try them in the IPython console and see what you get."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercise.** What is\n",
    "```\n",
    "print(2 + 2 == 4) \n",
    "\n",
    "print(1 + 3 != 4) \n",
    "```\n",
    "\n",
    "Explain what is going on here...."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercise** What is \n",
    "```\n",
    "print(\"sarah\" == 'Sarah')\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercise.** What do these comparisons do? Are they true or false? Why?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "print(type('Sarah') == str) # IS it a string? YES!!! \n",
    "print(type('Sarah') == int) # IS it an integer??? NO!\n",
    "print(len('Sarah') >= 3) # Is the length longer than three? YES!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " **Comparisons in String**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "name1 = 'Chase'\n",
    "name2 = 'Spencer'\n",
    "check =  name1 > name2\n",
    "print(\"Is Chase > Spencer \",check) #hmmmm...."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "https://stackoverflow.com/questions/4806911/string-comparison-technique-used-by-python\n",
    "\n",
    "Here is the quick run down, this does this thing in lexicographic ordering... this means: First the first two items are compared, and if they differ this determines the outcome of the comparison; if they are equal, the next two items are compared,\n",
    "and so on, until either sequence is exhausted. What determines the order...in this case note that \"S\" comes **later** in the alphabet than \"C\" thus is has a larger \"value\", thus \"Chase > Spencer\" is false.\n",
    "\n",
    "When comparing uppercase vs. lower case, uppercase come before lower case...The stuff like ```*&``` come before. How do I know exactly what is going on... here is a link to the unicode point ordering\n",
    "\n",
    "https://en.wikipedia.org/wiki/List_of_Unicode_characters\n",
    "\n",
    "And scroll down to the Latin Script /Basic Latin table there. There there is a number for each possible character. To see the number just type `ord(\"z\")` and note how this should give back the value 122 and then look in the table it should have the value 122. In the comparison above, what it is doing is taking the number in this table for the given character and then comparing it to the number for the other character. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "\"z\" > \"a\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "ord(\"!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "## Conditional (If/Else)\n",
    "\n",
    "Now that we know how to tell whether a comparison is true or false, we can build that into our code. \"Conditional\" statements allow us to do different things depending on the result of a comparison or Boolean variable, which we refer to as a condition. The logic looks like this:\n",
    "\n",
    "* if a condition is true, then do something.\n",
    "\n",
    "* if a conditions is false, do something else (or do nothing)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "if 1 > 0: # this statment checks the value, then IF TRUE it advances to the next line\n",
    "    print(\"1 is greater than 0\") # here where it prints the value\n",
    "    print(\"test\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Key issue, an **`if`** statement must always be followed by **\"`:`\"** and then the next line or lines associated with the statement must be indicated by 4 spaces. ONLY 4 spaces, Jupyter will do this automatically....there is also some kind of debate about spaces or tabs...here is some interesting info if you need to choose:\n",
    "\n",
    "https://stackoverflow.blog/2017/06/15/developers-use-spaces-make-money-use-tabs/"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    " x = 5               # we can change this later and see what happens\n",
    "\n",
    "if x > 6:\n",
    "    print('x =', x)\n",
    "\n",
    "print('Done!')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "x = 7\n",
    "\n",
    "condition = x > 6\n",
    "\n",
    "if condition:\n",
    "    print('if branch')             # do if true\n",
    "    print(condition)\n",
    "else:\n",
    "    print('else branch')           # do if false\n",
    "    print(condition)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercise.** Take the names name1 and name2, both of them strings. Write a program using if and else that prints the name that comes first in alphabetical order.  Test your program with name1 = 'Dave' and name2 = 'Glenn'."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercise** Make it insensitive to capitalization..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "---\n",
    "## Slicing\n",
    "\n",
    "This is an important stuff to be comfortable with. When we start to work with `Pandas` (the data package), slicing will be a key skill to \"slice\" the data in the way that we want. For now we will work with strings and lists.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "a = \"some\"\n",
    "print([a[0], a[1], a[2]])\n",
    "\n",
    "# Note how it is treating the string just like a tuple (remember python starts indexing from 0)\n",
    "# so we are calling each individual character...\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "a[1] = \"*\"  # can we re-assgin? # no...string is like a tuple where the object is immutable.\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "One of the interesting things about this is that there are both a **forward** counter and a **backward** counter. Here is an example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "print(a[-3]) # this should give an o, so 0 is s, -1 is e, -2, is m...\n",
    "#print(a[-400]) # But it will not do this infinitly, it will do this untill it returns\n",
    "# back to s or -4,  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercise** Take the string firstname = 'Monty' and write below it the forward and backward \n",
    "counting conventions. What integer would you put in square brackets to extract \n",
    "the third letter (n) under each system?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercise.** Find the last letter of the string lastname = 'Python'. Find the second \n",
    "to last letter using both the forward and backward counting conventions."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercise.** Take the list numberlist = [1, 5, -3]. Use slicing to set a variable \n",
    "first equal to the first item. Set another variable last equal to the last item. Set a third variable named middle equal to the middle item."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now how do we pull groups of objects out of a data structure. We use the **`:`** operator. What this does is when we have say `[0:2]` this will pull out the first element AND everything after it NOT including the object in the second position. That is the value after the colon is not included. LEts see this..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "c = 'something'\n",
    "\n",
    "print('c[1] is', c[1]) # We know this...\n",
    "print('c[1:2] is', c[1:2]) # This says take between 1 and 2 NOT including 2 (so same as above)\n",
    "print('c[1:3] is', c[1:3]) # This says take between 1 and 3 NOT including 3\n",
    "print('c[1:] is', c[1:]) # This says give from postion 1 onward so omething...if -1?\n",
    "print('c[1:-1] is', c[1:-1]) # This works, again, from postion 1 and -1 NOT including -1, so oemthin"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercise.** Set lastname = 'Python'. Extract the string 'thon'."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercise.** Set numlist = [1, 7, 4, 3]. Extract the middle two items and assign \n",
    "them to the variable middle. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercise.**\n",
    "\n",
    "- Extract all but the first item and assign them to the variable allbutfirst. \n",
    "\n",
    "- Extract all but the last item and assign them to the variable allbutlast."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "## `for` Loop\n",
    "\n",
    "As with the conditional operation, this is a key skill. In particular, it allows for us to scale up the number of operations without having to constantly write code to perform each one. \n",
    "\n",
    "The book has some examples, but let me suggest one that I see all the time...suppose you have bunch of datasets. How to you read them in. Use a for loop. So you create a list of the names of the data sets, then you work through the list and read each one it. What the for loop allowed you to do is for a small change in your code you have scaled your operation by however much."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "namelist = ['Chase', 'Dave', 'Sarah', 'Spencer']    # creates the list \"namelist\"\n",
    "# below, the word \"item\" is arbitrary. End the line with a colon.\n",
    "\n",
    "for item in namelist:    # goes through the items in the list one at a time\n",
    "   print(item)    # indent this line exactly 4 spaces\n",
    "# if there is code after this, we'd typically leave a blank line in-between"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "One thing to notice is the `item` which is a place holder. The specific name `item` has no attachment to anything, all it says is that as it works through each object in the list, its temporary name will be `item`. Here, try to change `item` to `bloob` and see what happens.\n",
    "\n",
    "Here is a numerical calculation...this is common in scientific computing..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "numlist = [4, -2, 5]\n",
    "total = 0\n",
    "\n",
    "for num in numlist:\n",
    "    total = total + num\n",
    "\n",
    "print(total)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now here is a string. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "word   = 'anything'\n",
    "for letter in word:\n",
    "    \n",
    "    print(letter)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note how general this is. The key issue is that as long as the for loop is over an \"itteratable\" object, then this this will work. Ask your self, what itterable objects do we know.\n",
    "\n",
    "Now this example below combines the for loop and a conditional"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "vowels = 'aeiouy'\n",
    "word   = 'anything'\n",
    "\n",
    "for letter in word:\n",
    "    \n",
    "    if letter in vowels:\n",
    "        \n",
    "        print(letter)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercise.** Take the list `stuff = ['cat', 3.7, 5, 'dog']`.\n",
    "\n",
    "- Write a program that prints the elements of stuff.\n",
    "- Write a program that tells us the type of each element of stuff.\n",
    "- Challenging. Write a program that goes through the elements of stuff and prints only the elements that are strings; that is, the print the elements where function type returns the value str."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercise.** Consider the list `namelist = ['Chase', 'Dave', 'Sarah', 'Spencer']`. \n",
    "\n",
    "Write a loop that goes through the list until it reaches a name than begins with the letter S. At that point it prints the names and exits the loop."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Loops over Ranges\n",
    "\n",
    "I think this is less important in data work. We need to know it though, so let's work through it. The first thing to learn is the type `range`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "range?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "my_first_range = range(0,10,2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "type(my_first_range)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "print(list(my_first_range)) # why do need to add a list() function in print function?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "for number in range(1,5,2): # the variable \"number\" can be anything\n",
    "    \n",
    "    print(number)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "for number in range(1, 11):\n",
    "    square = number**2\n",
    "    \n",
    "    print('Number and its square:', number, square)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "## List Comprehension\n",
    "\n",
    "The basic idea is to create implicit loops on itterable objects like lists (note it need not be a list, just something we can itterate on). We refer to this as list comprehensions. It is useful in certain circumstances and shows up a lot in Python code. \n",
    "\n",
    "To understand list list comprehension, lets first remind our selves what a loop is doing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "namelist = ['Chase', 'Dave', 'Sarah', 'Spencer']\n",
    "\n",
    "for item in namelist:\n",
    "    \n",
    "    print(item)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A list comprehension gives us more compact syntax for the same thing:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "[print(item) for item in namelist]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notices what this is doing:\n",
    "- First there are the square brackets, this means we are creating a NEW LIST\n",
    "\n",
    "- The first part within the brackes is the operation we want to perform on the old list. Here we want to print it.\n",
    "\n",
    "- Then after the operation on the \"item\" we describe the for operation, the variable, and then the itterable oject we want to grab from. \n",
    "\n",
    "- Essentialy what all this says is \"do ``operation`` on ``item`` in the list\"\n",
    "\n",
    "Again, as with loops, the variable `item` is a dummy:  we can use any name we wish.  Replace `item` with your pet's name to see for yourself.\n",
    "\n",
    "Lets see some examples:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "fruit = ['apple', 'banana', 'clementine'] # A list...\n",
    "\n",
    "FRUIT = [item.upper() for item in fruit] \n",
    "\n",
    "print(FRUIT)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also apply conditions within list comprehensions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "fruit6 = [item for item in fruit if len(item)<=6]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "fruit6"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercise.** Take the list of growth rates g = [0.02, 0.07, 0.07]. Write a list comprehension that multiplies each element by 100 to turn it into a percentage.\n",
    "\n",
    "\n",
    "**Exercise.** Take the mixed type list `[True, \"2\", 3.0, 4]` and create a new list of the associated types. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Final point about this: List comprehensions and related stuff are okay to use for simple cases. However, for more complicated situations, comprehensions be very hard to read and understand. Hence, a traditional ``for`` loop would be more appropriate. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "---\n",
    "## Functions\n",
    "\n",
    "The key idea here is that rather than repeating the same lines of code over and over again. We can create a function that performs some distinct operation. This is a good strategy for a lot of reasons\n",
    "* Efficient in terms of writing code \n",
    "* It facilitates easy to read code \n",
    "* Avoids any debuging issue that may arise when you have to modify multiple lines of code in the same exact way (just change the code in the function). \n",
    "* Finally, it will give us insight to what is behind various packages that we will be using in the future...what are they just a collection of functions!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "def hello(firstname):               # define the function\n",
    "    print('Hello,', firstname)\n",
    "      "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A couple of things:\n",
    " \n",
    " - Similar syntax to for loops, if statements. Here we start with def (short for definition), then we create the name of the function and then any inputs...\n",
    " \n",
    " - Four spaces for all operations preformed by the function. If it does not have four spaces, it is not recognized as part of the function.\n",
    " \n",
    "One more thing. We have only have to run this code cell once. Once we do so the function is in the namespace and is good to go.\n",
    " "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "hello('Chase')   "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "hello([1,2,3])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "whos"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This shows us that the function is there and available.\n",
    "\n",
    "Returning to the function above, how would I modify it to return a different message if firstname is not a string?\n",
    "\n",
    "Now sometimes we want the function to return a value...this is how we do it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def squareme(number):\n",
    "    \"\"\"\n",
    "    Takes numerical input and returns its square\n",
    "    \"\"\"\n",
    "    return number**2, number        # this is what the function sends back"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "x, y = squareme(2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def value_one():               # define the function\n",
    "    return 1.0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "value_one()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "max?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def combine(first, last):\n",
    "    \"\"\"\n",
    "    Takes strings 'first' and 'last' and returns new string 'last, first'\n",
    "    \"\"\"\n",
    "    lastfirst = last + ', ' + first\n",
    "    return lastfirst                    # this is what the function sends back\n",
    "\n",
    "both = combine('Chase', 'Coleman')      # assign the \"return\" to both\n",
    "print(both)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- **Exercise.** Create and test a function nextyear that takes an integer year (say 2015) and returns the following year (2016).\n",
    "\n",
    "- **Exercise.** Create and test a function that takes a string year (say, '2015') and returns a string of the next year (say, '2016')."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- **Exercise.** Write a function that extracts the last letter from a string\n",
    "\n",
    "- **Exercise.** Use the function above and write a program so that last letter of each item in the list names = ['Chase', Dave', 'Sarah', 'Spencer'] is printed\n",
    "\n",
    "- Bonus (optional): Print the last letter only if it's a vowel.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "## Objects\n",
    "\n",
    "This is a key feature of python...it's an [object oriented programming language](https://en.wikipedia.org/wiki/Object-oriented_programming). What does that mean? For us this means that every thing is really an object with associated **methods** and **attributes**. A method is like a function that already togo with the given object. Methods in python are always completed with `()` . Attributes are go-to-go attributes about the object that can be accessed easily. What this means is that there are simple built-in ways to get information and perform operations on objects without having to write our on functions.  \n",
    "\n",
    "Functions, methods, and attributes differ primarily in their syntax:\n",
    "\n",
    "* Syntax of a **function**: `function(object)`\n",
    "* Syntax of a **method**: `object.method()`\n",
    "* Syntax of a **attribute**: `object.attribute`\n",
    "\n",
    "We used the former in the previous section and will consider the latter here.\n",
    "\n",
    "\n",
    "OK...but if I have say a list, how do I know the methods and attributes associated with it...here comes `TAB` completion which we covered in last `Notebook`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "whos"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "numberlist.append?\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "numberlist.append(7)\n",
    "\n",
    "print(numberlist)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "first_name = \"Chase\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "first_name.lower()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercise.** This one also come up in our work. Suppose we have a variable z = '12,345.6'. What is its type? Convert it to a floating point number without the comma. Hint: Use tab completion to find a method to get rid of the comma."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercise.** Take the list `fruit` and create a new list with the first letter capitalized. What method would you use to capitalize a string?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercise.**  Run the code\n",
    "\n",
    "```python\n",
    "firstname = 'John'\n",
    "lastname  = 'Lennon'\n",
    "firstlast = firstname + ' ' + lastname\n",
    "```\n",
    "\n",
    "Find a method to replace the n's in `firstlast` with asterisks."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercise.** Consider the following string `x = \"How many characters and words are in this string?\"`\n",
    "\n",
    "* How many characters does x contain?\n",
    "\n",
    "* Convert x to a list of individual characters.\n",
    "\n",
    "* Convert x to a list of individual words.\n",
    "\n",
    "* How many words does x contain?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now here is a question what is the difference between what I did above and what I'm doing below:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "x = \"How many characters and words are in this string?\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "x.rsplit()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercise (challenging)**. Use tab completion and the Object inspector to find and apply a method to the string name that counts the number of appearances of the letter s. Use name = 'Ulysses' as a test case."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Are their other ways of doing this????"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercise.** Consider the dictionary `names = {'Dave': 'Backus', 'Chase': 'Coleman', 'Spencer': 'Lyon', 'Glenn': 'Okun'}` \n",
    "\n",
    "* Use tab completion to get all the keys. \n",
    "* What type is the output above. Can you convert this to a list.\n",
    "* With your list, write a for loop over it, pass the keys to the dictionary, and print out the values."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "---\n",
    "## Summary"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Congratulations!** First, it's amazing that you have made it this far. Reflect on what you knew before working through this notebook, namely what we did in notebook 1. Now reflect on what you can do...AMAZING!!! Let us summarize some key things that we covered.\n",
    "\n",
    "* **Boolean variable and its operations**: We conduct the comparsion operation on the right: x = 3 > 2, and we can assign the boolean values (True or False) to the variable x. We also learned how to compare two strings.\n",
    "\n",
    "\n",
    "* **\"if\" conditional statement**: it allows us to do different things depending on the result of a comparison or Boolean variable.\n",
    "\n",
    "\n",
    "* **Slicing**: we learn **Forward** and **Backward** counting conventions in a list, do you know when to select which? We also cover using **`:`** operator to select groups of data.\n",
    "\n",
    "\n",
    "* **\"for\" Loop**:\n",
    "    * We can use `for` to loop through any iterable objects.\n",
    "    * We talk a common built-in iterable object/data sturcture: `range` to help us with the data slicing/indexing.\n",
    "\n",
    "\n",
    "* **Functions**: we learn how to define and use customized functions. \n",
    "\n",
    "\n",
    "* **Objects**: a core concept in a object oriented programming language like python. It can help us understand how we can use **`.`** operations to call methods and attributes in an object. \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "hide_input": false,
  "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.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}