03-DataStructures_solutions.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Data Structures\n",
    "\n",
    "In this notebook, we'll explore different types of data structures that Python can use to store information, namely **lists, tuples, and dictionaries.**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "\n",
    "## At the end of this notebook, you'll be able to:\n",
    "* Compare & contrast the types of structures that Python uses to store data points\n",
    "* Recognize & create lists, tuples, and dictionaries in Python\n",
    "* Index, slice, cast, and mutate lists\n",
    "* Understand the implications of mutability and object-oriented programming\n",
    "\n",
    "<hr>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Lists\n",
    "A _list_ is a mutable collection of ordered items, that can be of mixed type.\n",
    "\n",
    "**Mutable** means that individual items in the object can be changed. Lists are mutable. Tuples and strings are not -- they're **immutable**.\n",
    "\n",
    "Lists are created using square brackets `[ ]`, and individual elements are separated by commas."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "scrolled": true,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['mango', 'kiwi', 'pineapple', 'apple']\n"
     ]
    }
   ],
   "source": [
    "# Create a list of fruits\n",
    "my_fruits = ['mango','kiwi','pineapple','apple']\n",
    "print(my_fruits)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Useful list methods\n",
    "- Check the length of your list by using `len(my_list)`\n",
    "- Use `my_list.append()` to add elements to a list\n",
    "- Remove elements by index using `del my_list[index]`\n",
    "- Remove elements by value by using `my_list.remove('value')`\n",
    "- Sort by using `my_list.sort()`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "scrolled": true,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "original:  ['mango', 'kiwi', 'pineapple', 'apple']\n",
      "sorted:  ['apple', 'kiwi', 'mango', 'pineapple']\n"
     ]
    }
   ],
   "source": [
    "# Try different list methods here\n",
    "print('original: ',my_fruits)\n",
    "my_fruits.sort()\n",
    "print('sorted: ', my_fruits)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['apple', 'kiwi', 'mango']"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_fruits.remove('pineapple')\n",
    "my_fruits"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### List indexing & slicing\n",
    "**Indexing** refers to selecting an item from within a collection (e.g., lists, tuples, and strings). Indexing is done by placing the **index number** in square brackets, directly after the list variable.\n",
    "\n",
    "For example, if `my_list = [1,3,5]`, we can get the second value using `my_list[1]`. (Remember that Python starts indexing at zero!)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Reminders\n",
    "- Python is zero-based (The first index is '0')\n",
    "- Negative indices index backwards through a collection"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "scrolled": true,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'apple'"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Try indexing our list of fruits here\n",
    "first_fruit = my_fruits[0]\n",
    "first_fruit"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### If we want multiple items, we can **slice** the list.\n",
    "\n",
    "There are a few ways to slice:\n",
    "\n",
    "1. We can **slice** a part of a list using the syntax `[start:stop]`, which extracts characters between index start and stop (-1).\n",
    "\n",
    "**Notes**\n",
    "- `start` is __included__ then every element __until__ `stop` is included.\n",
    "- Negative values count backwards through the list."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "2. If we omit either (or both) of start or stop from `[start:stop]`, the default is the beginning and the end of the string, respectively, e.g. `[:3]`\n",
    "3. We can also define the step size (instead of default 1) using the syntax `[start:stop:step]`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "<div class=\"alert alert-success\"><b>Task:</b> For our list of fruits, create three different slices, and save them as different variables:\n",
    "    \n",
    "1. A slice of the first two fruits.\n",
    "2. A slice of the middle three fruits.\n",
    "3. A slice of the last fruit.\n",
    "    \n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "scrolled": true,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['apple', 'kiwi']\n",
      "['kiwi', 'lychee', 'mango']\n",
      "['pineapple']\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "list"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Your code here!\n",
    "my_fruits = ['apple', 'kiwi', 'lychee', 'mango', 'pineapple']\n",
    "\n",
    "first_two = my_fruits[:2]\n",
    "print(first_two)\n",
    "\n",
    "middle_three = my_fruits[1:4]\n",
    "print(middle_three)\n",
    "\n",
    "last_fruit = my_fruits[4:5]\n",
    "#last_fruit = my_fruits[-1]\n",
    "print(last_fruit)\n",
    "type(last_fruit)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Checking length\n",
    "We can use the function `len( )` to check the length of lists.\n",
    "\n",
    "**Note**: We can also use this to get the number of characters in a string!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Checking membership\n",
    "We can use `in` to see if an item exists in a list. The `in` operator checks whether an element is present in a collection, and can be negated with `not`. _(More on operators in the next lecture)_"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "scrolled": true,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'lemon' in my_fruits"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Mutating lists\n",
    "After definition, we can update members of our list _because lists are mutable!_ This also impacts aliases of our lists."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "scrolled": true,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "my_fruits:  ['apple', 'kiwi', 'lychee', 'mango', 'pineapple']\n",
      "fruits_2:  ['apple', 'kiwi', 'lychee', 'mango', 'pineapple']\n",
      "my_fruits:  ['apple', 'kiwi', 'lychee', 'mango', 'pineapple', 'orange']\n",
      "fruits_2:  ['apple', 'kiwi', 'lychee', 'mango', 'pineapple', 'orange']\n"
     ]
    }
   ],
   "source": [
    "# Create alias of our list\n",
    "fruits_2 = my_fruits\n",
    "print('my_fruits: ',my_fruits)\n",
    "print('fruits_2: ' ,fruits_2)\n",
    "\n",
    "# Update the original list\n",
    "my_fruits.append('orange')\n",
    "\n",
    "# Check both lists\n",
    "print('my_fruits: ',my_fruits)\n",
    "print('fruits_2: ' ,fruits_2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "139944823230272"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "id(my_fruits)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "139944823230272"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "id(fruits_2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Creating lists of lists\n",
    "Sometimes, it's useful to create lists of lists. Often, if we import big datasets as lists, this is how it will be organized.\n",
    "\n",
    "![](https://swcarpentry.github.io/python-novice-inflammation/fig/indexing_lists_python.png)\n",
    "<div align=\"center\"><a href=\"https://swcarpentry.github.io/python-novice-inflammation/04-lists/index.html\">Image source</a></div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "scrolled": true,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "gene1\n"
     ]
    }
   ],
   "source": [
    "gene_1 = ['gene1',0.48,0.55]\n",
    "gene_2 = ['gene2',0.38,0.85]\n",
    "gene_3 = ['gene3',0.21,0.81]\n",
    "all_genes = [gene_1, gene_2, gene_3]\n",
    "\n",
    "# We can use this syntax to get a specific value\n",
    "print(all_genes[0][0])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Tuples\n",
    "A _tuple_ is an **immutable** collection of ordered items, that can be of mixed type.\n",
    "\n",
    "* Tuples are created using parentheses.\n",
    "* Indexing works similar to lists."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "scrolled": true,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('my_gene', 2.3, 6)"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Define a tuple\n",
    "my_tuple = ('my_gene',2.3,6)\n",
    "my_tuple"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "<div class=\"alert alert-success\"><b>Question</b>: Before running the cell below, try to predict: What will be printed out from running this code?</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "scrolled": true,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Overlap\n"
     ]
    }
   ],
   "source": [
    "lst = ['a', 'b', 'c']\n",
    "tup = ('b', 'c', 'd')\n",
    "\n",
    "if lst[-1] == tup[-1]:\n",
    "    print('EndMatch')\n",
    "elif tup[1] in lst:\n",
    "    print('Overlap')\n",
    "elif len(lst) == tup:\n",
    "    print('Length')\n",
    "else:\n",
    "    print('None')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(lst) == tup"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Casting between variable types\n",
    "We can use `list( )` or `tuple( )` to convert variables into different types. This is called **casting**.\n",
    "\n",
    "This is particularly useful when we use an operator like `range( )` which generates a range, but in the form of an **iterator**."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "**Note**: `range`, like indexing, is defined with `start`,`stop`, and `step`, but commas in between each. Remember that you can always use `?range` or `help(range)` to get details on how a function works. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {
    "scrolled": true,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 1, 2, 3, 4, 5, 6, 7]"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Test range here\n",
    "fruit_tuple = tuple(my_fruits)\n",
    "fruit_tuple\n",
    "\n",
    "list(range(8))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Dictionaries\n",
    "Dictionaries are also like lists, except that each element is a key-value pair. The syntax for dictionaries is `{key1 : value1, ...}:`\n",
    "\n",
    "### When dictionaries are useful\n",
    "1. Flexible & efficient way to associate labels with heterogeneous data\n",
    "2. Use where data items have, or can be given, labels\n",
    "3. Appropriate for collecting data of different kinds (e.g., name, addresses, ages)\n",
    "\n",
    "> In the cell below, create a dictionary for three countries and capitals using the syntax `{country:capital,...}`. Remember that strings still need parentheses!\n",
    "\n",
    "**Note**: You can also create an empty dicitionary using `{}` and fill it using `dictionary['key'] = 'value'`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {
    "scrolled": true,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Paris'"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "capitals = {'France':'Paris','US':'DC','Germany':'Berlin'}\n",
    "capitals['France']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "<div class=\"alert alert-success\"><b>Question:</b> Before running the cell below, predict: What would the following code produce?</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {
    "scrolled": true,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'France': 'Paris', 'US': 'DC', 'Germany': 'Berlin', 'United Kingdom': 'Wales'}"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "capitals.update({'United Kingdom':'Wales'})\n",
    "capitals"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "<div class=\"alert alert-success\"><b>Task</b>: What happens if we look for a key that doesn't exist? Try this above."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "ename": "KeyError",
     "evalue": "'Kenya'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mKeyError\u001b[0m                                  Traceback (most recent call last)",
      "\u001b[0;32m/tmp/ipykernel_117/731844248.py\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mcapitals\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'Kenya'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mKeyError\u001b[0m: 'Kenya'"
     ]
    }
   ],
   "source": [
    "capitals['Kenya']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Additional dictionary functionality\n",
    "- Use `capitals.update(morecapitals)` to add another dictionary entry\n",
    "- Use `del capitals['US']` to delete entries\n",
    "- Loop by key or values, or both"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "<hr>\n",
    "\n",
    "## Additional resources\n",
    "<a href=\"https://swcarpentry.github.io/python-novice-gapminder/11-lists/index.html\">Software Carpentries Lists</a>\n",
    "\n",
    "<a href=\"https://python101.pythonlibrary.org/chapter3_lists_dicts.html\">Python 101: Lists, Tuples, and Dictionaries</a>\n",
    "\n",
    "<a href=\"https://github.com/jakevdp/WhirlwindTourOfPython/blob/6f1daf714fe52a8dde6a288674ba46a7feed8816/06-Built-in-Data-Structures.ipynb\">Whirlwind Tour of Python: Built-In Data Structures</a>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## About this notebook\n",
    "This notebook is largely derived from UCSD COGS18 Materials, created by Tom Donoghue & Shannon Ellis, as well as the <a href=\"https://github.com/jrjohansson/scientific-python-lectures/blob/master/Lecture-1-Introduction-to-Python-Programming.ipynb\">Scientific Python Lecture</a> by J.R. Johansson."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.5"
  },
  "rise": {
   "theme": "serif"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}