01_python/python_lists_tuples.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "051067cd",
   "metadata": {},
   "source": [
    "# Python lists and tuples"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "9910ee8f",
   "metadata": {},
   "source": [
    "## Lists: simple, nested, empty"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "973f4dec",
   "metadata": {},
   "source": [
    "Lists are collections of any number (0, 1, 2, ...) of elements (possibly of different types).  \n",
    "In a list, each element has its position. The index numbers the positions. Note, that the first position has index zero.  \n",
    "After a list is created it can be changed - elements can be added, removed or modified.\n",
    "\n",
    "Let's start with a list of elements of the same type:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d68287f3",
   "metadata": {},
   "outputs": [],
   "source": [
    "dailyKCal = [ 2330, 1990, 2150, 2290, 1920, 2370, 2050 ]\n",
    "dailyKCal"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b8d697a1",
   "metadata": {},
   "outputs": [],
   "source": [
    "days = [ \"Mon\", \"Tue\", \"Wed\", \"Thu\", \"Fri\", \"Sat\", \"Sun\" ]\n",
    "days"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1383178f",
   "metadata": {},
   "outputs": [],
   "source": [
    "goodMoods = [ True, True, False, True, True, False, True ]\n",
    "goodMoods"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "9cc99632",
   "metadata": {},
   "source": [
    "The `type(...)` function can be used to check whether an object is of type `list`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1d379f90",
   "metadata": {},
   "outputs": [],
   "source": [
    "type( goodMoods )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5070f455",
   "metadata": {},
   "outputs": [],
   "source": [
    "type( [ 2330, 1990, 2150 ] )"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fd8c1a11",
   "metadata": {},
   "source": [
    "A list may also contain elements of different types:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6e7d56c7",
   "metadata": {},
   "outputs": [],
   "source": [
    "dataDay1 = [ 2330, \"Mon\", True ]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "18d024ca",
   "metadata": {},
   "source": [
    "In particular, lists can be nested. Here are two examples of lists containing other lists:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e4e740e8",
   "metadata": {},
   "outputs": [],
   "source": [
    "dataByDays = [ [ 2330, \"Mon\", True ], [ 1990, \"Tue\", True ], [ 2150, \"Wed\", False ] ]\n",
    "dataByDays"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4fb7e343",
   "metadata": {},
   "outputs": [],
   "source": [
    "dataByVars = [ dailyKCal, days, goodMoods ]\n",
    "dataByVars"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "dcce802d",
   "metadata": {},
   "source": [
    "Note, a list can also be empty. A new empty list can be created as follows:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4c67c528",
   "metadata": {},
   "outputs": [],
   "source": [
    "[]"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "b08dadbf",
   "metadata": {},
   "source": [
    "## Tuples"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "48e8abc6",
   "metadata": {},
   "source": [
    "Tuples are also collections of any number (0, 1, 2, ...) of elements (possibly of different types).  \n",
    "In a tuple, each element has its position. The index numbers the positions. Note, that the first position has index zero.  \n",
    "**Tuples are immutable** - once a tuple is created, it is not possible to change the elements."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "d6f5f432",
   "metadata": {},
   "source": [
    "Tupes are created with a syntax similar to lists. For tuples use `(...)` instead of `[...]`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "96a991d6",
   "metadata": {},
   "outputs": [],
   "source": [
    "dailyKCal = ( 2330, 1990, 2150, 2290, 1920, 2370, 2050 )\n",
    "dailyKCal"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "91287f18",
   "metadata": {},
   "outputs": [],
   "source": [
    "type( dailyKCal )"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "3f13c4a8",
   "metadata": {},
   "source": [
    "Because `(` and `)` are also used in arithmetics, a special notation (with an extra `,`) is needed to create a tuple with exactly one element:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "afdac0f1",
   "metadata": {},
   "outputs": [],
   "source": [
    "singleDayTuple = ( \"Mon\", )\n",
    "type( singleDayTuple )"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "8fc2fda6",
   "metadata": {},
   "source": [
    "Compare:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0f562c16",
   "metadata": {},
   "outputs": [],
   "source": [
    "type( ( 1 ) )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1ae52c8a",
   "metadata": {},
   "outputs": [],
   "source": [
    "type( ( 1, ) )"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "fee8708a",
   "metadata": {},
   "source": [
    "An empty tuple is `()`."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "225e2669",
   "metadata": {},
   "source": [
    "Note the assignment of a tuple to multiple variables:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e53d9d00",
   "metadata": {},
   "outputs": [],
   "source": [
    "x, y, z = ( \"a\", True, 0 )"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5136ab86",
   "metadata": {},
   "source": [
    "## Concatenation are repetition"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "3c5ef980",
   "metadata": {},
   "source": [
    "Let's assume that each list below describes some preparation steps:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0727f4cf",
   "metadata": {},
   "outputs": [],
   "source": [
    "americano = [ \"espresso\", \"hot water\" ]\n",
    "caffe_latte = [ \"espresso\", \"steamed milk\" ]\n",
    "latte_macchiato = [ \"steamed milk\", \"espresso\" ]\n",
    "apple_pie_set = [ \"apple pie\", \"whipped cream\" ]\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "439c7ddf",
   "metadata": {},
   "source": [
    "Then, steps for a larger order can be combined using list concatentation (`+`) and list repetition (`*`) operators:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ba65d470",
   "metadata": {},
   "outputs": [],
   "source": [
    "order_steps = 2 * americano + caffe_latte + 3 * apple_pie_set + latte_macchiato\n",
    "order_steps"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a140f13c",
   "metadata": {},
   "source": [
    "Concatenation and repetition works also for tuples.\n",
    "Concatenating a tuple with a list leads to an error."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e28e46bb",
   "metadata": {},
   "outputs": [],
   "source": [
    "# ( 1, ) + [ 2 ]     # Leads to TypeError"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "3052ca6f",
   "metadata": {},
   "source": [
    "## Access/change of a single element"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "fbe3e698",
   "metadata": {},
   "source": [
    "Let's define a list (or a tuple):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ae899123",
   "metadata": {},
   "outputs": [],
   "source": [
    "days = [ \"Mon\", \"Tue\", \"Wed\", \"Thu\", \"Fri\", \"Sat\", \"Sun\" ]\n",
    "days"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "e0591c19",
   "metadata": {},
   "source": [
    "The first element of a list/tuple can be accessed at index zero:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "95216d1a",
   "metadata": {},
   "outputs": [],
   "source": [
    "days[0]"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "266102b4",
   "metadata": {},
   "source": [
    "To calculate the total number of elements (length) in a list/tuple use `len(...)`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e5bccfe3",
   "metadata": {},
   "outputs": [],
   "source": [
    "len( days )"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "1866e36c",
   "metadata": {},
   "source": [
    "The last element of a list/tuple can be accessed as follows:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "440885a7",
   "metadata": {},
   "outputs": [],
   "source": [
    "days[ len(days)-1 ]"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "c0abd981",
   "metadata": {},
   "source": [
    "Negative index allows accessing elements relative to the end. Another way to access the last element is:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "edc02072",
   "metadata": {},
   "outputs": [],
   "source": [
    "days[ -1 ]"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "1af3f08b",
   "metadata": {},
   "source": [
    "Usage of an index beyond the range of elements present in a list/tuple raises an error exception:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "edfea46d",
   "metadata": {},
   "outputs": [],
   "source": [
    "# days[7]                # IndexError: tuple index out of range \n",
    "                         # valid indexes are 0,1,2,3,4,5,6"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "b963aa9a",
   "metadata": {},
   "source": [
    "In lists the elements can be modified:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1d55b364",
   "metadata": {},
   "outputs": [],
   "source": [
    "days = [ \"Mon\", \"Tue\", \"Wed\", \"Thu\", \"Fri\", \"Sat\", \"Sun\" ]\n",
    "days[0] = \"MONDAY\"       # works fine, days is a list\n",
    "days"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "423fbc67",
   "metadata": {},
   "source": [
    "But the tuples are immutable - the following code raises an error exception:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a407166e",
   "metadata": {},
   "outputs": [],
   "source": [
    "days = ( \"Mon\", \"Tue\", \"Wed\", \"Thu\", \"Fri\", \"Sat\", \"Sun\" )\n",
    "# days[0] = \"MONDAY\"     # TypeError: 'tuple' object does not support item assignment"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "42062f7c",
   "metadata": {},
   "source": [
    "## Access/change of multiple elements"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "2b616c96",
   "metadata": {},
   "source": [
    "The slice operator `[n:m]` applied to a list/tuple gets its elements from the positions `n`...`m-1` and creates a new list/tuple containing only them: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b0f4905e",
   "metadata": {},
   "outputs": [],
   "source": [
    "# ----- the following few code cells work both for lists and tuples -----\n",
    "# days = ( \"Mon\", \"Tue\", \"Wed\", \"Thu\", \"Fri\", \"Sat\", \"Sun\" )\n",
    "days = [ \"Mon\", \"Tue\", \"Wed\", \"Thu\", \"Fri\", \"Sat\", \"Sun\" ]\n",
    "days[2:5]                # note: Elements with indexes 2,3 and 4 (but not 5).\n",
    "                         #       \"Mon\" has index 0."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "bd818706",
   "metadata": {},
   "source": [
    "`[:m]` denotes indexes from the beginning (`0`) till `m-1`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b9986163",
   "metadata": {},
   "outputs": [],
   "source": [
    "workingDays = days[:5]\n",
    "workingDays"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "33da4aff",
   "metadata": {},
   "source": [
    "Similarly, `[n:]` denotes indexes from `n` till the last:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a2e02578",
   "metadata": {},
   "outputs": [],
   "source": [
    "weekendDays = days[5:]\n",
    "weekendDays"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "249651cd",
   "metadata": {},
   "source": [
    "Consequently, a slice `[:]` makes a separate copy of the whole list:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2baa4a36",
   "metadata": {},
   "outputs": [],
   "source": [
    "copiedDays = days[:]"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "1d1be630",
   "metadata": {},
   "source": [
    "Slicing `[n:m:step]` can take an extra `step` argument: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4e58b025",
   "metadata": {},
   "outputs": [],
   "source": [
    "days[1:6:2]"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "d5b79ccb",
   "metadata": {},
   "source": [
    "The `step` argument can be negative:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d6883de8",
   "metadata": {},
   "outputs": [],
   "source": [
    "days[6:1:-2]"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "9eab2677",
   "metadata": {},
   "source": [
    "In lists, several elements can be modified as follows:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "132f82f2",
   "metadata": {},
   "outputs": [],
   "source": [
    "# ----- modification here, so it can't be a tuple -----\n",
    "days = [ \"Mon\", \"Tue\", \"Wed\", \"Thu\", \"Fri\", \"Sat\", \"Sun\" ]\n",
    "days[2:3] = [ \"TUESDAY\", \"WEDNESDAY\" ]\n",
    "days\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "a64858d3",
   "metadata": {},
   "source": [
    "Note, that elements can be not only modified but also added/removed (i.e. the total length of the list changes):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "71b5c1c2",
   "metadata": {},
   "outputs": [],
   "source": [
    "# ----- modification here, so it can't be a tuple -----\n",
    "days = [ \"Mon\", \"Tue\", \"Wed\", \"Thu\", \"Fri\", \"Sat\", \"Sun\" ]\n",
    "days[2:3] = [ \"TUESDAY\", \"moon-eclipse-night!!!\", \"WEDNESDAY\" ]\n",
    "days"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2f4513b7",
   "metadata": {},
   "source": [
    "## Shallow and deeper copying"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "57bca0d6",
   "metadata": {},
   "source": [
    "Study the following example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "137f4992",
   "metadata": {},
   "outputs": [],
   "source": [
    "v = [ 1, 2, 3 ]   # []      allocates a new list\n",
    "                  # 1,2,3   fills the list with 1, 2, 3\n",
    "                  # v =     makes v point to the list\n",
    "w = v             # w = v   makes w point to the same thing as v\n",
    "v[0] = 100        #         changes the element of the list\n",
    "v"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "924e1f22",
   "metadata": {},
   "source": [
    "Because both `v` and `w` point to the same list, `w` has been also changed:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e7f8262a",
   "metadata": {},
   "outputs": [],
   "source": [
    "w"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "c77ade04",
   "metadata": {},
   "source": [
    "When the above behaviour is not desired, a deeper `copy()` needs to be enforced:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5bdf081a",
   "metadata": {},
   "outputs": [],
   "source": [
    "v = [ 1, 2, 3 ]\n",
    "w = v.copy()      # a new list is allocated\n",
    "                  # the elements of v are appended to the new list\n",
    "v[0] = 100\n",
    "v"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "636e27fd",
   "metadata": {},
   "source": [
    "Now, the change of `v` has not affected `w`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "06eeb333",
   "metadata": {},
   "outputs": [],
   "source": [
    "w"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "a996dfdd",
   "metadata": {},
   "source": [
    "## List comprehensions"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "fb445d20",
   "metadata": {},
   "source": [
    "Let's introduce a very powerful mechanisms allowing to perform operations on all elements of lists, tuples (or other iterable objects).  "
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "2f881c9e",
   "metadata": {},
   "source": [
    "The following list comprehension code:\n",
    "- produces a list: it is a list comprehension because of surrounding brackets `[` ... `]`\n",
    "- iterates through `someNums` (whatever object which can be iterated over)\n",
    "- in each iteration `x` is set to a next element value (`for x in`)\n",
    "- the result of expression `x**2` is stored to the output list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d85d3152",
   "metadata": {},
   "outputs": [],
   "source": [
    "someNums = [ 1, -2, 3, -4, 5 ]        # an iterable object\n",
    "[x**2 for x in someNums]              # a list comprehension"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "48cfa90e",
   "metadata": {},
   "source": [
    "Here, each iteration produces a tuple with two elements `(x, x**2)`. So the result is a list of tuples:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a14b4ed1",
   "metadata": {},
   "outputs": [],
   "source": [
    "someNums = [ 1, -2, 3, -4, 5 ]        # an iterable object\n",
    "[(x,x**2) for x in someNums]          # each element is a tuple"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "7cba3337",
   "metadata": {},
   "source": [
    "Note, that the list comprehension notation also allows for filtering (here: `x<0`):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8091bafc",
   "metadata": {},
   "outputs": [],
   "source": [
    "someNums = [ 1, -2, 3, -4, 5 ]        # an iterable object\n",
    "[x for x in someNums if x<0]          # only negative elements are processed"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "b2398d07",
   "metadata": {},
   "source": [
    "## Self-study tasks"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "f8cd9adc",
   "metadata": {},
   "source": [
    "### Understand errors"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "d39bf2cd",
   "metadata": {},
   "source": [
    "Try the following cells to get familiar with error messages.  \n",
    "Explain the errors."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c991128b",
   "metadata": {},
   "outputs": [],
   "source": [
    "nums = ( 1, 2, 3 )\n",
    "#nums[1] = 22              # what's wrong here?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c3221333",
   "metadata": {},
   "outputs": [],
   "source": [
    "nums = [ 1, 2, 3 ]\n",
    "#nums[3] = 4               # what's wrong here?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0e905b45",
   "metadata": {},
   "outputs": [],
   "source": [
    "txt = \"Statistics\"\n",
    "#txt[0] = \"s\"              # what's wrong here?"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "3894eb4d",
   "metadata": {},
   "source": [
    "### Understand difference"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "8c4f9310",
   "metadata": {},
   "source": [
    "Why `a` differs from `b`?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "836347fc",
   "metadata": {},
   "outputs": [],
   "source": [
    "v = [ 1, 2, 3 ]\n",
    "a = v\n",
    "v = [ 4, 5, 6 ]\n",
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9b32d520",
   "metadata": {},
   "outputs": [],
   "source": [
    "v = [ 1, 2, 3 ]\n",
    "b = v\n",
    "v[:] = [ 4, 5, 6 ]\n",
    "b"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "3883d92b",
   "metadata": {},
   "source": [
    "### Changing (or not) lists"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "cf8d33eb",
   "metadata": {},
   "source": [
    "Let's assume that a vector `v` with several random numbers is given (an example below).  \n",
    "Check Python `list` manuals to find programmatic ways in place marked with `...` to produce the various goals requested below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "30409eb0",
   "metadata": {},
   "outputs": [],
   "source": [
    "v = [ 5, 2, 1, 4, 3 ]\n",
    "# ...\n",
    "# Here v should be sorted in ascending order [ 1, 2, 3, 4, 5 ]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "30409eb0",
   "metadata": {},
   "outputs": [],
   "source": [
    "v = [ 5, 2, 1, 4, 3 ]\n",
    "# ...\n",
    "# Here v should be sorted in descending order [ 5, 4, 3, 2, 1 ]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "30409eb0",
   "metadata": {},
   "outputs": [],
   "source": [
    "v = [ 5, 2, 1, 4, 3 ]\n",
    "w = v\n",
    "# ...\n",
    "# Here v should be sorted [ 1, 2, 3, 4, 5 ] but w should still be [ 5, 2, 1, 4, 3 ]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "13a83c88",
   "metadata": {},
   "outputs": [],
   "source": [
    "v = [ 5, 2, 1, 4, 3 ]\n",
    "# ...\n",
    "# Here v should be reversed [ 3, 4, 1, 2, 5 ]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c2c5f469",
   "metadata": {},
   "outputs": [],
   "source": [
    "v = [ 5, 2, 1, 4, 3 ]\n",
    "w = v\n",
    "# ...\n",
    "# Here v should be reversed [ 3, 4, 1, 2, 5 ] but w should still be [ 5, 2, 1, 4, 3 ]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "78facd3a",
   "metadata": {},
   "outputs": [],
   "source": [
    "v = [ \"eeeee\", \"bb\", \"a\", \"dddd\", \"ccc\", \"bb\" ]\n",
    "# ...\n",
    "# Here, the third element should be deleted from v: [ \"eeeee\", \"bb\", \"dddd\", \"ccc\", \"bb\" ]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6b59d765",
   "metadata": {},
   "outputs": [],
   "source": [
    "v = [ \"eeeee\", \"bb\", \"a\", \"dddd\", \"ccc\", \"bb\" ]\n",
    "# ...\n",
    "# Here, the first element with value \"bb\" should be removed from v: [ \"eeeee\", \"a\", \"dddd\", \"ccc\", \"bb\" ]\n",
    "# Any ideas how to filter out all \"bb\" elements?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "22d4b331",
   "metadata": {},
   "outputs": [],
   "source": [
    "v = [ \"eeeee\", \"bb\", \"a\", \"dddd\", \"ccc\", \"bb\" ]\n",
    "# ...\n",
    "# Insert element \"F\" to v at index 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cbafc4d2",
   "metadata": {},
   "outputs": [],
   "source": [
    "v = [ \"eeeee\", \"bb\", \"a\", \"dddd\", \"ccc\", \"bb\" ]\n",
    "w = [ \"ffffff\", \"g\", \"ffffff\" ]\n",
    "# ...\n",
    "# Insert (\"slice in\") elements of w to v at index 2 (so, that v gets length 9 and v[2:5] has elements from w)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "aad3c27b",
   "metadata": {},
   "outputs": [],
   "source": [
    "v = [ \"eeeee\", \"bb\", \"a\", \"dddd\", \"ccc\", \"bb\" ]\n",
    "# ...\n",
    "# Here, a single new element \"F\" should be *appended* to the end of the list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "v = [ \"eeeee\", \"bb\", \"a\", \"dddd\", \"ccc\", \"bb\" ]\n",
    "w = [ \"ffffff\", \"g\", \"ffffff\" ]\n",
    "# ...\n",
    "# Extend the list by append elements of w to v at the end of v. (so, length of v should be 9!)\n",
    "# What goes wrong with `append(w)` here?"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "cb9cafae",
   "metadata": {},
   "source": [
    "### Checking membership"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ce01a55b",
   "metadata": {},
   "outputs": [],
   "source": [
    "v = [ \"ababab\", \"baaab\", \"bbbaa\", \"aabba\", \"aaaab\", \"abbaa\", \"aabbb\", \"abaaa\", \"aaaaa\", \"bbbab\", \"bbbqb\", \"aaaqb\", \"bbbbq\" ]\n",
    "w = \"bbbab\"\n",
    "# ...\n",
    "# How to programmatically find whether the value of w is *in* the iterable list v?\n",
    "# The result should be True or False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "64a154cb",
   "metadata": {},
   "outputs": [],
   "source": [
    "v = [ \"ababab\", \"baaab\", \"bbbaa\", \"aabba\", \"aaaab\", \"abbaa\", \"aabbb\", \"abaaa\", \"aaaaa\", \"bbbab\", \"bbbqb\", \"aaaqb\", \"bbbbq\" ]\n",
    "w = \"abaab\"\n",
    "# ...\n",
    "# How to programmatically find whether the value of w is *not in* the iterable list v?\n",
    "# The result should be True or False"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "c08332ca",
   "metadata": {},
   "source": [
    "### Understand conversions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f45e204a",
   "metadata": {},
   "outputs": [],
   "source": [
    "lst = [1,2,3,\"x\",\"y\",\"z\"]\n",
    "tuple( lst )              # the argument can be any object which can be iterated over"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "205dbd0a",
   "metadata": {},
   "outputs": [],
   "source": [
    "tpl = (1,2,3,\"x\",\"y\",\"z\")\n",
    "list( tpl )               # the argument can be any object which can be iterated over"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "27072de5",
   "metadata": {},
   "outputs": [],
   "source": [
    "tuple( \"Statistics\" )     # \"Statistics\" can be iterated over"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f25272f0",
   "metadata": {},
   "outputs": [],
   "source": [
    "list( 'Data Science' )"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "752caf67",
   "metadata": {},
   "source": [
    "### Practice comprehensions and try a generator"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "77ad45d4",
   "metadata": {},
   "source": [
    "Let's write a simple comprehension first:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f20f528a",
   "metadata": {},
   "outputs": [],
   "source": [
    "xs = [ 0, 1, 2, 3, 4, 5 ]\n",
    "# ys = [ ... ]            # write a comprehension to transform \n",
    "                          #   elements of xs according to formula:\n",
    "                          #   y = x^2 + x + 1\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "9bf8562b",
   "metadata": {},
   "source": [
    "Next, read about `range(...)` and use it to rewrite the definition of `xs` in the above code.  \n",
    "Check the type of `xs`. Note, that `xs` created by `range(...)` is not a list but the comprehesion still works (once).  \n",
    "Can you explain the mechanism (keyword: iterable)?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cee615f8",
   "metadata": {},
   "outputs": [],
   "source": [
    "# xs = range( ... )      # it should correspond to these numbers [ 0, 1, 2, 3, 4, 5 ]\n",
    "# ys = [ ... ]           # as before: y = x^2 + x + 1"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "ef437646",
   "metadata": {},
   "source": [
    "Now, write a comprehension to remove all elements equal to `toRemove` from `v`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "df9ae087",
   "metadata": {},
   "outputs": [],
   "source": [
    "toRemove = \"bb\"\n",
    "v = [ \"eeeee\", \"bb\", \"a\", \"dddd\", \"ccc\", \"bb\" ]\n",
    "# w = [ ... for ... if ... ]     # w should not have elements equal the value of toRemove"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "aadbe663",
   "metadata": {},
   "source": [
    "Next, generalize the last comprehension to handle a situation when `toRemove` contains more than one element.  \n",
    "Read about the `in` operator for lists and about `not` logical operator."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "832e8b07",
   "metadata": {},
   "outputs": [],
   "source": [
    "toRemove = [ \"bb\", \"a\" ]\n",
    "v = [ \"eeeee\", \"bb\", \"a\", \"dddd\", \"ccc\", \"bb\" ]\n",
    "# w = [ ... for ... if ... ]     # w should *not* have elements *in* toRemove list\n",
    "w"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5883ccdc",
   "metadata": {},
   "outputs": [],
   "source": [
    "v = [ \"ababab\", \"baaab\", \"bbbaa\", \"aabba\", \"aaaab\", \"abbaa\", \"aabbb\", \"abaaa\", \"aaaaa\", \"bbbab\", \"bbbqb\", \"aaaqb\", \"bbbbq\" ]\n",
    "w = [ \"aaaqb\", \"abbaa\", \"ababab\" ]\n",
    "# ...\n",
    "# Write a statement checking whether *all* elements of w are *in* v.\n",
    "# The result should be a single True or False value."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "033eda83",
   "metadata": {},
   "outputs": [],
   "source": [
    "v = [ \"ababab\", \"baaab\", \"bbbaa\", \"aabba\", \"aaaab\", \"abbaa\", \"aabbb\", \"abaaa\", \"aaaaa\", \"bbbab\", \"bbbqb\", \"aaaqb\", \"bbbbq\" ]\n",
    "w = [ \"abaaa\", \"bbbab\", \"qbbbq\" ]\n",
    "# ...\n",
    "# Write a statement checking whether *any* element of w is *not in* v.\n",
    "# The result should be a single True or False value."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "2890b03b",
   "metadata": {},
   "source": [
    "### Comprehensions with tuple elements"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "1dd5caa8",
   "metadata": {},
   "source": [
    "`zip(...)` can be used to build tuples out of elements of two iterables. Tuples of elements at the same positions can be iterated over. It also works for more than two lists."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4db93e55",
   "metadata": {},
   "outputs": [],
   "source": [
    "heights = [ 173, 179, 167, 195, 173, 184, 162, 169 ]  # 8 persons\n",
    "weights = [ 57, 58, 62, 84, 64, 74, 57, 44 ]          # same 8 persons, same order\n",
    "zip( heights, weights )                # this is a generator of ( height, weight ) tuples\n",
    "list( zip( heights, weights ) )        # when converted to list you see the tuples\n",
    "# ...\n",
    "# Write a statement generating list of BMIs for the 8 persons.\n",
    "# Hint: [ ... for h, v in ... ]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "75668aa6",
   "metadata": {},
   "source": [
    "`enumerate(...)` adds information at which index an element is:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5841eb5e",
   "metadata": {},
   "outputs": [],
   "source": [
    "heights = [ 173, 179, 167, 195, 173, 184, 162, 169 ]  # 8 persons\n",
    "enumerate( heights )                   # this is a generator of ( index, element ) tuple pairs\n",
    "tuple( enumerate( heights ) )          # do you understand this result?"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "bdb8d343",
   "metadata": {},
   "source": [
    "### Indexing nested list"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "bdb1fc21",
   "metadata": {},
   "source": [
    "Let's consider the following nested list:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9010b80c",
   "metadata": {},
   "outputs": [],
   "source": [
    "nestedList = [ \"a\", [ \"ba\", [ \"bba\", \"bbb\" ], \"bc\", [ \"bda\", \"bdb\" ], \"be\" ], \"c\", [ [ \"daa\", \"dab\" ] ] ]\n",
    "nestedList"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "f32063a7",
   "metadata": {},
   "source": [
    "Without running the code do you know what will be the result of each of the following indexing?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b68e1fa3",
   "metadata": {},
   "outputs": [],
   "source": [
    "# nestedList[2]\n",
    "# nestedList[1:2]\n",
    "# nestedList[1][1]\n",
    "# nestedList[3][0][1]\n",
    "# nestedList[2][0]\n",
    "# nestedList[3][0][0][2]\n",
    "# nestedList[3][0][0][2::-1]"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "jupyter",
   "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.2"
  },
  "vscode": {
   "interpreter": {
    "hash": "0fadeaac72bf3c14f9665939c662a31c8aa4e36681a8cd408ae34884627e6cff"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}