chapters/dict_and_set.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "fab19ed2",
   "metadata": {},
   "source": [
    "# 2D Lists, Dictionaries and Sets\n",
    "\n",
    "In this episode, we will learn more about Python data types, such as dictionaries and sets. However, I want to begin with a brief overview of 2-dimensional lists, as they can be used effectively to understand some basics of linear algebra.\n",
    "\n",
    "## 2-Dimensional Lists\n",
    "In our previous discussion, we learned that we can create lists in Python. I mentioned that we can use objects of different data types as elements of a list. But have you ever thought about using lists themselves as elements? Surprisingly, there is nothing stopping us from doing so."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6700fc7c-e5a8-434a-befa-1086469e136c",
   "metadata": {},
   "outputs": [],
   "source": [
    "M = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]\n",
    "print(M)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "34876e58",
   "metadata": {},
   "source": [
    "After that we can work with such list as it was a matrix:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "19d24fa5",
   "metadata": {},
   "outputs": [],
   "source": [
    "M = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]\n",
    "print(M[0][0])\n",
    "print(M[1][2])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b002840a",
   "metadata": {},
   "source": [
    "<video autoplay loop playsinline controls muted>\n",
    "    <source src=\"../_static/videos/2d_array.mp4\" type=\"video/mp4\">\n",
    "</video>\n",
    "\n",
    "You can create more complex nested structures.\n",
    "Now, I will show you examples of how to create 2D lists using list comprehensions:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "df7e16a0",
   "metadata": {},
   "outputs": [],
   "source": [
    "n, m = 5, 10 # let n corresponds to rows, and m to columns\n",
    "zeros = [[0] * m for i in range(n)]\n",
    "\n",
    "for row in zeros:\n",
    "    print(row)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "811e9445",
   "metadata": {},
   "source": [
    "Let's take a look at matrix multiplication as an example. \n",
    "Here, I would like to ask if you know how matrix multiplication looks like and why it is defined in this way?\n",
    "\n",
    "`````{tab-set}\n",
    "````{tab-item} Question\n",
    "Attempt to implement matrix multiplication for 2D lists.\n",
    "````\n",
    "\n",
    "````{tab-item} Answer\n",
    "Here is possible implementation for two lists `A` and `B`\n",
    "```python\n",
    "C = [[0] * len(B[0]) for i in range(len(A))]\n",
    "\n",
    "for i in range(len(A)):\n",
    "    for j in range(len(B[0])):\n",
    "        for k in range(len(B)):\n",
    "            C[i][j] += A[i][k] * B[k][j]\n",
    "```\n",
    "````\n",
    "`````\n",
    "\n",
    "\n",
    "\n",
    "## Dictionaries\n",
    "\n",
    "A Python's dictionary (`dict`) is like a real-life dictionary or a phone book. It contains key-value pairs, where each key maps to a specific value. In Python, we create dictionaries using curly braces `{}`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5e45eaed",
   "metadata": {
    "tags": [
     "hide-output"
    ]
   },
   "outputs": [],
   "source": [
    "person = {\n",
    "    \"name\": \"Vladimir\",\n",
    "    \"dob\": \"10/08/1994\",\n",
    "    \"age\": 29\n",
    "}\n",
    "print(person)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "004c0571",
   "metadata": {},
   "source": [
    "Here, as you can see, we have a map between keys and values. In this specific case, we have the following keys: `\"name\"`, `\"dob\"`, `\"age\"`, and their corresponding values: `\"Vladimir\"`, `\"10/08/1994\"`, and `29`. It's important to note that as keys of a dictionary, you can use not just strings, but also other immutable objects.\n",
    "\n",
    "\n",
    "````{warning}\n",
    "Python does not permit the use of mutable objects as dictionary keys. Therefore, the following example will result in an error:\n",
    "```python\n",
    "wrong_dict = {[1, 2, 3]: \"list\"}\n",
    "```\n",
    "````\n",
    "\n",
    "### Access the element of a dict\n",
    "We can access values in dictionary by specifying the key."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9656a70f",
   "metadata": {
    "tags": [
     "hide-output"
    ]
   },
   "outputs": [],
   "source": [
    "name = person[\"name\"]\n",
    "print(name)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1105ca07",
   "metadata": {},
   "source": [
    "As you can see, the syntax is similar to a list where we use the index to access specific elements. However, when it comes to dictionaries (`dict`), we should use key instead.\n",
    "\n",
    "```{warning}\n",
    "In Python dictionaries, the order of keys was traditionally considered arbitrary and not guaranteed. This means that the keys were stored in an unpredictable order, based on how Python's internal data structures managed them. However, starting from Python 3.7 and later versions, dictionaries maintain the insertion order of keys. This means that when you iterate through a dictionary, the keys are returned in the order in which they were added. This order-preserving behavior simplifies many operations, making dictionaries even more versatile for tasks like data processing and maintaining a sense of order in your data structures. So, while in older Python versions, the order of keys was unpredictable, in Python 3.7 and beyond, you can rely on the order of keys in dictionaries.\n",
    "```\n",
    "### Modifying Elements\n",
    "You can change values just like you would in a list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4eea947b",
   "metadata": {
    "tags": [
     "hide-output"
    ]
   },
   "outputs": [],
   "source": [
    "person[\"name\"] = \"Vlad\"\n",
    "print(person)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "145883a6",
   "metadata": {},
   "source": [
    "### Adding a new element\n",
    "You can also add new key-value pairs to a dictionary."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1ccd7fe9",
   "metadata": {
    "tags": [
     "hide-output"
    ]
   },
   "outputs": [],
   "source": [
    "person[\"interests\"] = [\"Photography\", \"Chess\"]\n",
    "print(person)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ac56b8de",
   "metadata": {},
   "source": [
    "Here we used a new key, `\"interests\"`, and assigned it a list value of `[\"Photography\", \"Chess\"]`.\n",
    "\n",
    "### Iterating throught a Dictionary\n",
    "There are various ways to iterate over dictionaries. Let's explore some examples.\n",
    "\n",
    "**Iterate over dict keys**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "07929893",
   "metadata": {
    "tags": [
     "hide-output"
    ]
   },
   "outputs": [],
   "source": [
    "# In this example we will iterate throught the values\n",
    "for k in person:\n",
    "    print(\"Current key:\", k)\n",
    "    print(\"Value for this key:\", person[k])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "205e8243",
   "metadata": {},
   "source": [
    "Here, we use the syntax `k in person` within a `for` loop to iterate over all possible keys inside the dictionary.\n",
    "\n",
    "\n",
    "**Iterate over dict values**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3b2aaea8",
   "metadata": {
    "tags": [
     "hide-output"
    ]
   },
   "outputs": [],
   "source": [
    "# In this example we will iterate throught the keys\n",
    "for value in person.values():\n",
    "    print(\"Current value:\", value)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "21f38fc2",
   "metadata": {},
   "source": [
    "Here, we use the `.values()` method of the dict which generates a sequence of all values in the dict.\n",
    "\n",
    "**Iterate over dict key-value pairs**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "156151db",
   "metadata": {
    "tags": [
     "hide-output"
    ]
   },
   "outputs": [],
   "source": [
    "for k, v in person.items():\n",
    "    print(k, v)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fede308d",
   "metadata": {},
   "source": [
    "Here, we use the `.items()` method of the dict which generates a sequence of all key-value pairs of the dict.\n",
    "\n",
    "\n",
    "Sometimes, there may be a need to convert either keys, values, or key-value pairs into a list. To accomplish this, we can use the following syntax:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "01ac7473",
   "metadata": {
    "tags": [
     "hide-output"
    ]
   },
   "outputs": [],
   "source": [
    "keys = list(person.keys())\n",
    "values = list(person.values())\n",
    "items = list(person.items())\n",
    "\n",
    "print(\"keys:\", keys)\n",
    "print(\"values:\", values)\n",
    "print(\"itmes:\", items)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "aa168f13",
   "metadata": {},
   "source": [
    "### Checking for Key Existence\n",
    "\n",
    "We can check if a key exists in a dictionary using `in`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e0d2b2be",
   "metadata": {
    "tags": [
     "hide-output"
    ]
   },
   "outputs": [],
   "source": [
    "print(\"name\" in person)\n",
    "print(\"country\" in person)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5ccd50ff",
   "metadata": {},
   "source": [
    "Why is it important? If you try to access an element with the wrong key, you will receive an error.\n",
    "Here is an example:\n",
    "\n",
    "```python\n",
    "print(person[\"Country\"])\n",
    "```\n",
    "\n",
    "In this case we get the following error:\n",
    "```\n",
    "KeyError: 'Country'\n",
    "```\n",
    "\n",
    "### Dictionary comprehension\n",
    "\n",
    "Last week, we explored list comprehension, a more advanced approach for creating lists. A similar method can be used for creating dictionaries. Let's examine an example"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8e3578b5",
   "metadata": {
    "tags": [
     "hide-output"
    ]
   },
   "outputs": [],
   "source": [
    "letters = {i: chr(97 + i) for i in range(26)}\n",
    "print(letters)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fcb06ec8",
   "metadata": {},
   "source": [
    "Here, we set our key-value pair with the expression `i: chr(97 + i)`. After that, we defined the interval for the `i` value using the `range` function.\n",
    "```{note}\n",
    "The `ord()` and `chr()` functions in Python are a dynamic duo for working with character data. `ord()` stands for \"ordinal\" and is used to find the Unicode code point of a character. For example, `ord('A')` returns 65, which is the code point for the uppercase 'A'. On the other hand, `chr()` is short for \"character\" and does the reverse - it converts a Unicode code point back into the corresponding character. So, `chr(65)` will give you 'A'. These functions are handy for text processing and character manipulation in various applications, from encoding to cryptography.\n",
    "```\n",
    "\n",
    "\n",
    "`````{tab-set}\n",
    "````{tab-item} Question\n",
    "Try to complete the following task: you're given a string. Your goal is to find the frequency of all unique elements, separated by whitespaces.\n",
    "````\n",
    "\n",
    "````{tab-item} Answer\n",
    "Here is possible implementation for some string `line`\n",
    "```python\n",
    "freq_dict = {}\n",
    "for w in line.split():\n",
    "    if w not in freq_dict:\n",
    "        freq_dict[w] = line.count(w)\n",
    "\n",
    "print(freq_dict)\n",
    "```\n",
    "````\n",
    "`````\n",
    "\n",
    "\n",
    "## Sets\n",
    "A set is a collection of unique elements, just like a bag of distinct objects. In Python, we create sets using curly braces `{}` or the `set()` constructor."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "fc84860f",
   "metadata": {
    "tags": [
     "hide-output"
    ]
   },
   "outputs": [],
   "source": [
    "digits = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}\n",
    "print(digits)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1a3a8c3a",
   "metadata": {},
   "source": [
    "Here, you can notice that we use the same braces as we do for `dict` definition. However, in this case, we don't use `key: value` syntax, which signals to Python that this is a different data type. As always, you can verify the type of an object by using the built-in `type` function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "fc472391",
   "metadata": {
    "tags": [
     "hide-output"
    ]
   },
   "outputs": [],
   "source": [
    "print(type(digits))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e769098c",
   "metadata": {},
   "source": [
    "We can check whether an element is in the set by using the `in` operator:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5d4ad380",
   "metadata": {
    "tags": [
     "hide-output"
    ]
   },
   "outputs": [],
   "source": [
    "print(0 in digits)\n",
    "print(10 not in digits) # here we check wheather 10 is not in the set by using 'not in'"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "16516545",
   "metadata": {},
   "source": [
    "### Set methods\n",
    "Here I will cover just some part of [all](https://www.w3schools.com/python/python_ref_set.asp) possible set methods:\n",
    "\n",
    "- `add()` - adds an element to the set\n",
    "- `clear()` - removes all elements from the set\n",
    "- `copy()` - returns a copy of the set\n",
    "- `remove()` - removes the specified element from the set"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "749dcabd",
   "metadata": {
    "tags": [
     "hide-output"
    ]
   },
   "outputs": [],
   "source": [
    "numbers = {10, 20}\n",
    "\n",
    "numbers.add(30)\n",
    "numbers.add(10)\n",
    "print(\"numbers after add:\", numbers)\n",
    "\n",
    "numbers.remove(10)\n",
    "print(\"numbers after remove:\", numbers)\n",
    "\n",
    "values = numbers.copy()\n",
    "print(\"values after copy:\", values)\n",
    "\n",
    "values.clear()\n",
    "print(\"values after clear:\", values)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ba21b930",
   "metadata": {},
   "source": [
    "### Set Operations\n",
    "\n",
    "Let's create two sets:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e6ac8296",
   "metadata": {
    "tags": [
     "hide-output"
    ]
   },
   "outputs": [],
   "source": [
    "A = {1, 2, 3, 4, 5}\n",
    "B = {2, 4, 5, 6, 7}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "883a903d",
   "metadata": {},
   "source": [
    "Python allows basic operations on sets, working as expected from a mathematical perspective:\n",
    "\n",
    "- `==` - checks whether two sets are equal (i.e., composed of the same elements)\n",
    "- `|` - represents the union of two sets\n",
    "- `&` - stands for set intersection\n",
    "- `-` - stands for set difference\n",
    "- `<=` - checks whether the left operand is a subset of the right one\n",
    "- `>=` - checks whether the right operand is a subset of the left one\n",
    "\n",
    "<video autoplay loop playsinline controls muted>\n",
    "    <source src=\"../_static/videos/set_operations.mp4\" type=\"video/mp4\">\n",
    "</video>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "dfbcc6ca",
   "metadata": {
    "tags": [
     "hide-output"
    ]
   },
   "outputs": [],
   "source": [
    "print(\"A == B:\", A == B)\n",
    "print(\"A | B:\", A | B)\n",
    "print(\"A & B:\", A & B)\n",
    "print(\"A - B\", A - B)\n",
    "print(\"A <= B:\", A <= B)\n",
    "print(\"A >= B:\", A >= B)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d963c694",
   "metadata": {},
   "source": [
    "### Iterating Through a Set\n",
    "\n",
    "You can use `for` loops to go through all elements in a set:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "01bf27db",
   "metadata": {
    "tags": [
     "hide-output"
    ]
   },
   "outputs": [],
   "source": [
    "A = {1, 2, 3, 4, 5}\n",
    "for elem in A:\n",
    "    print(elem)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f8a2160c",
   "metadata": {},
   "source": [
    "````{warning}\n",
    "Sets in Python are unordered objects. \n",
    "This means there's no guarantee that different runs of your program will have the same order of elements during iterations. \n",
    "You can verify this by running the following example several times:\n",
    "```python\n",
    "elements = set([\"ABC\", \"L\" * 10, \"B\" * 5, \"DEF\"])\n",
    "for elem in elements:\n",
    "    print(elem)\n",
    "```\n",
    "````"
   ]
  }
 ],
 "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.12.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}