Week 03.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Week 03"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Things to cover: \n",
    "\n",
    "Strings, more on lists, accumulator patterns, splitting strings into lists of stuff, string concat, string slicing, string methods, more list methods, casting string numbers into real numbers"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Admin stuff\n",
    "\n",
    "* All homework submissions need to have .py files for your code, unless something terrible has happened and you have explicit approval from me to turn in screenshots.  You will lose points for turning in only screenshots starting this week.\n",
    "\n",
    "* One of your homework problems is a disucssion item.  I have more specific directions about what I want in the homework assignment, be sure to read that.  The actual question (D4) asks you to just show output, but I want you to explain what's happening in each.  At least 2-3 sentences on each. No .py is reqired for this problem.\n",
    "\n",
    "* Be sure to read the homework notes and hints that I've supplied for this week!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Natural numbers\n",
    "\n",
    "When the book uses the word \"natural numbers\" it means positive whole numbers.  So 0, 1, 2, 3, 4, 5, etc.\n",
    "\n",
    "So the phrase \"first 5 natural numbers\" would want: [0, 1, 2, 3, 4] or..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 1, 2, 3, 4]\n"
     ]
    }
   ],
   "source": [
    "print(list(range(5)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Remember that the usage of 'n' is to mean an arbitrary whole and positive numbers."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter how many natural numbers you want: 11\n",
      "[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n",
      "6\n",
      "7\n",
      "8\n",
      "9\n",
      "10\n",
      "11\n"
     ]
    }
   ],
   "source": [
    "n = eval(input(\"Enter how many natural numbers you want: \"))\n",
    "\n",
    "start = 1\n",
    "stop = n + 1 # add 1 to force it to include the number\n",
    "\n",
    "result = list(range(start, stop))\n",
    "print(result)\n",
    "\n",
    "for number in result:\n",
    "    print(number)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Experimenting with `eval(input())` in PyCharm\n",
    "\n",
    "This came up in many questions within the moodle, so let's take some time to experiment and play with what eval is doing.\n",
    "\n",
    "Yes, we will need to talk a little about tuples.\n",
    "\n",
    "When eval is givin something like `1, 2, 3, 4` it's going to make a tuple out of it, without having other context."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "stuff: 1, 2, 3\n"
     ]
    }
   ],
   "source": [
    "stuff = eval(input(\"stuff: \"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 2, 3)\n"
     ]
    }
   ],
   "source": [
    "print(stuff) # look, ma, I made a tuple"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can do many things with tuples, including iterating over them."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n"
     ]
    }
   ],
   "source": [
    "for number in stuff:\n",
    "    print( number )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For clarity, we can still recast a tuple into a list to do more list-type things with it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "'tuple' object does not support item assignment",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-20-fdef21c8331e>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mstuff\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;36m2\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m: 'tuple' object does not support item assignment"
     ]
    }
   ],
   "source": [
    "stuff[0] = 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "give me a number: 11\n",
      "11111111\n",
      "44\n"
     ]
    }
   ],
   "source": [
    "num = input(\"give me a number: \")\n",
    "\n",
    "print(num * 4)\n",
    "\n",
    "num = eval(num)\n",
    "\n",
    "print(num * 4)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For example, we can rewrite values into tuples because they are immutable. But we can change values in lists."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['a new thing now', 2, 3]\n"
     ]
    }
   ],
   "source": [
    "stuff_is_a_list_now = list( stuff )\n",
    "\n",
    "stuff_is_a_list_now[0] = \"a new thing now\"\n",
    "\n",
    "print( stuff_is_a_list_now )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Please be sure to review the moodle forum for this week's homework and check the answers, but let me clarify here:  there are many ways to solve the programming exercises that do accumulation and other stuff to user inputted numbers.  The point of these is to be able to act upon an arbitrary list of stuff, and less so on the user interaction.  So long as you solve the issue of acting on a list of arbitary size and numerical values, you won't lose points.  For example, if you don't actually use the number of "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "# Accumulator patterns\n",
    "\n",
    "This is a pattern used to accumulate results over numbers, strings, data, etc.  Basically, anything that the `+` operator works with will accumulate.\n",
    "\n",
    "What the book and your homework cover are very basic toy versions of these things.  \n",
    "\n",
    "The basic battern is:\n",
    "\n",
    "```python\n",
    "accumulator_variable = 0\n",
    "\n",
    "for each_thing in that_stuff_over_there:\n",
    "    # process out what you need\n",
    "    accumulator_variable = accumulator_variable + each_thing\n",
    "    \n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "In the example below, yes, we could just use `sum()` over the list of values, but there are often times when you want to check something, or you have multiple places where things need to go."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "21\n"
     ]
    }
   ],
   "source": [
    "numbers = [0, 4, 1, 9, 7]\n",
    "\n",
    "total = 0\n",
    "\n",
    "for number in numbers:\n",
    "    total = total + number\n",
    "    \n",
    "print(total)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "So let's do an example here:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "15 35\n"
     ]
    }
   ],
   "source": [
    "list_of_tups = [ (1, 9), (2, 8), (3, 7), (4, 6), (5, 5) ]\n",
    "\n",
    "left_sum = 0\n",
    "right_sum = 0\n",
    "\n",
    "for tup in list_of_tups:\n",
    "    left = tup[0]\n",
    "    right = tup[1]\n",
    "    \n",
    "    left_sum = left_sum + left\n",
    "    right_sum = right_sum + right\n",
    "    \n",
    "print(left_sum, right_sum)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Group activity\n",
    "\n",
    "Can we think of some accumulator patterns that involve multiplication, division, or others?  Break out into small groups and brainstorm some examples.  Don't worry if they aren't examples you can actually code up at this point.  \n",
    "\n",
    "* 10 min to brainstorm\n",
    "* Pick a group spokesperson, that person should:\n",
    "    1. email me the list of your group\n",
    "    2. take notes on your idea\n",
    "    3. be prepared to take 2-3 minutes to explain what you settled on\n",
    "* 10 min to report out from the groups\n",
    "\n",
    "Can we actually code any of these? Don't worry, this isn't a group project.  Just discussion."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Accumulators with strings"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As I mentioned, you can do this with strings as well.  Let's use this example to explore some of our string methods, which is a preview for next week."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "sens = [\"Never have we been odder,\", \"going this way and that\", \n",
    "        \"to and from our realities that\", \"give us definitions that\",\n",
    "        \"you choose to ignore\", \"up and up\", \"never failing\", \"going to the limits or\",\n",
    "        \"to thrive or\", \"let these situations get the best of\", \n",
    "        \"you and unending desire to dive\", \"down into sand.\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Never going to give you up never going to let you down\n"
     ]
    }
   ],
   "source": [
    "first_words = []\n",
    "\n",
    "for sentence in sens:\n",
    "    words = sentence.split()\n",
    "    #print(words)\n",
    "    first_word = words[0]\n",
    "    first_words.append(first_word)\n",
    "    \n",
    "print(\" \".join(first_words))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Navigating two lists at a time\n",
    "\n",
    "This is borrowed from the week 2 lecture that I didn't get to"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "names = ['Starbuck', 'She-Ra', 'Ada', 'Leeloo']\n",
    "homes = ['Battlestar Galactica', 'Eternia', 'England', 'Mondoshawa']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The name is: Starbuck\n",
      "The name is: She-Ra\n",
      "The name is: Ada\n",
      "The name is: Leeloo\n",
      "The home is: Battlestar Galactica\n",
      "The home is: Eternia\n",
      "The home is: England\n",
      "The home is: Mondoshawa\n"
     ]
    }
   ],
   "source": [
    "for name in names:\n",
    "    print(\"The name is:\", name)\n",
    "    \n",
    "for home in homes:\n",
    "    print(\"The home is:\", home)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "How can we combine these things?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[(0, 'Starbuck'), (1, 'She-Ra'), (2, 'Ada'), (3, 'Leeloo')]\n"
     ]
    }
   ],
   "source": [
    "print(list(enumerate(names)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "So now that we're using the index position, we can use it elsewhere as well.  Say we wanted to also print out the home for each name.  \n",
    "\n",
    "Given that we know the lengths for each list are the same and we know that they match up..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "the index is: 0 -- the name is: Starbuck\n",
      "the index is: 1 -- the name is: She-Ra\n",
      "the index is: 2 -- the name is: Ada\n",
      "the index is: 3 -- the name is: Leeloo\n"
     ]
    }
   ],
   "source": [
    "for index, name in enumerate(names):\n",
    "    print(\"the index is:\", index, \"-- the name is:\", name)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The home of Starbuck is Battlestar Galactica\n",
      "The home of She-Ra is Eternia\n",
      "The home of Ada is England\n",
      "The home of Leeloo is Mondoshawa\n"
     ]
    }
   ],
   "source": [
    "for index, name in enumerate(names):\n",
    "    home = homes[index]\n",
    "    print(\"The home of\", name, \"is\", home)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "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": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Strings\n",
    "\n",
    "We're going to play a little bit with strings now, as prep for next week.  Hopefully after exploring the start/stop/step notation with range and lists, this should all look pretty similar.\n",
    "\n",
    "You've seen this before and been using them in `print()` statements, but now we're going to take a bit of a deeper dive into them.\n",
    "\n",
    "Two things to note:\n",
    "\n",
    "1. Strings can be sliced, using a syntax that's pretty much the same as you've done with lists.\n",
    "2. Strings have a bajillion methods, which you don't need to memorize.  Just keep this in mind, \"I need to do something with a string, let me look up how to do that.\"  Then do so and use it.  Here's a selection: https://docs.python.org/3/library/stdtypes.html#string-methods\n",
    "    * There are a few solid gold goodies here that you'll be using a lot:\n",
    "        * .split()\n",
    "        * .upper()/.lower()\n",
    "        * .endswith()/.beginswith()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## String indexing\n",
    "\n",
    "Remember our list slicing:\n",
    "\n",
    "`string[start:stop(still exclusive!!):step]`\n",
    "\n",
    "Strings work the same way.  Except instead of working through the elements of a list, you work through the individual letters.\n",
    "\n",
    "How does Python know to do this?  Because someone coded that into what it means to be a string and a list object.  You can just trust that it works that way."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "species = \"Meat Popsicle\" # assignment just like normal"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Meat Popsicle\n"
     ]
    }
   ],
   "source": [
    "print(species)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "M\n"
     ]
    }
   ],
   "source": [
    "print(species[0]) # get the first"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "e\n"
     ]
    }
   ],
   "source": [
    "print(species[-1]) # get the last"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Meat\n"
     ]
    }
   ],
   "source": [
    "print(species[0:4]) # get the first 4 letters\n",
    "# what is an equivalent expression to do this? e.g. which of these numbers are optional?"
   ]
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "kernelspec": {
   "display_name": "Python [conda root]",
   "language": "python",
   "name": "conda-root-py"
  },
  "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.5.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}