02_python/python_sets_dicts.ipynb

{
 "cells": [
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Python sets and dictionaries"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Lists/tuples (key points of the previous lesson)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Square brackets `[ ... ]` are used to create a new list.  \n",
    "Parentheses `( ... )` are used to create a new tuple.  \n",
    "A list/tuple has any number of elements.  \n",
    "Elements in a list/tuple may be repeated (duplicated).  \n",
    "Each element has its position.  \n",
    "First element is at index zero."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "grades = [ 7, 6, 7, 8, 6, 6.5, 8 ]\n",
    "print( \"Elements:\", grades )          # note: spaces are added\n",
    "print( \"Length:\", len( grades ) )\n",
    "print( \"4th element:\", grades[3] )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Content of a list can be modified. Lists are not immutable.\n",
    "Content of a tuple is fixed. Tuples are immutable."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "toBuy = [ \"yeast\", \"flour\", \"oil\", \"salt\" ]\n",
    "print( \"   Start:\", toBuy )\n",
    "toBuy[2] = \"olive oil\"\n",
    "print( \"Modified:\", toBuy )\n",
    "grades.append( \"sugar\" )\n",
    "print( \"Appended:\", toBuy )\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Comprehensions provide a very compact notation to:\n",
    "\n",
    "- Perform an operation of each element of a list/tuple.\n",
    "- Use a condition to filter elements of a list/tuple."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# this is a special tuple: note, at index 0 is the text \"zero\", at index 1 is the text \"one\", etc.\n",
    "# such a tuple can be used to map numbers to their names \n",
    "# (but note, only numbers starting from 0 can be mapped here; to map other texts/numbers, a dictionary will be used)\n",
    "digit2name = ( 'zero', 'one', 'two', 'three', 'four', 'five', 'six', 'seven', 'eight', 'nine' )\n",
    "print( \"     digit2name:\", digit2name )\n",
    "\n",
    "digits = [ 5, 2, 6, 2, 0, 9, 2, 1, 9 ]                     # some random numbers\n",
    "print( \"         digits:\", digits )\n",
    "\n",
    "digitsNames = [ digit2name[d] for d in digits ]\n",
    "print( \"    digitsNames:\", digitsNames )\n",
    "\n",
    "smallDigits = [ d for d in digits if d <= 3 ]\n",
    "print( \"    smallDigits:\", smallDigits )\n",
    "\n",
    "digitsWithNames = [ (d, digit2name[d] ) for d in digits ]  # tuples are produced here\n",
    "print( \"digitsWithNames:\", digitsWithNames )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note the basic functions which create a list (or a tuple) by iterating over elements of an object provided as argument:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "txt = \"Statistics\"\n",
    "list( txt )     # or tuple( txt )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A special case of a list is a list of integers created by `range(n)` generator function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "range( 10 )           # a generator, knows how to produce numbers from 0 to 9 when iterated\n",
    "tuple( range( 10 ) )  # a tuple: (0, 1, 2, 3, 4, 5, 6, 7, 8, 9)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Sets"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`set` is a built-in data type with the following properties:\n",
    "- it is a container which can keep any number (0, 1, 2, ...) of other elements\n",
    "- an element is either `in` the set or `not in` the set - there are no duplicated elements\n",
    "- elements can be added to a `set` or removed from it \n",
    "- an element added to a set cannot ever change, therefore only elements of *immutable* types are allowed\n",
    "- `frozenset` is an *immutable* variant of a set - once created it cannot be changed but therefore a `frozenset` can be used as an element of a set\n",
    "- it is possible to iterate over all elements of a set, but no assumptions can be made about iteration order"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### A new set"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's consider a *tiramisu* preparation example (note two ways to create a set: `{...}` and `set(...)`):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# See https://www.recipesfromitaly.com/tiramisu-original-italian-recipe/\n",
    "# A *set* with ingredients needed for tiramisu:\n",
    "tiramisuIngredients = { \"ladyfingers\", \"mascarpone\", \"eggs\", \"sugar\", \"espresso\", \"rum\", \"cocoa\" }\n",
    "\n",
    "# An example *set* of ingredients which might be available\n",
    "# (note: here first a list is created and then it is converted to a set)\n",
    "inHouseIngredients = set( [ \"eggs\", \"espresso\", \"cocoa\", \"butter\", \"strawberries\" ] )\n",
    "inHouseIngredients"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Use `len(...)` to find the number of elements in a set:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "len( tiramisuIngredients )"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The type of an object can be checked (as usual) with `type(...)`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "type( tiramisuIngredients )"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "But note, that the *empty set* cannot be created with `{}` - it leads to an object of a different type:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "type( {} )"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To create the *empty set* use `set()` with no arguments:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "type( set() )"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Sets algebra"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Standard algebraic operations on sets are [drawn here](set_operations.png)."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For the tiramisu example, sets of potential interest can be constructed with the operators:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Which ingredients are already available in house:\n",
    "tiramisuIngredients & inHouseIngredients"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# What still needs to be bought to prepare tiramisu:\n",
    "tiramisuIngredients - inHouseIngredients"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Sets: is an element in or not?"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Whether a single element is present `in` a set can be tested as follows:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"milk\" in tiramisuIngredients"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To check whether an element is `not in` a set, use:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"milk\" not in tiramisuIngredients"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Consider also this example of using `not in` inside a comprehension iterating over a set:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# A True/False map whether an in-house-ingredient is not needed for tiramisu.\n",
    "[(ing,ing not in tiramisuIngredients) for ing in inHouseIngredients]"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note: the `set` methods `issubset(...)` and `issuperset(...)` allow to test whether all elements of one set are also present in the other set. The same functions are provided through `<=`, `=>` operators. The `==` allows to check whether two sets have identical elements."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "tiramisuIngredients.issubset( inHouseIngredients )"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Sets: adding/removing elements "
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's consider a set with some available ingredients:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "inHouseIngredients"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "New elements can be added as follows:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# For a single element:\n",
    "inHouseIngredients.add( 'bread' )\n",
    "\n",
    "# For an iterable collection of elements (it can also be another set):\n",
    "inHouseIngredients.update( [ 'salami', 'tomatoe' ] )\n",
    "\n",
    "inHouseIngredients"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And here are some examples how to remove elements:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "# For an element currently in the set:\n",
    "inHouseIngredients.remove( \"bread\" )\n",
    "\n",
    "# Note: KeyError exception would be raised because \"BREAD\" is not in the set:\n",
    "# inHouseIngredients.remove( \"BREAD\" ) \n",
    "\n",
    "# For a value which might be in the set (but no error when the value is not there):\n",
    "inHouseIngredients.discard( \"BREAD\" )"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Sets: a loop over all elements"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The following code allows to perform some operations (here: `print(...)`) *for each* element present in the set.  \n",
    "The order in which the elements are iterated over is not defined."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for ing in tiramisuIngredients:\n",
    "    print( \"Needed for tiramisu:\", ing )"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Dictionaries"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`dict` is a built-in data type with the following properties:\n",
    "- it is a container which can keep any number (0, 1, 2, ...) of (*key*, *value*) `items`\n",
    "- the primary goal: using a key it is possible to quickly `get` its corresponding value\n",
    "- there are no duplicates among the `keys`; it is possible whether a key is `in` or `not in` a dict object\n",
    "- the keys must be of *immutable* type\n",
    "- a value corresponding to a key can be of a mutable type\n",
    "- new items can be added\n",
    "- existing items can be removed\n",
    "- `for` loops can iterate over all items of a dictionary, or over the `keys`, or over `values`"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### A new dictionary"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Use the following notation to create a dictionary from element pairs (note the curly braces: `{`...`}`):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "day2KCal = { \"Mon\": 2330, \"Tue\": 1990, \"Wed\": 2150 }\n",
    "day2KCal"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The type of the created object is:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "type( day2KCal )"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note: repeating the same key (here: `Mon`) overwrites the previously associated value:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "{  \"Mon\": 2330, \"Tue\": 1990, \"Wed\": 2150, \"Mon\": 1000 }"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The following code allows to build a dictionary from two iterable objects:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "days = ( \"Mon\", \"Tue\", \"Wed\", \"Thu\", \"Fri\", \"Sat\", \"Sun\" )      # a tuple\n",
    "dayKCals = [ 2330, 1990, 2150, 2290, 1920, 2370, 2050 ]         # a list\n",
    "zip( days, dayKCals )           # a generator, iterable over tuples (day, dayKCal)\n",
    "list( zip( days, dayKCals ) )   # a list of tuples generated by the generator\n",
    "\n",
    "day2KCal = dict( zip( days, dayKCals ) )\n",
    "day2KCal"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is the standard way to find the number of items (here: key-value pairs) in a collection:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "len( day2KCal )"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note: this is how a new empty dictionary is created:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "{}"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Dict: getting, adding or modifying elements"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's start with a dictionary:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "day2KCal = { \"Mon\": 2330, \"Tue\": 1990, \"Wed\": 2150 }\n",
    "day2KCal"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To add a new value or change a value for a single key, use the following:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "day2KCal[ \"Thu\" ] = 2290\n",
    "day2KCal"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Multiple items can be added/updated by calling `update(...)` for an iterable over (key, value) items: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "day2KCal.update( [ ( \"Fri\", 1920 ), ( \"Sat\", 2370 ) ] )\n",
    "day2KCal"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The square bracket `[`...`]` operator can be used to get an element for a provided key.  \n",
    "The key must be present in the dictionary or an error will be thrown:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# day2KCal[ \"Monday\" ]         # \"Monday\" is an invalid key and raises KeyError exception\n",
    "day2KCal[ \"Mon\" ]              # returns the value for the key \"Mon\""
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `get( key, defaultValue )` function may be used to avoid exceptions when the key is missing in the dictionary. Then the `defaultValue` is returned:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "day2KCal.get( \"Monday\", 100 )  # does not raise any exception\n",
    "                               # but it returns the second argument (here 100)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The following two examples show how to check whether a key is `in` or is `not in` a dictionary:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"Tuesday\" in day2KCal"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "aKey = \"Tuesday\"\n",
    "aKey not in day2KCal"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Dict: removing an element"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A few possibilities exists to remove an element:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "day2KCal = { \"Mon\": 2330, \"Tue\": 1990, \"Wed\": 2150 }\n",
    "day2KCal.pop( \"Tue\" )           # removes Tue but returns the value which Tue had\n",
    "                                # raises exception if the key is not found\n",
    "\n",
    "day2KCal.pop( \"Monday\", None )  # removes only when the key is present; returns the second argument\n",
    "                                # does not raise the key not found exception"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Or:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [],
   "source": [
    "del day2KCal[ \"Mon\" ]           # also removes an existing element\n",
    "                                # raises exception if the key is not found"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Dict: all keys, all values or their pairs"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "With `values()` it is possible to iterate over all values in a dictionary:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "day2KCal = { \"Mon\": 2330, \"Tue\": 1990, \"Wed\": 2150 }\n",
    "day2KCal.values()                  # this is an iterable collection\n",
    "                                   # it is a view: it will change if the dict changes"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "An example of `values()` used in a list comprehension:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "kJoules = [kCal * 4.184 for kCal in day2KCal.values()]\n",
    "kJoules"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`items()` provide an iterator over dictionary, generating two element tuples (key, value).  \n",
    "Here, this iterator is used to create another dictionary:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "day2KCal.items()                  # this is a generator of (day, kCal) tuples\n",
    "day2KJoule = { day: kCal * 4.184 for day, kCal in day2KCal.items()}\n",
    "day2KJoule"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It is also possible to iterate only over `keys()`.  \n",
    "The following example creates a tuple of all dictionary keys:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "day2KCal.keys()                   # this is a generator\n",
    "days = tuple( day2KCal.keys() )   # iterates over the generator and produces a tuple\n",
    "days"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Dict: a loop over elements"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`items()`, `values()`, `keys()` can also be used in loops. For example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "day2KCal = { \"Mon\": 2330, \"Tue\": 1990, \"Wed\": 2150 }\n",
    "for day, kCal in day2KCal.items():\n",
    "    print( \"On\", day, \"consumed food was\", kCal, \"kCal or\", kCal * 4.184, \"kJ.\" )"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Formatting strings"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Compare the `print` command from the previous example with the print below which uses *f-strings (formatted string literals)*."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "day2KCal = { \"Mon\": 2330, \"Tue\": 1990, \"Wed\": 2150 }\n",
    "for day, kCal in day2KCal.items():\n",
    "    print( f\"On {day} consumed food was {kCal} kCal or {kCal * 4.184} kJ.\" )"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In *f-strings* `f\"`...`\"` variables/expressions can be put between `{`...`}` to have their values inserted into the surrounding text."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = \"Statistics\"\n",
    "y = \"Data Science\"\n",
    "f\"{x} and {y}\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "f\"{x}\" \" and \" f'{y}'            # Note, there are several strings here\n",
    "                                 # and they get concatenated"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "( f\"{x}\"\n",
    "\" and \"\n",
    "f\"{y}\" )                         # The above example in a multiline version, see (...)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The *f-strings* notation allows to specify rounding and alignment of the inserted text.  \n",
    "Consider the following examples:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from math import pi\n",
    "{ \n",
    "    \"               full precision\":  f\"{pi}\",\n",
    "    \"                  four digits\":  f\"{pi:.4f}\",\n",
    "    \"four digits and forced + sign\":  f\"{pi:+.4f}\",\n",
    "    \"                right aligned\":  f\"{pi:12.4f}\",\n",
    "    \"               center aligned\":  f\"{pi:^12.4f}\",\n",
    "    \"                 left aligned\":  f\"{pi:<12.4f}\",\n",
    "    \"            exponent notation\":  f\"{pi * 1000:.4e}\",\n",
    "    \"        with comma separators\":  f\"{pi * 1e6:,.2f}\",     # Note: the comma here is ok\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Self-study tasks"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Generating random integers"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Use `from random import randint` to make the function `randint` available.  \n",
    "Try `randint` to generate a random number in the range `[0,...,9]` (both ends inclusive).  \n",
    "Write a list comprehension to generate a list with 20 random numbers in the range.  \n",
    "Store the generated list in the variable `vs`.  \n",
    "\n",
    "*Note:* The `range(...)` generator might be useful in the comprehension.\n",
    "\n",
    "*Question:* What would be `set(vs)`?"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Counting elements"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A list of many elements is provided in the variable `vs` (identical elements may occur multiple times in the list).  \n",
    "(*Note:* Such a list can be the output from the previous exercise, but it can be a list of for example text strings).\n",
    "\n",
    "Write your own element *counter* which produces a dictionary with keys being the unique elements of the `vs` list and the values representing their counts.  \n",
    "Store the dictionary in `v2cnt`.\n",
    "\n",
    "*Note:* There are many solutions. You may first build a set of unique `vs` elements. Then initialize a dictionary for these elements with `0` count values. Finally, in a `for` loop increase the counts in the dictionary."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [],
   "source": [
    "# For example, for this list:\n",
    "vs = [ 1, 7, 3, 1, 0, 2, 5, 7, 8, 2, 6, 2, 4, 1, 5, 5, 0, 2, 5, 4, 1, 3, 1, 8, 2, 1 ]\n",
    "\n",
    "# The solution should be (0 is present twice, 1 is six times, 2 five times...)\n",
    "# vs2cnt = {0: 2, 1: 6, 2: 5, 3: 2, 4: 2, 5: 4, 6: 1, 7: 2, 8: 2}"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Removing from a dictionary all items of given values"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Given is a dictionary `licPlate2color` with colors of cars corresponding to some license plates.  \n",
    "Create a filtered dictionary `lp2c` which does not contain cars of colors listed in `toRemoveColors`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [],
   "source": [
    "licPlate2color = {\n",
    "    \"VA-111-V\": \"silver\", \"SB-222-W\": \"red\", \"XC-333-L\": \"red\",\n",
    "    \"AB-111-E\": \"white\", \"ER-222-U\": \"black\", \"BV-333-Z\": \"white\",\n",
    "    \"CC-111-J\": \"silver\", \"UI-222-R\": \"green\", \"GF-333-U\": \"silver\",\n",
    "    \"WT-111-K\": \"white\", \"KJ-222-Q\": \"silver\", \"LK-333-I\": \"black\",\n",
    "}\n",
    "toRemoveColors = [ \"white\", \"silver\", \"black\" ]"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Build a dictionary with values being lists"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Some people are described at the same positions in two lists: `names` and `countries` (see below).  \n",
    "Build a dictionary `country2names` with values being lists of `names` of people from a country given by the key.  \n",
    "For example: `country2names[\"nl\"]` should be a list `['Jeroen', 'Sanne']`.\n",
    "\n",
    "*Note:* A possible solution may use `defaultdict` imported from `collections` package."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [],
   "source": [
    "names =     [\"Grzegorz\", \"Małgorzata\", \"Paweł\", \"Jeroen\", \"Sanne\", \"Ana\", \"Sofia\", \"Javier\", \"Sofia\"]\n",
    "countries = [\"pl\",       \"pl\",         \"pl\",    \"nl\",     \"nl\",    \"es\",  \"es\",    \"es\",     \"es\"]"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Reverse a list and sample elements"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A volleyball team has 11 players (each of a different name). The players specialize and have their own roles.\n",
    "The `player2role` dictionary provides the roles of the players.\n",
    "\n",
    "For a volleyball set the team needs to select 6 players with the following roles:\n",
    "- one `setter`,\n",
    "- one `dia`,\n",
    "- two `middle` attackers,\n",
    "- two `outside` attackers.  \n",
    "The numbers of needed players of each role is given by the `role2num` dictionary.\n",
    "\n",
    "From the complete team choose 6 player randomly but so that there is a correct number of players with each role.  \n",
    "The result should be a dictionary (keys are the roles, values are lists of chosen players).\n",
    "\n",
    "*Hint:* `from random import sample` (search for documentation of the function `sample`)\n",
    "\n",
    "*Hint:* Based on the previous exercise build first `role2players` dictionary (reverse `player2role`).\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [],
   "source": [
    "from random import sample\n",
    "\n",
    "role2num = { \"setter\": 1, \"dia\": 1, \"middle\": 2, \"outside\": 2 }\n",
    "\n",
    "player2role = { \n",
    "    \"Chen\": \"setter\", \"Martijn\": \"setter\",\n",
    "    \"Marnick\": \"dia\", \"Simon\": \"dia\",\n",
    "    \"David\": \"middle\", \"Luuk\": \"middle\",\n",
    "    \"Ronald\": \"outside\", \"Alex\": \"outside\", \"Kadir\": \"outside\", \"Koen\": \"outside\"\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### NATO phonetic alphabet"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When spelling a word, the following `codeWords` are used to represent letters (`a` is pronounced `alpha`, `b` is `bravo`, ...).\n",
    "\n",
    "Build a dictionary `chr2codeWord` which will map a letter `chr` to its code word `chr2codeWord[chr]`.  \n",
    "For example, `chr2codeWord['s']` should be equal to `sierra`.  \n",
    "Do not type the content manually - use `split` to get a list of words from `codeWords` and then write a comprehension to build a dictionary mapping the first letter (`codeWord[0]`) to the corresponding `codeWord`.\n",
    "\n",
    "Finally, given `word = \"statistics\"` write a comprehension mapping letters from `word` to a list of code words in the order how they should be spelled (`sierra`, `tango`, `alpha`, `tango`, ...)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "codeWords = \"alpha bravo charlie delta echo foxtrot golf hotel india juliet kilo lima mike november oscar papa quebec romeo sierra tango uniform victor whiskey x-ray yankee zulu\"\n",
    "codeWords"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Read weather data"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Understand the Open-Meteo web page:  \n",
    "https://open-meteo.com/en/docs#latitude=52.16&longitude=4.49&hourly=temperature_2m.  \n",
    "\n",
    "On that page you may generate a URL link providing access to weather predictions, for example for temperature in Leiden:  \n",
    "https://api.open-meteo.com/v1/forecast?latitude=52.16&longitude=4.49&hourly=temperature_2m\n",
    "\n",
    "The data is provided in the [JSON](https://en.wikipedia.org/wiki/JSON) format which can be easily read in Python using the `json` and `urllib.request` libraries.\n",
    "\n",
    "Use the following code to get the `data`. Find out how to extract the list with temperatures and the list with corresponding time point texts. Finally, build a dictionary object `time2temp` mapping the time point text to the temperature."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [],
   "source": [
    "import urllib.request, json \n",
    "url = \"https://api.open-meteo.com/v1/forecast?latitude=52.16&longitude=4.49&hourly=temperature_2m\"\n",
    "data = json.load( urllib.request.urlopen(url) )\n",
    "# print(data)          # use this to print the nested list with data"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "EfDS",
   "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.13.1"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}