basic_datatypes.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Basic datatypes in Python\n",
    "# Table of Contents\n",
    "* [References](#References)\n",
    "* [Introduction](#Introduction)\n",
    "    + [Built-in data types](#Built-in-data-types)\n",
    "    + [Data structures](#Data-structures)\n",
    "    + [Dynamic typing](#Dynamic-typing-and-type()-function)\n",
    "* [Arithmetics of built-in data types](#Arithmetics-of-built-in-data-types)\n",
    "    + [Arithmetic operations with integers](#Arithmetic-operations-with-integers)\n",
    "    + [Arithmetic operations with floats](#Arithmetic-operations-with-floats)\n",
    "    + [Exercises on basic data type arithmetics](#Exercises-on-basic-data-type-arithmetics)\n",
    "    + [Type Promotion and Type Casting](#Type-Promotion-and-Type-Casting)\n",
    "    + [Quiz on basic data type arithmetics](#Quiz-on-basic-data-type-arithmetics)\n",
    "* [Non-arithmetic operators with built-in data types](#Non-arithmetic-operators-with-built-in-data-types)\n",
    "    + [Comparison operators](#Comparison-operators)\n",
    "    + [Exercises on comparison operators](#Exercises-on-comparison-operators)\n",
    "    + [Logical operators](#Logical-operators)\n",
    "    + [Exercises on logical operators](#Exercies-on-logical-operators)\n",
    "* [Data structures and their use](#Data-structures-and-their-use)\n",
    "    + [List](#List)\n",
    "        - [Lexicographical comparison](#Lexicographical-comparison)\n",
    "        - [Identity operators](#Identity-operators)\n",
    "        - [Membership operators](#Membership-operators)\n",
    "        - [Slicing](#Slicing)\n",
    "    + [Exercises on lists](#Exercises-on-lists)\n",
    "    + [Tuple](#Tuple)\n",
    "    + [Set](#Set)\n",
    "    + [Exercises on sets methods and operators](#Exercises-on-sets-methods-and-operators)\n",
    "    + [Dictionary](#Dictionary)\n",
    "    + [Exercises on dictionaries](#Exercises-on-dictionaries)\n",
    "* [String](#String)\n",
    "    + [Exercises on strings](#Exercises-on-strings)\n",
    "* [Mutable and immutable objects](#Mutable-and-immutable-objects)\n",
    "* [Unpacking](#Unpacking)\n",
    "    + [The `*` operator](#The-*-operator)\n",
    "    + [The `**` operator](#The-**-operator)\n",
    "    + [Nested unpacking](#Nested-unpacking)\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# References\n",
    "\n",
    "Additional material can be found in the following references:\n",
    "\n",
    "* Official documentation on [Python build-in data types](https://docs.python.org/3/library/stdtypes.html)\n",
    "* Official documentation on [Python data model](https://docs.python.org/3/reference/datamodel.html)\n",
    "* Python For Everybody: [Variables, Expressions, and Statements](https://www.py4e.com/lessons/memory)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# Some relevant modules\n",
    "import sys\n",
    "import math\n",
    "from tutorial import basic_datatypes as bdt"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "# Introduction\n",
    "In Python, we distinguish built-in data types and structures, which are more complex ways to organise and store data collections.\n",
    "In this tutorial we will cover the most commonly used ones.\n",
    "\n",
    "## Built-in data types\n",
    "\n",
    "There are several built-in data types in Python.\n",
    "The most commonly used ones are the following:\n",
    "  1. Integers (`int`), e.g.\n",
    "  ```python\n",
    "  1, -2, 0, 100\n",
    "  ```\n",
    "  2. Floats (`float`), e.g.\n",
    "  ```python\n",
    "  1.0, -2.5, 0.0, 100.0\n",
    "  ```\n",
    "  3. Strings (`str`), e.g. \n",
    "  ```python\n",
    "  \"Hello, World\", \"1\", \"2.5\"\n",
    "  ```\n",
    "  4. Booleans (`bool`), e.g. \n",
    "  ```python\n",
    "  True, False\n",
    "  ```\n",
    "  5. NoneType (`NoneType`), e.g. \n",
    "  ```python\n",
    "  None\n",
    "  ```\n",
    "The built-in data types are the basic building blocks for representing and manipulating data.\n",
    "\n",
    "## Data structures\n",
    "Data structures are more complex ways of organizing and storing data collections.\n",
    "Data structures may contain built-in data types as well as other data structures.\n",
    "The most commonly used data structures are:\n",
    "  1. Lists (`list`), e.g.\n",
    "  ```python\n",
    "  [1, 2, 3], [\"Hello\", \"World\"], [1, 2.5, \"Hello\"]\n",
    "  ```\n",
    "  2. Tuples (`tuple`), e.g.\n",
    "  ```python\n",
    "  (1, 2, 3), (\"Hello\", \"World\"), (1, 2.5, \"Hello\")\n",
    "  ```\n",
    "  3. Dictionaries (`dict`), e.g.\n",
    "  ```python\n",
    "  {\"key1\": 1, \"key2\": 2}, {\"key1\": \"Hello\", \"key2\": \"World\"}, {\"key1\": 1, \"key2\": 2.5, \"key3\": \"Hello\"}\n",
    "  ```\n",
    "  4. Sets (`set`), e.g.\n",
    "  ```python\n",
    "  {1, 2, 3}, {\"Hello\", \"World\"}, {1, 2.5, \"Hello\"}\n",
    "  ```\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "## Dynamic typing and `type()` function\n",
    "\n",
    "Python is a dynamically typed language.\n",
    "Dynamic typing means that the variable type is determined at runtime rather than being explicitly declared by the programmer.\n",
    "The type of a variable is determined by the value assigned to it.\n",
    "In Python, the type of a variable can be checked by the `type()` function.\n",
    "Let's see how this works in practice.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "a = 1\n",
    "print(f\"My type is {type(a)}\")\n",
    "\n",
    "a = 1.0\n",
    "print(f\"My type has changed, now it is {type(a)}\")\n",
    "\n",
    "a = \"now I am a string\"\n",
    "print(f\"My type ha changed again, now it is {type(a)}\")\n",
    "\n",
    "a = [1, 2, 3]\n",
    "print(f\"I became a list now: {type(a)}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-info\">\n",
    "<b>Remember:</b>: Python is a dynamically typed language. The type of a variable is determined at runtime.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There is, however, a way to explicitly declare the type of a variable.\n",
    "This is useful for error checking, documentation, and code readability.\n",
    "Static typing, however, is optional in Python.\n",
    "Moreover, variables declared with static typing are not checked at runtime and can be reassigned to a different type.\n",
    "To prevent this from happening it is suggested to use external tools like [mypy](http://mypy-lang.org/) to check your code for type errors."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Arithmetics of built-in data types"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Arithmetic operations with integers\n",
    "\n",
    "In Python, the basic arithmetic operations are supported for integers.\n",
    "The following list shows the supported arithmetic operations and their corresponding symbols:\n",
    "    \n",
    "  * Addition: `+` (sum of two integers is an integer)\n",
    "  * Subtraction: `-` (difference of two integers is an integer)\n",
    "  * Multiplication: `*` (product of two integers is an integer)\n",
    "  * Division: `/` (quotient of two integers is a float)\n",
    "  * Floor division: `//` (quotient of two integers is an integer)\n",
    "  * Modulo: `%` (remainder of two integers is an integer)\n",
    "  * Exponentiation: `**`  (exponentiation of two integers is an integer)\n",
    "\n",
    "Let's see how these operations work in practice:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "x = 5\n",
    "y = 3\n",
    "print(f\"Addition: {x + y}\")\n",
    "print(f\"Subtraction: {x - y}\")\n",
    "print(f\"Multiplication: {x * y}\")\n",
    "print(f\"Division: {x / y}\")\n",
    "print(f\"Floor division: {x // y}\")\n",
    "print(f\"Exponentiation: {x ** y}\")\n",
    "print(f\"Modulo: {x % y}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's have a closer look at the difference between \"standard\" and floor division."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "x = 5\n",
    "y = 3\n",
    "div = x / y\n",
    "floor_div = x // y\n",
    "\n",
    "print(f\"Division: {div}, {type(div)}\")\n",
    "print(f\"Floor division: {floor_div}, {type(floor_div)}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-info\">\n",
    "<b>Remember:</b>: The division operation `/` always returns a `float`.\n",
    "If you want the division to return `int`, you have to use the `//` operator.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "## Arithmetic operations with floats\n",
    "\n",
    "Floats share the same arithmetic operations as integers, with the difference that the result of such an operation is always a float.\n",
    "Let's see how these operations work in practice:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "x = 5.0\n",
    "y = 2.0\n",
    "print(f\"Addition: {x + y}\")\n",
    "print(f\"Subtraction: {x - y}\")\n",
    "print(f\"Multiplication: {x * y}\")\n",
    "print(f\"Division: {x / y}\")\n",
    "print(f\"Floor division: {x // y}\")\n",
    "print(f\"Exponentiation: {x ** y}\")\n",
    "print(f\"Modulo: {x % y}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-info\">\n",
    "<b>Note:</b>: The floor division operation `//` returns a `float` in case of floats.\n",
    "However, the returned float is rounded down to the nearest integer, which is 2.0 in the example above.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercises on basic data type arithmetics"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the cell below you should write the code that solves the following exercises:\n",
    "\n",
    "  1. Write a Python program to that gets three float numbers and retuns $(a + b) * c$.\n",
    "  2. Write a Python program that computes the area of a circle with radius $r$.\n",
    "  2. Write a Python program that returns a solution of quadratic equation $ax^2 + bx + c = 0$. We consider only the case when solutions are real numbers."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "%reload_ext tutorial.tests.testsuite"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "%%ipytest\n",
    "def solution_addition_multiplication(a: float, b:float, c:float) -> float:\n",
    "    # Your code starts here\n",
    "    return\n",
    "    # Your code ends here"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "%%ipytest\n",
    "def solution_circle_area(r: float) -> float:\n",
    "    # Your code starts here\n",
    "    return\n",
    "    # Your code ends here"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "%%ipytest\n",
    "\n",
    "def solution_quadratic_equation(a: float, b: float, c: float) -> float:\n",
    "    # Your code starts here\n",
    "    solution1 = 0.0\n",
    "    solution2 = 0.0\n",
    "    # Your code ends here\n",
    "    return solution1, solution2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Type Promotion and Type Casting\n",
    "\n",
    "It is common to perform arithmetic operations with two variables of different types.\n",
    "The rule here is to convert the lower data type to the higher one to prevent data loss.\n",
    "For example, when summing an integer and float, the integer is first converted to float and then summation is performed:\n",
    "\n",
    "```python\n",
    "a = 3 # Int\n",
    "b = 2.0 # Float\n",
    "a + b ## is 5.0. a is first converted to 3.0 and then added to 2.0\n",
    "5.0\n",
    "```\n",
    "\n",
    "Here is the hierarchy of the data types, where the lower one is always converted to the higher one:\n",
    "```python\n",
    "bool -> int -> float -> complex\n",
    "```\n",
    "\n",
    "Keep in mind that it is not always possible to perform type promotion.\n",
    "For instance, Python is not able to sum float and string - it will instead raise `TypeError`.\n",
    "Something like follows:\n",
    "```python\n",
    "---------------------------------------------------------------------------\n",
    "TypeError                                 Traceback (most recent call last)\n",
    "----> 1 1.0 + \"2.0\"\n",
    "\n",
    "TypeError: unsupported operand type(s) for +: 'float' and 'str'\n",
    "```\n",
    "\n",
    "Let's see how the type promotion works in practice."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "bool_number = True\n",
    "int_number = 2\n",
    "float_number = 3.0\n",
    "complex_number = 5.0 + 3.2j\n",
    "\n",
    "# bool + int\n",
    "res = bool_number + int_number\n",
    "print(f\"bool + int: Result is {res}. Type of the result {type(res)}\")\n",
    "\n",
    "# int + float\n",
    "res = int_number + float_number\n",
    "print(f\"int + float: Result is {res}. Type of the result {type(res)}\")\n",
    "\n",
    "# float + complex\n",
    "res = float_number + complex_number\n",
    "print(f\"float + complex: Result is {res}. Type of the result {type(res)}\")\n",
    "\n",
    "# bool + float\n",
    "res = bool_number + float_number\n",
    "print(f\"bool + float: Result is {res}. Type of the result {type(res)}\")\n",
    "\n",
    "# int + complex\n",
    "res = int_number + complex_number\n",
    "print(f\"int + complex: Result is {res}. Type of the result {type(res)}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As anticipated above, summing `str` and `float` will raise an exception.\n",
    "The idea behind is that `int`, `float` and `complex` are [numeric types](https://docs.python.org/3/library/stdtypes.html#numeric-types-int-float-complex), so they belong to the same [type hierarchy](https://peps.python.org/pep-3141) and can be promoted to each other.\n",
    "On the other hand, `str` is a [sequence type](https://docs.python.org/3/library/stdtypes.html#sequence-types-list-tuple-range), so it belongs to a different type hierarchy."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# This should fail.\n",
    "2.5 + \"1.5\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "But is there a way to still perform the summation from above?\n",
    "```python\n",
    "2.5 + \"1.5\"\n",
    "```\n",
    "\n",
    "It is possible, but the programmer should explicitely perform data casting, something like the following:\n",
    "```python\n",
    "2.5 + float(\"1.5\")  # This works!\n",
    "```\n",
    "\n",
    "Here are built-in Python operators for data casting.\n",
    "```python\n",
    "bool()  # Converst object to the boolean type\n",
    "int()  # Converts object to the integer type\n",
    "float()  # Converts object to the float type\n",
    "complex()  # Converts object to the complex type\n",
    "str()  # Converts object to the string type\n",
    "```\n",
    "Keep in mind that it is **not always possible** to convert an object of basic type to another basic type.\n",
    "For instance, an attempt to convert `complex` to `float` will raise `TypeError`.\n",
    "See the examples below to understand how this works in practice."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "bool_number = True\n",
    "int_number = 2\n",
    "float_number = 3.0\n",
    "complex_number = 5.0 + 3.2j\n",
    "string_number = \"6.0\"\n",
    "\n",
    "# bool -> int\n",
    "res = int(bool_number)\n",
    "print(f\"bool -> int: Result is {res}. Type of the result {type(res)}\")\n",
    "\n",
    "# int -> float\n",
    "res = float(int_number)\n",
    "print(f\"int -> float: Result is {res}. Type of the result {type(res)}\")\n",
    "\n",
    "# float -> complex\n",
    "res = complex(float_number)\n",
    "print(f\"float -> complex: Result is {res}. Type of the result {type(res)}\")\n",
    "\n",
    "# float -> string\n",
    "res = str(float_number)\n",
    "print(f\"float -> string: Result is {res}. Type of the result {type(res)}\")\n",
    "\n",
    "# complex -> string\n",
    "res = str(complex_number)\n",
    "print(f\"complex -> string: Result is {res}. Type of the result {type(res)}\")\n",
    "\n",
    "# string -> float\n",
    "res = float(string_number)\n",
    "print(f\"string -> int: Result is {res}. Type of the result {type(res)}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Quiz on basic data type arithmetics"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "bdt.IntegerFloatDivistion()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Non-arithmetic operators with built-in data types"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Comparison operators\n",
    "\n",
    "In Python, the comparison operations are supported for basic types.\n",
    "The following list shows the supported comparison operations and their corresponding symbols:\n",
    "    \n",
    "  * Equal: `==` (returns `True` if two objects are equal, `False` otherwise)\n",
    "  * Not equal: `!=` (returns `True` if two objects are not equal, `False` otherwise)\n",
    "  * Greater than: `>` (returns `True` if the first object is greater than the second, `False` otherwise)\n",
    "  * Less than: `<` (returns `True` if the first object is less than the second, `False` otherwise)\n",
    "  * Greater than or equal to: `>=` (returns `True` if the first object is greater than or equal to the second, `False` otherwise)\n",
    "  * Less than or equal to: `<=` (returns `True` if the first object is less than or equal to the second, `False` otherwise)\n",
    "\n",
    "Let's see how these operations work in practice:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-info\">\n",
    "<b>Hint:</b> Remember about type promotion. It works the same way as for the arithmetic operations.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "print(f\"1 is smaller than 2, this is {1<2}\")\n",
    "print(f\"1 is greater than 2, this is {1>2}\")\n",
    "print(f\"1 is equal to 1.0, this is {1 == 1.0}. Do you remember about the type promotion?\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-warning\">\n",
    "<b>Attention:</b> This is not recommended to use equality operator `==` to compare floats.\n",
    "</div>\n",
    "\n",
    "We suggest using the `math.isclose()` function instead.\n",
    "The reason is that the equality operator `==` is too precise for floats.\n",
    "Two very close numbers can be different in computer memory.\n",
    "For example, the following two numbers are different:\n",
    "```python\n",
    "a = 0.1 + 0.2\n",
    "b = 0.3\n",
    "\n",
    "a == b\n",
    "```\n",
    "Instead, if using the `math.isclose()` function - things will work properly.\n",
    "Here is an example of how it works:\n",
    "```python\n",
    "a = 0.1 + 0.2\n",
    "b = 0.3\n",
    "math.isclose(a, b)\n",
    "```\n",
    "\n",
    "Try it for yourself in the cell below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "import math\n",
    "\n",
    "a = 0.1 + 0.2\n",
    "b = 0.3\n",
    "print(f\"Is {a} equal to {b}? {a == b}\")\n",
    "\n",
    "a = 0.1 + 0.2\n",
    "b = 0.3\n",
    "print(f\"Is {a} close to {b}? {math.isclose(a, b)}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercises on comparison operators\n",
    "\n",
    "In the cell below you should write the code that solves the following exercises:\n",
    "\n",
    "  1. Write a Python program to that gets three float numbers and retuns `True` if $a + b = c$ and `False` otherwise.\n",
    "  2. Write a Python program that checks if a given number is even.\n",
    "  3. Write a Python program that checks if a given number is greater than 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "%reload_ext tutorial.tests.testsuite"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "%%ipytest\n",
    "\n",
    "def solution_a_plus_b_equals_c(a: float, b: float, c: float) -> float:\n",
    "    # Your code starts here\n",
    "    return\n",
    "    # Your code ends here\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "%%ipytest\n",
    "\n",
    "def solution_number_is_even(number: float) -> bool:\n",
    "    # Your code starts here\n",
    "    return number\n",
    "    # Your code ends here\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%ipytest\n",
    "\n",
    "def solution_number_is_greater_than_zero(number: float) -> bool:\n",
    "    # Your code starts here\n",
    "    return\n",
    "    # Your code ends here"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Logical operators\n",
    "\n",
    "The following list shows the logical operators that exist in Python:\n",
    "    \n",
    "  * `and` (logical AND)\n",
    "  * `or` (logical OR)\n",
    "  * `not` (logical NOT)\n",
    "\n",
    "Logical operations are used to combine two or more conditions.\n",
    "The result of the logical operation is always a boolean value.\n",
    "Let's see how these operations work in practice:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Logical `AND` returns `True` if both operands are `True`, and `False` otherwise:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# True\n",
    "print(True and True)\n",
    "\n",
    "# False\n",
    "print(True and False)\n",
    "\n",
    "# False\n",
    "print(False and False)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Logical `OR` returns `True` if at least one of the operands is `True`, and `False` otherwise:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# True\n",
    "print(True or True)\n",
    "\n",
    "# True\n",
    "print(True or False)\n",
    "\n",
    "# False\n",
    "print(False or False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Logical `NOT` returns `True` if the operand is `False`, and `False` otherwise:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# True\n",
    "print(not False)\n",
    "\n",
    "# False\n",
    "print(not True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Logical operators can be combined with comparison operators to create more complex conditions.\n",
    "For example, the following condition is `True` if the variable `x` is greater than 0 and less than 10:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "x = 5\n",
    "print(x > 0 and x < 10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can do something even more complex.\n",
    "Like checking if the variable `x` is greater than 0 and less than 10 or equal to 20:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "x = 0\n",
    "print((x>0 and x<10) or x == 20)\n",
    "\n",
    "x = 5\n",
    "print((x>0 and x<10) or x == 20)\n",
    "\n",
    "x = 10\n",
    "print((x>0 and x<10) or x == 20)\n",
    "\n",
    "x = 15\n",
    "print((x>0 and x<10) or x == 20)\n",
    "\n",
    "x = 20\n",
    "print((x>0 and x<10) or x == 20)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-info\">\n",
    "<b>Note:</b> Ultimately, this is up to you to decide how complex your conditions should be.\n",
    "At the same time we suggest to keep them as simple as possible to avoid bugs and make the code more readable.\n",
    "</div>\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercises on logical operators\n",
    "\n",
    "In the cell below you should write the code that solves the following exercises:\n",
    "\n",
    "  1. Write a Python program that checks if a given number is positive and even.\n",
    "  2. Write a Python program that checks if a given number is strictly lower than 0 or greater than (or equal to) 100."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "%reload_ext tutorial.tests.testsuite"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "%%ipytest\n",
    "\n",
    "def solution_number_is_positive_and_even(number: float) -> bool:\n",
    "    # Your code starts here\n",
    "    return\n",
    "    # Your code ends here"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "%%ipytest\n",
    "\n",
    "def solution_number_is_lower_than_0_or_greater_than_100(number: float) -> bool:\n",
    "    # Your code starts here\n",
    "    return\n",
    "    # Your code ends here"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Data structures and their use"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this section, we will learn about the most common data structures in Python.\n",
    "The data structures are used to store collections of data.\n",
    "The data structures that we will learn about are the following: List (`list`), Tuple (`tuple`), Set (`set`), and Dictionary (`dict`).\n",
    "\n",
    "The common feature of data structures is the ability to store different objects, including basic types and other data structures.\n",
    "\n",
    "See below an example of a list that contains different types of data:\n",
    "```python\n",
    "my_list = [1, 2.5, \"Hello\", [1, 2, 3], {\"a\": 1, \"b\": 2}]\n",
    "```\n",
    "\n",
    "In the example above, the list `my_list` contains five elements of type `int`, `float`, `str`, `list`, and `dict` respectively.\n",
    "\n",
    "In the following, we will have a closer look at each data structure."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## List\n",
    "\n",
    "List is a mutable data structure that can store different data types.\n",
    "The list is defined by square brackets `[]` and the elements are separated by commas `,`.\n",
    "The elements of the list can be accessed by their index.\n",
    "The index of the first element is `0`, the index of the second element is `1`, and so on.\n",
    "The index of the last element is `-1`, the index of the second last element is `-2`, and so on.\n",
    "\n",
    "Let's see how the list works in practice:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "my_list = [1, 2.5, \"abc\", True, None]\n",
    "\n",
    "print(f\"my_list is {my_list}\")\n",
    "print(f\"The first element of 'my_list' is {my_list[0]} and is of type {type(my_list[0])}\")\n",
    "print(f\"The last element of 'my_list' is {my_list[-1]} and is of type {type(my_list[-1])}\")\n",
    "\n",
    "print(f\"The length of 'my_list' is {len(my_list)}\")\n",
    "\n",
    "my_list[2] = \"def\"\n",
    "print(f\"my_list was changed to {my_list}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-warning\">\n",
    "<b>Warning:</b> Despite the heterogeneous lists being possible in Python, it is not recommended to use them. We suggest keeping lists homogeneous (e.g. containing only elements of the same type) whenever possible.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The following operations can be done with the list:\n",
    "    \n",
    "  * `list.append(element)` - adds the element to the end of the list\n",
    "  * `list.insert(index, element)` - inserts the element at the specified index\n",
    "  * `list.remove(element)` - removes the first occurrence of the element\n",
    "  * `list.pop(index)` - removes the element at the specified index and returns it\n",
    "  * `list.clear()` - removes all the elements from the list\n",
    "  * `list.index(element)` - returns the index of the first occurrence of the element\n",
    "  * `list.count(element)` - returns the number of occurrences of the element\n",
    "  * `list.sort()` - sorts the list\n",
    "  * `list.reverse()` - reverses the order of the list\n",
    "  * `list.copy()` - returns a copy of the list\n",
    "\n",
    "  let's see how these operations work in practice:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "my_list = [1, 2.5, \"abc\", True, None]\n",
    "\n",
    "my_list.append(2.5)\n",
    "print(f\"my_list has been appended: {my_list}\")\n",
    "\n",
    "my_list.insert(1, \"test\")\n",
    "print(f\"A new element 'test' has been inserted at index 1: {my_list}\")\n",
    "\n",
    "my_list.remove(2.5)\n",
    "print(f\"The first occurence of 2.5 has been removed: {my_list}\")\n",
    "\n",
    "popped_element = my_list.pop(2)\n",
    "print(f\"The element at index 2 ({popped_element}) has been popped out: {my_list}\")\n",
    "\n",
    "print(f\"The index of None is {my_list.index(None)}\")\n",
    "print(f\"The number of 'inserted' in my_list is {my_list.count('inserted')}\")\n",
    "\n",
    "\n",
    "my_list.clear()\n",
    "print(f\"my_list is cleared: {my_list}\")\n",
    "\n",
    "my_list = [3, 1, 2, 5, 4]\n",
    "my_list.sort()\n",
    "print(f\"my_list is sorted: {my_list}\")\n",
    "\n",
    "my_list.reverse()\n",
    "print(f\"my_list is reversed: {my_list}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Also, some of the operations we have seen earlier can be used for lists:\n",
    "\n",
    "  * `list1 + list2` - concatenates two lists\n",
    "  * `list * n` - repeats the list `n` times\n",
    "  * `==`, `!=`, `<`, `<=`, `>`, `>=` compare two lists lexicographically, which means that the lists are compared element by element, starting from the first element (see more information below)\n",
    "          \n",
    "Let's see how these operations work in practice:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "my_list = [1, 2.5, \"abc\", True, None]\n",
    "\n",
    "print(f\"my_list is {my_list}\")\n",
    "\n",
    "print(f\"my_list + [1, 2, 3] is {my_list + [1, 2, 3]}\")\n",
    "print(f\"my_list * 2 is {my_list * 2}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the following, we will have a closer look at other operations that can be done with lists."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Lexicographical comparison\n",
    "\n",
    "The comparison operators `==`, `!=`, `<`, `<=`, `>`, `>=` can be used to compare two lists.\n",
    "The comparison is done lexicographically, which means that the lists are compared element by element, starting from the first element.\n",
    "If the first elements are equal, the second elements are compared, and so on.\n",
    "The result of the comparison is defined by the first pair of elements that are not equal.\n",
    "In that case, the length difference between the two lists doesn't play a role.\n",
    "\n",
    "Whenever two lists of different lengths are compared, and the shorter list is a prefix of the longer list, the shorter list is considered smaller.\n",
    "\n",
    "Let's see some examples below:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "my_list1 = [1, 2, 3]\n",
    "my_list2 = [1, 2, 3, 4, 5, 6]\n",
    "my_list3 = [0, 1000, 3000]\n",
    "my_list4 = [4, 5]\n",
    "\n",
    "print(f\"my_list1 is smaller than my_list2: {my_list1 < my_list2}. This is because my_list1 is shorter than my_list2 while the first three elements are the same.\")\n",
    "print(f\"my_list1 is smaller than my_list4: {my_list1 < my_list4}. This is because the first element of my_list1 is smaller than the first element of my_list4.\")\n",
    "print(f\"my_list3 is smaller than my list1: {my_list3 < my_list1}. This is because the first element of my_list3 is smaller than the first element of my_list1.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Identity operators\n",
    "\n",
    "Identity operators are used to compare the objects.\n",
    "It is not enough for them to be equal, they should be the same object, with the same memory location.\n",
    "\n",
    "The following list shows the identity operators that exist in Python:\n",
    "    \n",
    "  * `is` (returns `True` if both operands are the same object, `False` otherwise)\n",
    "  * `is not` (returns `True` if both operands are not the same object, `False` otherwise)\n",
    "\n",
    "The identity operators are often used to check if a variable is `None` or not.\n",
    "It is not recommended to use the equality operator `==` to check if a variable is `None`.\n",
    "At the same time it is not recommended to use the identity operators to check if two variables are equal."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-warning\">\n",
    "<b>Warning:</b> Always use the identity operators to check if a variable is `None` or not.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "my_list1 = [1, 2, 3]\n",
    "my_list2 = [1, 2, 3]\n",
    "my_list3 = my_list1\n",
    "\n",
    "print(f\"my_list1 is equal to my_list2: {my_list1 == my_list2}, but my_list1 is not my_list2: {my_list1 is not my_list2}\")\n",
    "print(f\"my_list1 is equal to my_list3: {my_list1 == my_list3}, and my_list1 is my_list3: {my_list1 is my_list3}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Membership operators\n",
    "\n",
    "Membership operators are used for checking if an object is presented in a list.\n",
    "The following membership operators exist in Python:\n",
    "    \n",
    "  * `in` (returns `True` if the specified object is present in the list, `False` otherwise)\n",
    "  * `not in` (returns `True` if the specified object is not present in the list, `False` otherwise)\n",
    "\n",
    "Let's see how these operations work in practice:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "my_list = [1, 2.5, True, None]\n",
    "\n",
    "print(f\"1 is in my_list: {1 in my_list}\")\n",
    "print(f\"3 is not in my_list: {3 not in my_list}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Slicing\n",
    "\n",
    "Slicing is a technique that allows us to access a subset of elements from a list.\n",
    "The slicing is done by specifying the index of the first element, the index of the last element, and the step.\n",
    "The index of the first element is included, the index of the last element is excluded.\n",
    "The syntax of the slicing is the following: `my_list[first_index:last_index:step]`.\n",
    "Let's see how the slicing works in practice:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "my_list = [1, 2.5, \"abc\", True, None, \"x\", \"y\", \"z\"]\n",
    "\n",
    "print(f\"my_list is {my_list}\")\n",
    "\n",
    "print(f\"Second, third and fourth element of my_list are {my_list[1:4]}\")\n",
    "print(f\"First three elements of my_list are {my_list[:3]}\")\n",
    "print(f\"All elements of the list starting from the third one are {my_list[2:]}\")\n",
    "print(f\"Every second element of my_list are {my_list[::2]}\")\n",
    "print(f\"Every second element of my_list starting from the second one are {my_list[1::2]}\")\n",
    "print(f\"All elements of the list in reverse order are {my_list[::-1]}\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercises on lists\n",
    "\n",
    "1. Write a program that takes a list of numbers and returns a new list with every second element removed.\n",
    "2. Write a program that takes a list and returns the first and last element of the list.\n",
    "3. Write a program that returns `True` if the first and last element of the list are the same, otherwise return `False`.\n",
    "4. Write a program that takes two lists and returns `True` if they are equal.\n",
    "5. Write a program that takes two lists and returns `True` if they equal but not the same object.\n",
    "6. Write a program that takes two lists and returns `True` if the first list is greater or equal to the second list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "%reload_ext tutorial.tests.testsuite"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "%%ipytest\n",
    "\n",
    "def solution_remove_every_second_element_from_list(my_list: list[float]) -> list[float]:\n",
    "    # Your code starts here\n",
    "    return\n",
    "    # Your code ends here"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "%%ipytest\n",
    "\n",
    "def solution_return_first_and_last_element_from_list(my_list: list[float]) -> list[float]:\n",
    "    # Your code starts here\n",
    "    return\n",
    "    # Your code ends here"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "%%ipytest\n",
    "\n",
    "def solution_first_and_last_element_are_equal(my_list: list[float]) -> bool:\n",
    "    # Your code starts here\n",
    "    return\n",
    "    # Your code ends here"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "%%ipytest\n",
    "\n",
    "def solution_lists_are_equal(list1: list, list2: list) -> bool:\n",
    "    # Your code starts here\n",
    "    return\n",
    "    # Your code ends here"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "%%ipytest\n",
    "\n",
    "def solution_lists_are_not_same_but_equal(list1: list, list2: list) -> bool:\n",
    "    # Your code starts here\n",
    "    return\n",
    "    # Your code ends here"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "%%ipytest\n",
    "\n",
    "def solution_greater_or_equal(list1: list, list2: list) -> bool:\n",
    "    # Your code starts here\n",
    "    return\n",
    "    # Your code ends here"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Tuple\n",
    "\n",
    "Tuple is similar to a list in many ways.\n",
    "However, the tuple is immutable, which means that it cannot be changed after it is created.\n",
    "The tuple is defined by round brackets `()` and its elements are separated by commas `,`.\n",
    "The elements of the tuple can be accessed by their index in the same way as the list.\n",
    "The advantage of the tuple over the list is that it is faster and more memory efficient, which makes it a good choice for storing data that does not change.\n",
    "The disadvantage of the tuple is that it cannot be changed after it is created, and it does not have many methods.\n",
    "\n",
    "Let's see how the tuple works in practice:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "my_tuple = (1, 2.5, True, None)\n",
    "\n",
    "print(f\"my_tuple is {my_tuple}\")\n",
    "print(f\"The first element of 'my_tuple' is {my_tuple[0]} and is of type {type(my_tuple[0])}\")\n",
    "print(f\"The last element of 'my_tuple' is {my_tuple[-1]} and is of type {type(my_tuple[-1])}\")\n",
    "print(f\"The length of 'my_tuple' is {len(my_tuple)}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Unlike lists, sets and dictionaries, tuples do not require parentheses.\n",
    "Parenthesis are required only when there's some ambiguity.\n",
    "We will discuss it in more details in the [`Functions`](functions.ipynb) chapter.\n",
    "\n",
    "For now, let's just see how to define tuples without parentheses:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "my_tuple = 1, 2.5, True, None\n",
    "\n",
    "print(f\"my_tuple is {my_tuple} and is of type {type(my_tuple)}\")\n",
    "\n",
    "# It is possible to create a tuple with only one element by adding a comma after it\n",
    "my_tuple = 1,\n",
    "\n",
    "print(f\"my_tuple is {my_tuple} and is of type {type(my_tuple)}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-danger\">\n",
    "<b>Warning:</b> Since a tuple is an immutable object, an attempt to change it or its elements will result in an error.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "my_tuple[2] = False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "my_tuple.append(\"It won't work :(\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The workaround here is to create another tuple with extended content:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "my_tuple = (1, 2.5, True, None)\n",
    "values_to_add = (1, 2, 3)\n",
    "\n",
    "new_tuple = my_tuple + values_to_add\n",
    "print(f\"my_tuple is {my_tuple}\")\n",
    "print(f\"new_tuple is {new_tuple}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "At the same time tuples are slightly more efficient when it comes to memory usage.\n",
    "Let's see how much memory the list and the tuple take:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "my_list = [1, 2.5, True, None]\n",
    "my_tuple = (1, 2.5, True, None)\n",
    "\n",
    "# Memory usage\n",
    "print(f\"Memory usage of my_list: {sys.getsizeof(my_list)}\")\n",
    "print(f\"Memory usage of my_tuple: {sys.getsizeof(my_tuple)}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Unlike the list, the tuple does not have many methods because of its immutability.\n",
    "The two methods that exist for the tuple are `tuple.count(element)` and `tuple.index(element)`.\n",
    "Let's see how these methods work in practice:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "my_tuple = (1, 2.5, 3,  True, None, 3)\n",
    "\n",
    "print(f\"The index of None is {my_tuple.index(None)}\")\n",
    "print(f\"The number of 3 in my_tuple is {my_tuple.count(3)}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Same operators that work for the list can be used for the tuple:\n",
    "\n",
    "  * `element in tuple` - returns `True` if the element is in the tuple, `False` otherwise\n",
    "  * `element not in tuple` - returns `True` if the element is not in the tuple, `False` otherwise\n",
    "  * `tuple1 + tuple2` - concatenates two tuples\n",
    "  * `tuple * n` - repeats the tuple `n` times\n",
    "  * `==`, `!=`, `<`, `<=`, `>`, `>=` compare two tuples lexicographically\n",
    "  * `is`, `is not` compare the identity of two tuples\n",
    "\n",
    "Tuples also support slicing, which means that we can access a subset of elements from a tuple.\n",
    "\n",
    "See the examples below:\n",
    "  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "my_tuple1 = (1, 2.5, True, None)\n",
    "my_tuple2 = (2, 2.5, True, None)\n",
    "\n",
    "print(f\"my_tuple1 is {my_tuple1}\")\n",
    "print(f\"1 is in my_tuple1: {1 in my_tuple1}\")\n",
    "\n",
    "print(f\"my_tuple1 + (1, 2, 3) is {my_tuple1 + (1, 2, 3)}\")\n",
    "print(f\"my_tuple1 * 2 is {my_tuple1 * 2}\")\n",
    "\n",
    "print(f\"my_tuple1 == my_tuple2 is {my_tuple1 == my_tuple2}\")\n",
    "\n",
    "print(f\"Showing every second element of my_tuple1: {my_tuple1[1::2]}\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Tuple vs list\n",
    "\n",
    "The main difference between the tuple and the list is that the tuple is immutable, which means that it cannot be changed after it is created.\n",
    "\n",
    "The following table shows the main differences between the tuple and the list:\n",
    "\n",
    "| Tuple | List |\n",
    "| --- | --- |\n",
    "| Immutable | Mutable |\n",
    "| Faster | Slower |\n",
    "| Less memory | More memory |\n",
    "| Less methods | More methods |\n",
    "\n",
    "\n",
    "So when should we use the tuple and when should we use the list?\n",
    "\n",
    "* Tuples are faster than lists. If you define a constant set of elements and you need to iterate over it, it is better to use the tuple instead of the list.\n",
    "* Tuples makes your code safer if you \"write-protect\" data that does not need to be changed.\n",
    "* Some tuples can be used as dictionary keys, while lists cannot. See more about dictionaries in the [Dictionary](#Dictionary) section.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Set\n",
    "\n",
    "Set is a collection of unique elements.\n",
    "The set is defined by curly brackets `{}`, and its elements are separated by commas `,`.\n",
    "The elements of the set cannot be accessed by their index.\n",
    "The advantage of the set over the list is that it is faster and more memory efficient, which makes it a good choice for storing data that does not contain duplicates.\n",
    "Sets are mutable, which means that they can be changed after they are created.\n",
    "Also, operations with sets are very efficient.\n",
    "\n",
    "Let's see how the set works in practice:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "my_set = {1, 2.5, True, None}\n",
    "\n",
    "print(f\"my_set is {my_set}\")\n",
    "print(f\"The length of 'my_set' is {len(my_set)}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There can only be one occurrence of each element in the set.\n",
    "Therefore, operations like `set.add(element)` and `set.update(elements)` will not add the element if it is already in the set.\n",
    "Also, counting the number of occurrences of an element in the set does not make sense, as it can only be `0` or `1`.\n",
    "Instead, the `in` operator can be used to check if the element is in the set or not."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "my_set = {1, 2.5, True, None}\n",
    "\n",
    "print(f\"my_set is {my_set}\")\n",
    "\n",
    "my_set.add(1)\n",
    "print(f\"my_set is unchanged, since it contained 1 before: {my_set}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, let's look at the efficiency of operations with sets.\n",
    "They are based on the hash table, which means that the lookup of an element in a set is very fast.\n",
    "On average a lookup operation takes a constant time `O(1)` and does not depend on the size of the set.\n",
    "\n",
    "Let's see how fast the lookup operation is in practice and compare it with the list and the tuple:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# Time efficiency of list and tuple\n",
    "import time\n",
    "import random\n",
    "\n",
    "my_list = list(range(1000000))\n",
    "my_tuple = tuple(range(1000000))\n",
    "my_set = set(range(1000000))\n",
    "\n",
    "randomised_list = list(range(60000))\n",
    "\n",
    "random.shuffle(randomised_list)\n",
    "start = time.time()\n",
    "for i in randomised_list:\n",
    "    i in my_list\n",
    "end = time.time()\n",
    "print(f\"Time to search in list: {end - start} s\")\n",
    "\n",
    "\n",
    "random.shuffle(randomised_list)\n",
    "start = time.time()\n",
    "for i in randomised_list:\n",
    "    i in my_tuple\n",
    "end = time.time()\n",
    "print(f\"Time to search in tuple: {end - start} s\")\n",
    "\n",
    "\n",
    "random.shuffle(randomised_list)\n",
    "start = time.time()\n",
    "for i in randomised_list:\n",
    "    i in my_set\n",
    "end = time.time()\n",
    "print(f\"Time to search in set: {end - start} s\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here are the commonly used operations for the sets:\n",
    "    \n",
    "  * `set.add(element)` - adds the element to the set\n",
    "  * `set.update(elements)` - adds several elements to the set\n",
    "  * `set.remove(element)` - removes the element from the set\n",
    "  * `set.discard(element)` - removes the element from the set if it is present\n",
    "  * `set.pop()` - removes and returns an arbitrary element from the set\n",
    "  * `set.clear()` - removes all the elements from the set\n",
    "  * `set.copy()` - returns a copy of the set\n",
    "\n",
    "Let's see how these operations work in practice:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "my_set = {1, 2.5, True, None}\n",
    "\n",
    "print(f\"my_set is {my_set}\")\n",
    "\n",
    "my_set.add(2)\n",
    "print(f\"my_set now also contains 2: {my_set}\")\n",
    "\n",
    "my_set.update([1, 2, 3])\n",
    "print(f\"Only 3 was added to my_set, the rest was already there: {my_set}\")\n",
    "\n",
    "my_set.remove(1)\n",
    "print(f\"my_set no longer contains 1: {my_set}\")\n",
    "\n",
    "my_set.discard(2)\n",
    "print(f\"my_set no longer contains 2: {my_set}\")\n",
    "\n",
    "my_set.discard(2)\n",
    "print(f\"my_set is unchanged, since it did not contain 2: {my_set}\")\n",
    "\n",
    "popped_element = my_set.pop()\n",
    "print(f\"my_set no longer contains {popped_element}: {my_set}\")\n",
    "\n",
    "my_set.clear()\n",
    "print(f\"my_set is cleared: {my_set}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There are a few special methods that can be used with the sets:\n",
    "  * `set1.union(set2)` - returns a new set containing all distinct elements from both sets\n",
    "  * `set1.intersection(set2)` - returns a new set with elements that are present in both sets\n",
    "  * `set1.difference(set2)` - returns a new set with elements that are in the `set1` but not in the `set2`.\n",
    "  * `set1.symmetric_difference(set2)` - returns a new set with elements that are in either set, but not both\n",
    "  * `set1.issubset(set2)` - returns `True` if the first set is a subset of the second set, `False` otherwise\n",
    "  * `set1.issuperset(set2)` - returns `True` if the first set is a superset of the second set, `False` otherwise\n",
    "  * `set1.isdisjoint(set2)` - returns `True` if the two sets have no elements in common, `False` otherwise"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "my_set1 = {1, 2, 3, 4, 5}\n",
    "my_set2 = {4, 5, 6, 7, 8}\n",
    "my_set3 = {3, 4, 5}\n",
    "\n",
    "print(f\"Union of my_set1 and my_set2 is {my_set1.union(my_set2)}\")\n",
    "print(f\"Intersection of my_set1 and my_set2 is {my_set1.intersection(my_set2)}\")\n",
    "print(f\"Difference of my_set1 and my_set2 is {my_set1.difference(my_set2)}\")\n",
    "print(f\"Symmetric difference of my_set1 and my_set2 is {my_set1.symmetric_difference(my_set2)}\")\n",
    "print(f\"my_set3 is a subset of my_set1: {my_set3.issubset(my_set1)}\")\n",
    "print(f\"my_set3 is a subset of my_set2: {my_set3.issubset(my_set2)}\")\n",
    "print(f\"my_set1 is a supercet of my_set3: {my_set1.issuperset(my_set3)}\")\n",
    "print(f\"my_set2 is a supercet of my_set3: {my_set3.issuperset(my_set2)}\")\n",
    "print(f\"my_set1 is disjoint with my_set2: {my_set1.isdisjoint(my_set2)}\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here is the list of operators that work with sets:\n",
    "\n",
    "  * `set1 == set2` - returns `True` if the two sets are equal, `False` otherwise\n",
    "  * `set1 != set2` - returns `True` if the two sets are not equal, `False` otherwise\n",
    "  * `set1 <= set2` - returns `True` if the first set is a subset of the second set, `False` otherwise\n",
    "  * `set1 < set2` - returns `True` if the first set is a subset of the second set and they are not equal, `False` otherwise\n",
    "  * `set1 >= set2` - returns `True` if the first set is a superset of the second set, `False` otherwise\n",
    "  * `set1 > set2` - returns `True` if the first set is a superset of the second set and they are not equal, `False` otherwise\n",
    "  * `set1 | set2` - returns a new set containing all distinct elements from both sets\n",
    "  * `set1 & set2` - returns a new set with elements that are present in both sets\n",
    "  * `set1 - set2` - returns a new set with elements that are in the `set1` but not in the `set2`.\n",
    "  * `set1 ^ set2` - returns a new set with elements that are in either set, but not both"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercises on sets methods and operators\n",
    "\n",
    "As you can see, most of the operators from the cell above have the same functionality as the \"special\" sets' methods like `union`, `intersection`, `difference`, `symmetric_difference`, `issubset`, `issuperset`, and `isdisjoint`.\n",
    "In the exercise below let's try to implement these methods using operators."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "%reload_ext tutorial.tests.testsuite"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "%%ipytest\n",
    "\n",
    "def solution_sets_union(set1: set, set2: set) -> set:\n",
    "    # Your code starts here\n",
    "    return\n",
    "    # Your code ends here"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%ipytest\n",
    "\n",
    "def solution_sets_intersection(set1: set, set2: set) -> set:\n",
    "    # Your code starts here\n",
    "    return\n",
    "    # Your code ends here"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%ipytest\n",
    "\n",
    "def solution_sets_difference(set1: set, set2: set) -> set:\n",
    "    # Your code starts here\n",
    "    return\n",
    "    # Your code ends here"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%ipytest\n",
    "\n",
    "def solution_sets_symmetric_difference(set1: set, set2: set) -> set:\n",
    "    # Your code starts here\n",
    "    return\n",
    "    # Your code ends here   "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%ipytest\n",
    "\n",
    "def solution_sets_subset(set1: set, set2: set) -> set:\n",
    "    # Your code starts here\n",
    "    return\n",
    "    # Your code ends here"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%ipytest\n",
    "\n",
    "def solution_sets_superset(set1: set, set2: set) -> set:\n",
    "    # Your code starts here\n",
    "    return\n",
    "    # Your code ends here"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "%%ipytest\n",
    "\n",
    "def solution_sets_disjoint(set1: set, set2: set) -> set:\n",
    "    # Your code starts here\n",
    "    return\n",
    "    # Your code ends here"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Dictionary\n",
    "\n",
    "A dictionary is a collection of key-value pairs.\n",
    "The dictionary is defined by curly brackets `{}`, and the key-value pairs are separated by commas `,`.\n",
    "The key-value pairs are defined by a colon `:`.\n",
    "\n",
    "The value of the dictionary can be accessed by their key:\n",
    "\n",
    "```python\n",
    "my_dict = {'key1': 'value1', 'key2': 'value2'}\n",
    "print(my_dict['key1'])\n",
    "```\n",
    "\n",
    "To store keys in the dictionary, the hash table is used the same way as for the sets.\n",
    "This makes the lookup of the value by the key very fast.\n",
    "\n",
    "Let's see how the dictionary works in practice."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "my_dict = {\"a\": 1, \"b\": 2.5, \"c\": \"abc\", 1: True, 2: None}\n",
    "\n",
    "print(f\"my_dict is {my_dict}\")\n",
    "print(f\"The length of 'my_dict' is {len(my_dict)}\")\n",
    "\n",
    "\n",
    "my_dict[\"a\"] = 1000\n",
    "print(f\"my_dict is {my_dict}\")\n",
    "\n",
    "my_dict[\"d\"] = \"new element\"\n",
    "print(f\"my_dict now also contains 'd': {my_dict}\")\n",
    "\n",
    "del my_dict[\"a\"]\n",
    "print(f\"my_dict no longer contains 'a': {my_dict}\")\n",
    "\n",
    "# It is also fine to use numbers as keys. But be careful, since they are not indexed and cannot be used the same way as in lists and tuples.\n",
    "print(f\"Accessing a value with a number as the key: {my_dict[1]}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-warning\">\n",
    "\n",
    "<b> Warning: </b> The keys of the dictionary must be hashable.\n",
    "This means that the `hash` function must work for such them: `hash(key)`.\n",
    "The most common hashable types are numbers, strings, and tuples.\n",
    "The lists are not hashable, so they cannot be used as keys.\n",
    "\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here is the list of commonly used methods of dictionaries:\n",
    "\n",
    "  * `dict.get(key)` - returns the value of the key if it is in the dictionary, `None` otherwise\n",
    "  * `dict.pop(key[, default])` - removes the key-value pair from the dictionary and returns the value. If the `default` value is provided it will be returned if the key is not in the dictionary.\n",
    "  * `dict.popitem()` - removes and returns an arbitrary key-value pair from the dictionary\n",
    "  * `dict.clear()` - removes all the key-value pairs from the dictionary\n",
    "  * `dict.copy()` - returns a copy of the dictionary\n",
    "  * `dict.update(other_dict)` - updates the dictionary with the key-value pairs from the other dictionary\n",
    "  * `dict.fromkeys(keys, value)` - creates a new dictionary with the keys from the first argument and the value from the second argument\n",
    "  * `dict.keys()` - returns a view object that displays a list of all the keys in the dictionary\n",
    "  * `dict.values()` - returns a view object that displays a list of all the values in the dictionary\n",
    "  * `dict.items()` - returns a view object that displays a list of all the key-value pairs in the dictionary (often used in `for` loops)\n",
    "\n",
    "The following operators work with dictionaries:\n",
    "\n",
    "  * `key in dict` - returns `True` if the key is in the dictionary, `False` otherwise\n",
    "  * `dict1 == dict2` - returns `True` if the two dictionaries are equal, `False` otherwise\n",
    "  * `dict1 is dict2` - returns `True` if the two dictionaries are the same object, `False` otherwise"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "my_dict = {\"a\": 1, \"b\": 2.5, \"c\": \"abc\", 1: True, 2: None}\n",
    "\n",
    "print(f\"my_dict is {my_dict}\")\n",
    "\n",
    "print(f\"Getting a value with the 'get' method: {my_dict.get('a')}\")\n",
    "print(f\"Getting a value with the 'get' method, if the key does not exist: {my_dict.get('d')}\")\n",
    "\n",
    "print(f\"Getting a value with the 'pop' method: {my_dict.pop('a')}\")\n",
    "print(f\"my_dict no longer contains 'a': {my_dict}\")\n",
    "\n",
    "print(f\"Getting a value with the 'pop' method, if the key does not exist: {my_dict.pop('d', None)}\")\n",
    "print(f\"my_dict is unchanged, since it did not contain 'd': {my_dict}\")\n",
    "\n",
    "print(f\"Remove and return an arbitrary set element: {my_dict.popitem()}\")\n",
    "print(f\"my_dict is now one element shorter: {my_dict}\")\n",
    "\n",
    "my_dict.clear()\n",
    "print(f\"my_dict is cleared: {my_dict}\")\n",
    "\n",
    "my_dict1 = {\"a\": 1, \"b\": 2.5, \"c\": \"abc\", 1: True, 2: None}\n",
    "my_dict2 = my_dict1.copy()\n",
    "print(f\"Contents of my_dict1 is the same as my_dict2 ({my_dict1 == my_dict2}), but are they still the same object? ({my_dict1 is my_dict2})\")\n",
    "\n",
    "my_dict1.update({\"d\": \"new element\"})\n",
    "print(f\"my_dict1 now also contains 'd': {my_dict1}\")\n",
    "\n",
    "my_dict = dict.fromkeys([\"a\", \"b\", \"c\"], 0)\n",
    "print(f\"my_dict is {my_dict}\")\n",
    "\n",
    "print(f\"Getting all keys: {my_dict.keys()}\")\n",
    "print(f\"Getting all values: {my_dict.values()}\")\n",
    "print(f\"Getting all key-value pairs: {my_dict.items()}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercises on dictionaries\n",
    "\n",
    "1. Write a program that receives a dictionary and a key as input and returns the value of the key if it is in the dictionary, `None` otherwise. The dictionary should remain unchanged.\n",
    "2. Write a program that receives a dictionary and a key as input and removes the key-value pair from the dictionary and returns the value. If the key is not in the dictionary, the program should return `None`.\n",
    "3. Write a program that receives two dictionaries as input and returns the first dictionary updated with the key-value pairs from the second dictionary. The second dictionary should remain unchanged."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "%reload_ext tutorial.tests.testsuite"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "%%ipytest\n",
    "from typing import TypeVar, Hashable, Any\n",
    "\n",
    "def solution_dict_return_value(my_dict: dict[Hashable, Any], key: Hashable) -> Any:\n",
    "    # Your code starts here\n",
    "    return\n",
    "    # Your code ends here"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "%%ipytest\n",
    "from typing import TypeVar, Hashable, Any\n",
    "\n",
    "def solution_dict_return_delete_value(my_dict: dict[Hashable, Any], key: Hashable) -> Any:\n",
    "    # Your code starts here\n",
    "    return\n",
    "    # Your code ends here"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "%%ipytest\n",
    "\n",
    "from typing import TypeVar, Hashable, Any\n",
    "\n",
    "def solution_update_one_dict_with_another(dict1: dict[Hashable, Any], dict2: dict[Hashable, Any]) -> dict[Hashable, Any]:\n",
    "    # Your code starts here\n",
    "    return\n",
    "    # Your code ends here"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# String\n",
    "\n",
    "Despite strings belonging to the base type, they can also be considered a **list** of characters and share many of the list's properties.\n",
    "This is why we decided to place them in a separate section.\n",
    "To define a string, we use single quotes `'` or double quotes `\"`.\n",
    "\n",
    "```python\n",
    "my_string = 'Hello, world!'\n",
    "```\n",
    "\n",
    "It is also possible to define a string using triple quotes `'''` or `\"\"\"`.\n",
    "This is useful when we need to define a string that contains several lines.\n",
    "\n",
    "```python\n",
    "my_string = '''Hello,\n",
    "world!'''\n",
    "```\n",
    "\n",
    "Most of the operators that work with lists also work with strings.\n",
    "The following operators work with strings:\n",
    "\n",
    "  * `string1 + string2` - concatenates two strings\n",
    "  * `string * n` - concatenates the string `n` times\n",
    "  * `string[i]` - returns the character at the `i`-th position\n",
    "  * `string[i:j]` - returns the substring from the `i`-th position to the `j`-th position\n",
    "  * `string[i:j:k]` - returns the substring from the `i`-th position to the `j`-th position with the step `k`\n",
    "  * `string1 == string2` - returns `True` if the two strings are lexicographically equal, `False` otherwise\n",
    "  * `string1 != string2` - returns `True` if the two strings are lexicographically not equal, `False` otherwise\n",
    "  * `string1 < string2` - returns `True` if the first string is lexicographically less than the second string, `False` otherwise\n",
    "  * `string1 <= string2` - returns `True` if the first string is lexicographically less than or equal to the second string, `False` otherwise\n",
    "  * `string1 > string2` - returns `True` if the first string is lexicographically greater than the second string, `False` otherwise\n",
    "  * `string1 >= string2` - returns `True` if the first string is lexicographically greater than or equal to the second string, `False` otherwise\n",
    "  * `string1 is string2` - returns `True` if the two strings are the same object, `False` otherwise\n",
    "  * `string1 is not string2` - returns `True` if the two strings are not the same object, `False` otherwise"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "my_string1 = \"Hello, \"\n",
    "my_string2 = \"World!\"\n",
    "print(f\"my_strings are '{my_string1}' and '{my_string2}'\")\n",
    "\n",
    "my_string3 = my_string1 + my_string2\n",
    "print(f\"The concatenation of strings is '{my_string3}'\")\n",
    "\n",
    "my_string4 = my_string1 * 3\n",
    "print(f\"Multiplying a string by the number 3 is '{my_string4}'\")\n",
    "\n",
    "print(f\"The first character of my_string3 is '{my_string3[0]}'\")\n",
    "print(f\"The last character of my_string3 is '{my_string3[-1]}'\")\n",
    "\n",
    "print(f\"The first 2 characters of my_string3 is '{my_string3[:2]}'\")\n",
    "print(f\"The last 2 characters of my_string3 is '{my_string3[-2:]}'\")\n",
    "\n",
    "print(f\"The characters of my_string3 from index 2 to 4 are '{my_string3[2:5]}'\")\n",
    "print(f\"All even characters of my_string3 are '{my_string3[::2]}'\")\n",
    "print(f\"All odd characters of my_string3 are '{my_string3[1::2]}'\")\n",
    "\n",
    "my_string5 = \"Hello, World!\"\n",
    "print(f\"my_string3 is equal to my_string5 ({my_string3 == my_string5}). However, they are not the same object ({my_string3 is not my_string5}).\")\n",
    "\n",
    "print(f\"my_string2 is greater than my_string1 ({my_string2 > my_string1}). This is because the first character 'W' is greater than 'H'.\")\n",
    "print(f\"my_string1 is smaller than my_string3 ({my_string1 < my_string3}). Despite they share common starting characters, the length of my_string3 is greater than my_string1.\")\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here are the methods commonly used when dealing with strings:\n",
    "\n",
    "* `string.capitalize()` - returns a copy of the string with the first character capitalized and the rest lowercased\n",
    "* `string.lower()` - returns a copy of the string with all the characters lowercased\n",
    "* `string.upper()` - returns a copy of the string with all the characters uppercased\n",
    "* `string.count(substring, start, end)` - returns the number of non-overlapping occurrences of substring in the string\n",
    "* `string.startswith(prefix, start, end)` - returns `True` if the string starts with the prefix, `False` otherwise\n",
    "* `string.endswith(suffix, start, end)` - returns `True` if the string ends with the suffix, `False` otherwise\n",
    "* `string.find(substring, start, end)` - returns the lowest index in the string where substring is found, or `-1` if not found\n",
    "* `string.replace(old, new, number)` - returns a copy of the string with `number` occurrences of old replaced by new. If `number` is omitted, all occurrences are replaced\n",
    "* `string.split(separator, maxsplit)` - returns a list of the words in the string, using a separator as the delimiter string. If `maxsplit` is given, at most `maxsplit` splits are done. If `separator` is not provided, the string will be split on any whitespace character.\n",
    "* `string.join(iterable)` - returns a string consisting of the strings in the iterable joined by the string on which the method is called\n",
    "* `string.splitlines(keepends)` - returns a list of the lines in the string, breaking at line boundaries. If `keepends` is `True`, the line breaks are included in the resulting list\n",
    "* `string.isalnum()` - returns `True` if the string consists of alphanumeric characters, `False` otherwise\n",
    "* `string.isalpha()` - returns `True` if the string consists of alphabetic characters, `False` otherwise\n",
    "* `string.isdigit()` - returns `True` if the string consists of digits, `False` otherwise\n",
    "* `string.islower()` - returns `True` if the string consists of lowercase characters, `False` otherwise\n",
    "* `string.isupper()` - returns `True` if the string consists of uppercase characters, `False` otherwise\n",
    "* `string.isspace()` - returns `True` if the string consists of whitespace characters, `False` otherwise\n",
    "* `string.istitle()` - returns `True` if the string consists of words that start with an uppercase character followed by lowercase characters, `False` otherwise\n",
    "\n",
    "... and many more."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercises on strings\n",
    "\n",
    "1. Write a program that receives a string as input and returns a copy of the string with the first character capitalized and the rest lowercased.\n",
    "2. Write a program that receives a string as input and returns a copy of the string with all the characters lowercased.\n",
    "3. Write a program that receives a string with several words separated by any whitespace character (space, new line, Tab, etc.) as input and returns a list of the words in the string.\n",
    "4. Write a program that receives a list of words as input and returns a string consisting of the words in the list separated by commas.\n",
    "5. Write a program that receives a string as input and returns a list of the lines in the string, breaking at line boundaries."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "%reload_ext tutorial.tests.testsuite"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "%%ipytest\n",
    "\n",
    "def solution_string_capitalize(my_string: str) -> str:\n",
    "    # Your code starts here\n",
    "    return\n",
    "    # Your code ends here"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "%%ipytest\n",
    "\n",
    "def solution_string_lower_case(my_string: str) -> str:\n",
    "    # Your code starts here\n",
    "    return\n",
    "    # Your code ends here"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "%%ipytest\n",
    "\n",
    "def solution_string_word_split(my_string: str) -> str:\n",
    "    # Your code starts here\n",
    "    return\n",
    "    # Your code ends here"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "%%ipytest\n",
    "\n",
    "def solution_string_join_commas(my_list: str) -> str:\n",
    "    # Your code starts here\n",
    "    return\n",
    "    # Your code ends here"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "%%ipytest\n",
    "\n",
    "def solution_string_split_lines(my_string: str) -> list[str]:\n",
    "    # Your code starts here\n",
    "    return\n",
    "    # Your code ends here"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Mutable and immutable objects\n",
    "\n",
    "In Python, objects are either **mutable** or **immutable**.\n",
    "Mutable objects can be changed after creation, while immutable objects cannot.\n",
    "The following types are mutable:\n",
    "\n",
    "  * `list`\n",
    "  * `dict`\n",
    "  * `set`\n",
    "\n",
    "The following types are immutable:\n",
    "    \n",
    "  * `int`\n",
    "  * `float`\n",
    "  * `bool`\n",
    "  * `str`\n",
    "  * `tuple`\n",
    "    \n",
    "When we assign a mutable object to a variable, we are assigning a reference to the object.\n",
    "This means if we change the object - the variable will also change.\n",
    "This is not the case with immutable objects.\n",
    "When we assign an immutable object to a variable, we are assigning a copy of the object.\n",
    "\n",
    "\n",
    "An easy way to check if an object is mutable or immutable is to use the `id()` function.\n",
    "This function returns the identity of the object.\n",
    "If the identity of two objects is the same, then they are the same object.\n",
    "\n",
    "Let's see a few examples to better understand this concept.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# Immutable objects\n",
    "\n",
    "a = 1\n",
    "b = a\n",
    "\n",
    "print(f\"At the beginning, a is {a} (id={id(a)}) and b is {b} (id={id(b)}), so they are the same object ({a is b}).\")\n",
    "\n",
    "print(\"Now let's change the value of a to 2.\")\n",
    "\n",
    "a = 2\n",
    "\n",
    "print(f\"Now a is {a} (id={id(a)}) and b is {b} (id={id(b)}), so they are not the same object anymore ({a is not b}).\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# Mutable objects\n",
    "\n",
    "my_list1 = [1, 2, 3]\n",
    "my_list2 = my_list1\n",
    "\n",
    "print(f\"At the beginning, my_list1 is {my_list1} (id={id(my_list1)}) and my_list2 is {my_list2} (id={id(my_list2)}), so they are the same object ({my_list1 is my_list2}).\")\n",
    "\n",
    "print(\"Now let's update the value of my_list1.\")\n",
    "\n",
    "my_list1.append(4)\n",
    "\n",
    "print(f\"Now my_list1 is {my_list1} (id={id(my_list1)})\")\n",
    "\n",
    "print(f\"At the same time my_list2 is also updated to {my_list2} (id={id(my_list2)}), so both my_list1 and my_list2 are still referring to same object ({my_list1 is my_list2}).\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Unpacking\n",
    "\n",
    "Unpacking is a way to extract the elements of a sequence into variables.\n",
    "This is useful when we want to assign the elements of a sequence to variables."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "coordinates = 4.42, -12.45 # creates a tuple\n",
    "x, y, = coordinates # unpacks the tuple\n",
    "\n",
    "print(f\"x is {x} and y is {y}\")\n",
    "\n",
    "my_list = [1, 2, 3]\n",
    "x, y, z = my_list\n",
    "\n",
    "print(f\"x is {x}, y is {y} and z is {z}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Any iterable can be considered a \"packed\" container. **Unpacking** works by assigning the variables' names on the left of `=` to the values on the right **according to their relative position** (the 1st of the left = 1st on the right, 2nd on the left = 2nd on the right, and so on).\n",
    "\n",
    "There are two operators in Python that enable you to have more control on how to unpack iterables: these are the `*` and `**` operators."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## The `*` operator"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When used on the **left-hand side** (LHS) of `=` it means \"pack **the rest of the iterable** that appears on the **right-hand side** (RHS)\"."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "my_tuple = (1, 3, 4, 5, 6)\n",
    "\n",
    "a, *b = my_tuple # here `*b` means \"the rest of `my_tuple`\"\n",
    "print(a, b)\n",
    "\n",
    "s = 'Python'\n",
    "a, b, *c, d = s # here `*c` means \"the rest of the string 'Python' except the last character 'n', which is stored in the variable `d`\"\n",
    "print(a, b, c, d)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We could do the same with slicing, it's just less readable:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "a, b, c, d = s[0], s[1], s[2:-1], s[-1]  # In this case, 'c' IS NOT a list but a sub-string because we used slicing.\n",
    "\n",
    "print(a, b, c, d)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Of course, we **cannot use** the `*` operator **more than one time on the LHS.**\n",
    "What would mean \"the rest of the iterable\" if `*` appears more than once? 🤔\n",
    "\n",
    "On the RHS, the `*` operator has the opposite meaning: \"**unpack** the iterable(s) into single elements and assign them to the left-hand side symbols\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "tuple1 = (1, 2, 3, 4)\n",
    "tuple2 = ('a', 'b', 'c', 'd')\n",
    "\n",
    "tuple3 = *tuple1, *tuple2\n",
    "print(f\"Unnpacking tuples `tuple1` and `tuple2` into `tuple3`: {tuple3}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The meaning of `tuple3 = *tuple1, *tuple2` is \"unpack both iterables `tuple1` and `tuple2`, put their elements in a tuple and assign it to `tuple3`\"."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `*` operator works with **any iterable**. However be aware that for sets the order is not guaranteed.\n",
    "\n",
    "Here are several examples:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "sequence1 = \"abc\"\n",
    "sequence2 = \"cde\"\n",
    "\n",
    "# Unpacking into a set\n",
    "set1 = {*sequence1, *sequence2}\n",
    "print(f\"Unpacking sequences `sequence1` and `sequence2` into `set1`: {set1}. Note that the elements are unique.\")\n",
    "\n",
    "# Unpacking set\n",
    "s = {10, -99, 3, 'd'}\n",
    "\n",
    "a, *b, c = s # there's no guarantee that a = 10, c = 'd', b = [-99, 3]\n",
    "print(f\"a = {a} b = {b} c = {c}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Unpacking unordered type is useful when you want to create a single collection containing:\n",
    "\n",
    "- Items from multiple sets\n",
    "- All the keys of multiple dictionaries.\n",
    "\n",
    "For example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "dict1 = {'p': 1, 'y': 2}\n",
    "dict2 = {'t': 3, 'h': 4}\n",
    "dict3 = {'h': 5, 'o': 6, 'n': 7} # note that key 'h' is in both d2 and d3\n",
    "\n",
    "my_list = [*dict1, *dict2, *dict3]\n",
    "print(f\"Unpacking dictionaries `dict1`, `dict2` and `dict3` into `my_list`: {my_list}\")\n",
    "\n",
    "my_set = {*dict1, *dict2, *dict3}\n",
    "print(f\"Unpacking dictionaries `dict1`, `dict2` and `dict3` into `my_set`: {my_set}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-info\">\n",
    "<b>Note:</b> When working with dictionaries, <code>*</code> unpacks (i.e., iterates) <b>over keys</b>.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## The `**` operator"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Since `*` unpacks the keys of a dictionary, how can we unpack values as well?\n",
    "We can use the `**` operator.\n",
    "\n",
    "Here is how it works:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "dict1 = {'p': 1, 'y': 2}\n",
    "dict2 = {'t': 3, 'h': 4}\n",
    "dict3 = {'h': 5, 'o': 6, 'n': 7} # Note that key 'h' is in both dict2 and dict3\n",
    "\n",
    "my_dict = {**dict1, **dict2, **dict3} # The value of 'h' in dict3 will overwrite the value of 'h' in dict2: keys must unique.\n",
    "print(f\"Unpacking dictionaries `dict1`, `dict2` and `dict3` into `my_dict`: {my_dict}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Nested unpacking"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python supports **nested unpacking** as well:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "my_list = [1, 2, [3, 4]]\n",
    "\n",
    "# we could unpack it with\n",
    "a, b, c = my_list\n",
    "print(f\"a = {a} b = {b} c = {c}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "But we could also unpack `[3, 4]` into two different variables:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "a, b, (c, d) = my_list\n",
    "print(f\"a = {a} b = {b} c = {c} d = {d}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "What about the rule: \"the `*` operator can only be used **once** on the LHS\"?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "a, *b, (c, *d) = [1, 2, 3, 'python']\n",
    "print(f\"a = {a} b = {b} c = {c} d = {d}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As you can see, the correct rule is:\n",
    "\n",
    "<div class=\"alert alert-block alert-info\">\n",
    "You can use the <code>*</code> operator once <b>in a single unpacking statement</b>.\n",
    "</div>\n",
    "\n",
    "In the above examples of nested unpacking, we have **two unpacking expressions**, hence `*` can be used once on the LHS of each of them."
   ]
  }
 ],
 "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.11.1"
  },
  "vscode": {
   "interpreter": {
    "hash": "31f2aee4e71d21fbe5cf8b01ff0e069b9275f58929596ceb00d14d90e3e16cd6"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}