04_DataStructures.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1dyjg8Lrk5PC"
      },
      "source": [
        "# Data Structures\n",
        "(notebook from Dr. Ashley Juavinett, ENDURE workshop 2023)\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": {
        "id": "mbo9a46kk5PD"
      },
      "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": {
        "id": "erAfWlopk5PD"
      },
      "source": [
        "## Why Data Structures?"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "gZFWQR1lk5PD"
      },
      "source": [
        "While there are many programming languages that operates through different instructions, they all share one common thing: data structures.\n",
        "\n",
        "A data structure is a data organization and storage format. It can be of various data types and can be used for searching, storing or comparing specific data."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "WpBmwT-Ck5PD"
      },
      "source": [
        "A good analogy for programming data structures are glass containers: they vary in size, properties and functionality. We also choose the best container depending on what needs to be stored.\n",
        "\n",
        "<center><img src=\"https://drive.google.com/uc?id=1kCcDzpIn60HtAtk8NUqvKY4Wma_36oj3\">"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "LzhJbqlKk5PD"
      },
      "source": [
        "### Data Types"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "GCGu-Gz2k5PD"
      },
      "source": [
        "Data types are items that help *classify* or *categorize* data. They represent what kind of *value* each item has, and can be assigned to an *object* that can be accessed later on. These items are called *variables*."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2lCL1FIwk5PD"
      },
      "source": [
        "Here are some data structure types with examples:\n",
        "<center><img src=\"https://drive.google.com/uc?id=1fiIM9_ydwnK8gYn1mi40QDEiljkZkKy3\">"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "o0qoVzYvk5PD"
      },
      "source": [
        "Note how some structures can have *mixed* data types (like list and tuple), and others can only have one type (like integers or booleans)."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "4nzf-_CLk5PD"
      },
      "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": null,
      "metadata": {
        "scrolled": true,
        "id": "0SRcbQ15k5PD"
      },
      "outputs": [],
      "source": [
        "# Create a list of fruits\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "gQOMkhchk5PE"
      },
      "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": null,
      "metadata": {
        "scrolled": true,
        "id": "XcnrHF0tk5PE"
      },
      "outputs": [],
      "source": [
        "# Try different list methods here\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "baM2amZhk5PE"
      },
      "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": {
        "id": "WHOEVMwGk5PE"
      },
      "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": null,
      "metadata": {
        "scrolled": true,
        "id": "LDcdXTQtk5PE"
      },
      "outputs": [],
      "source": [
        "# Try indexing our list of fruits here\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1ucdxZRGk5PE"
      },
      "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": {
        "id": "nydPDH25k5PE"
      },
      "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": {
        "id": "gjr-WUSQk5PE"
      },
      "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": null,
      "metadata": {
        "scrolled": true,
        "id": "aQ8Bmizkk5PE"
      },
      "outputs": [],
      "source": [
        "# Your code here!\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "57iz25LIk5PE"
      },
      "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": "code",
      "execution_count": null,
      "metadata": {
        "id": "n_uosPbEk5PE"
      },
      "outputs": [],
      "source": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "XeKRzlZtk5PE"
      },
      "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": null,
      "metadata": {
        "scrolled": true,
        "id": "9RZyHuSKk5PE"
      },
      "outputs": [],
      "source": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "OkLsZRatk5PE"
      },
      "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": null,
      "metadata": {
        "scrolled": true,
        "id": "txt03EzYk5PE"
      },
      "outputs": [],
      "source": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "0m0tL-hvk5PE"
      },
      "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://media.giphy.com/media/z1meXneq0oUh2/giphy.gif)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "scrolled": true,
        "id": "0xeqcidFk5PE"
      },
      "outputs": [],
      "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])"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "blX2TVGZk5PE"
      },
      "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": null,
      "metadata": {
        "scrolled": true,
        "id": "hylB5lGmk5PE"
      },
      "outputs": [],
      "source": [
        "# Define a tuple\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "q_mfXr6vk5PE"
      },
      "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": null,
      "metadata": {
        "scrolled": true,
        "id": "EgC53pcEk5PE"
      },
      "outputs": [],
      "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": "markdown",
      "metadata": {
        "id": "wNRA7AkHk5PE"
      },
      "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": {
        "id": "llJ5YIu4k5PE"
      },
      "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": null,
      "metadata": {
        "scrolled": true,
        "id": "h2118utpk5PE"
      },
      "outputs": [],
      "source": [
        "# Test range here"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "h7m-18Dmk5PF"
      },
      "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": null,
      "metadata": {
        "id": "8hGPVpKYk5PF"
      },
      "outputs": [],
      "source": [
        "capitals = {'United Kingdom':'London','France':'Paris','Spain':'Madrid'}\n",
        "capitals"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "aYgYiN-gk5PF"
      },
      "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": null,
      "metadata": {
        "id": "U-a_5MVhk5PF"
      },
      "outputs": [],
      "source": [
        "capitals.update({'United Kingdom':'England'})\n",
        "capitals"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "XhFahgkak5PF"
      },
      "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": "markdown",
      "metadata": {
        "id": "3G3F1mKqk5PF"
      },
      "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": {
        "id": "ZcHHI7O1k5PF"
      },
      "source": [
        "## Recap"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "KpduFf_Rk5PF"
      },
      "source": [
        "<b><font color='blue'> Breakout room activity! </font></b> Inspect and execute the codes below, and as a breakout room, find the error and a solution to them."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "3_hms9PQk5PF"
      },
      "outputs": [],
      "source": [
        "# 1. Solution must be \"True\"\n",
        "multiple_list = [[1,2,3],4,5,6,(7,8,9)]\n",
        "\n",
        "print('-- Validate your solution --')\n",
        "len(multiple_list)==3 and [7,8,9] in multiple_list"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "MXfRRFdxk5PF"
      },
      "outputs": [],
      "source": [
        "# 2. Solution must be \"True\"\n",
        "# Hint: add the string * new list * to the end of multiple_list\n",
        "multiple_list.add([new list])\n",
        "\n",
        "print('-- Validate your solution --')\n",
        "type(multiple_list[-1]) == str"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "pvDe3pQKk5PF"
      },
      "outputs": [],
      "source": [
        "# 3. Solution must be \"True\"\n",
        "# Your code here\n",
        "\n",
        "print('-- Validate your solution --')\n",
        "multiple_list[0] == 'new list'"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "LvT9d89ak5PF"
      },
      "outputs": [],
      "source": [
        "# 4. Solution must be \"True\"\n",
        "# Hint: create a dictionary with numerical even numbers as keys and the next odd number as string value\n",
        "## (e.g. 2 and 3 as key and value)\n",
        "\n",
        "print('-- Validate your solution --')\n",
        "type(even_dic) == dict and all(type(key)==int for key in even_dic.keys()) and all(type(val)==str for val in even_dic.values())"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "cGRapA9Hk5PF"
      },
      "outputs": [],
      "source": [
        "# 5. Solution must be \"True\"\n",
        "# Hint: add a key-value to even_dic\n",
        "\n",
        "print('-- Validate your solution --')\n",
        "3 in even_dic.keys()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ELH9V8jnk5PF"
      },
      "source": [
        "<b><font color='blue'> How did you fix the previous code?"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "atrqgTJMk5PF"
      },
      "outputs": [],
      "source": [
        "# 1.\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "kNARotuyk5PF"
      },
      "outputs": [],
      "source": [
        "# 2.\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "GksxO3wSk5PF"
      },
      "outputs": [],
      "source": [
        "# 3.\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "o6-8-60dk5PF"
      },
      "outputs": [],
      "source": [
        "# 4.\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "UrRu0zk_k5PF"
      },
      "outputs": [],
      "source": [
        "# 5.\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "50G2E5Ybk5PF"
      },
      "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": {
        "id": "q9C1YVNok5PG"
      },
      "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.\n",
        "\n",
        "Want to run this notebook as a slideshow? If you have Python (or Anaconda) follow <a href=\"http://www.blog.pythonlibrary.org/2018/09/25/creating-presentations-with-jupyter-notebook/\">these instructions</a> to setup your computer with the RISE plugin."
      ]
    }
  ],
  "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.8.8"
    },
    "rise": {
      "theme": "serif"
    },
    "colab": {
      "provenance": []
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}