pfn_4.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "2-Yz0-fSktMw"
   },
   "source": [
    "# Dictionaries\n",
    "\n",
    "Dictionaries are a mutable datatype consisting of key and value pairs. They are good for quickly accessing the values of arbitrary keys. Keys and values can both be any data type.\n",
    "\n",
    "Dictionaries look like this:\n",
    "```\n",
    "{\n",
    "  key0: value0,\n",
    "  key1: value1,\n",
    "  key2: value2\n",
    "}\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "id": "JjnFGOxffAyv"
   },
   "outputs": [],
   "source": [
    "# Dictionaries:\n",
    "monkey_A = {\n",
    "'spiketimes': [0,20,34,56],\n",
    "'name': 'Einstein',\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "id": "F8vWMzo4fAyv",
    "outputId": "7ff915a1-4fa8-417f-8d70-045441a1234f"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'spiketimes': [0, 20, 34, 56], 'name': 'Einstein'}"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "monkey_A"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "P1z9CEezcd3L"
   },
   "source": [
    "In VSCode, we can see the functions available as properties of monkey_A by typing `monkey_A.` and seeing the autocomplete options that come up (more on functions and properties in future lessons). Explore a few of these using `help`, `?`, or `??`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "id": "DQoLBC5Vcd3L",
    "outputId": "81b2ec04-3786-4600-dd0e-5f7c45f19b51"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[1;31mDocstring:\u001b[0m\n",
      "D.pop(k[,d]) -> v, remove specified key and return the corresponding value.\n",
      "\n",
      "If the key is not found, return the default if given; otherwise,\n",
      "raise a KeyError.\n",
      "\u001b[1;31mType:\u001b[0m      builtin_function_or_method\n"
     ]
    }
   ],
   "source": [
    "monkey_A.pop?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "JmMftxN7cd3L"
   },
   "source": [
    "Using the above strategy, can you figure out how to list the keys in the dictionary? Try it out below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "jG_SIu6XfAyv",
    "outputId": "8f00f4c5-3f99-497a-bd5d-f4cc2037cfe0"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dict_keys(['spiketimes', 'name'])"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "monkey_A.keys() # lists the keys in the dictionary\n",
    "#why do we need the () so we can see everything\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "sHFeUPMITkxI"
   },
   "source": [
    "You can access a dictionary's value by using the key as an index."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "id": "C7ms44AbfAyv",
    "outputId": "17361e83-bde3-40a1-89b1-3e689b5eba34"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 20, 34, 56]"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "monkey_A['spiketimes'] # gets the value at the key inside the brackets"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "2e80huhKc1PB"
   },
   "source": [
    "What will `monkey_A['name']` output?\n",
    "\n",
    "Guess, and then type and run below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "id": "koSoYxyMfAyv"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Einstein'"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "monkey_A['name']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "nCzuGa94Tyo0"
   },
   "source": [
    "Indexing also allows you to change a key's value or add a new key-value pair."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "id": "Q7psX3R2fAyv"
   },
   "outputs": [],
   "source": [
    "monkey_A['lab'] = 'Churchland' # adds key, value pair to dictionary ('lab' is the key, 'Churchland' is the value)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "id": "uLsFxys4jTKr",
    "outputId": "d729f219-fd50-42d1-86b7-44daefeaad4e"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'spiketimes': [0, 20, 34, 56], 'name': 'Einstein', 'lab': 'Churchland'}"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "monkey_A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "id": "Ek933PWNfAyv",
    "outputId": "19513287-40e3-496a-fa23-3da8c6b9393d"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'lab' in monkey_A # test if a key is in a dictionary\n",
    "# this also work with strings (e.g. 'hi' in 'abhi' will be True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "id": "ZmVwk6bxfAyv",
    "outputId": "97272f92-2143-4a89-ed6e-09c79288dc25"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "del monkey_A['lab'] # delete a key value pair\n",
    "'lab' in monkey_A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "id": "ppgjADm4jTK2",
    "outputId": "d3b2c8a0-0b62-4d31-f1d7-cbfc2df0090e"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'spiketimes': [0, 20, 34, 56], 'name': 'Einstein'}"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "monkey_A\n",
    "\n",
    "'''Why don't we use print? By default, python will print the last line '''"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "zrEbKxVLlXUL"
   },
   "source": [
    "you can create dictionaries from lists and by setting keys equal to values using the `dict` constructor"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "E1z-_Gu3fAyv",
    "outputId": "d64a9d50-e457-4550-b617-b6d82a4179a2"
   },
   "outputs": [],
   "source": [
    "my_list = [(1,'Jasmine'), (2, 'Jasmine'), (3, 'Jasmine'), (4, 'Sam'), (5,'Sam')]\n",
    "print(my_list)\n",
    "\n",
    "dict(my_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "ylPBVB5YfAyv",
    "outputId": "8168d99c-0c15-4620-f1d3-bc71331c627b"
   },
   "outputs": [],
   "source": [
    "dict(instructor_1 = 'Jasmine', instructor_2 = 'Sam', instructor_3 = 'Abhi')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "FF_FUEVxjTK3"
   },
   "source": [
    "Note that dictionary keys need to be unique, so, for example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "jNqi7aK8jTK4",
    "outputId": "b78796f5-d38a-4126-b6f2-f8c32f1eb3ff"
   },
   "outputs": [],
   "source": [
    "my_list = [(1,'Jasmine'), (1, 'Abhi')]\n",
    "dict(my_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "aw_365dtjTK4"
   },
   "source": [
    "will not give what we expect, but values do not need to be unique, which is why the below works."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "gFknaikgjTK4",
    "outputId": "8d4295d4-4a0b-42c3-9d8d-2106f2d8934d"
   },
   "outputs": [],
   "source": [
    "my_list = [(1,'Jasmine'), (2, 'Jasmine')]\n",
    "dict(my_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "DVb0Vp4-a76E"
   },
   "source": [
    "## Exercise\n",
    "\n",
    "1. Create a dictionary (using any of the above methods) of what you would order for lunch if you could. Have the keys be the menu items, and the values be their prices. Store the dictionary in a variable called `lunch_menu`\n",
    "2. Print out the keys of the dictionary.\n",
    "3. Get the price for a specific menu item out of the dictionary.\n",
    "4. Check if a certain menu item is in the dictionary.\n",
    "5. Delete that menu item from the dictionary.\n",
    "6. Check again if that menu item is in the dictionary."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "lunch_menu = {\n",
    "'hotdog': '$4',\n",
    "'omakase': '$100',\n",
    "'bbqribs': '$50',\n",
    "'lemonaid': '$3',\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dict_keys(['hotdog', 'omakase', 'bbqribs', 'lemonaid'])"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lunch_menu.keys()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'$100'"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lunch_menu['omakase']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'hotdog' in lunch_menu"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "ename": "KeyError",
     "evalue": "'hotdog'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mKeyError\u001b[0m                                  Traceback (most recent call last)",
      "\u001b[1;32mc:\\Users\\msjrr\\intropythongitrepo\\intropython\\pfn_4.ipynb Cell 30\u001b[0m in \u001b[0;36m<cell line: 1>\u001b[1;34m()\u001b[0m\n\u001b[1;32m----> <a href='vscode-notebook-cell:/c%3A/Users/msjrr/intropythongitrepo/intropython/pfn_4.ipynb#Y256sZmlsZQ%3D%3D?line=0'>1</a>\u001b[0m \u001b[39mdel\u001b[39;00m lunch_menu[\u001b[39m'\u001b[39m\u001b[39mhotdog\u001b[39m\u001b[39m'\u001b[39m]\n\u001b[0;32m      <a href='vscode-notebook-cell:/c%3A/Users/msjrr/intropythongitrepo/intropython/pfn_4.ipynb#Y256sZmlsZQ%3D%3D?line=1'>2</a>\u001b[0m \u001b[39mprint\u001b[39m(lunch_menu)\n",
      "\u001b[1;31mKeyError\u001b[0m: 'hotdog'"
     ]
    }
   ],
   "source": [
    "del lunch_menu['hotdog']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'omakase': '$100', 'bbqribs': '$50', 'lemonaid': '$3'}\n"
     ]
    }
   ],
   "source": [
    "print(lunch_menu)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "MGFATd1CfAyw"
   },
   "source": [
    "# Tuples \n",
    "Tuples are static, or immutable. Like strings, you cannot modify them once you have created them. Indexing works with tuples like it works with lists. Tuples are useful when you want to make sure something cannot accidentally get modified, and we will use them when we learn about functions next class."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "id": "vVWlOcr-fAyw"
   },
   "outputs": [],
   "source": [
    "my_tup = 'test',0,1 #created a tuple..could also had () aournd it "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "id": "ozc7W3KWfAyw",
    "outputId": "91f9ee64-0bdb-4aec-f3f8-40bc1d7c84b5"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('test', 0, 1)"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_tup"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "id": "tKZ9YvO4fAyw",
    "outputId": "862ab08f-42d8-44ea-bf30-5de7d3176ba6"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'test'"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_tup[0] #similar to list you can index into them"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "zAmTVwRlgR84"
   },
   "source": [
    "What will `my_tup[1]` output? Guess before typing and checking below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "id": "NjwcFuVefAyw",
    "outputId": "3827de57-f8c2-403b-8922-c7fa912ecf42"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_tup[1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "id": "EfjCO8FDfAyw"
   },
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "'tuple' object does not support item assignment",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32mc:\\Users\\msjrr\\intropythongitrepo\\intropython\\pfn_4.ipynb Cell 38\u001b[0m in \u001b[0;36m<cell line: 1>\u001b[1;34m()\u001b[0m\n\u001b[1;32m----> <a href='vscode-notebook-cell:/c%3A/Users/msjrr/intropythongitrepo/intropython/pfn_4.ipynb#X43sZmlsZQ%3D%3D?line=0'>1</a>\u001b[0m my_tup[\u001b[39m0\u001b[39m] \u001b[39m=\u001b[39m \u001b[39m'\u001b[39m\u001b[39mit worked\u001b[39m\u001b[39m'\u001b[39m\n",
      "\u001b[1;31mTypeError\u001b[0m: 'tuple' object does not support item assignment"
     ]
    }
   ],
   "source": [
    "my_tup[0] = 'it worked' # will this line work? It is immutable so it cannot be changed after creation "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {
    "id": "yWzAHCrUfAyw"
   },
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "can only concatenate tuple (not \"int\") to tuple",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32mc:\\Users\\msjrr\\intropythongitrepo\\intropython\\pfn_4.ipynb Cell 39\u001b[0m in \u001b[0;36m<cell line: 1>\u001b[1;34m()\u001b[0m\n\u001b[1;32m----> <a href='vscode-notebook-cell:/c%3A/Users/msjrr/intropythongitrepo/intropython/pfn_4.ipynb#X44sZmlsZQ%3D%3D?line=0'>1</a>\u001b[0m my_tup \u001b[39m+\u001b[39;49m \u001b[39m0\u001b[39;49m\n",
      "\u001b[1;31mTypeError\u001b[0m: can only concatenate tuple (not \"int\") to tuple"
     ]
    }
   ],
   "source": [
    "my_tup + 0 # what about this? You can add two tuples"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {
    "id": "jP-IR9F7fAyw"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('test', 0, 1, 0)"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_tup + (0,) # creates a new tuple, but my_tup is unchanged. This is how you add and not like above"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {
    "id": "bSRaJdEGfAyw",
    "outputId": "ad5cc416-d587-499f-e0e0-864250865985"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('test', 0, 1)"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_tup"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {
    "id": "AF9plXdOfAyw"
   },
   "outputs": [],
   "source": [
    "new_tup = my_tup + (0,) # I would need to assign this to a new value to add the two tuples "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {
    "id": "75NyJNOlfAyw"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('test', 0, 1, 0)"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "new_tup # what will new_tup be?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {
    "id": "o6fMFfexfAyw"
   },
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "'tuple' object doesn't support item deletion",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32mc:\\Users\\msjrr\\intropythongitrepo\\intropython\\pfn_4.ipynb Cell 44\u001b[0m in \u001b[0;36m<cell line: 1>\u001b[1;34m()\u001b[0m\n\u001b[1;32m----> <a href='vscode-notebook-cell:/c%3A/Users/msjrr/intropythongitrepo/intropython/pfn_4.ipynb#X52sZmlsZQ%3D%3D?line=0'>1</a>\u001b[0m \u001b[39mdel\u001b[39;00m my_tup[\u001b[39m0\u001b[39m]\n",
      "\u001b[1;31mTypeError\u001b[0m: 'tuple' object doesn't support item deletion"
     ]
    }
   ],
   "source": [
    "del my_tup[0] # Will this work? "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "rlz3_3dwtgUR"
   },
   "source": [
    "## Tuple Unpacking and Packing\n",
    "\n",
    "Tuple packing and unpacking refers to separating a tuple into variables or joining variables into a tuple. When unpacking `_` is used as a placeholder for a tuple value you do not care about using in further code."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('test', 0, 1)"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = my_tup[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [],
   "source": [
    "a, b, c = my_tup  #you would need to match the structure of the tuple "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'test'"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a, b , _ = my_tup #You can add \"_\"for all the parts you don't want to give a label to"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 164
    },
    "id": "kBXZw1THTP_8",
    "outputId": "bc8269e4-b86f-475e-913e-0b750d803e63"
   },
   "outputs": [],
   "source": [
    "a,b = my_tup # fails because only have two values to unpack into but tuple has 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "8kvGBPKLfAyw"
   },
   "outputs": [],
   "source": [
    "a,b,_ = my_tup # tuple unpacking"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "R1L9he9sfAyx",
    "outputId": "100fcd83-60e6-4d0f-ddf6-8741f54932d0"
   },
   "outputs": [],
   "source": [
    "print(a,b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "o5dquy_RfAyx"
   },
   "outputs": [],
   "source": [
    "new_tup = 1,2,3 # tuple packing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "sORUVCEtfAyx",
    "outputId": "b78bc8f9-424c-4d58-fbac-c72062c8b249"
   },
   "outputs": [],
   "source": [
    "new_tup"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "Bg_dKPT0TlvA",
    "outputId": "1ea4504d-02ba-4d2b-f10b-fa662115b980"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "((1, 2), 3)\n"
     ]
    }
   ],
   "source": [
    "hierarchical_tup = (1,2),3\n",
    "print(hierarchical_tup)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {
    "id": "JznAs8bDULe1",
    "outputId": "e69ed330-1e98-4d08-ef18-6c9f555ad95a"
   },
   "outputs": [
    {
     "ename": "ValueError",
     "evalue": "not enough values to unpack (expected 3, got 2)",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[1;32mc:\\Users\\msjrr\\intropythongitrepo\\intropython\\pfn_4.ipynb Cell 56\u001b[0m in \u001b[0;36m<cell line: 2>\u001b[1;34m()\u001b[0m\n\u001b[0;32m      <a href='vscode-notebook-cell:/c%3A/Users/msjrr/intropythongitrepo/intropython/pfn_4.ipynb#X63sZmlsZQ%3D%3D?line=0'>1</a>\u001b[0m \u001b[39m# Let's say we want a b and c to represent the three elements in our hierarchical tuple\u001b[39;00m\n\u001b[1;32m----> <a href='vscode-notebook-cell:/c%3A/Users/msjrr/intropythongitrepo/intropython/pfn_4.ipynb#X63sZmlsZQ%3D%3D?line=1'>2</a>\u001b[0m a,b,c \u001b[39m=\u001b[39m hierarchical_tup\n",
      "\u001b[1;31mValueError\u001b[0m: not enough values to unpack (expected 3, got 2)"
     ]
    }
   ],
   "source": [
    "# Let's say we want a b and c to represent the three elements in our hierarchical tuple\n",
    "a,b,c = hierarchical_tup\n",
    "# Why does this fail?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [],
   "source": [
    "(a,b),c = hierarchical_tup"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "VL38sLF-TqRN"
   },
   "outputs": [],
   "source": [
    "# How can we unpack this?\n",
    "\n",
    "# Unpack multiple tuples\n",
    "\n",
    "x, c = hierarchical_tup\n",
    "a,b = x\n",
    "\n",
    "# Hierarchical Tuple Unpacking\n",
    "\n",
    "(a,b),c = hierarchical_tup"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "e0QEHD5Jg3l5"
   },
   "source": [
    "## Exercise:\n",
    "\n",
    "1. Are tuples mutable or immutable?\n",
    "2. Create a tuple of your and your coding partner's names, called `our_names`.\n",
    "3. Unpack the tuple using a placeholder for your own name.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [],
   "source": [
    "our_names = 'Inis', 'Carlos'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [],
   "source": [
    "_, c = our_names"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Carlos'"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "c"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "YYKtXB35f5Ip"
   },
   "source": [
    "# For loops\n",
    "\n",
    "For loops let us repeat code, for example when iterating through a dictionary, list, or a tuple. We can also use for loops when we want to repeat code a certain number of times."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "boVLqbFxcd3O"
   },
   "source": [
    "### Directly iterate through a list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [],
   "source": [
    "teachers = ['jasmine', 'sam', 'abhi']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {
    "id": "MzvAGtzxfAyw",
    "outputId": "f08933e7-56a2-4fa0-d86c-24e79a4cc91b"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "jasmine\n",
      "sam\n",
      "abhi\n"
     ]
    }
   ],
   "source": [
    "for val in teachers: # directly iterate through the items in a list.\n",
    "    print(val) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "9UnNKWETjIew"
   },
   "source": [
    "### Directly iterate through a tuple\n",
    "\n",
    "This works in the same way as for a list. Can you write something like above using new_tup instead of teachers? Try it below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "_lL4mI2TjYFb"
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "TgEtxsnGhlsK"
   },
   "source": [
    "### Directly Iterate through a Dict"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {
    "id": "VwOUlQyrfAyv",
    "outputId": "c7be43be-3691-4c47-a973-5ac6f649c723"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dict_keys(['spiketimes', 'name'])\n",
      "spiketimes [0, 20, 34, 56]\n",
      "name Einstein\n"
     ]
    }
   ],
   "source": [
    "print(monkey_A.keys())\n",
    "for k in monkey_A.keys():\n",
    "    print(k,monkey_A[k])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {
    "id": "xBRJkrMRU-Mm"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dict_items([('spiketimes', [0, 20, 34, 56]), ('name', 'Einstein')])\n"
     ]
    }
   ],
   "source": [
    "print(monkey_A.items())# list of items"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {
    "id": "4-5sA7udU_vp"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "spiketimes [0, 20, 34, 56]\n",
      "name Einstein\n"
     ]
    }
   ],
   "source": [
    "for key, value in monkey_A.items(): # combines tuple unpacking with items\n",
    "    print(key, value)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "S2afN9MMVBXK"
   },
   "outputs": [],
   "source": [
    "# the above is equivalent to:\n",
    "for item in monkey_A.items():\n",
    "    key, value = item\n",
    "    print(key, value)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "OAHHcIJ1cd3O"
   },
   "source": [
    "### Range"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {
    "id": "ncPwp0JgfAyv",
    "outputId": "cd87f09e-c06e-40e9-9dac-36dd6c04d496"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n"
     ]
    }
   ],
   "source": [
    "for i in range(6):\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "QfcnBp65k9JK"
   },
   "source": [
    "Look at the help information for range -- what does it do? Can you create for loop through a range like above that starts at 1 and stops at 7 (inclusive)?\n",
    "\n",
    "Try below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {
    "id": "TVkxabxck8tf",
    "outputId": "3ca087e3-135c-44a4-e86b-768bf56536d3"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n",
      "6\n",
      "7\n"
     ]
    }
   ],
   "source": [
    "for i in range(1,8):\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "BoXE9eGznq_V"
   },
   "source": [
    "What about one that starts at 0 and ends at 6 (inclusive) where only every other number is iterated through? (Hint: use the step argument to range)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {
    "id": "8drHV9gPh0mh",
    "outputId": "8f59a710-23f3-4ffc-9209-55a08541b222"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "2\n",
      "4\n",
      "6\n"
     ]
    }
   ],
   "source": [
    "for i in range(0,7,2):\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "3\n",
      "6\n",
      "9\n"
     ]
    }
   ],
   "source": [
    "for i in range (0,10,3):\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "coeTRDcJiJKP"
   },
   "source": [
    "How can we use range with a for loop to print both the index and the value for each element of a list?\n",
    "\n",
    "When you want to modify entries in a list, it is helpful to have the index for the entries."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {
    "id": "ObQZxs8efAyw",
    "outputId": "f0e8892a-3c6c-466f-e736-48c5f309d8ca"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['jasmine', 'sam', 'abhi']\n",
      "0 jasmine\n",
      "1 sam\n",
      "2 abhi\n"
     ]
    }
   ],
   "source": [
    "print(teachers)\n",
    "for i in range(len(teachers)):\n",
    "  print(i, teachers[i])\n",
    "  teachers[i] += 'n'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {
    "id": "-QQBgj13fAyw",
    "outputId": "9e70c2b4-1471-4e9e-cc2c-58161eb6808a"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['jasminen', 'samn', 'abhin']"
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "teachers # what do you expect this to output?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "utPkDkfSl2o3"
   },
   "source": [
    "### List Comprehension\n",
    "With something called **list comprehension**, you can use a for loop in line to create dictionaries and lists like this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "yZhjx5ycmBgP",
    "outputId": "46ec902d-d37c-49b4-ebbd-cc9eef3c7fe2"
   },
   "outputs": [],
   "source": [
    "my_list = [x**2  for x in range(6) if x%2==0] # only uses x's where the condition is true\n",
    "print(my_list)\n",
    "\n",
    "# The above code is equivalent to:\n",
    "my_list = []\n",
    "for x in range(6):\n",
    "  if x%2 == 0:\n",
    "    my_list.append(x**2)\n",
    "\n",
    "print(my_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "bydyJ7sFl9YJ",
    "outputId": "995b8188-851b-4182-aa66-56d8a0c235b1"
   },
   "outputs": [],
   "source": [
    "my_dict = {x:x**2 for x in range(6)}\n",
    "print(my_dict)\n",
    "\n",
    "# The above code is equivalent to:\n",
    "my_dict = {}\n",
    "for x in range(6):\n",
    "  my_dict[x] = x**2\n",
    "\n",
    "print(my_dict)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 3\n",
      "1 5\n",
      "2 8\n",
      "3 10\n"
     ]
    }
   ],
   "source": [
    "a = [3, 5, 8, 10]\n",
    "for i in range(len(a)):\n",
    "  print(i, a[i])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "61njf6Uvlh3Y"
   },
   "source": [
    "### Exercise:\n",
    "1. Create a list using list comprehension where any values between 2 and 10 inclusive that are divisible by 3 are added to the list. Assign the list to a variable called `divisible_3s`.\n",
    "2. Using a for loop, print the index and the value at that index for every element in `divisible_3s`.\n",
    "3. Create a dictionary using list comprehension where the key is $x^3$ and the value is $x^2$ for x's between 1 and 4 inclusive. Assign the dictionary to variable `cube_square`.\n",
    "4. Print the key and value for every key, value pair in `cube_square`\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "yW9lTC09XFH9"
   },
   "source": [
    "# While loops\n",
    "\n",
    "While loops, unlike for loops, will iterate indefinitely, until the condition following the while is False. You might want to do this if you are using an iterative algorithm where you want the performance to get above a certain level before stopping, for example with machine learning (more on this later)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "peOupu0RI8JZ",
    "outputId": "ed1e87b9-f107-490d-e591-4a41d52b6cf5"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "8192\n"
     ]
    }
   ],
   "source": [
    "# While loops\n",
    "# find largest power of 2 less than 9000\n",
    "power = 0\n",
    "while 2**power < 9000:\n",
    "  power +=1\n",
    "power-=1\n",
    "print(2**power)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "BAuzUIArcd3Q"
   },
   "source": [
    "If you put a condition that is never False, your code may run indefinitely, and you may have to interrupt your kernel to get it to stop."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "ssSWSwWocd3Q"
   },
   "outputs": [],
   "source": [
    "i=0\n",
    "while i < 10:\n",
    "  print(i) # this will run forever becuase i here is constant "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "Ji5YtRefcd3Q"
   },
   "source": [
    "## Exercise:\n",
    "The Collatz sequence begins with some starting number. Given its previous number $n$, it generates the next number based on the following rule: if $n$ is even, the next number is $n/2$. If $n$ is odd, the next number is $3n+1$.\n",
    "\n",
    "Write some code below that generates the Collatz sequence for a starting number of $27$ until the number hits $1$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {
    "id": "zSfx7fwvXKRP"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.0\n",
      "1.0\n"
     ]
    }
   ],
   "source": [
    "# Collatz sequence\n",
    "n = 27\n",
    "\n",
    "while n != 1:\n",
    "    if n%2==0:\n",
    "        n = n / 2\n",
    "    else:\n",
    "        n = 3*n +1\n",
    "print(n)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "UsuwA6bLXH3a"
   },
   "source": [
    "# Break and Continue\n",
    "\n",
    "`break` and `continue` are statements that can be used within loops. \n",
    "\n",
    "When code reaches a `continue` statement, it jumps to the next iteration of the loop without running the rest of the code in the loop.\n",
    "\n",
    "When code reaches a `break` statement it jumps outside the loop (skipping any remaining iterations) without running the rest of the code in the loop.\n",
    "\n",
    "A `pass` statement, finally is completely ignored. This is useful when code is required syntactically, but you don't actually want to run anything there.\n",
    "\n",
    "For these statements it may not be entirely clear right now what their purpose is, but they become particularly useful in managing more complex code."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "UYopzdZeUPJB",
    "outputId": "5d2b13bb-1907-41c6-8648-7dbb601e40c7"
   },
   "outputs": [],
   "source": [
    "for i in range(10):\n",
    "  print('New loop')\n",
    "  if i%2==0:\n",
    "    continue\n",
    "  print(i) # This command is skipped for all even numbers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "qvO4OzE-Ug9p",
    "outputId": "73264ebc-7758-477c-a492-c0006193f270"
   },
   "outputs": [],
   "source": [
    "for i in range(10):\n",
    "  print('New loop')\n",
    "  if i==5:\n",
    "    break # Leaves the loop completely once it encounters this statement\n",
    "  print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "UEAZHnq8L_9S",
    "outputId": "0256c866-a174-424b-9872-cc27a4f8d850"
   },
   "outputs": [],
   "source": [
    "for i in range(10):\n",
    "  print('New loop')\n",
    "  if i==5:\n",
    "    pass # Leaves the loop completely once it encounters this statement\n",
    "  print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "8S5vIY-Acd3Q"
   },
   "source": [
    "## Exercises\n",
    "\n",
    "1. Fix this code so it runs."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "zyqY-mp5cd3R"
   },
   "outputs": [],
   "source": [
    "for i in range(10):"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "p-IqL4gmcd3R"
   },
   "source": [
    "2. Add something we just learned about to this code so the last thing it prints is 10."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "Z8-cMFqXcd3R"
   },
   "outputs": [],
   "source": [
    "for i in range(15,-1,-1):\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "gNg_ywtJcd3R"
   },
   "source": [
    "3. Add something we just learned to the below code so it doesn't print multiples of 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "te0Hsyp6cd3R"
   },
   "outputs": [],
   "source": [
    "for i in range(10):\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "ACTqOGFDKpLN"
   },
   "source": [
    "# Functions\n",
    "\n",
    "Currently, you are writing code simply by defining code that will be executed immediately. As you create larger codebases and share them with other people, it will be important for you to structure your code in functions: structure which execute a certain piece of code.\n",
    "\n",
    "For example, the Fibonacci sequence starts with $x_0=0$ and $x_1=1$. We then define $x_{j+2}=x_j+x_{j+1}$. The following functions prints out each value of the Fibonacci sequence until some value $n$.\n",
    "\n",
    "You can recognize functions by the `def` symbol in the beginning. `fibonacci` is the function's name and the variable in parentheses afterwards is an argument provided to the function. (Multiple arguments would be separated by commas.)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {
    "id": "W7IJztF2LjWV"
   },
   "outputs": [],
   "source": [
    "def fibonacci(n):\n",
    "  \"\"\" \n",
    "  Print fibonnacci series up to n.\n",
    "  Args:\n",
    "      n (int): Maximum value of the fibonacci series to print.\n",
    "\n",
    "  \"\"\"\n",
    "  a,b = 0, 1\n",
    "  while a <n:\n",
    "    print(a)\n",
    "    next= a+b\n",
    "    a = b\n",
    "    b = next\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "MaX0kYVjLywA",
    "outputId": "22a25660-824c-4a90-e64e-5eee5d8c6922"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "1\n",
      "2\n",
      "3\n",
      "5\n",
      "8\n",
      "13\n",
      "21\n",
      "34\n",
      "55\n",
      "89\n",
      "144\n",
      "233\n",
      "377\n",
      "610\n",
      "987\n",
      "1597\n",
      "2584\n"
     ]
    }
   ],
   "source": [
    "fibonacci (3000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "6_SHo5e9L3Tm",
    "outputId": "573fee9d-ce9c-48f6-f5b9-40c394a5ab16"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on function fibonacci in module __main__:\n",
      "\n",
      "fibonacci(n)\n",
      "    Print fibonnacci series up to n.\n",
      "    Args:\n",
      "        n (int): Maximum value of the fibonacci series to print.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(fibonacci) #will print the box string "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "Z1gUnJvgX2nN"
   },
   "source": [
    "## Exercise"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "qAxQ1ckoX6aa"
   },
   "source": [
    "Write a function (called `collatz`) that takes in a starting value and returns the Collatz sequence. As a reminder, the rule was:\n",
    "- if the previous value $n$ was even, the next value is $n/2$.\n",
    "- if the previous value was odd, the next value is $3n+1$.\n",
    "Let the function end when the value taken is $1$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {
    "id": "pCbeupqJX4sg"
   },
   "outputs": [],
   "source": [
    "def collatz(n):\n",
    "\n",
    "    while n != 1:\n",
    "        if n%2 == 0:\n",
    "            n = n / 2\n",
    "        else:\n",
    "            n = 3*n + 1\n",
    "        print(n)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10.0\n",
      "5.0\n",
      "16.0\n",
      "8.0\n",
      "4.0\n",
      "2.0\n",
      "1.0\n"
     ]
    }
   ],
   "source": [
    "collatz (20)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "LM_xJGLvZ9ZM"
   },
   "outputs": [],
   "source": [
    "collatz(2)\n",
    "\n",
    "collatz(5)\n",
    "\n",
    "collatz(1000)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "UkNyOI3EMwWl"
   },
   "source": [
    "## return"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "jEZjP5HY3uzI"
   },
   "source": [
    "The return sequence leaves the function and returns any variable coming afterwards."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "yxURaD0hMyiv"
   },
   "outputs": [],
   "source": [
    "def fib_return (n):\n",
    "  \"\"\" \n",
    "  Print fibonnacci series up to n.\n",
    "  Args:\n",
    "      n (int): Maximum value of the fibonacci series to return.\n",
    "  Returns:\n",
    "      list: List of fibonacci sequence values\n",
    "  \"\"\"\n",
    "\n",
    "  fib_list = []\n",
    "  a,b = 0, 1\n",
    "  while a <n:\n",
    "    fib_list.append(a)\n",
    "    next= a+b\n",
    "    a = b\n",
    "    b = next\n",
    "  return fib_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "tPdhbbclNVzL",
    "outputId": "2df09202-6a2f-460a-8646-6e82c2119484"
   },
   "outputs": [],
   "source": [
    "fib_return(1000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "xajaFnEaNW-L"
   },
   "outputs": [],
   "source": [
    "my_fib_list = fib_return(1000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "KHL5G-OeogNy",
    "outputId": "4834881d-fad8-4456-b688-3b93bc9c3412"
   },
   "outputs": [],
   "source": [
    "my_fib_list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "1s2FZYoLMH_e"
   },
   "source": [
    "## Default arguments"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 185
    },
    "id": "7keLw1rjMKAR",
    "outputId": "03ae5ce6-dca7-4196-f3ab-449b4db57399"
   },
   "outputs": [],
   "source": [
    "# We cannot run fib_return without specifying n:\n",
    "fib_return()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "OR9FPTvtMEdl"
   },
   "outputs": [],
   "source": [
    "# Default arguments can be specified but don't have to be:\n",
    "def fib_return (n=10):\n",
    "  \"\"\" \n",
    "  Print fibonnacci series up to n.\n",
    "  Args:\n",
    "      n (int): Maximum value of the fibonacci series to return. Default value is 1.\n",
    "  Returns:\n",
    "      list: List of fibonacci sequence values\n",
    "  \"\"\"\n",
    "\n",
    "  fib_list = []\n",
    "  a,b = 0, 1\n",
    "  while a <n:\n",
    "    fib_list.append(a)\n",
    "    next= a+b\n",
    "    a = b\n",
    "    b = next\n",
    "  return fib_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "5gdYbJT5Mq8Y",
    "outputId": "7382a455-8d38-4ce2-c427-6c9727205bc7"
   },
   "outputs": [],
   "source": [
    "fib_return()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "pyqV-HW5Msc1",
    "outputId": "f94c5f3e-354c-46ac-c629-64d4287c4014"
   },
   "outputs": [],
   "source": [
    "fib_return(n=20)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "h9Rc1rMgWybG"
   },
   "source": [
    "## Warning about default arguments"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "IJcOlIwSW5G4"
   },
   "source": [
    "Your default arguments should never be mutable. Otherwise repeated function calls can interact with each other."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "FV8vpc3QW-Yt",
    "outputId": "74262165-e7d1-4e48-ccea-66ad496c5301"
   },
   "outputs": [],
   "source": [
    "# mutable arguments\n",
    "\n",
    "def f(a, L=[]):\n",
    "    L.append(a)\n",
    "    return L\n",
    "\n",
    "print(f(1)) # predict what will happen?\n",
    "print(f(2))\n",
    "print(f(3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "LrqpbhBUpjtf"
   },
   "outputs": [],
   "source": [
    "# Which data types are mutable -> dictionaries and lists"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "Et7ck1k6XFfx",
    "outputId": "4fb811e5-0296-4c7f-f91d-7c4415db6bfa"
   },
   "outputs": [],
   "source": [
    "# Solution\n",
    "def f(a, L=None):\n",
    "    if L is None: # None now provides a marker that we would like to use the default argument.\n",
    "        L = []\n",
    "    L.append(a)\n",
    "    return L\n",
    "  \n",
    "print(f(1))\n",
    "print(f(2))\n",
    "print(f(3))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "4NZdLmyPXvKm"
   },
   "source": [
    "## Args and kwargs"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "29rU47TLX3Wu"
   },
   "source": [
    "You can also use a piece of code that allows you to provide arbitrary arguments (with or without keywords) to your function. If you use `*args` as one of the arguments of your function, this will take any unnamed argument and put all of them in a tuple:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "iYf7iSpBYl6H",
    "outputId": "8cab68cd-025a-4e21-e3f6-837ffb2b3c7b"
   },
   "outputs": [],
   "source": [
    "def f(a, *args):\n",
    "  print(a)\n",
    "  print(args)\n",
    "f(1, 2, 3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "2ruDF2iUp_Z_",
    "outputId": "ba37087d-bb99-4698-dacc-0c0004d7a68e"
   },
   "outputs": [],
   "source": [
    "\n",
    "f(1, 2, 3, 4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "TAE7dacPYwW2",
    "outputId": "63b65fda-31ba-4326-a5e8-c1be2e707d5e"
   },
   "outputs": [],
   "source": [
    "# The name args is not important\n",
    "def f(a, *variable):\n",
    "  print(a)\n",
    "  print(variable)\n",
    "f(1, 2, 3)\n",
    "f(1, 2, 3, 4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "0mcpVppFY_go"
   },
   "source": [
    "Similarly, if you put two asterisks in front of your variable (e.g. ``**kwargs``), it will assign all names variables to kwargs (in a dictionary format)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "n5dVtKfsZJ87",
    "outputId": "1f2f1ff0-c902-4e66-d211-9d2e7b85e11e"
   },
   "outputs": [],
   "source": [
    "def f(a, **kwargs):\n",
    "  print(a)\n",
    "  print(kwargs)\n",
    "f(a=1, b=2, c=3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "Zc0cqC5iZSRV"
   },
   "source": [
    "Again, we're mostly explaining this so you are familiar with it later on, when it will become extremely useful."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "z4YPIlu2HI7F"
   },
   "source": [
    "# Errors\n",
    "\n",
    "By now, we have seen several pieces of code that have failed to run. In that case, Python does not only raise an error, but also specifies what exactly went wrong."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 132
    },
    "id": "F1GYYda3HJxJ",
    "outputId": "f1d63ad1-c05a-4996-e237-33cdfa0f6332"
   },
   "outputs": [],
   "source": [
    "# A syntax error indicates that your code is not properly formatted:\n",
    "a = 2\n",
    "print(a+3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 202
    },
    "id": "2mAQwq28JLrE",
    "outputId": "66730e78-edbe-42d7-9d77-0f5626a72658"
   },
   "outputs": [],
   "source": [
    "# A type error indicates that a function received an input of the wrong type\n",
    "a = '2'\n",
    "print(a+3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 202
    },
    "id": "P6EtkeuuJe3I",
    "outputId": "2bcf36b9-ef0e-4ca8-d240-187f952a1581"
   },
   "outputs": [],
   "source": [
    "# An index error suggests that it is not possible to index an object in the attempted way.\n",
    "a = [2, 3]\n",
    "a[3]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "wbf3mJarJ13C"
   },
   "source": [
    "You can return errors yourself using the command `raise`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 202
    },
    "id": "PazoBY2BJ6mP",
    "outputId": "5e32e212-e11a-47cd-87e3-371a610b1330"
   },
   "outputs": [],
   "source": [
    "a = 3\n",
    "if a == 3:\n",
    "  raise ValueError('a should not be three')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "aSeePGDQKfjt"
   },
   "source": [
    "## Exercise\n",
    "1. Try to get Python to raise two additional error messages.\n",
    "2. Write a function `integer_add` that takes two arguments and adds them together. If either of the arguments are not integers, it should raise an error. What is the correct error for this issue?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "69tzIjsSlnLg"
   },
   "source": [
    "# Try / Except\n",
    "\n",
    "\n",
    "`try` tries the code in the `try` codeblock, and if it gives an error, runs code in an `except` code block. Best practice is to specify the errors you expect in the `except` statement so that you don't accidentally allow an unexpected error to go by unreported and unnoticed.\n",
    "\n",
    "For example, lets say that we want to count the number of occurrences of each letter in a given word -- for this example we will use abracadabra, but we want our code to work on any word.\n",
    "\n",
    "We might decide to do this using a dictionary where the keys are the letters and the values are the number of times that letter has occurred. We only want to have letters that do occur in the word as keys in our dictionary."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "LoeAK22yl0I1"
   },
   "outputs": [],
   "source": [
    "word = \"abracadabra\"\n",
    "\n",
    "letter_counts = {}\n",
    "for letter in word: # we can loop through strings like lists or tuples.\n",
    "  letter_counts[letter]+=1 # add one to the value at key letter"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "NjStbt0fmhN3"
   },
   "outputs": [],
   "source": [
    "word = \"abracadabra\"\n",
    "\n",
    "\n",
    "letter_counts = {}\n",
    "for letter in word:\n",
    "  try:\n",
    "    letter_counts[letter]+=1\n",
    "  except KeyError: # we specify the type of error we expect here\n",
    "    letter_counts[letter] = 1\n",
    "\n",
    "print(letter_counts)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "BfAqgKC9niNE"
   },
   "source": [
    "See below for why it is important to specify the type of error you expect. Since we specified the type of error we expected and got a different error, we still find out that there is an error, and can take precautions to make sure we don't, for example, overwrite important info."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "6CP-Ds3TncpL"
   },
   "outputs": [],
   "source": [
    "word = \"abracadabra\"\n",
    "\n",
    "\n",
    "letter_counts = {}\n",
    "letter_counts['a'] = \"important info that should not be overwritten\" # something unexpected as a value\n",
    "for letter in word:\n",
    "  try:\n",
    "    letter_counts[letter]+=1\n",
    "  except KeyError: # we specify the type of error we expect here\n",
    "    letter_counts[letter] = 1\n",
    "\n",
    "print(letter_counts)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "jF2KxGiMn_Ye"
   },
   "source": [
    "What happens if you do not specify KeyError after `except` and just write `except:`?\n",
    "\n",
    "Try modifying below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "tw28VBnGn3Bd"
   },
   "outputs": [],
   "source": [
    "word = \"abracadabra\"\n",
    "\n",
    "\n",
    "letter_counts = {}\n",
    "letter_counts['a'] = \"important info that should not be overwritten\" # something unexpected as a value\n",
    "for letter in word:\n",
    "  try:\n",
    "    letter_counts[letter]+=1\n",
    "  except KeyError: # we specify the type of error we expect here\n",
    "    letter_counts[letter] = 1\n",
    "\n",
    "print(letter_counts)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "MJGOvgPApCTJ"
   },
   "source": [
    "### Exercise:\n",
    "Use try/except to write code that takes numbers a and b and prints a/b. If it gets an error (for example b is 0), it should instead print \"Cannot divide by zero\". Try your code with a few different choices of a and b to make sure it works correctly."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "tFZpyEgPon0U"
   },
   "outputs": [],
   "source": [
    "a=2\n",
    "b=0"
   ]
  }
 ],
 "metadata": {
  "colab": {
   "collapsed_sections": [
    "aSeePGDQKfjt"
   ],
   "provenance": []
  },
  "kernelspec": {
   "display_name": "Python 3.10.4 ('intropython')",
   "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.10.4"
  },
  "vscode": {
   "interpreter": {
    "hash": "0a284bd4ac99e16fcaaae46c1796fb44e60adc4a5ad019ef4c2cab7112a774f8"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}