Introduction.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "3f18200a-34d1-4637-a8bd-b96b0e0de43d",
   "metadata": {},
   "source": [
    "\n",
    "# Python Introduction - Programming Basics and Data Types"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a197e9ca-4d53-4ecf-b055-2f1ac30f8ee5",
   "metadata": {},
   "source": [
    "\n",
    "\n",
    "This page (that you see right now) is called a **Notebook**. It is a convenient development tool, as it allows you to run your code in blocks (called **cells**) and immediately visualize the output. Furthermore, the variables defined in a cell are stored in memory and are readily available in all other cells. In the cell below, we are performing the operation 3 + 4. To execute it and visualize the result, just select the cell with your mouse (or moving down with an arrow) and press the **play** button in the command bar at the top of this page. Alternatively, you can use the shortcut [ctrl] + [enter] to run the cell ([shift] + [enter] to run the cell and move to the next one).\n",
    "\n",
    "Specifically, this **Notebook** is a [Jupyter Notebook](https://jupyter.org) a web application for creating and sharing computational documents. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "6c5901dd-c891-4c4a-a387-8ecad3df4434",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "3 + 4"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f026b5e8-376d-48a7-97fd-52f0c995f232",
   "metadata": {},
   "source": [
    "If you ran the cell correctly, you should see the output \"7\" appearing below your cell.\n",
    "\n",
    "Now you are ready to create your first cell. A cell can be of 3 types: **Code**, **Markdown** or **Raw**. To create a new cell, just press the \"+\" button in the command bar. Alternatively, select a cell (the cell, not its content!) and press the key \"b\" or \"a\" to create a cell below or above. By default, the cell is created in Code mode. This means that you can right away write your code and run it. You can switch mode by selecting it in the command bar, or with the shortcuts \"m\" for Markdown, \"r\" for Raw and \"y\" for code.\n",
    "\n",
    "Now create a new cell below this one, write some arithmetic expressions and execute them. Do you get the expected results?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "65414cb0-1ec8-43f8-8b5d-bb5efc36730a",
   "metadata": {},
   "source": [
    "## Data types - Fundamentals\n",
    "Python is a strongly, dynamically typed language. Each value has its own type: for example, 1 is an integer, while 1.0 is a float. However, variables can change their type throughout their lifetime. Here is a simple example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "28b24364-3f15-4ffd-bfd1-0596de0aea74",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x = 1, type of x:  <class 'int'>\n",
      "x = 1., type of x:  <class 'float'>\n"
     ]
    }
   ],
   "source": [
    "x = 1\n",
    "print(\"x = 1, type of x: \", type(x))\n",
    "\n",
    "x = 1.\n",
    "print(\"x = 1., type of x: \", type(x))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e9c6f4b8-8db4-4af3-beea-bc01a5b5b912",
   "metadata": {},
   "source": [
    "Some python operations (\"+\", \"-\", \"\\*\", \"%\", \"\\*\\*\", \"//\") will preserve the data type of their inputs, while others (e.g, \"/\") might change the type. Indeed, (\"/\") will always return a float. See the following examples:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "f5fa339d-79df-4c33-828f-bbb904e60c73",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x = 3 + 4, result:  7  type of x:  <class 'int'>\n",
      "x = 3. + 4., result:  7.0  type of x:  <class 'float'>\n",
      "x = 6 / 4, result:  1.5  type of x:  <class 'float'>\n",
      "x = 7. // 2, result:  3.0  type of x:  <class 'float'>\n",
      "x = 4 ** 3, result:  64  type of x:  <class 'int'>\n",
      "x = 22.5 % 3, result:  1.5  type of x:  <class 'float'>\n"
     ]
    }
   ],
   "source": [
    "x = 3 + 4\n",
    "print(\"x = 3 + 4, result: \", x, \" type of x: \", type(x))\n",
    "\n",
    "x = 3. + 4.\n",
    "print(\"x = 3. + 4., result: \", x, \" type of x: \", type(x))\n",
    "\n",
    "x = 6 / 4\n",
    "print(\"x = 6 / 4, result: \", x, \" type of x: \", type(x))\n",
    "\n",
    "x = 7. // 2\n",
    "print(\"x = 7. // 2, result: \", x, \" type of x: \", type(x))\n",
    "\n",
    "x = 4 ** 3\n",
    "print(\"x = 4 ** 3, result: \", x, \" type of x: \", type(x))\n",
    "\n",
    "x = 22.5 % 3\n",
    "print(\"x = 22.5 % 3, result: \", x, \" type of x: \", type(x))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7f321ec5-b1f6-4b12-a9ae-f39387297391",
   "metadata": {},
   "source": [
    "Besides integers and floats, Python supports two other fundamental data types: **booleans** and **strings**. Booleans can just store the values \"True\" or \"False\", while strings are a more complex type, which can store characters, words and sentences (comprising lots of different characters). Here are some examples:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "e3e84e73-21cc-4710-85bf-10a50873dfdf",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x = False, type of x:  <class 'bool'>\n",
      "x = 'a', type of x:  <class 'str'>\n",
      "x = 'abcd efgh', type of x:  <class 'str'>\n"
     ]
    }
   ],
   "source": [
    "x = False\n",
    "print(\"x = False, type of x: \", type(x))\n",
    "\n",
    "x = 'a'\n",
    "print(\"x = 'a', type of x: \", type(x))\n",
    "\n",
    "x = 'abdc efgh'\n",
    "print(\"x = 'abcd efgh', type of x: \", type(x))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "872b9274-0bbd-4762-a44f-713cfe71f40c",
   "metadata": {},
   "source": [
    "You can conveniently change the type of a variable by applying one of the following builtin functions: <code>int()</code>, <code>float()</code>, <code>bool()</code>, <code>str()</code>. Pay attention: not all strings can be converted to integers, booleans or floats! And all integers and floats apart from 0 will be converted into the boolean \"True\"."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "8569a2f9-f512-4014-b861-f98eec4962d2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x = int(7.5), result:  7  type of x:  <class 'int'>\n",
      "x = float(3), result:  3.0  type of x:  <class 'float'>\n",
      "x = str(3.18), result:  3.18  type of x:  <class 'str'>\n",
      "x = int(False), result:  0  type of x:  <class 'int'>\n",
      "x = bool(234), result:  True  type of x:  <class 'bool'>\n"
     ]
    },
    {
     "ename": "ValueError",
     "evalue": "invalid literal for int() with base 10: 'ab'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "Cell \u001b[0;32mIn [5], line 16\u001b[0m\n\u001b[1;32m     13\u001b[0m x \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mbool\u001b[39m(\u001b[38;5;241m234\u001b[39m)\n\u001b[1;32m     14\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mx = bool(234), result: \u001b[39m\u001b[38;5;124m\"\u001b[39m, x, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124m type of x: \u001b[39m\u001b[38;5;124m\"\u001b[39m, \u001b[38;5;28mtype\u001b[39m(x))\n\u001b[0;32m---> 16\u001b[0m x \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mint\u001b[39;49m\u001b[43m(\u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mab\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m)\u001b[49m\n",
      "\u001b[0;31mValueError\u001b[0m: invalid literal for int() with base 10: 'ab'"
     ]
    }
   ],
   "source": [
    "x = int(7.5)\n",
    "print(\"x = int(7.5), result: \", x, \" type of x: \", type(x))\n",
    "\n",
    "x = float(3)\n",
    "print(\"x = float(3), result: \", x, \" type of x: \", type(x))\n",
    "\n",
    "x = str(3.18)\n",
    "print(\"x = str(3.18), result: \", x, \" type of x: \", type(x))\n",
    "\n",
    "x = int(False)\n",
    "print(\"x = int(False), result: \", x, \" type of x: \", type(x))\n",
    "\n",
    "x = bool(234)\n",
    "print(\"x = bool(234), result: \", x, \" type of x: \", type(x))\n",
    "\n",
    "x = int(\"ab\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e4b66e67-9bc0-4a4b-843a-b434c09f0a1e",
   "metadata": {},
   "source": [
    "The last expression int(\"ab\") triggered what is called an **exception**. This means that the function <code>int()</code> received an \"exceptional\" input, which it cannot interpret as an integer. In such cases the default exception is \"ValueError\". In the cell below, try to convert a string to an integer without causing any exception!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "8fe69000-e5e6-422d-aa0f-983b0d34e636",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "345\n"
     ]
    }
   ],
   "source": [
    "### Insert your code here\n",
    "x = int(\"345\")\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a183f714-6afb-4c88-8199-57a9bae76154",
   "metadata": {},
   "source": [
    "The string data type is very powerful. It offers many methods out of the box, which make some operations very easy. For example, you can turn letters into capital letters by calling capitalize(). The section \"String Methods\" of the python documentation (https://docs.python.org/3/library/stdtypes.html) gives a more general overview of all the available operations.\n",
    "\n",
    "**Exercise 1**: in the cell below, use the appropriate string function to verify that the string \"th\" is included in the word \"Python\", but that the string \"tuna\" is not."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "31d0165a-6c25-4f99-8b2f-80d03ca9299c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "th is in Python: True\n",
      "tuna is in Python: False\n"
     ]
    }
   ],
   "source": [
    "### Insert your code here\n",
    "s_1 = \"Python\"\n",
    "s_2 = \"th\"\n",
    "s_3 = \"tuna\"\n",
    "\n",
    "print(f\"{s_2} is in {s_1}:\",  s_2 in s_1)\n",
    "print(f\"{s_3} is in {s_1}:\", s_3 in s_1)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9b13e032-5fe9-4f70-8e47-0f63d84375f3",
   "metadata": {},
   "source": [
    "**Exercise 2**: replace all the characters \"a\" in the string \"abracadabra\" with \"u\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "ad284faa-3169-40ef-a019-c61ab9050211",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ubrucudubru\n"
     ]
    }
   ],
   "source": [
    "### Insert your code here\n",
    "s = \"abracadabra\"\n",
    "s_u = s.replace(\"a\", \"u\")\n",
    "print(s_u)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b7b6ca0b-632c-4d59-a809-a2fcbb900d72",
   "metadata": {},
   "source": [
    "**Exercise 3**: use the function \"format\" to include the result of the computation 3 + 4 in the string \"If you sum 3 and 4 you obtain {}\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "2b1facf4-18f6-47cc-ab14-8f3bde71a2ad",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "if you sum 3 and 4 you obtain 7\n"
     ]
    }
   ],
   "source": [
    "### Insert your code here\n",
    "s = \"if you sum 3 and 4 you obtain {}\".format(3 + 4)\n",
    "print(s)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "473d53c3-913e-4a39-934b-450618ff8602",
   "metadata": {},
   "source": [
    "## Loops and ifs\n",
    "As most programming languages, Python supports **for** and **while** loops. For loops iterate through all the elements of a given object, until the end is reached or a **break** statement is called inside the loop body. While loops, instead, iterate until a certain condition is met. Here are 2 minimal examples:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "45da1a19-b6e1-480b-aabe-2899b95e2535",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "4\n",
      "9\n",
      "16\n",
      "25\n",
      "36\n",
      "49\n",
      "64\n",
      "81\n"
     ]
    }
   ],
   "source": [
    "i = 0\n",
    "while i < 10:\n",
    "    print(i ** 2)\n",
    "    i += 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "55562bf9-8220-4f5f-ae3b-d5593a339fba",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "4\n",
      "9\n",
      "16\n",
      "25\n",
      "36\n",
      "49\n",
      "64\n",
      "81\n"
     ]
    }
   ],
   "source": [
    "for i in range(10):\n",
    "    print(i ** 2)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "be929892-7b5c-4ecb-bda8-b533692e662b",
   "metadata": {},
   "source": [
    "While the two code snippets produce the same output, in the first one we are manually defining the iteration count variables. In the second example, instead, we are taking advantage of the builtin function <code>range()</code>, which is a special type of immutable iterable object.\n",
    "To understand what that means, we need to have a look on **generators** and **iterators**:\n",
    "- Generator: A generator is a special type of iterable in Python that generates values on-the-fly, one at a time, and thus saves memory by not storing all values in memory at once. Hence, they are objects which can be looped through with a for loop (or by calling another builtin function, <code>next()</code>) and return one element after another. The loop asks the generator at each iteration to return the next element, and the generator executes.\n",
    "- Iterator: An iterator is an object that represents a stream of data and can be iterated (looped) through. Iterators implement the <code>__iter__()</code> and <code>__next__()</code> methods, allowing you to access elements one by one. While range() itself is not an iterator, you can create an iterator from it using the iter() function. For example, iter(range(1, 5)) would create an iterator that generates the numbers 1, 2, 3, and 4 as you loop through it."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c2451bef-d7bd-413a-93d4-ab6c2188591f",
   "metadata": {},
   "source": [
    "Python also obviously offers the possibility of assessing whether a certain condition is verified with an **if - else** statement. If multiple exclusive conditions are to different behavior, then one should use the **elif** keyword. Python supports the common binary operators <, >, ==, !=, <=, >=, or, and not. Here is a minimal example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "d358b50c-49ca-4bea-b6f6-daf0993200d3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Rome\n"
     ]
    }
   ],
   "source": [
    "state = \"Italy\"\n",
    "\n",
    "if state == \"Italy\":\n",
    "    print(\"Rome\")\n",
    "elif state == \"France\":\n",
    "    print(\"Paris\")\n",
    "elif state == \"Germany\":\n",
    "    print(\"Berlin\")\n",
    "elif state == \"Switzerland\":\n",
    "    print(\"de jure: none, de facto: Bern\")\n",
    "else:\n",
    "    print(\"I don't know the capital of the state\", state)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b616264e-06e2-46e7-8014-a5f6915f7110",
   "metadata": {},
   "source": [
    "**Exercise 4**: write some code which, given an integer, prints whether it is even or odd"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "68100195-54a1-4c26-bc8d-c34294a4ddb2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10 is even\n"
     ]
    }
   ],
   "source": [
    "### Insert your code here\n",
    "a_int = 10\n",
    "\n",
    "if a_int % 2 == 0:\n",
    "    print(f\"{a_int} is even\")\n",
    "else:\n",
    "    print(f\"{a_int} is odd\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "96e498b1-f51f-48d8-b3f7-2357c80499df",
   "metadata": {},
   "source": [
    "**Exercise 5**: write some code which, given two integers, prints whether the second one is a divisor of the first one"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "98a01b91-051a-4581-bea2-8e9144cd20a7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "15 is a divisor of 45\n"
     ]
    }
   ],
   "source": [
    "### Insert your code here\n",
    "int_1 = 45\n",
    "int_2 = 15\n",
    "\n",
    "if int_1 % int_2== 0:\n",
    "    print(f\"{int_2} is a divisor of {int_1}\")\n",
    "else:\n",
    "    print(f\"{int_2} is not a divisor of {int_1}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "41f187ac-dcfb-4d18-b03c-ab8c26c62fa1",
   "metadata": {},
   "source": [
    "**Exercise 6**: write some code which, given two strings, prints the larger one if one of them is contained it the other, otherwise it concatenates them and prints the resulting string"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "cd2fd134-f65d-4aef-b7f0-942ddd49e85c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "uhlala\n"
     ]
    }
   ],
   "source": [
    "### Insert your code here\n",
    "string_1 = \"la\"\n",
    "string_2 = \"uhlala\"\n",
    "\n",
    "if string_1 in string_2:\n",
    "    print(string_2)\n",
    "elif string_2 in string_1:\n",
    "    print(string_1)\n",
    "else:\n",
    "    print(string_1 + string_2)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "54eff858-d6e4-40b3-bafb-b8b4de38a2c7",
   "metadata": {},
   "source": [
    "## Data types - Containers I\n",
    "The container datatypes are extremely useful in Python. Today, you will learn about lists and dictionaries, while next week you will get to know sets and tuples.\n",
    "\n",
    "### Lists\n",
    "\n",
    "Lists are ordered collections of values. The elements of a list can be of any type. You can retrieve an element of a list through its index (starting from 0!). There are many ways to create lists. You can generate a list directly defining its elements or by passing an iterable object (an object you can go thourgh with a for loop) to the function <code>list()</code>."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "993bb677-2a7b-440e-ad07-ee886dd48614",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x = [1, 3, 5, 6] , type of x:  <class 'list'>\n",
      "The element of the list in position 2 is 5\n",
      "List including the 10 digits:  [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n"
     ]
    }
   ],
   "source": [
    "x = [1, 3, 5, 6]\n",
    "print(\"x = [1, 3, 5, 6] , type of x: \", type(x))\n",
    "\n",
    "x_2 = x[2]\n",
    "print(\"The element of the list in position 2 is\", x_2) # note this is the third element!\n",
    "\n",
    "x = list(range(10))\n",
    "print(\"List including the 10 digits: \", x)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e2cf25dd-468d-4c79-a866-c911cd2e098f",
   "metadata": {},
   "source": [
    "Lists support many useful operations, such as <code>append()</code> and <code>extend()</code>:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "25a3af28-26e8-4de3-b55c-5c991eb477d7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Base list:  [1, 4, 6]\n",
      "After appending 8:  [1, 4, 6, 8]\n",
      "And after extending it by [3, 5]:  [1, 4, 6, 8, 3, 5]\n"
     ]
    }
   ],
   "source": [
    "x = [1, 4, 6]\n",
    "print(\"Base list: \", x)\n",
    "\n",
    "x.append(8)\n",
    "print(\"After appending 8: \", x)\n",
    "\n",
    "x.extend([3, 5])\n",
    "print(\"And after extending it by [3, 5]: \", x)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ed1f4711-81f8-4927-a78c-05105e665a30",
   "metadata": {},
   "source": [
    "Lists can be conveniently looped through with a for statement. Besides the standard syntax, they also support what is called the **list comprehension** syntax, which you can use, for example, to generate a new list starting from an existing one, or from a generator."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "2dadef2b-7f5c-47f0-9662-7a0ffe168928",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 9, 25, 36]\n"
     ]
    }
   ],
   "source": [
    "x = [1, 3, 5, 6]\n",
    "\n",
    "x_squared = []\n",
    "for el in x:\n",
    "    x_squared.append(el**2)\n",
    "print(x_squared)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "cc42e0a4-ec40-465d-85ce-11f45a083d21",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 9, 25, 36]\n"
     ]
    }
   ],
   "source": [
    "x = [1, 3, 5, 6]\n",
    "x_squared = [el ** 2 for el in x]\n",
    "print(x_squared)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "638fd30c-aaa9-48eb-8f10-4b0b15832974",
   "metadata": {},
   "source": [
    "**Exercise 7**. Print the last two elements of the French-speaking cities in the following nested list and then remove the element that does not represent a city of Switzerland. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "82edc36d-46de-4493-abc8-82c3cfd8cf38",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Geneva', 'Sion']\n",
      "[['Lausanne', 'Geneva', 'Sion'], ['Bern', 'Basel', 'Zürich'], ['Lugano']]\n"
     ]
    }
   ],
   "source": [
    "cities = [[\"Lausanne\", \"Geneva\", \"Sion\"], [\"Bern\", \"Basel\", \"Zürich\"], \"Auckland\", [\"Lugano\"]]\n",
    "### Insert your code here\n",
    "print(cities[0][-2:])\n",
    "cities.pop(2)\n",
    "print(cities)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "32afdd9e-aba8-42c5-a168-7ef1a09382c4",
   "metadata": {
    "tags": []
   },
   "source": [
    "**Exercise 8**. Compute the mean and the variance of all the numbers in the following list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "b39f12eb-0a3b-4dad-b9d7-e0f6a056af91",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "mean: 14.2\n",
      "variance: 169.36\n"
     ]
    }
   ],
   "source": [
    "numbers = [5, 11, 4, 0, 3, 23, 41, 2, 25, 42, 13, 7, 4, 14, 19]\n",
    "### Insert your code here\n",
    "list_sum = 0\n",
    "list_len = 0\n",
    "for el in numbers:\n",
    "    list_sum += el\n",
    "    list_len += 1\n",
    "mean = list_sum / list_len\n",
    "var = 0\n",
    "for el in numbers:\n",
    "    var += (el-mean)**2\n",
    "var /= list_len\n",
    "print('mean:', mean)\n",
    "print('variance:', var)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8acccfec-e600-4af3-9c76-2fffa66b68e3",
   "metadata": {},
   "source": [
    "### Dictionaries\n",
    "\n",
    "Dictionaries are another useful built-in datatype. They simply represent a map between two sets: the **keys** and the **values**. They are the natural representation of a .json file in a python object. Dictionaries, similarly to lists and sets, can be created by direct definition or by calling the function dict() on an iterable object (this time the elements of the iterable object must have two values each - the key and the value!)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "56a9d4fe-cea4-4d24-b6e8-5e4dbbd0cb36",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Animal to sound: {'dog': 'woof', 'cat': 'meow', 'pig': 'oink', 'cow': 'moo'}\n",
      "The same dict, but defined in another way:  {'dog': 'woof', 'cat': 'meow', 'pig': 'oink', 'cow': 'moo'}\n"
     ]
    }
   ],
   "source": [
    "x = {\n",
    "    \"dog\": \"woof\",\n",
    "    \"cat\": \"meow\",\n",
    "    \"pig\": \"oink\",\n",
    "    \"cow\": \"moo\"\n",
    "}\n",
    "print(\"Animal to sound:\", x)\n",
    "\n",
    "x = dict([[\"dog\", \"woof\"], [\"cat\", \"meow\"], [\"pig\", \"oink\"], [\"cow\", \"moo\"]])\n",
    "print(\"The same dict, but defined in another way: \", x)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "32290bbd-3610-4af0-97a7-b48a31b97dc4",
   "metadata": {},
   "source": [
    "Accessing the values stored in a dictionary can be done by key (through the function .get() or through square brackets):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "10751bbd-ec39-4568-b4cb-877835ee02f2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The dog's call is woof\n",
      "The cow's call is moo\n"
     ]
    }
   ],
   "source": [
    "sound = x[\"dog\"]\n",
    "print(\"The dog's call is\", sound)\n",
    "\n",
    "sound = x.get(\"cow\")\n",
    "print(\"The cow's call is\", sound)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5a5a7c7f-7136-4156-816e-89344548e032",
   "metadata": {},
   "source": [
    "To add an element to a dictionary or to change the value associated to a certain key you can either use the square brackets or the function update()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "c9c0031d-ddff-4e26-af8b-0114f5f882e9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'dog': 'woof', 'cat': 'meow', 'pig': 'oink', 'cow': 'moo', 'donkey': 'hee-haw', 'owl': 'hoot'}\n"
     ]
    }
   ],
   "source": [
    "x[\"donkey\"] = \"hee-haw\"\n",
    "x.update({\"owl\": \"hoot\"})\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a3f48027-dc6e-4bd6-81d8-a9a79b9eb0a7",
   "metadata": {},
   "source": [
    "You can access the keys of your dictionary with the function <code>keys()</code> which returns a dict_keys object. For simplicity, you can convert this object in a list using the function <code>list()</code>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "7e45bf0b-3b69-4d42-8688-b05e9035795a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The keys in the dictionary are:  ['dog', 'cat', 'pig', 'cow', 'donkey', 'owl']\n"
     ]
    }
   ],
   "source": [
    "keyset = list(x.keys())\n",
    "print(\"The keys in the dictionary are: \", keyset)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7e8457f2-4ea6-4cc5-8a41-ab5144c1a33c",
   "metadata": {},
   "source": [
    "And of course you can iterate through a dictionary. Calling a for loop through a dictionary actually iterates through its keyset. If you want to iterate through the dictionary's keys and values simultaneously, you can use the handy method <code>items()</code>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "46ad3bb5-0696-4559-9b3e-306c75a99dea",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The iteration variable is:  dog\n",
      "And I can use it to access the value:  woof\n",
      "The iteration variable is:  cat\n",
      "And I can use it to access the value:  meow\n",
      "The iteration variable is:  pig\n",
      "And I can use it to access the value:  oink\n",
      "The iteration variable is:  cow\n",
      "And I can use it to access the value:  moo\n",
      "The iteration variable is:  donkey\n",
      "And I can use it to access the value:  hee-haw\n",
      "The iteration variable is:  owl\n",
      "And I can use it to access the value:  hoot\n",
      "\n",
      "But I can also access the key and the value together\n",
      "key: dog, value: woof\n",
      "key: cat, value: meow\n",
      "key: pig, value: oink\n",
      "key: cow, value: moo\n",
      "key: donkey, value: hee-haw\n",
      "key: owl, value: hoot\n"
     ]
    }
   ],
   "source": [
    "for key in x:\n",
    "    print(\"The iteration variable is: \", key)\n",
    "    print(\"And I can use it to access the value: \", x[key])\n",
    "\n",
    "print('')\n",
    "print(\"But I can also access the key and the value together\")\n",
    "for key, value in x.items():\n",
    "    print(\"key: {}, value: {}\".format(key,value))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2b1bc305-b813-4681-8f8d-e66804497564",
   "metadata": {},
   "source": [
    "Important! Dictionaries are not ordered collections, so it is not possible to get their elements by index."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fe525275-4eac-4ce0-9d6d-0b2c84f53224",
   "metadata": {},
   "source": [
    "**Exercise 9**. Create a dictionary where the keys are numbers between 1 and 10 (both included) and the values are the square of the keys."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "36893d18-c76e-4132-99b0-c0ee83889bb5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{1: 1, 2: 4, 3: 9, 4: 16, 5: 25, 6: 36, 7: 49, 8: 64, 9: 81, 10: 100}\n"
     ]
    }
   ],
   "source": [
    "### Insert your code here\n",
    "mydict = dict()\n",
    "for x in range(1,11):\n",
    "    mydict[x] = x**2\n",
    "print(mydict)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "16734967-9f26-4cd5-a761-3ab59216778b",
   "metadata": {},
   "source": [
    "### General exercises"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d5072271-0d12-4fc6-80a2-f360ddf63af5",
   "metadata": {},
   "source": [
    "Now it's time to use all the concepts you have learned today and put them together!"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3f9e0e37-a1ef-4934-8b0e-399b9bed4572",
   "metadata": {},
   "source": [
    "**Exercise 10**. Write some code which, given an input integer N, computes all the prime numbers up to N and stores them in a list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "387bf032-652d-450d-8ac3-fce0918e7f5f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97, 101, 103, 107, 109, 113, 127, 131, 137, 139, 149, 151, 157, 163, 167, 173, 179, 181, 191, 193, 197, 199, 211, 223, 227, 229, 233, 239, 241, 251, 257, 263, 269, 271, 277, 281, 283, 293, 307, 311, 313, 317, 331, 337, 347, 349, 353, 359, 367, 373, 379, 383, 389, 397, 401, 409, 419, 421, 431, 433, 439, 443, 449, 457, 461, 463, 467, 479, 487, 491, 499, 503, 509, 521, 523, 541, 547, 557, 563, 569, 571, 577, 587, 593, 599, 601, 607, 613, 617, 619, 631, 641, 643, 647, 653, 659, 661, 673, 677, 683, 691, 701, 709, 719, 727, 733, 739, 743, 751, 757, 761, 769, 773, 787, 797, 809, 811, 821, 823, 827, 829, 839, 853, 857, 859, 863, 877, 881, 883, 887, 907, 911, 919, 929, 937, 941, 947, 953, 967, 971, 977, 983, 991, 997]\n"
     ]
    }
   ],
   "source": [
    "### Insert your code here\n",
    "n = 1000\n",
    "survivors = list(range(2, n + 1))\n",
    "primes = []\n",
    "\n",
    "while survivors:\n",
    "    primes.append(survivors[0])\n",
    "    survivors = [s for s in survivors if s % survivors[0]]\n",
    "print(primes) "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "666b799a",
   "metadata": {},
   "source": [
    "**Exercise 11 (BONUS)**. This exercise is a little two-player game. Write an algorithm that guesses a particular number that the other player knows in the fastest possible way. For simplicity, you can use the <code>random</code> package to generate a random number from the interval [1,100] to select the guessed number. After guessing a number, your program should tell you if the guessed number is the correct one, or if it is smaller or greater than the target one. Then, based on this information, you guess a new number and perform the previous steps in an iterative way. Count the number of steps until you find the number."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "dbf941e0",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Target:  25\n",
      "Number of iterations:  1 guess:  25\n"
     ]
    }
   ],
   "source": [
    "import random\n",
    "target = random.randint(1, 100)\n",
    "### Insert your code here\n",
    "print(\"Target: \", target)\n",
    "\n",
    "max_it = 100\n",
    "\n",
    "guess = 50\n",
    "lim_right = 100\n",
    "lim_left = 1\n",
    "i = 0\n",
    "while guess != target and i < max_it:\n",
    "    if target > guess:\n",
    "        lim_left = guess\n",
    "        guess = int((lim_right + guess) / 2)\n",
    "    else:\n",
    "        lim_right = guess\n",
    "        guess = int((lim_left + guess) / 2)\n",
    "    i += 1\n",
    "print(\"Number of iterations: \", i, \"guess: \", guess)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2e7ca21a",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.10.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}