LECTURES/Lecture_02.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "1CnJ9L-np9rn"
   },
   "source": [
    "# PYTHON COURSE FOR SCIENTIFIC PROGRAMMING \n",
    "**Main Editors of this lecture:**\n",
    "\n",
    "Arnau Parrilla Gibert: arnauparrilla@gmail.com \n",
    "\n",
    "Xabier Oianguren Asua: oiangu9@gmail.com\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "7j-0zDCyiVzS"
   },
   "source": [
    "# LECTURE II : The Loops and Iterables\n",
    "\n",
    "### $(1.)$ - [*THE FOR LOOP*](#1)\n",
    "### $(2.)$ - [*THE WHILE LOOP*](#2)\n",
    "\n",
    "\n",
    "Imagine we want to repeat a piece of code over and over until certain condition is hit, or imagine that we want to repeat a piece of code once per each element of a sequence of elements or indices. Moreover, imagine that the number of times we need to do this is not determined while we are coding, that it will be determined dynamically when the script is used by somebody, or used for different input data.\n",
    "\n",
    "It is to solve these kinds of situations and more that we have the **loops**.\n",
    "\n",
    "#### <ins>There are two types of loops:</ins>\n",
    "* A `for` loop is a piece of code that will be repeated once per each element of an **iterable** sequence of elements. \n",
    "\n",
    "The **slogan** is *for each element of [this], execute this block of code*.\n",
    "* A `while` loop is a piece of code that will be repeated as long as a condition is true.\n",
    "\n",
    "The **slogan** is *while [this] is True, execute this block of code, over and over*-\n",
    "\n",
    "### Iteration\n",
    "Each time a block of code is repeated, it is called an **iteration**!\n",
    "\n",
    "--------"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "rOdmBUPysJEo"
   },
   "source": [
    "<a id='1'></a>\n",
    "\n",
    "# (1.) The For Loop\n",
    "The **slogan** is *for each element of [this], execute this block of code*.\n",
    "\n",
    "Structure:\n",
    "\n",
    "        for <variable_that_will_sweep_the_iterable> in <iterable>:       \n",
    "            Block of code to repeat\n",
    "  \n",
    "For instance, lists are **iterable** objects, meaning they have a sequence of elements that we can cross one by one:\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "lis = [0,1,2,3,4,5]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 199
    },
    "colab_type": "code",
    "id": "KB9sMFgqPegm",
    "outputId": "c9691970-b4e4-4f83-e57e-c3e1df92fb2c"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hola\n",
      "Iteration number 0\n",
      "hola\n",
      "Iteration number 1\n",
      "hola\n",
      "Iteration number 2\n",
      "hola\n",
      "Iteration number 3\n",
      "hola\n",
      "Iteration number 4\n",
      "hola\n",
      "Iteration number 5\n"
     ]
    }
   ],
   "source": [
    "for i in lis:\n",
    "    print(\"hola\")\n",
    "    print(f\"Iteration number {i}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hola\n",
      "Iteration number 8.9\n",
      "hola\n",
      "Iteration number Duuude!\n",
      "hola\n",
      "Iteration number True\n",
      "hola\n",
      "Iteration number 3.3333333333333335\n"
     ]
    }
   ],
   "source": [
    "for mermin in [8.9, \"Duuude!\", True, 10/3]:\n",
    "    print(\"hola\")\n",
    "    print(f\"Iteration number {mermin}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As you see, in each of the iterations, the variable we set as the index that iterates, takes a different value. In fact, if we have a variable with the same name outside the loop, its value will only be changed inside it, but also when the loop is finished! The last value it takes will be its new value."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hola\n",
      "Iteration number 8.9\n",
      "hola\n",
      "Iteration number Duuude!\n",
      "hola\n",
      "Iteration number True\n",
      "hola\n",
      "Iteration number 3.3333333333333335\n",
      "Outside of the loop! Finally! 3.3333333333333335\n"
     ]
    }
   ],
   "source": [
    "x=8\n",
    "for x in [8.9, \"Duuude!\", True, 10/3]:\n",
    "    print(\"hola\")\n",
    "    print(f\"Iteration number {x}\")\n",
    "print(\"Outside of the loop! Finally!\", x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "oDr13MjAPuEm"
   },
   "source": [
    "Now, `for` loops have endless uses, but one of their main uses is to provide us an index that counts iterations. That is, a variable that tells us in each of the iterations of the block of code, in which iteration the execution is at."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 199
    },
    "colab_type": "code",
    "id": "N38_FY2OtPsB",
    "outputId": "c0adfec3-1413-49a9-ecac-17ca32f66efa"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Iteration number 0\n",
      "8\n",
      "Iteration number 1\n",
      "9\n",
      "Iteration number 2\n",
      "10\n",
      "Iteration number 3\n",
      "11\n",
      "Iteration number 4\n",
      "12\n",
      "Iteration number 5\n",
      "13\n"
     ]
    }
   ],
   "source": [
    "x=8\n",
    "for i in [0,1,2,3,4,5]:\n",
    "    print(f\"Iteration number {i}\")\n",
    "    print(x+i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It is very uncomfortable however needing to write the whole list of indices, because imagine, in real codes, `for` loops typically iterate for thousands of times. There is a Python function to help us with this though! \n",
    "The `range()` function. \n",
    "\n",
    "* `range(N)` returns the whole numbers from `0` till $N-1$.\n",
    "* `range(n,N,k)` returns the whole numbers from `n` till `N-1`, with steps of `k` (if `k` is negative, the range will be given in reverse order)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Index equal to 3\n",
      "Index equal to 6\n",
      "Index equal to 9\n"
     ]
    }
   ],
   "source": [
    "for i in range(3, 12, 3):\n",
    "    print(f\"Index equal to {i}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Nano-Exercise 1: Print if the numbers from 0 to 10 are: \"Zero\",\"Odd\" or \"Even\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number 0 is Zero\n",
      "Number 1 is Odd\n",
      "Number 2 is Even\n",
      "Number 3 is Odd\n",
      "Number 4 is Even\n",
      "Number 5 is Odd\n",
      "Number 6 is Even\n",
      "Number 7 is Odd\n",
      "Number 8 is Even\n",
      "Number 9 is Odd\n",
      "Number 10 is Even\n"
     ]
    }
   ],
   "source": [
    "for i in range(11):\n",
    "    if i==0:\n",
    "        print(f\"Number {i} is Zero\")\n",
    "    elif i%2:\n",
    "        print(f\"Number {i} is Odd\")\n",
    "    else:\n",
    "        print(f\"Number {i} is Even\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Note** that inside each iteration, we can modify the value of the iterating index, but it will be renewed normally with the next value in the next iteration."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 199
    },
    "colab_type": "code",
    "id": "8TOS-q7HQMn8",
    "outputId": "9001959f-69dc-4538-885b-2330ab82a947"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Iteration 0\n",
      "Odd 11\n",
      "Iteration 1\n",
      "Even 12\n",
      "Iteration 2\n",
      "Odd 13\n",
      "Iteration 3\n",
      "Even 14\n",
      "Iteration 4\n",
      "Odd 15\n",
      "Iteration 5\n",
      "Even 16\n"
     ]
    }
   ],
   "source": [
    "for i in range(6):\n",
    "    print(f\"Iteration {i}\")\n",
    "    i = i+11\n",
    "    if(i%2):\n",
    "        print(f\"Odd {i}\")\n",
    "    else:\n",
    "        print(f\"Even {i}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Iterables and their Functions\n",
    "As we saw, **list**s are iterables, the output of some functions like `range()` as well. But there are many others that we will see in the future. \n",
    "\n",
    "Another one you know are the `strings`!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 90
    },
    "colab_type": "code",
    "id": "bmQeCNHfGWGt",
    "outputId": "5889370b-7c93-42fb-a5c9-bbf7f2347ece"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A\n",
      "v\n",
      "i\n",
      "s\n",
      "o\n",
      " \n",
      "a\n",
      " \n",
      "n\n",
      "a\n",
      "v\n",
      "e\n",
      "g\n",
      "a\n",
      "n\n",
      "t\n",
      "e\n",
      "s\n",
      "!\n",
      "!\n",
      "!\n"
     ]
    }
   ],
   "source": [
    "x = \"Aviso a navegantes!!!\"\n",
    "for i in x:\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "But there is a universal way! Any iterable can be indexed, just as we did with lists and strings, that is, we can directly access the `i`-th element of the list using `[i]` after its name. Well, then we can iterate over the indices and whenever we need the `i`-th element of an iterable or another, we just access it!\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2.3 y\n",
      "4.5 a\n",
      "9.8 t\n",
      "10.2 u\n",
      "9 s\n",
      "35.8\n"
     ]
    }
   ],
   "source": [
    "l=[2.3, 4.5, 9.8, 10.2, 9]\n",
    "s=\"yatusabehlapeseerre\"\n",
    "\n",
    "x=0\n",
    "for j in range(5):\n",
    "    print(f\"{l[j]} {s[j]}\")\n",
    "    x+=l[j]\n",
    "\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "But there are Python functions that can help us make it easier to read"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "76EucokjNHnV"
   },
   "source": [
    "\n",
    "*   `enumerate(<iterable>)`: It takes an iterable and it will output pairs of values (again as an iterable), being the index position `i` and the `i`-th value. \n",
    "\n",
    "The best way to understand what it does is with an example. **Note** that we have now **two** variables!\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 90
    },
    "colab_type": "code",
    "id": "Z8DpOllaNBzt",
    "outputId": "58e2f04a-2e4b-4b62-ba29-5e700fb14755"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The index 0 The iterand s\n",
      "The index 1 The iterand i\n",
      "The index 2 The iterand l\n",
      "The index 3 The iterand e\n",
      "The index 4 The iterand n\n",
      "The index 5 The iterand c\n",
      "The index 6 The iterand i\n",
      "The index 7 The iterand s\n",
      "The index 8 The iterand i\n",
      "The index 9 The iterand s\n",
      "The index 10 The iterand p\n",
      "The index 11 The iterand l\n",
      "The index 12 The iterand a\n",
      "The index 13 The iterand u\n"
     ]
    }
   ],
   "source": [
    "word = \"silencisisplau\"\n",
    "for a,b in enumerate(word):\n",
    "    print(f\"The index {a} The iterand {b}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If I just set one variable, it will be a sort of list (technically, a *tuple*, another iterable type) that contains the two."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(0, 6)\n",
      "0\n",
      "6\n",
      "(1, 3.5)\n",
      "1\n",
      "3.5\n",
      "(2, 7.4)\n",
      "2\n",
      "7.4\n"
     ]
    }
   ],
   "source": [
    "l=[6, 3.5, 7.4]\n",
    "for x in enumerate(l):\n",
    "    print(x)\n",
    "    print(x[0])\n",
    "    print(x[1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "P8g26jUx555F"
   },
   "source": [
    "In order to iterate two or more iterables at the same time, we can use:\n",
    "\n",
    "*   `zip(<iterable1>, <iterable2>,...)`: Returns pairs of elements being the paired elements of both iterables.   \n",
    "\n",
    "  **Note**: The loop repeats as many times as the shortest iterable"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 90
    },
    "colab_type": "code",
    "id": "ZtP7duuANnze",
    "outputId": "44441333-ac1a-4a5e-b3ce-40343e9c9dfb"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "h a I\n",
      "o d  \n",
      "l e h\n",
      "a u a\n"
     ]
    }
   ],
   "source": [
    "w1 = \"hola\"\n",
    "w2 = \"adeu\"\n",
    "w3 = \"I had enough!\"\n",
    "for i,j,k in zip(w1,w2,w3):\n",
    "    print(i,j,k)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 90
    },
    "colab_type": "code",
    "id": "Ea2kqsJe95oL",
    "outputId": "f459c05a-8384-4d8d-fd50-879d6295e525"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "h llenties 101 4\n",
      "o Sakon 102 3\n",
      "l [1, 2, 3] 103 2\n",
      "a 236 104 1\n"
     ]
    }
   ],
   "source": [
    "l1 = \"hola\"\n",
    "l2 = [\"llenties\",\"Sakon\",[1,2,3],236]\n",
    "l3 = [101,102,103,104]\n",
    "l4 = range(4,-1,-1)\n",
    "for i,j,k,z in zip(l1,l2,l3,l4):\n",
    "    print(i,j,k,z)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Note**: The loop repeats itself with the length of the shortest iterable."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Nano-Exercise 2: Compute the final grade for every student and save it into a list\n",
    "Note the `round(x, decimals)` function allows us to round a number `x` with `decimal` decimal places."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The final grades are [6.69, 7.4, 7.36, 7.36],\n",
      " with an average 7.202\n"
     ]
    }
   ],
   "source": [
    "w = [0.3,0.3,0.2,.1,.1] #weights for exam1,exam2 ... respectively\n",
    "exam1 = [4.9,7,8.2,9]\n",
    "exam2 = [7,7,6.8,4.9]\n",
    "pract1 = [9.1,7,8,7.9]\n",
    "pract2 = [9,10,4.6,8.2]\n",
    "pract3 = [4,8,8,7.9]\n",
    "\n",
    "average=0\n",
    "final_grades = []\n",
    "for i,j,k,l,m in zip(exam1,exam2,pract1,pract2,pract3):\n",
    "    final_grades.append( round( i*w[0]+j*w[1]+k*w[2]+l*w[3]+m*w[4], 2) )\n",
    "    average+=final_grades[-1]\n",
    "average/=len(exam1)\n",
    "\n",
    "print(f\"The final grades are {final_grades},\\n with an average {average:.4}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There are better ways to do this, but this is already functional!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "9XnUA9h7rXsf"
   },
   "source": [
    "# Extra: List Comprehension"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "S66vJmOtrryI"
   },
   "source": [
    "It might be annoying to need to write several lines of code inside a `for` only to generate the components of a list.\n",
    "List comprehensions provide a concise way to do this. They allow you to create a list that requires a `for` loop in its creation, all in a single line of code. Neat."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "VuW2OdnhsNXW"
   },
   "source": [
    "The general template for a list comprehension is\n",
    "\n",
    "`my_list = [ <expression_involving_var> for <var> in <iterable> if <condition_involving_var> ]  `\n",
    "\n",
    "It is best to see an example to understand this. \n",
    "\n",
    "The following two cells generate the exact same list containing the squares of the first 9 numbers that are even."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "id": "tPhTXJ49rbRP",
    "outputId": "71784829-aaca-4d20-83f5-a3dc7020d7ef",
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 4, 16, 36, 64]\n"
     ]
    }
   ],
   "source": [
    "# the standard way to do this\n",
    "l = []\n",
    "for i in range(10):\n",
    "    if i%2==0:\n",
    "        l.append(i**2)\n",
    "print(l)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "id": "tPhTXJ49rbRP",
    "outputId": "71784829-aaca-4d20-83f5-a3dc7020d7ef",
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 4, 16, 36, 64]\n"
     ]
    }
   ],
   "source": [
    "# All in a single line\n",
    "l = [i**2 for i in range(10) if i%2==0]\n",
    "print(l)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you do not write a condition it will be applied to all the elements."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]\n"
     ]
    }
   ],
   "source": [
    "# All in a single line\n",
    "l = [ i**2 for i in range(10) ]\n",
    "print(l)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "qHu_NRXEecik"
   },
   "source": [
    "Or another example, a sub-list with the names that start from a vowel."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "id": "3EumfSVrwCwv",
    "outputId": "0492fd08-41d0-488d-edba-0a60b02375ed"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Aitor', 'Agustí', 'Imma', 'Olga']\n"
     ]
    }
   ],
   "source": [
    "all_names = [\"Fina\", \"Verónica\", \"Aitor\", \"Agustí\", \"Imma\", \"Olga\"]\n",
    "\n",
    "vowel_names = [ name for name in all_names if name[0] in ['A', 'E', 'I', 'O', 'U'] ] \n",
    "print(vowel_names)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Lifehack: in**\n",
    "\n",
    "Note that we used the special operator `in`. This takes a value in the left and checks `==` with all the elements in the iterable on its the right. If one of them outputs `True` then the output is `True`, else, it is `False`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "print( 'w' in ['www.scn2.cat', 'w', 'hey'] )\n",
    "print( 'w' in ['www.scn2.cat', 'o', 'hey'] )\n",
    "print( 'w' in 'www.scn2.cat' )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Nano-Exercise 2 again, but now with list comprehension"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[6.69, 7.4, 7.36, 7.36]\n"
     ]
    }
   ],
   "source": [
    "w = [0.3,0.3,0.2,0.1,0.1] #weights for exam1,exam2 ... respectively\n",
    "exam1 = [4.9,7,8.2,9]\n",
    "exam2 = [7,7,6.8,4.9]\n",
    "pract1 = [9.1,7,8,7.9]\n",
    "pract2 = [9,10,4.6,8.2]\n",
    "pract3 = [4,8,8,7.9]\n",
    "\n",
    "final_grades = [ round( i*w[0]+j*w[1]+k*w[2]+l*w[3]+m*w[4], 2) for i,j,k,l,m in zip(exam1,exam2,pract1,pract2,pract3) ]\n",
    "\n",
    "print(final_grades)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Lifehack: Break code line!**\n",
    "\n",
    "Note that you can divide a line of code in multiple lines, for easier readability, with a backslash `\\`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [],
   "source": [
    "final_grades = \\\n",
    "     [ \n",
    "        round( i*w[0]+j*w[1]+k*w[2]+l*w[3]+m*w[4], 2)  \\\n",
    "                for i,j,k,l,m \\\n",
    "                      in zip(exam1,exam2,pract1,pract2,pract3) \n",
    "     ]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "_b3iMm5AkKxm"
   },
   "source": [
    "---\n",
    "<a id='2'></a>\n",
    "## (2.) The While Loop\n",
    "The **slogan** is *while [this] is True, execute the block of code, over and over*.\n",
    "\n",
    "Structure:\n",
    "\n",
    "        while <boolean_expression>:       \n",
    "            Block of code to repeat\n",
    "\n",
    "As long as the condition is `True`, the block of code will be repeated (even for ever if it is never `False`! So be careful!)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a = 5 b = 9\n",
      "a = 6 b = 8\n",
      "a = 7 b = 7\n",
      "a = 8 b = 6\n",
      "a = 9 b = 5\n",
      "a = 10 b = 4\n",
      "a = 11 b = 3\n",
      "a = 12 b = 2\n",
      "a = 13 b = 1\n",
      "a = 14 b = 0\n"
     ]
    }
   ],
   "source": [
    "a = 5\n",
    "b = 9\n",
    "while a<10 or b>=0:\n",
    "    print(\"a =\",a,\"b =\",b)\n",
    "    a = a + 1\n",
    "    b = b - 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "JZ9wpsLAktr3"
   },
   "source": [
    "In the next example, the while loop will act as a `for` in `range(10)`:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 201
    },
    "colab_type": "code",
    "id": "NYONGzlzk2ti",
    "outputId": "c0c37de8-2cc0-4dc4-dcfe-5a74d0ecba34"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n",
      "6\n",
      "7\n",
      "8\n",
      "9\n"
     ]
    }
   ],
   "source": [
    "i = 0\n",
    "while i<10:\n",
    "    print(i)\n",
    "    i = i + 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Of course, unlike in the case of a `for`, if the variables that we make reference to in the condition are not defined still, they will not appear out of the blue! There is no clue for the machine as for what their value should be! So take care to make sure that the variables are already defined or else you will get an error.\n",
    "\n",
    "**Also** importantly, the value of those variables is **not** reset every iteration!\n",
    "\n",
    "### Nano-Exercise 3: \n",
    "Ask the user for a string and tell them in which position happens the letter `a` (all using while loops). If the user introduces a string that does not contain `a`, keep asking them for a string that does, until they input it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "> Give me a string with 'a' and I can tell you where the letter 'a' happens! :\n",
      "why?\n",
      "\n",
      "There was no 'a' there!\n",
      "> Give me a string with 'a' and I can tell you where the letter 'a' happens!:\n",
      "no\n",
      "\n",
      "There was no 'a' there!\n",
      "> Give me a string with 'a' and I can tell you where the letter 'a' happens!:\n",
      "okaay\n",
      "\n",
      "> The letter 'a' happens for the first time in the position 2 in \n",
      "\n",
      "okaay\n"
     ]
    }
   ],
   "source": [
    "string = input(\"> Give me a string with 'a' and I can tell you where the letter 'a' happens! :\\n\")\n",
    "while not 'a' in string:\n",
    "    print(\"\\nThere was no 'a' there!\")\n",
    "    string = input(\"> Give me a string with 'a' and I can tell you where the letter 'a' happens!:\\n\")\n",
    "\n",
    "i = 0\n",
    "while(string[i]!='a'):\n",
    "    i += 1\n",
    "\n",
    "print(f\"\\n> The letter 'a' happens for the first time in the position {i} in \\n\\n{string}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 35
    },
    "colab_type": "code",
    "id": "rqQQyywImYkx",
    "outputId": "14e64293-5e76-4b9a-dc38-793ad4ca701e"
   },
   "source": [
    "**Lifehack: A Menu**\n",
    "\n",
    "And this is how one can generate a user interface **menu**!\n",
    "\n",
    "You offer the user what your code is capable of doing, and ask them to choose an option. You keep asking until they input a reasonable option, and stop asking when they choose the exit option!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### A Seemingly bad idea\n",
    "\n",
    "`while True:`\n",
    "\n",
    "Since the while loop continues while the expression inside is `True`, if one places directly a `True` there, it will run forever!!!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## (1. & 2.): Nested Loops\n",
    "\n",
    "Of course, it is possible to nest loops inside other loops, be them of one or the other kind. Just as it was possible to nest `if/elif/else` conditions without bounds.\n",
    "\n",
    "For example, let us use a nested `for` set to generate all the possible combinations of the elements of some lists."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {},
   "outputs": [],
   "source": [
    "names = [ \"Gandalf\", \"Goku\", \"Misa\"]\n",
    "surnames1 = [\"Potter\", \"Daimaku\", \"Uzumaki\"]\n",
    "surnames2 = [ \"Nobi\", \"Stark\", \"Kenobi\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Gandalf Potter Nobi\n",
      "Gandalf Potter Stark\n",
      "Gandalf Potter Kenobi\n",
      "Gandalf Daimaku Nobi\n",
      "Gandalf Daimaku Stark\n",
      "Gandalf Daimaku Kenobi\n",
      "Gandalf Uzumaki Nobi\n",
      "Gandalf Uzumaki Stark\n",
      "Gandalf Uzumaki Kenobi\n",
      "Goku Potter Nobi\n",
      "Goku Potter Stark\n",
      "Goku Potter Kenobi\n",
      "Goku Daimaku Nobi\n",
      "Goku Daimaku Stark\n",
      "Goku Daimaku Kenobi\n",
      "Goku Uzumaki Nobi\n",
      "Goku Uzumaki Stark\n",
      "Goku Uzumaki Kenobi\n",
      "Misa Potter Nobi\n",
      "Misa Potter Stark\n",
      "Misa Potter Kenobi\n",
      "Misa Daimaku Nobi\n",
      "Misa Daimaku Stark\n",
      "Misa Daimaku Kenobi\n",
      "Misa Uzumaki Nobi\n",
      "Misa Uzumaki Stark\n",
      "Misa Uzumaki Kenobi\n"
     ]
    }
   ],
   "source": [
    "for name in names:\n",
    "    for surname1 in surnames1:\n",
    "        for surname2 in surnames2:\n",
    "            print(f\"{name} {surname1} {surname2}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Make sure you understand why the next thing does not work!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Gandalf Potter Nobi\n",
      "Goku Daimaku Stark\n",
      "Misa Uzumaki Kenobi\n"
     ]
    }
   ],
   "source": [
    "for name, surname1, surname2 in zip(names, surnames1, surnames2):\n",
    "    print(f\"{name} {surname1} {surname2}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Nano-Exercise 4.1:\n",
    "\n",
    "Given the list `words`, create another list with the position of the words where a vowel appears for the first time. \n",
    "\n",
    "If there is none, assume `-1`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {},
   "outputs": [],
   "source": [
    "words = [\"solid\", \"state\", \"is\", \"my\", \"worst\", \"nightmare\", \"Then\", \"wait\", \"for\", \"liquid\", \"state\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 0, -1, 1, 1, 2, 1, 1, 1, 2]\n"
     ]
    }
   ],
   "source": [
    "positions=[]\n",
    "\n",
    "for word in words: # you know that all the words will need to be iterated over\n",
    "    k=0\n",
    "    while (k<len(word)) and (not word[k] in \"aeiou\"): # note that the other way around it would fail!\n",
    "        k+=1\n",
    "    if k==len(word):\n",
    "        k=-1 # there was no vowel!\n",
    "    positions.append(k)\n",
    "    i+=1\n",
    "print(positions)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "jTRLymhIUJAG"
   },
   "source": [
    "## (1. & 2.): Break and Continue"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "fMnRAtzu55lE"
   },
   "source": [
    "The `break` and `continue` orders are used to give either `for` or `while` loops greater flexibility, allowing one to altere the normal flow of the loops."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "Pn4l-eSwU9df"
   },
   "source": [
    "### Break\n",
    "With the `break` statement we can force the loop to stop its iterations and exit the closest loop's indented block immediately (closest in terms of indentation levels). \n",
    "\n",
    "That is, even if the condition for a `while` loop may still be `True` or the last iteration of a `for`loop has not been reached, the code execution jumps immediately to the next line outside the closest loop's indentation level."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 52
    },
    "colab_type": "code",
    "id": "6BWY4VpcnBEr",
    "outputId": "9992451c-61d2-43a9-bffb-a64ae59842f1"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "x = 1\n",
    "while True:\n",
    "    x = x*2\n",
    "    if(x>5):\n",
    "        break\n",
    "    print(hola)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Can you guess why the list in the penultimate list is not printed while the last one is?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 199
    },
    "colab_type": "code",
    "id": "0Xsrb5jrJgDw",
    "outputId": "8df2c46c-d412-4873-a0cd-ac8fda8a1823"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n",
      "-\n",
      "a\n",
      "e\n",
      "i\n",
      "-\n",
      "-\n",
      "7\n",
      "8\n",
      "9\n",
      "-\n"
     ]
    }
   ],
   "source": [
    "m = [[1,2,3],['a','e','i'], [4,5,6],[7,8,9]]\n",
    "for k, lista in enumerate(m):\n",
    "    for j in lista:\n",
    "        if k==2:\n",
    "            break\n",
    "        print(j)\n",
    "    print(\"-\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You are right! Only the closest loop is broken! That is, we would need two `break` statements to stop it all."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n",
      "-\n",
      "a\n",
      "e\n",
      "i\n",
      "-\n",
      "4\n",
      "5\n",
      "6\n"
     ]
    }
   ],
   "source": [
    "m = [[1,2,3],['a','e','i'], [4,5,6],[7,8,9]]\n",
    "out=False\n",
    "for k, lista in enumerate(m):\n",
    "    for j in lista:\n",
    "        if k==2:\n",
    "            out=True\n",
    "            break\n",
    "        print(j)\n",
    "    if out:\n",
    "        break\n",
    "    print(\"-\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Nano-Exercise 4.2: Now Using Only For Loops\n",
    "\n",
    "Given the list `words`, create another list with the position of the words where a vowel appears for the first time. \n",
    "If there is none, assume `-1`.\n",
    "\n",
    "**Do it using exclusively `for` loops!**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [],
   "source": [
    "words = [\"solid\", \"state\", \"is\", \"my\", \"worst\", \"nightmare\", \"Then\", \"wait\", \"for\", \"liquid\", \"state\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 0, -1, 1, 1, 2, 1, 1, 1, 2]\n"
     ]
    }
   ],
   "source": [
    "positions=[]\n",
    "for num_word, word in enumerate(words):\n",
    "    for k, letter in enumerate(word):\n",
    "        if letter in \"aeiou\":\n",
    "            positions.append(k)\n",
    "            break\n",
    "        if len(positions)!=num_word: # it means that no letter was a vowel!\n",
    "            positions.append(-1)\n",
    "print(positions)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "1Tl_Ui6IXjA9"
   },
   "source": [
    "### Continue\n",
    "With the `continue` statement, the execution is forced to immediately jump to the next iteration of the closest loop (in terms of indentation levels), even if in the same block there were still more lines below the `continue`. That is, the loop is not broken, but forced to go to the next iteration.\n",
    "\n",
    "For example here, in the iteration where `i==3`, the code below (the `print`) is skipped and the loop continues in the next iteration."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 86
    },
    "colab_type": "code",
    "id": "Bxf3ZX2a4b-q",
    "outputId": "d4fa9bc0-c3a8-4d8f-b740-b4505ed6646a"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "4\n",
      "5\n"
     ]
    }
   ],
   "source": [
    "i = 0\n",
    "while(i<5):\n",
    "    i += 1\n",
    "    if(i==3):\n",
    "        continue\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Nano-Exercise 5:\n",
    "\n",
    "Print all the numbers in the lists except when they are equal to 4."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n",
      "-\n",
      "5\n",
      "6\n",
      "-\n",
      "7\n",
      "9\n",
      "-\n"
     ]
    }
   ],
   "source": [
    "m = [[1,2,3],[4,5,6],[7,4,9]]\n",
    "for i in range(len(m)):\n",
    "    for j in range(len(m[0])):\n",
    "        if(m[i][j]==4):\n",
    "            continue\n",
    "        print(m[i][j])\n",
    "    print(\"-\")"
   ]
  }
 ],
 "metadata": {
  "colab": {
   "collapsed_sections": [],
   "name": "SesionTwo.ipynb",
   "provenance": []
  },
  "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.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}