3_01_Data_Structures.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "toc_visible": true,
      "authorship_tag": "ABX9TyMtI1yBsoL+vrnTXz61533B",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/edwardoughton/spatial_computing/blob/main/3_01_Data_Structures.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## **Data structures**\n",
        "\n",
        "Here we will explore various data structures commonly used in computing programming, with reference to spatial computing in Python.\n",
        "\n"
      ],
      "metadata": {
        "id": "2X32NDGO1JjO"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## **Data Structures - Lists**\n",
        "\n",
        "One of the most commonly used data structures is a list, denoted by using square brackets, e.g., `[]`. A list can contain a wide range of elements, whether ints, floats, strings, or other data structures such as lists.  \n",
        "\n",
        "Lists are ordered, thus they retain the sequence in which their consituent elements were placed.\n",
        "\n",
        "Moreover, lists ae mutable, which basically means we are able to change them as we desire, e.g., using a range of in-built python functions for manipulation, including `append()`, `extend()`, `insert()`, `remove()`, `sort()`, `reverse()`, and `sorted()`."
      ],
      "metadata": {
        "id": "kQBO7AbaHV1X"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Example: A list\n",
        "my_list = [1,2,3,4]\n",
        "my_list"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "LMuL7-MO1A0h",
        "outputId": "e4c5d15e-e7f4-45a8-944b-7d7af0b2b38f"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[1, 2, 3, 4]"
            ]
          },
          "metadata": {},
          "execution_count": 35
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "We can access an element of a list by indexing, using square index brackets e.g., `mylist[0]`.\n",
        "\n",
        "Via a positional number, we are asking Python to return the element at a certain position in the list structure.\n",
        "\n",
        "Note: Python is zero indexed, thus the first element is at position zero."
      ],
      "metadata": {
        "id": "sJC6tvboIiq1"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Example: Getting an element from a list\n",
        "my_list = [1,2,3,4]\n",
        "print(\"The first element in my list is {}.\".format(my_list[0]))\n",
        "print(\"The second element in my list is {}.\".format(my_list[1]))\n",
        "print(\"The third element in my list is {}.\".format(my_list[2]))\n",
        "print(\"The forth element in my list is {}.\".format(my_list[3]))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "WZoN61x1Is9Z",
        "outputId": "d73887df-00db-4ce1-f61c-891f884abe37"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "The first element in my list is 1.\n",
            "The second element in my list is 2.\n",
            "The third element in my list is 3.\n",
            "The forth element in my list is 4.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "We can also modify an element of our list.\n",
        "\n",
        "For example, let us suppose we want to replace a certain element. We just need to specify the list name, followed by square index brackets and the positional index number. Then we can allocate a replacement value, as demonstrated in the code below:"
      ],
      "metadata": {
        "id": "eI9WhJiX1Q4O"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Example: Modifying an element of a list\n",
        "my_list = [1,2,3,4]\n",
        "my_list[1] = 'NA'\n",
        "my_list[3] = 4.5\n",
        "my_list"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "NWZtMmlrJb0L",
        "outputId": "11a3ba1d-2cfb-48b2-d700-5d69dd3a8e36"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[1, 'NA', 3, 4.5]"
            ]
          },
          "metadata": {},
          "execution_count": 45
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Finally, we can easily add elements to our list.\n",
        "\n",
        "For example, by using the `append()` function, which adds any new elements to the end of the existing list."
      ],
      "metadata": {
        "id": "Ri18xWgAKH3Z"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Example: Modifying an element of a list\n",
        "my_list = [1,2,3,4]\n",
        "my_list.append(5)\n",
        "my_list.append(6)\n",
        "my_list"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "bkn65HE-KG86",
        "outputId": "aeaa1a67-3ed4-468f-b7f7-08380b93ba80"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[1, 2, 3, 4, 5, 6]"
            ]
          },
          "metadata": {},
          "execution_count": 49
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "To remove an item from a list, we can use the in-built `.remove()` function."
      ],
      "metadata": {
        "id": "gpYDfhoIyaMm"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Example: Remove an item from a list\n",
        "my_list = [1,2,3,4]\n",
        "my_list.remove(1)\n",
        "my_list"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "4nb9UI5qyZMA",
        "outputId": "4d61efb2-8967-4232-85d0-686c27878ec3"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[2, 3, 4]"
            ]
          },
          "metadata": {},
          "execution_count": 84
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Also, we are easily able to count the number of elements in our list (the length), via the built-in `len()` function.\n"
      ],
      "metadata": {
        "id": "1OXQg_tLx_Eu"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Example: Find the length of a list\n",
        "my_list = [1,2,3,4]\n",
        "print(len(my_list))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "bGW7Kg6rx_p7",
        "outputId": "b555a30e-852a-4fe7-d126-a5b50063db34"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "4\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Moreover, to check if a list contains a specific element, we can use an `if` function."
      ],
      "metadata": {
        "id": "-vWW3bPdyyDA"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Example: Find the length of a list\n",
        "my_list = [1,2,3,4]\n",
        "if 1 in my_list:\n",
        "  print('yes')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Dj-05yxfyxf_",
        "outputId": "0cf30ee8-46a8-41cd-f442-a1463e26d78a"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "yes\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Task**\n",
        "* Create a list of your four favorite shops (for use in a spatial route optimization problem) and print the list.\n",
        "* Print the first shop name in your list.\n",
        "* You need to visit a new location. Add to the list the name of this new shop.\n",
        "* To optimize the number of stops, you decide to collect some basic items from an existing shop. Thus, remove one shop name from the list.\n",
        "* For your list of shops, print the length.\n",
        "* What if you are not sure if you have a shop in your list? Can you write some logic to check, and print the shop name if present?"
      ],
      "metadata": {
        "id": "WJ7q4U-bw9w4"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Enter your attempt here\n"
      ],
      "metadata": {
        "id": "Zpccq-qLw-l4"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## **Data Structures - Tuples**\n",
        "\n",
        "Like lists, tuples are also ordered (so if you call a tuple from memory, it will be presented in the order in which you specified the original data structure).\n",
        "\n",
        "We can create a tuple by using normal parentheses, e.g., `()`.\n",
        "\n",
        "However, tuples contrast with lists in that they are immutable. Thus, once you create the elements of these data structures, they cannot be further changed."
      ],
      "metadata": {
        "id": "4T0G24oALB1L"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Example: A tuple\n",
        "my_tuple = (1,2,3,4)\n",
        "my_tuple"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "RY5ggq2I1PUi",
        "outputId": "1f9d8112-2439-417d-9c7b-2a8202d5629e"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(1, 2, 3, 4)"
            ]
          },
          "metadata": {},
          "execution_count": 36
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "We are able to print a particular element of a tuple, using square bracket indexing."
      ],
      "metadata": {
        "id": "1NbP3F5N_YCk"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Example: Accessing a tuple element\n",
        "my_tuple = (1,2,3,4)\n",
        "print(my_tuple[0])"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "TK8x94FS_Xfg",
        "outputId": "c76eed2c-01c2-4f9b-f21b-d51f41b03a07"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "1\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "We are not able to replace elements, once specified."
      ],
      "metadata": {
        "id": "wp2fgVv91x29"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Example: Tuples are immutable\n",
        "my_tuple = (1,2,3,4)\n",
        "my_tuple[2] = 'replacement_element'\n",
        "my_tuple    #   Will thrown an error"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 234
        },
        "outputId": "1dfad150-c83e-4743-8f77-1600f85b4597",
        "id": "3GmwIVFhLKIc"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "error",
          "ename": "TypeError",
          "evalue": "'tuple' object does not support item assignment",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-52-8c773b6245fc>\u001b[0m in \u001b[0;36m<cell line: 3>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;31m# Example: A tuple\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      2\u001b[0m \u001b[0mmy_tuple\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m3\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m4\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 3\u001b[0;31m \u001b[0mmy_tuple\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m'replacement_itm'\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      4\u001b[0m \u001b[0mmy_tuple\u001b[0m    \u001b[0;31m#   Will thrown an error\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;31mTypeError\u001b[0m: 'tuple' object does not support item assignment"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Therefore, if you need to replace a tuple element, you have to respecify the whole data structure."
      ],
      "metadata": {
        "id": "fsSy5Uj3LKIe"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Example: Respecifying a tuple to replace an element\n",
        "my_tuple = (1,2,3,4)\n",
        "print(my_tuple)\n",
        "my_tuple2 = (my_tuple[0], my_tuple[1], 'replacement_element', my_tuple[3])\n",
        "print(my_tuple2)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "dcd233d9-f104-4c59-f069-06018f190cc4",
        "id": "d_jj9rmcLKvH"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "(1, 2, 3, 4)\n",
            "(1, 2, 'replacement_element', 4)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Within spatial computing, it is common for us to store our coordinates in tuples, like so:"
      ],
      "metadata": {
        "id": "3xwAygnJNkZk"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Example: Storing coordinates within a tuple\n",
        "coordinates = (1.234, 2.765)\n",
        "print(coordinates)\n",
        "\n",
        "x, y = coordinates\n",
        "print(\"x: {}, y: {}\".format(x, y))  # Output: x: 3, y: 4"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "tfx9GEPdNlWX",
        "outputId": "b200d013-f517-47aa-b66e-0ddc04a8eae0"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "(1.234, 2.765)\n",
            "x: 1.234, y: 2.765\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Task**\n",
        "* Create a tuple containing your four favorite shops (for use in a spatial route optimization problem) and print the tuple.\n",
        "* Print the first and last elements in your tuple.\n",
        "* Attempt to replace the second element of your tuple with another shop name. Reflect on why you received the error.\n",
        "* Convert your first tuple, into a second tuple, but replace one of the shop names."
      ],
      "metadata": {
        "id": "Dl_jgea8_Miq"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Enter your attempt here\n"
      ],
      "metadata": {
        "id": "XwXfVnA-_NOp"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## **Data Structures - Dictionaries**\n",
        "\n",
        "One of the most powerful and flexible data structures in computing programming is the dictionary, denoted via curly brackets, e.g., `{}`.\n",
        "\n",
        "The structure of a dictionary focuses on key-value pairs, which allows you to later obtain information values by passing an explicit key.\n",
        "\n",
        "Unlike lists and tuples, dictionaries are unordered (as their purpose is to allow key-value operations).\n",
        "\n",
        "Keys can be strings, ints or floats.  "
      ],
      "metadata": {
        "id": "fH9qyhNLLKvI"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Example: Specifying a dictionary\n",
        "my_dict = {\n",
        "  \"var1\": 1,\n",
        "  \"var2\": 2,\n",
        "  3: 3,\n",
        "  4.5: 4\n",
        "}\n",
        "my_dict"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "-1WICDaB2AD_",
        "outputId": "4f0a4c75-6eac-468f-dc14-eb29c967a715"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "{'var1': 1, 'var2': 2, 3: 3, 4.5: 4}"
            ]
          },
          "metadata": {},
          "execution_count": 60
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "And values can also be pretty much anything you desired, from strings, ints or floats, to lists, tuples, dicts or another multi-dimensional structure (e.g., a list of dicts)."
      ],
      "metadata": {
        "id": "kHVteVBPph9O"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Example: Specifying a dictionary\n",
        "my_dict = {\n",
        "  \"var1\": [1,2,3],\n",
        "  \"var2\": (1,2,3),\n",
        "  3: {\n",
        "      'var1': 1,\n",
        "      'var2': 2\n",
        "  }\n",
        "}\n",
        "my_dict"
      ],
      "metadata": {
        "id": "cb6AMOUC2HcB"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "To access a value in a dict, we can use square index brackets.\n",
        "\n"
      ],
      "metadata": {
        "id": "2Q9qW3dLp1hg"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Example: Accessing dictionary values\n",
        "my_dict = {\n",
        "  \"var1\": 1,\n",
        "  \"var2\": 2,\n",
        "}\n",
        "my_dict['var2']"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "CJrSRjOap67X",
        "outputId": "2d31c6dd-6dcf-4c88-d23a-1673320b88e2"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "2"
            ]
          },
          "metadata": {},
          "execution_count": 61
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Dictionaries are mutable, and therefore we can easily add new key-value pairs."
      ],
      "metadata": {
        "id": "b1AeyTzAqJAx"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Example: Adding dictionary values\n",
        "my_dict = {\n",
        "  \"var1\": 1,\n",
        "  \"var2\": 2,\n",
        "}\n",
        "my_dict['var3'] = 3\n",
        "print(my_dict)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "KTYAnRYiqL7A",
        "outputId": "a323b307-1a88-4916-964e-0369a70273a9"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "{'var1': 1, 'var2': 2, 'var3': 3}\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "We can also modify a key's value."
      ],
      "metadata": {
        "id": "-XZhAhNiqSOw"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Example: Modifying dictionary values\n",
        "my_dict = {\n",
        "  \"var1\": 1,\n",
        "  \"var2\": 2,\n",
        "}\n",
        "my_dict['var2'] = 'replacement_element'\n",
        "print(my_dict)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "aW83X3z_qnOv",
        "outputId": "f913248b-412f-4b8d-ac04-595a054a3d36"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "{'var1': 1, 'var2': 'replacement_element'}\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Task**\n",
        "* Create a dictionary for your favorite Point of Interest (PoI) (for use in a spatial route optimization problem) and print the dictionary. Include a key for the name, city/county, and a tuple of coordinates.\n",
        "* Print the name and coordinates from your PoI dictionary.\n",
        "* Add a new key-value pair to your dictionary for your time spent at the location (e.g., \"time_spent\").\n",
        "* Remove the tuple of coordinates from your dictionary."
      ],
      "metadata": {
        "id": "QvEaru3-COYz"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Enter your attempt here\n"
      ],
      "metadata": {
        "id": "d8TCQP4cCOZJ"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## **Data Structures - Sets**\n",
        "\n",
        "A set provides you with the number of unique elements. A set has no inherent order.\n",
        "\n",
        "We denote a set using the curly brackets (but they differ from dictionaries because they are not based on key-value pairs).\n",
        "\n",
        "\n",
        "\n"
      ],
      "metadata": {
        "id": "h1KJTpltrdr7"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Example: Creating a set\n",
        "my_set = {1,2,3,4}\n",
        "print(my_set)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "5uvwAcrArcj6",
        "outputId": "5973ffe5-269e-40b1-ed07-294fe22f7a29"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "{1, 2, 3, 4}\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "You can also convert an existing list into a set."
      ],
      "metadata": {
        "id": "oQuLG-NzD6t4"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Example: Converting a list into a set\n",
        "my_list = [1,1,2,2,3,3,4,4,5,5]\n",
        "print(set(my_list))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "0gMCrtZsD8PX",
        "outputId": "7ab6bf66-aea5-4fed-d394-ba625fe18bc9"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "{1, 2, 3, 4, 5}\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "We can add to a set using the `add()` function."
      ],
      "metadata": {
        "id": "dii862imutZv"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Example: Creating a set\n",
        "my_set = {1,2,3,4}\n",
        "print(\"The length of my set is: {}\".format(len(my_set)))\n",
        "my_set.add('abc')\n",
        "print(\"The length of my set is: {}\".format(len(my_set)))\n",
        "my_set"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "qwQoKBY_ur9a",
        "outputId": "6ec92663-3122-46c4-d6aa-7c0258a70a99"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "The length of my set is: 4\n",
            "The length of my set is: 5\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "{1, 2, 3, 4, 'abc'}"
            ]
          },
          "metadata": {},
          "execution_count": 2
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Remember, as a set contains unique elements, if you add a new element which already matches an existing, the length of the set will stay the same.  "
      ],
      "metadata": {
        "id": "yjOhkCpVu0Ce"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#Example: Sets are unique collections of elements\n",
        "my_set = {1,2,3,4}\n",
        "print(\"The length of my set is: {}\".format(len(my_set)))\n",
        "my_set.add('abc')\n",
        "print(\"The length of my set is: {}\".format(len(my_set)))\n",
        "my_set.add(1)\n",
        "print(\"The length of my set is: {}\".format(len(my_set)))\n",
        "my_set"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ME0oVOJbu0os",
        "outputId": "3f7d9f1d-adcf-4e5a-b958-b1195620fdba"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "The length of my set is: 4\n",
            "The length of my set is: 5\n",
            "The length of my set is: 5\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "{1, 2, 3, 4, 'abc'}"
            ]
          },
          "metadata": {},
          "execution_count": 4
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Sometimes, we may need to remove elements from a set, via the `.remove()` function."
      ],
      "metadata": {
        "id": "aW8a-DmwvXp2"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#Example: Removing elements from a sets\n",
        "my_set = {1,2,3,4}\n",
        "print(\"The length of my set is: {}\".format(len(my_set)))\n",
        "my_set.remove(4)\n",
        "print(\"The length of my set is: {}\".format(len(my_set)))\n",
        "print(my_set)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "yUq9t6RfvYYZ",
        "outputId": "f4131384-6b7e-4ddc-c966-005ae52ff493"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "The length of my set is: 4\n",
            "The length of my set is: 3\n",
            "{1, 2, 3}\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Task**\n",
        "* Create a list sequence containing the 14 days of the week, for the January 1st to January 14th period. Now convert this list to a set. Reflect on the changes that took place.\n",
        "* Remove from your set any weekend days.\n",
        "* Now add back to your set the day of Saturday.\n",
        "* Find the length of your final set.  \n"
      ],
      "metadata": {
        "id": "9MdB27ioDUao"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Enter your attempt here\n"
      ],
      "metadata": {
        "id": "EM-jgIdWDUay"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## **Data Structures - Strings**\n",
        "\n",
        "While we have already covered strings when exploring data types, they are also a data structure (e.g., character sequences).\n"
      ],
      "metadata": {
        "id": "O7kP4PMbrX2b"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#Example: We can swap the case of a string\n",
        "my_string = \"I am a string.\"\n",
        "print(my_string.lower())\n",
        "print(my_string.upper())"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "gDQRv85Qv_Yd",
        "outputId": "0bb4445f-f14a-4442-be4a-2ceb960f5bad"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "i am a string.\n",
            "I AM A STRING.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "We can also replace parts of a string, which is very useful, via the `.replace()` function."
      ],
      "metadata": {
        "id": "tttUzwBGwMes"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#Example: We can swap the case of a string\n",
        "my_string = \"I am a string.\"\n",
        "print(my_string.replace(\"string\", \"machine\")) # Swapping \"string\" for \"machine\"\n",
        "print(my_string.replace(\" \", \"\")) # Stripping all whitespace\n",
        "print(my_string.replace(\" \", \"_\")) # Swapping whitespace for underscores"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "fLE92LPpwNgz",
        "outputId": "70936363-6ab6-4f06-c5bc-84f21a5c9214"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "I am a machine.\n",
            "Iamastring.\n",
            "I_am_a_string.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Task**\n",
        "* Create a string for the name of your favorite shop in sentence case.\n",
        "* Convert your string to all lower case.\n",
        "* Convert your string to all upper case.\n",
        "* Replace all of the vowels in your favorite shop name with hyphens.\n"
      ],
      "metadata": {
        "id": "OviBUowzDyNr"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Enter your attempt here\n"
      ],
      "metadata": {
        "id": "RWkMxVF2DyN1"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## **Multi-dimensional data structures**\n",
        "\n",
        "An important concept to understand is that we are able to nest our data structures within each other.\n",
        "\n",
        "The most important data structures for you to understand will be the use of lists of lists, lists of tuples and lists of dictionaries, as we will explore here."
      ],
      "metadata": {
        "id": "tfhqeO-_2K3X"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## **Multi-dimensional data structures - Lists of lists**\n",
        "\n",
        "We can create complex data structures by nesting one structure (e.g., a list), within another list.\n",
        "\n",
        "To do this, we just have to follow the same rules in the meta-list, as we would when entering elements into a normal list.\n",
        "\n",
        "For example, each list element needs to be separated by a comma."
      ],
      "metadata": {
        "id": "ev49fhKIFFkH"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Example: A list of lists\n",
        "my_list_of_lists = [\n",
        "    [1,2,3,4],\n",
        "    [1,2,3,4],\n",
        "    [1,2,3,4]\n",
        "]\n",
        "my_list_of_lists"
      ],
      "metadata": {
        "id": "viXC6Hai2R-x"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## **Multi-dimensional data structures - Lists of tuples**\n",
        "\n",
        "We can also do the same for lists of tuples, we just have to separate each tuple by a comma."
      ],
      "metadata": {
        "id": "p3CsziwnFkCD"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Example: A list of tuples\n",
        "my_list_of_tuples = [\n",
        "    (1,2,3,4),\n",
        "    (1,2,3,4),\n",
        "    (1,2,3,4)\n",
        "]\n",
        "my_list_of_tuples"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "3fO9spq-2YdW",
        "outputId": "170b9a98-5ad5-4bfd-81a8-7c36b54d76a6"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[(1, 2, 3, 4), (1, 2, 3, 4), (1, 2, 3, 4)]"
            ]
          },
          "metadata": {},
          "execution_count": 38
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## **Multi-dimensional data structures - Lists of dictionaries**\n",
        "\n",
        "Finally, we can next explore dictionaries within lists, thus forming a list of dictionaries. We again just have to separate each dict by a comma."
      ],
      "metadata": {
        "id": "OD-Hkcf9FwiX"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Example: A list of dictionaries\n",
        "my_list_of_dicts = [\n",
        "  {\"var1\": 1, \"var2\": 2, \"var3\": 3, \"var4\": 4},\n",
        "  {\"var1\": 1, \"var2\": 2, \"var3\": 3, \"var4\": 4},\n",
        "  {\"var1\": 1, \"var2\": 2, \"var3\": 3, \"var4\": 4},\n",
        "]\n",
        "my_list_of_dicts"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "oGJECx_w2kNQ",
        "outputId": "917f1ede-7676-4a2c-cea5-f6023ce172fa"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[{'var1': 1, 'var2': 2, 'var3': 3, 'var4': 4},\n",
              " {'var1': 1, 'var2': 2, 'var3': 3, 'var4': 4},\n",
              " {'var1': 1, 'var2': 2, 'var3': 3, 'var4': 4}]"
            ]
          },
          "metadata": {},
          "execution_count": 39
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Task**\n",
        "\n",
        "Each of these multi-dimensional data structures behaves and follows the same rules as the meta-structure.\n",
        "\n",
        "For example, lists are ordered and mutable, meaning if we want to access the first list in a list of dicts, we can index using the method covered earlier in the first exercise.\n",
        "\n",
        "* Create a list of list. You can reuse the list you created earlier with your preferred shop names. Print the first list in the list of lists. Print the second element.\n",
        "* Create a list of tuples. Make each tuple a set of coordinates. Extract the second tuple in the list of tuples. Then print both the x and y coordinates from the extracted tuple.\n",
        "* Create a list of dicts. Reuse the dictionary you created earlier for your PoI, but expand this to 3 PoIs. Access the last dict in your list, and then print each one of the values in the dict.   \n"
      ],
      "metadata": {
        "id": "V8j5r67FFCPZ"
      }
    }
  ]
}