Tutorial001_IntroToPython.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Getting started in python-with-jupyter guide\n",
    "-[the official tutorial](https://docs.python.org/3/)\n",
    "\n",
    "-[nice intro to basics of language](https://www.w3schools.com/python/default.asp)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Assign a variable and print it out (much more on different variable types in NumPy tutorials)\n",
    "[obama kills fly](https://www.youtube.com/watch?v=yyQ3ToiimyM)\n",
    "\n",
    "case sensitive\n",
    "no explicit term to initialize variable as in C or other languages (e.g. no \"int x, x=8\" synatax)\n",
    "\n",
    "var names must start with underscore character or a letter - NOT a number\n",
    "\n",
    "can only contain alpha-numeric characters and underscores (A-z, 0-9, and _ )\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Obama kills as fly\n",
      "Obama kills another's fly\n"
     ]
    }
   ],
   "source": [
    "# define a string...\n",
    "x = 'Obama kills as fly'\n",
    "print(x)\n",
    " \n",
    "# this is another way to define a string\n",
    "x = \"Obama kills another fly\"\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Obama kills another's fly 17 times a day\n"
     ]
    }
   ],
   "source": [
    "# declare a numerical variable, can easily combine with strings in print statement...\n",
    "y = 17\n",
    "print(x, y, 'times a day')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-info\">\n",
    "Note that Python is a strongly typed language - some languages will implicitly (automatically) recast variable types (e.g. basic or java). Python allows explcit recasting or reassignment to a variable of a different type, but will not do so automatically except in obvious cases like upcasting\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "value of x:  2 type of x:  <class 'int'>\n",
      "value of x:  2 type of x:  <class 'str'>\n"
     ]
    }
   ],
   "source": [
    "# declare x as an int\n",
    "x = 2\n",
    "print('value of x: ', x, 'type of x: ', type(x))\n",
    "\n",
    "# now declare as a string, this is ok...\n",
    "x = '2'\n",
    "print('value of x: ', x,  'type of x: ', type(x))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "type of x:  <class 'str'> type of y:  <class 'int'>\n"
     ]
    },
    {
     "ename": "TypeError",
     "evalue": "must be str, not int",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-11-74a0f8b6a408>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      7\u001b[0m \u001b[0;31m# so this will throw an error, whereas in some other languages it might\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      8\u001b[0m \u001b[0;31m# either return 4 (e.g. VB if recast to ints) or maybe even 22 (java if recast to strs)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 9\u001b[0;31m \u001b[0mx\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0my\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m: must be str, not int"
     ]
    }
   ],
   "source": [
    "# but you can't do this because you can't combine int and str data types\n",
    "y = 2\n",
    "x = '2'\n",
    "\n",
    "print('type of x: ', type(x), 'type of y: ', type(y))\n",
    "\n",
    "# so this will throw an error, whereas in some other languages it might \n",
    "# either return 4 (e.g. VB if recast to ints) or maybe even 22 (java if recast to strs)\n",
    "x+y  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-warning\">\n",
    "variable assignments often lead to <b>references</b> in Python, not <b>copies</b> as in many languages.\n",
    "This is SUPER important to understand!\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[3, 5]\n"
     ]
    }
   ],
   "source": [
    "# assign a variable - short array in this case\n",
    "x = [1,5]\n",
    "\n",
    "# then make another variable, y, and assign it to x\n",
    "y = x\n",
    "\n",
    "# in most languages this would make a copy of what is in x and then assign that to y\n",
    "# i.e. you would have two separate variables that contain independent copies of the data\n",
    "# but in Python, by default, y is just a reference to x and in turn they reference the same\n",
    "# data in memory.\n",
    "\n",
    "# change the first element in y and see what happens to x!\n",
    "y[0] = 3\n",
    "\n",
    "print(x)\n",
    "\n",
    "# we'll talk about 'deep copies' later when we get to NumPy (and fancy indexing/slicing), just keep this in mind for now"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Control flow - conditionals and loops to iteratively apply functionality to series of data\n",
    "[if...elif...else conditions](https://www.w3schools.com/python/python_conditions.asp)\n",
    "\n",
    "[while and for loops](https://www.w3schools.com/python/python_while_loops.asp)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x = 10\n"
     ]
    }
   ],
   "source": [
    "# if...elif...else...\n",
    "# note the indentation! this is key as python has no 'begin...end' syntax like the curly braces in C or R  \n",
    "x = 10\n",
    "\n",
    "# then see what x is...\n",
    "if x > 10:\n",
    "    print(\"yep, its greater than 10\")\n",
    "elif x == 10:\n",
    "    print('x = 10')\n",
    "elif 0 <= x < 10:\n",
    "    print(\"x is less than 10, but still >= 0\")\n",
    "elif x < 0:\n",
    "    print(\"x is negative\")\n",
    "else: # catch-all\n",
    "    print(\"who knows what x is - maybe imaginary?\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "that's not even a number you gave me\n"
     ]
    }
   ],
   "source": [
    "# even better - use nested if...elif...else statements to catch errors \n",
    "x = 'string'\n",
    "\n",
    "\n",
    "if type(x) is int:\n",
    "\n",
    "    # then see what x is...\n",
    "    if x > 10:\n",
    "        print(\"yep, its greater than 10\")\n",
    "    elif x == 10:\n",
    "        print('x = 10')\n",
    "    elif 0 <= x < 10:\n",
    "        print(\"x is less than 10, but still >= 0\")\n",
    "    elif x < 0:\n",
    "        print(\"x is negative\")\n",
    "    else: # catch-all\n",
    "        print(\"who knows what x is?\")\n",
    "\n",
    "else: # catch all\n",
    "    print(\"that's not even a number you gave me\")\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "yep, its greater than 10\n"
     ]
    }
   ],
   "source": [
    "# if you mess up the indentation, then it will throw an error\n",
    "x = 20\n",
    "\n",
    "# then see what x is...\n",
    "if x > 10:\n",
    "    print(\"yep, its greater than 10\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### For loops - iteratively do stuff a fixed number of times "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "ename": "IndentationError",
     "evalue": "expected an indented block (<ipython-input-27-d3d191891599>, line 8)",
     "output_type": "error",
     "traceback": [
      "\u001b[0;36m  File \u001b[0;32m\"<ipython-input-27-d3d191891599>\"\u001b[0;36m, line \u001b[0;32m8\u001b[0m\n\u001b[0;31m    print('Iteration: ', i, x[i]*y[i])\u001b[0m\n\u001b[0m        ^\u001b[0m\n\u001b[0;31mIndentationError\u001b[0m\u001b[0;31m:\u001b[0m expected an indented block\n"
     ]
    }
   ],
   "source": [
    "#iterate using a for loop\n",
    "y = [20,10,0]\n",
    "x = [0,10,20]\n",
    "\n",
    "# loop over elements by iterating from 0:len(x)-1 and applying * operation to each \n",
    "# set of elements in x, y. Note that \"range(len(x))\" is iterable (it defines a range, not just a single number)\n",
    "for i in range(len(x)):\n",
    "    print('Iteration: ', i, x[i]*y[i])\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "range(0, 3)"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "range(len(x))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For loops can iterate directly over lists. This can be convienient/faster if you do not care about what iteration a loop is on or do not need to go through multiple lists at once. You can skip to the next iteration of a for-loop using the **continue** command."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "100\n",
      "400\n"
     ]
    }
   ],
   "source": [
    "# print positive values of x^2\n",
    "for i in x:\n",
    "    if i == 0:\n",
    "        continue\n",
    "    else:\n",
    "        print(i*i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### While loop - keep looping until some condition is met...also illustration of 'break' - make sure that you think carefully before using a 'while' loop...if you don't have a reachable escape condition then it will just sit there and spin forever!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.6066766502914913\n",
      "0.8790408495511526\n",
      "0.8071094732351763\n",
      "0.9018110237038203\n",
      "0.37836693846348457\n",
      "0.4939436829451781\n",
      "0.02887925111434453\n",
      "0.9118753822297947\n",
      "0.756419066698272\n",
      "0.038552040410820054\n",
      "0.020362211956076792\n",
      "0.3319501336131725\n",
      "0.9051020433565558\n",
      "0.3918586562969191\n",
      "0.6133269233870872\n",
      "0.8853322651499417\n",
      "0.16169842864675887\n",
      "0.7104070837807461\n",
      "0.039707307750215914\n",
      "0.6767016489742128\n",
      "0.12476295609401522\n",
      "0.0706996043998741\n",
      "0.27371909333383826\n",
      "0.4131124272704644\n",
      "0.47848611556024057\n",
      "0.7005222677067616\n",
      "0.9520188546359964\n",
      "0.4504545994197173\n",
      "0.7608736912263251\n",
      "0.670796449621201\n",
      "0.8979519274367953\n",
      "0.8609472884824648\n",
      "0.1347277391203482\n",
      "0.9622852289769173\n",
      "0.2162252984499251\n",
      "0.2764249398866131\n",
      "0.4633314998958509\n",
      "0.10464696842673094\n",
      "0.33155511539473614\n",
      "0.976921076434106\n",
      "0.9575364440069156\n",
      "0.5167511091521977\n",
      "0.032711773882525\n",
      "0.8872793164905844\n",
      "0.44014076459036244\n",
      "0.23553537427074778\n",
      "0.16295761437787348\n",
      "0.5038790761882431\n",
      "0.5417915127259322\n",
      "0.3001486443507746\n",
      "0.6652897101511076\n",
      "0.1051968533374017\n",
      "0.24772271184279826\n",
      "0.203729662367372\n",
      "0.7757964706484707\n",
      "0.3810758487897419\n",
      "0.9852032155866961\n",
      "0.23800827646495093\n",
      "0.4565874195450573\n",
      "0.21073810923864023\n",
      "0.9777747774085742\n",
      "0.12086052161261374\n",
      "0.3113232155987209\n",
      "0.8116713453255558\n",
      "0.9116974711418264\n",
      "0.7734756878091225\n",
      "0.30792170959695986\n",
      "0.953817471646996\n",
      "0.7534501096794799\n",
      "0.6186214092348004\n",
      "0.9964155086935755\n"
     ]
    }
   ],
   "source": [
    "import random\n",
    "x = random.random()\n",
    "print(x)\n",
    "while x < .99:\n",
    "    x = random.random()\n",
    "    print(x)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### break out of a while loop"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "# break statement\n",
    "x = random.random()\n",
    "\n",
    "# as long as x is less than .9999999 then keep going, UNLESS x is in between .86 and .88, then bail out\n",
    "while x < .99999999:\n",
    "    x = random.random()\n",
    "    print(x)\n",
    "    \n",
    "    if x > .86 and x < .88:\n",
    "        print('x is between .86 and .88')\n",
    "        break\n",
    "        "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### A common use of the 'break' statement - infinite loop until condition is met. Expample: having your stimulus presentation software wait for input from hardware (rig, fMRI machine, etc).  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Start stimulus presentation?[y/n]?\n",
      "lfroasjdflkasjdlfkjasd\n",
      "Start stimulus presentation?[y/n]?\n",
      "lsdf.sdnfg\n",
      "Start stimulus presentation?[y/n]?\n",
      "lasdfnglkjsdfl\n",
      "Start stimulus presentation?[y/n]?\n",
      "lasjdflkasdjf\n",
      "Start stimulus presentation?[y/n]?\n",
      "laksjdflkajsdlf\n",
      "Start stimulus presentation?[y/n]?\n",
      "y\n",
      "starting stimulus\n"
     ]
    }
   ],
   "source": [
    "stim_trigger = ''\n",
    "while 1:\n",
    "    print('Start stimulus presentation?[y/n]?')\n",
    "    stim_trigger = input()\n",
    "    if stim_trigger == 'y':\n",
    "        print('starting stimulus')  \n",
    "        break    \n",
    "    elif stim_trigger == 'n':\n",
    "        print('exiting experiment')\n",
    "        break\n",
    "        \n",
    "# alternate form where the 'break' condition is specified in the while statement\n",
    "# stim_trigger = ''\n",
    "# while stim_trigger != 'y':\n",
    "#     print('Start stimulus presentation?[y/n]?')\n",
    "#     stim_trigger = input()\n",
    "        \n",
    "# print('starting stimulus')       "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## List, tuples, sets and dictionaries\n",
    "\n",
    "Python has a number of data types that you may find useful:\n",
    "\n",
    "Lists are initialized with brackets '[]'\n",
    "\n",
    "Tuples are initialized with parenthesis '()'\n",
    "\n",
    "Dictionaries are initializes with curly brackets '{}'\n",
    "\n",
    "A list is exactly what it sounds like. Each element in a list can be just about anything: a scalar, annother list, annother data type (tuple, dictionary, iterator), or even a function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 1, 2, 3, 4]\n"
     ]
    }
   ],
   "source": [
    "# define a simple list\n",
    "a_simple_list = [0,1,2,3,4]\n",
    "print(a_simple_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Indexing into lists...basics. will do more with this next time in NumPy. Remember: the element at the start index is included, but the stop index is NOT included...as a result, the number of elements returned is (stop-start). "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-info\">\n",
    "Python, like C and many other languages, uses 0-based counting (whereas Matlab uses 1-based counting). \n",
    "\n",
    "\n",
    "![zero based counting](https://imgs.xkcd.com/comics/donald_knuth.png)\n",
    "\n",
    "![schematic](http://serenceslab.ucsd.edu/231_stuff/support_files/index_python.png)\n",
    "\n",
    "Several reasons for this but here are a few intuitions. \n",
    "(1) In our list above, if you wanted to find the value of the first element, how many places do you have to move away from the start? the answer is 0...(2) efficiency - in our list of 5 elements (or more generally N elements), all index values (i) fall between 0 <= i < N. However, if we had 1 based indexing, then all values would fall between 1 <= i < N+1. Small difference, but slightly more overhead.  \n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 1, 2, 3, 4]\n",
      "2\n"
     ]
    }
   ],
   "source": [
    "# some examples...remember the 0 thing we just talked about\n",
    "#- items in a list can be accessed by an index and a pair of square brackets\n",
    "print(a_simple_list)\n",
    "print(a_simple_list[2])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 1, 2, 3, 4, 5]\n"
     ]
    }
   ],
   "source": [
    "#- items can be added to a list by using the append function\n",
    "a_simple_list.append(5)\n",
    "print(a_simple_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 1, 2, 3, 4, 5]\n",
      "[0, 1, 2]\n"
     ]
    }
   ],
   "source": [
    "# To access the first n items in a list:\n",
    "n = 3\n",
    "print(a_simple_list)\n",
    "print(a_simple_list[:n])  # goes up to, but does not incldue, the stop index"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 1, 2, 3, 4, 5]\n",
      "[3, 4, 5]\n"
     ]
    }
   ],
   "source": [
    "# To access the items in a list after n:\n",
    "print(a_simple_list)\n",
    "print(a_simple_list[n:])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 1, 2, 3, 4, 5]\n",
      "[2, 3]\n"
     ]
    }
   ],
   "source": [
    "# To access a range of values:\n",
    "print(a_simple_list)\n",
    "print(a_simple_list[2:4])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 1, 2, 3, 4, 5]\n",
      "[2, 3, 4]\n"
     ]
    }
   ],
   "source": [
    "# You can also use negative numbers to work from the back of the list:\n",
    "print(a_simple_list)\n",
    "print(a_simple_list[-4:-1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 1, 2, 3, 4, 5]\n",
      "[0, 2, 4]\n"
     ]
    }
   ],
   "source": [
    "# Grab every second item in a list\n",
    "print(a_simple_list)\n",
    "print(a_simple_list[::2])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2, 4, 6]\n"
     ]
    }
   ],
   "source": [
    "# Grab every second item starting with the 2nd item and going to the 8th item\n",
    "another_list = [0,1,2,3,4,5,6,7,8,9,10]   # make a longer list...\n",
    "print(another_list[2:8:2])                "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 1, 2, 3, 4, 5]\n",
      "[5, 4, 3, 2, 1, 0]\n"
     ]
    }
   ],
   "source": [
    "# Reverse a list\n",
    "print(a_simple_list)\n",
    "print(a_simple_list[::-1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### built in methods related to lists"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[7, 5, 4, 1]\n",
      "[1, 4, 5, 7]\n"
     ]
    }
   ],
   "source": [
    "a_list = [7,5,4,1]\n",
    "print(a_list)\n",
    "a_list.sort()\n",
    "print(a_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Pop: 5\n",
      "0 1 2 3 4\n"
     ]
    }
   ],
   "source": [
    "#- pop function - \n",
    "print('Pop: %d', %a_simple_list.pop())\n",
    "print(*a_simple_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# to see a full set of methods type a_list. then hit the tab key...\n",
    "a_list."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### can also call built in python methods\n",
    "\n",
    "[list of built in methods](https://docs.python.org/3/library/functions.html)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a_list = [7,5,4,1]\n",
    "print('length of this list: ', len(a_list))\n",
    "print('max of this list: ', max(a_list))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "min of this list:  bob\n",
      "max of this list:  cindy\n"
     ]
    }
   ],
   "source": [
    "# note that not all methods work for all types, and in other cases you get kind of cool behavior like this:\n",
    "a_list = ['bob', 'charlie','cindy']\n",
    "print('min of this list: ', min(a_list))\n",
    "print('max of this list: ', max(a_list))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-info\">\n",
    "Lists can contain mixed data types - they can even contain FUNCTIONS\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2018, 'UCSD', [0, 1, 2, 3, 4], range(0, 5), <built-in function sum>, [1, 1, 2, 3, 5, 8, 13, 21]]\n",
      "The next item in the fibonacci sequence is: 34 \n"
     ]
    }
   ],
   "source": [
    "a_weird_list = [2018,'UCSD',a_simple_list,range(5),sum,[1,1,2,3,5,8,13,21]]\n",
    "print(a_weird_list)\n",
    "print('The next item in the fibonacci sequence is: %d '%a_weird_list[4](a_weird_list[5][-2:]))\n",
    "\n",
    "# note the indexing of a_weird_list[5][-2:]...5th element of a_weird_list, and last two elements of the list in in the 5th spot..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<function sum(iterable, start=0, /)>"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a_weird_list[4]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### using the zip function to make a list of pairs from two separate lists "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[(1, 4), (2, 3), (3, 2), (4, 1)]\n"
     ]
    }
   ],
   "source": [
    "list_a = [1,2,3,4]\n",
    "list_b = [4,3,2,1]\n",
    "x = list(zip(list_a, list_b))\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### now unzip it to recover original lists"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 2, 3, 4)\n",
      "(4, 3, 2, 1)\n"
     ]
    }
   ],
   "source": [
    "z, u = zip(*x)\n",
    "print(z)\n",
    "print(u)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Tuples\n",
    "\n",
    "Tuples are collections of things and they are very similar to lists in a lot of ways. The main difference is that they are **immutable** meaning once they are created they cannot be changed... "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 'fish', 2, 'fish')\n",
      "('red', 'fish', 'blue', 'fish')\n"
     ]
    }
   ],
   "source": [
    "a_simple_tuple = (1,'fish',2,'fish')\n",
    "annother_tuple = ('red','fish','blue','fish')\n",
    "print(a_simple_tuple)\n",
    "print(annother_tuple)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('fish', 2, 'fish', 1)\n",
      "(100,) <class 'tuple'>\n",
      "100 <class 'int'>\n"
     ]
    }
   ],
   "source": [
    "# tuples are indexed the same way as lists\n",
    "print(a_simple_tuple[::-1])\n",
    "\n",
    "# a tuple can be created with only one element by including a trailing comma\n",
    "not_a_tuple = (100)\n",
    "a_short_tuple = (100,)\n",
    "\n",
    "print(a_short_tuple, type(a_short_tuple))\n",
    "print(not_a_tuple, type(not_a_tuple))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Tuples are immutable! Can't do this..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "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-54-8919b864f5a0>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0ma_simple_tuple\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;36m5\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      2\u001b[0m \u001b[0ma_simple_tuple\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mannother_tuple\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mTypeError\u001b[0m: 'tuple' object does not support item assignment"
     ]
    }
   ],
   "source": [
    "a_simple_tuple[0] = 5\n",
    "a_simple_tuple.append(annother_tuple)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-warning\">\n",
    "But, tuples can still change!\n",
    "If a tuple points to annother variable, and that variable changes, then the tuple \n",
    "value in that location *will* change. Important to be aware of when bug hunting.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "([1, 2, 3], 4)\n"
     ]
    }
   ],
   "source": [
    "a = [1,2,3]  # - list (mutable)\n",
    "c = (a,4)    # - tuple (immutable)\n",
    "print(c)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "([1, 14, 3], 4)\n"
     ]
    }
   ],
   "source": [
    "a[1]=14\n",
    "print(c)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Tuples are *iterable*\n",
    "Tuples (as well as lists) can be iterated over in for loop"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 is type: <class 'int'>\n",
      "fish is type: <class 'str'>\n",
      "2 is type: <class 'int'>\n",
      "fish is type: <class 'str'>\n"
     ]
    }
   ],
   "source": [
    "for i in a_simple_tuple:\n",
    "    print('%s is type: %s' %(i,type(i)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Dictionaries\n",
    "Unlike lists & tuples, dictionaries are indexed by 'keys' which mark each entry"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "School:\t Santa Barbara \tNumber of students:\t 21574\n",
      "School:\t Santa Cruz \tNumber of students:\t 16962\n",
      "School:\t Irvine \tNumber of students:\t 27331\n",
      "School:\t Los Angeles \tNumber of students:\t 30873\n",
      "School:\t Merced \tNumber of students:\t 6815\n",
      "School:\t Riverside \tNumber of students:\t 19799\n",
      "School:\t San Diego \tNumber of students:\t 28127\n",
      "School:\t San Francisco \tNumber of students:\t 0\n",
      "School:\t Berkeley \tNumber of students:\t 29310\n",
      "School:\t Davis \tNumber of students:\t 29379\n"
     ]
    }
   ],
   "source": [
    "UC_Enrollment = {'Santa Barbara':21574,'Santa Cruz':16962,'Irvine': 27331,'Los Angeles':30873,\n",
    "                 'Merced':6815,'Riverside':19799,'San Diego':28127,'San Francisco':0,\n",
    "                 'Berkeley':29310,'Davis':29379}\n",
    "# source: https://www.thoughtco.com/comparison-university-of-california-campuses-786974\n",
    "\n",
    "# the keys command gives a list of all keys (not technically a list but behaves the same way)\n",
    "schools = UC_Enrollment.keys()\n",
    "\n",
    "# can loop over and print out...\n",
    "for school in schools:\n",
    "    num_students = UC_Enrollment[school]\n",
    "    print('School:\\t', school, '\\tNumber of students:\\t',num_students)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Can add new entries "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'Santa Barbara': 21574, 'Santa Cruz': 16962, 'Irvine': 27331, 'Los Angeles': 30873, 'Merced': 6815, 'Riverside': 19799, 'San Diego': 28127, 'San Francisco': 0, 'Berkeley': 29310, 'Davis': 29379, 'UC11': '100000000'}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "19799"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "UC_Enrollment[\"UC11\"] = \"100000000\"\n",
    "print(UC_Enrollment)\n",
    "UC_Enrollment[\"Riverside\"]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### And delete entries"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [],
   "source": [
    "del UC_Enrollment[\"UC11\"]\n",
    "#del UC_Enrollment  # delete the entire dictionary\n",
    "# UC_Enrollment.clear() # clear out all entries"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Dictionaries are also directly iterable (both keys and indexed values)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "21574\n",
      "16962\n",
      "27331\n",
      "30873\n",
      "6815\n",
      "19799\n",
      "28127\n",
      "0\n",
      "29310\n",
      "29379\n"
     ]
    }
   ],
   "source": [
    "for x in UC_Enrollment.values():\n",
    "    print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Santa Barbara 21574\n",
      "Santa Cruz 16962\n",
      "Irvine 27331\n",
      "Los Angeles 30873\n",
      "Merced 6815\n",
      "Riverside 19799\n",
      "San Diego 28127\n",
      "San Francisco 0\n",
      "Berkeley 29310\n",
      "Davis 29379\n"
     ]
    }
   ],
   "source": [
    "for x, y in UC_Enrollment.items():\n",
    "    print(x, y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Sets are collections of unique elements - like a dictionary but keys"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{1, 2, 3}\n"
     ]
    }
   ],
   "source": [
    "x = {1,2,3}  # x = set([1,2,3])\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{1, 2, 3, 4, 5}\n"
     ]
    }
   ],
   "source": [
    "x = {1,1,1,2,3,4,5}  # only unique elements!\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### sets support mathmatical 'set' operations like union, intersection, difference, etc"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1, 2, 3, 4, 5, 6}"
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = {1,2,3,4}\n",
    "y = {3,4,5,6}\n",
    "x.union(y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{3, 4}"
      ]
     },
     "execution_count": 68,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x.intersection(y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Python functions - declare your own functions so that you can easily use algorithms that you need over and over."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def check_input_value(x):\n",
    "    \n",
    "    if x > 0:\n",
    "        x = x + 10\n",
    "        print('adding 10 to input, new number is:', x)\n",
    "    elif x < 0:\n",
    "        x = x - 10\n",
    "        print('subtracting 10 from input, new number is:', x)\n",
    "    else:\n",
    "        x = NaN\n",
    "        print('enter a number')\n",
    "        \n",
    "    return x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# now call the function and pass in a number\n",
    "y = check_input_value(10)\n",
    "print(y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### write the function out to a .py file for repeated using the writefile cell magic command (note the %% for cell magics as opposed to % for line magics)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Writing check_input_value.py\n"
     ]
    }
   ],
   "source": [
    "%%writefile check_input_value.py\n",
    "\n",
    "def check_input_value(x):\n",
    "    \n",
    "    if x > 0:\n",
    "        x = x + 10\n",
    "        print('adding 10 to input, new number is:', x)\n",
    "    elif x < 0:\n",
    "        x = x - 10\n",
    "        print('subtracting 10 from input, new number is:', x)\n",
    "    else:\n",
    "        x = NaN\n",
    "        print('enter a number')\n",
    "        \n",
    "    return x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### write out a .py file that has multiple functions in it, then you can call it as a module"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Overwriting some_random_tools.py\n"
     ]
    }
   ],
   "source": [
    "%%writefile some_random_tools.py\n",
    "\n",
    "def square(x):\n",
    "    y = x * x # or x**2\n",
    "    return y\n",
    "\n",
    "def times_ten(x):\n",
    "    y = x * 10\n",
    "    return(y)\n",
    "\n",
    "def cubed(x):\n",
    "    y = x * x * x\n",
    "    return(y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### now import your new module and access the functionality. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "25\n",
      "50\n",
      "125\n"
     ]
    }
   ],
   "source": [
    "import some_random_tools as srt\n",
    "\n",
    "x = 5\n",
    "\n",
    "print(srt.square(x))\n",
    "\n",
    "print(srt.times_ten(x))\n",
    "\n",
    "print(srt.cubed(x))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### handy way to keep track of values passed to a function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [],
   "source": [
    "def minus_two_numbers(x,y):\n",
    "    z = x - y \n",
    "    return z"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 74,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "minus_two_numbers(x=10, y=5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### BUT you can also do this to gain flexibility if you remember in the input requires but you forget what order"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 75,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "minus_two_numbers(y=5, x=10)  # still get the right answer by explicitly declaring input vars by name"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-info\">\n",
    "If a variable is defined within a function, like 'z' above, then it is in the local namespace - it is created when the function is called and then destroyed after the function returns. Variables created outside of functions are in the global namespace and can be accessed from any cell in the notebook. \n",
    "</div>"
   ]
  }
 ],
 "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.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}