hist3368-week2-navigating-lists-and-dictionaries.ipynb

{
 "cells": [
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Hist 3368 - Navigating Lists and Dictionaries\n",
    "\n",
    "*by Jo Guldi*\n",
    "\n",
    "This Notebook introduces the concept of 'navigating' different data types.  It will help you figure out how to find your way around dictionaries and lists, the two data types that we'll encounter most frequently in this class. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "What you will learn:\n",
    "    * how to use square brackets -- [ ] -- or .index() -- to select an item from a list\n",
    "    * how to use the functions .append() and .count() to do things with lists\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Navigating the 'List' Data Type"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In previous sessions, we introduced *variables*. A variable is a nametag that can be placed on any object.  \n",
    "\n",
    "But Python also has particular data types that involve not just *one* object but *several*. You can think of these data types as *baskets* rather than nametags.  Each basket has a name. But the basket contains multiple items.\n",
    "\n",
    "The kind of basket we're going to start with is a list. Lists have certain attributes:\n",
    "\n",
    "    * Lists are ordered.  The first object in a list is always the first; the second is always the second, etc. (unless you change the order)\n",
    "    * You can add to lists, typically using the function .append()\n",
    "    \n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Remember that we use *square brackets* to make a list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "streaming = ['netflix', 'hulu', 'disney+', 'appletv+']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "With python lists, square brackets mean 'which.'  The number in the brackets tells the computer which count of an item to look for.  Note that counting starts at 0."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'disney+'"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "streaming[2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'appletv+'"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "streaming[3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'netflix'"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "streaming[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The opposite of using brackets is .index()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "streaming.index('netflix')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The index of disney+ is: 2\n"
     ]
    }
   ],
   "source": [
    "index = streaming.index('disney+')\n",
    "print('The index of disney+ is:', index)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can also use square brackets with a colon to call the first items in a list. This will be useful when we are looking at hundreds of pages of text. You won't want to flood your screen by looking at millions of characters at once; however, you might want to look at one paragraph of 100 words. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['netflix']"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "streaming[:1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['netflix', 'hulu']"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "streaming[:2]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Another useful navigation tool is to call the last few entries in a list by using a negative number in the square brackets."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A negative number in brackets calls the nth to the last item in the list "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'prime'"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "streaming[-2]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A negative number followed by a colon calls the last n items in the list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['appletv+', 'prime', 'hulu']"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "streaming[-3:]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Using .append() and .count() with lists"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Lists take a number of built-in functions, for instance 'append' and 'count.'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [],
   "source": [
    "streaming.append('prime')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['netflix', 'hulu', 'disney+', 'appletv+', 'prime', 'hulu', 'prime']"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "streaming"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [],
   "source": [
    "streaming.append('hulu')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['netflix', 'hulu', 'disney+', 'appletv+', 'prime', 'hulu', 'prime', 'hulu']"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "streaming"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "streaming.count('hulu')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "song = ['row', 'row', 'row', 'your', 'boat', 'gently', 'down', 'the', 'stream'] \n",
    "song.count('row')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "But what if we want to count every word?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## The 'Dictionary' Data Type"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Dictionaries have their own rules for how data is organized.  They are also navigated with specific functions that pertain only to dictionaries.  That's why it's important to know whether your data is a list or a dictionary at any given time!  Otherwise, the commands you use to navigate are liable to act funny.\n",
    "\n",
    "What is a dictionary?\n",
    "\n",
    "* A 'dictionary' is a data type with 'keys' that correspond to 'values.' \n",
    "* A colon -- ':' -- is used to separate keys from values.  \n",
    "* Key-value pairs are separated by commas.  \n",
    "\n",
    "Why would you need a dictionary?\n",
    "\n",
    "* Technically, dictionaries don't have an order.  They will automatically try to re-order their values -- alphabetically or by number. This makes them a bad structure for storing raw text, where the order of the words is important.  \n",
    "* However, dictionaries are a fast way of storing values that need to be 'looked up' by the computer at some point.  This makes them ideal for storing certain information -- for instance lists of special words, also known as a 'controlled vocabulary.'\n",
    "\n",
    "What's inside a dictionary?\n",
    "\n",
    "* Technically, each key-value pair is a tuple.\n",
    "* The individual tuples of the dictionary can have any kind of contents -- strings, integers, boolean statements, whatever.  But there must be *exactly* two of them per entry.\n",
    "\n",
    "How do you call the information in a dictionary?\n",
    "\n",
    "* You can call just the keys, with .keys(), or just the values, with .values()\n",
    "* You can look up any given value if you know its key, or vice versa.  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {},
   "outputs": [],
   "source": [
    "black_tea = {\n",
    "    'supplier' : 'Twinings',\n",
    "    'name' : 'English Breakfast',\n",
    "    'boxes_in_stock' : 12,\n",
    "    'loose_leaf' : True\n",
    "    }"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Calling the items a dictionary"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can do some of the things with dictionaries you can do with lists, but not others. \n",
    "\n",
    "For instance, you **can** use square brackets with dictionaries, just like lists."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Twinings'"
      ]
     },
     "execution_count": 99,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "black_tea['supplier'] "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The function .get() does exactly the same thing:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Twinings'"
      ]
     },
     "execution_count": 101,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "black_tea.get('supplier')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notice that the input is different. Instead of inputting the index number like you did with index -- streaming[0] -- you use square brackets to call dictionaries by their **key**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*Now let's talk about what you can't do with dictionaries.*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You **can't** navigate back to the keys based on a certain value.  Why?  Because Python dictionaries are meant to be used to look up values based on known keys, not the other way around.  You can look up keys to your heart's content -- but you cannot go the other way around and use 'Twinings' to find the supplier."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You **can't** navigate the items in dictionaries with for loops by using the 'in' operator,  as you do with lists:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "'dict' object is not callable",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-102-c3b2e26bec38>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0;32mfor\u001b[0m \u001b[0mpotato\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mblack_tea\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      2\u001b[0m     \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mpotato\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mTypeError\u001b[0m: 'dict' object is not callable"
     ]
    }
   ],
   "source": [
    "for potato in black_tea():\n",
    "    print(potato)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notice the 'TypeError' dictionary.  This is why data types matter"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### .keys() and .values() with Dictionaries"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Instead of calling dictionaries as you do lists, you have to call either the keys or the values.\n",
    "\n",
    "    .keys()\n",
    "    .values()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dict_keys(['supplier', 'name', 'boxes_in_stock', 'loose_leaf'])"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "black_tea.keys()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dict_values(['Twinings', 'English Breakfast', 12, True])"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "black_tea.values()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### You can export keys or values as lists"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Using the function list(), you can also export either set -- that is, either **keys** or **values** --  to a list, which you can then call the normal way."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Twinings', 'English Breakfast', 12, True]"
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(black_tea.values())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Poof! It was the values to the dictionary, but now it's a list!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['supplier', 'name', 'boxes_in_stock', 'loose_leaf']"
      ]
     },
     "execution_count": 65,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(black_tea.keys())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You already know how to navigate lists."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "12"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(black_tea.values())[2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'boxes_in_stock'"
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(black_tea.keys())[2]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Assignment"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Create a variable called by your middle name.  Write out the lyrics to a poem or song of your choice of at least five lines as a list.  \n",
    "* Write out the code to navigate this list:\n",
    "    * What is the **first** item in the list?\n",
    "    * What is the **last** item in the list?\n",
    "    \n",
    "* Use the \".append()\" function to add the word 'rutabaga' to the end of your list.\n",
    "* Use the function \".count()\" to count how many times the word \"the\" appears in your song.\n",
    "    \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Paste a screenshot of your code and the answers into the box in Canvas."
   ]
  }
 ],
 "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.9.10 (main, Feb 25 2022, 18:07:24) \n[Clang 13.0.0 (clang-1300.0.29.30)]"
  },
  "vscode": {
   "interpreter": {
    "hash": "aee8b7b246df8f9039afb4144a1f6fd8d2ca17a180786b69acc140d282b71a49"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}