L2_conditionals_and_cycles.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "095b3ade",
   "metadata": {},
   "source": [
    "## Conditionals\n",
    "\n",
    "Executes an instruction or a group of instructions if some *condition* is (or is *not*) satisfied. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "44d85508",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a is larger than 5\n"
     ]
    }
   ],
   "source": [
    "# Print a message only if a is greater then 5 \n",
    "\n",
    "a=10\n",
    "if a > 5: \n",
    "   print(\"a is larger than 5\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "4647698f",
   "metadata": {},
   "outputs": [],
   "source": [
    "# In this case, nothing will be printed\n",
    "\n",
    "a=4\n",
    "if a > 5: print(\"a is larger than 5\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "a43d6fe4",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a is lower than 5\n"
     ]
    }
   ],
   "source": [
    "# Here, an alternative is given...\n",
    "\n",
    "a=4\n",
    "\n",
    "if a > 5:\n",
    "    print(\"a is larger than 5\")\n",
    "else:\n",
    "    print(\"a is lower than 5\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "137ba3e5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a is lower than 5\n"
     ]
    }
   ],
   "source": [
    "# Pay attention...\n",
    "\n",
    "a=5\n",
    "\n",
    "if a > 5:\n",
    "    print(\"a is larger than 5\")\n",
    "else:\n",
    "    print(\"a is lower than 5\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "59018ea8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a is equal to 5\n"
     ]
    }
   ],
   "source": [
    "# Now it is better...\n",
    "\n",
    "a=5\n",
    "\n",
    "if a > 5:\n",
    "    print(\"a is larger than 5\")\n",
    "elif a < 5:\n",
    "    print(\"a is lower than 5\")\n",
    "else:\n",
    "    print(\"a is equal to 5\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8d53fae3",
   "metadata": {},
   "source": [
    "Comparison operators:\n",
    "\n",
    "```\n",
    ">, <, >=, <=, ==, !=\n",
    "\n",
    "```\n",
    "Note that the *equal* test is ```==``` (that is: not just ```=```, that would instead be an *assignment*); the last test (```!=```) means *not equal*."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "23a32e3c",
   "metadata": {},
   "source": [
    "In more recent versions of Python (from 3.10), the *match/case* construct has been implemented.\n",
    "\n",
    "Note: how to check the *Python version*: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "6d8fc41c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3.11.5 | packaged by Anaconda, Inc. | (main, Sep 11 2023, 13:26:23) [MSC v.1916 64 bit (AMD64)]\n"
     ]
    }
   ],
   "source": [
    "import sys   # import the sys library (sys stands for system)\n",
    "print(sys.version)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8149f44d",
   "metadata": {},
   "source": [
    "Since the Python version is newer than the 3.10, here is the *match/case* construct:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "26887e2e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Quite recent 3.11 version\n"
     ]
    }
   ],
   "source": [
    "version = sys.version[0:4]\n",
    "\n",
    "match version:\n",
    "    case '2.9':\n",
    "        print(\"Old version 2.9\")\n",
    "    case '3.10':\n",
    "        print(\"version 3.10\")\n",
    "    case '3.11':\n",
    "        print(\"Quite recent 3.11 version\")\n",
    "    case other:\n",
    "        print(\"Some undefined version\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dd39fd42",
   "metadata": {},
   "source": [
    "### Comparing numbers: some notes about precision\n",
    "\n",
    "When comparing two numbers, always pay attention to situations like the following one (in the preceeding lecture we already encountered some issues with reference to *precision* and *type* of variables)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "9938a262",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n"
     ]
    }
   ],
   "source": [
    "a=1.\n",
    "b=1.00000001\n",
    "\n",
    "print(a == b)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3ae36b9f",
   "metadata": {},
   "source": [
    "The usual way to handle this is:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "c69fc107",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a is equal to b (within the threshold)\n"
     ]
    }
   ],
   "source": [
    "threshold=1e-6\n",
    "\n",
    "a=1.\n",
    "b=1.00000001\n",
    "\n",
    "if (abs(a-b) < threshold):  # abs(x) is the absolute value of x\n",
    "    print(\"a is equal to b (within the threshold)\")\n",
    "else:\n",
    "    print(\"a is not equal to b\")\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5921954d",
   "metadata": {},
   "source": [
    "### An aside on errors and exceptions..."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "63fcef10",
   "metadata": {},
   "source": [
    "But, what if *b* (or some other tested parameter) is not defined!?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "51410646",
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'b' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "Cell \u001b[1;32mIn[10], line 2\u001b[0m\n\u001b[0;32m      1\u001b[0m \u001b[38;5;28;01mdel\u001b[39;00m(b)     \u001b[38;5;66;03m# remove the variable b from memory\u001b[39;00m\n\u001b[1;32m----> 2\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m b \u001b[38;5;241m>\u001b[39m \u001b[38;5;241m5\u001b[39m:\n\u001b[0;32m      3\u001b[0m     \u001b[38;5;28mprint\u001b[39m(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mb is greater than 5\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n",
      "\u001b[1;31mNameError\u001b[0m: name 'b' is not defined"
     ]
    }
   ],
   "source": [
    "del(b)     # remove the variable b from memory\n",
    "if b > 5:\n",
    "    print(\"b is greater than 5\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6c1229f0",
   "metadata": {},
   "source": [
    "You see: you got an **NameError** type of... *error*\n",
    "\n",
    "If you foresee that this is a possible cause of error in your code, you can handle it by coding what the *reaction* of the code itself should be (not just to write a *dreadful* error message and stop...).\n",
    "\n",
    "We have the *try/except* construct to help us in these situations:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "7640eeb4",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "I don't know what b is\n"
     ]
    }
   ],
   "source": [
    "try:\n",
    "    if b > 5:\n",
    "        print(\"b is greater then 5\")  \n",
    "except NameError:\n",
    "    print(\"I don't know what b is\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ce713a20",
   "metadata": {},
   "source": [
    "Here a slightly more complex situation where there is not a *NameError* (that would be handled as before), but we try to divide by 0..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "37768f68",
   "metadata": {},
   "outputs": [
    {
     "ename": "ZeroDivisionError",
     "evalue": "division by zero",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mZeroDivisionError\u001b[0m                         Traceback (most recent call last)",
      "Cell \u001b[1;32mIn[12], line 4\u001b[0m\n\u001b[0;32m      1\u001b[0m c\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m10\u001b[39m\n\u001b[0;32m      2\u001b[0m e\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m0\u001b[39m\n\u001b[1;32m----> 4\u001b[0m \u001b[38;5;28mprint\u001b[39m(c\u001b[38;5;241m/\u001b[39me)\n",
      "\u001b[1;31mZeroDivisionError\u001b[0m: division by zero"
     ]
    }
   ],
   "source": [
    "c=10\n",
    "e=0\n",
    "\n",
    "print(c/e)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2f7a3f3c",
   "metadata": {},
   "source": [
    "We had a **ZeroDivisionError**; we could handle it with:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "c5a96b46",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "You are trying to divide by zero\n"
     ]
    }
   ],
   "source": [
    "c=10\n",
    "e=0\n",
    "\n",
    "try:\n",
    "    d=c/e\n",
    "    print(\"d is \",d)\n",
    "except ZeroDivisionError:\n",
    "    print(\"You are trying to divide by zero\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b07a9209",
   "metadata": {},
   "source": [
    "More than one exception can be implemented:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "c64fc053",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "You are trying to divide by zero\n"
     ]
    }
   ],
   "source": [
    "c=10\n",
    "e=0\n",
    "\n",
    "try:\n",
    "    d=c/e\n",
    "    print(\"The value of c/e is: %4.2f\" % d)\n",
    "except ZeroDivisionError:\n",
    "    print(\"You are trying to divide by zero\") \n",
    "except NameError:\n",
    "    print(\"Some variable is not defined\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "76def90b",
   "metadata": {},
   "source": [
    "---- **Close of the *Aside*** ---- \n",
    "\n",
    "Conditions can be evaluated to *True* or *False* before the conditional expression is executed. \n",
    "\n",
    "In this case we use the Python function *all* to check if all of the elements of the *a* list are *True* (note that there exists the function *any* that checks if *at least one* element is *True*); the function *all* returns a *bool*:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "df668913",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Boolean array a:  [ True  True False  True False]\n",
      "Result of the 'all' function on the array 'a': False \n",
      "\n",
      "At least one element of the list is False\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "a=np.array([1,1,0,1,0], dtype=bool)\n",
    "test = all(a)\n",
    "\n",
    "print(\"Boolean array a: \", a)\n",
    "print(\"Result of the 'all' function on the array 'a': %r \\n\" % test)\n",
    "\n",
    "if test:\n",
    "    print(\"All of the elements of the list are True\")\n",
    "else:\n",
    "    print(\"At least one element of the list is False\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f79c40bf-effa-4571-91c7-f607720e740b",
   "metadata": {},
   "source": [
    "Among the operators that act on boolean's, the *not* operator returns the *negation* of a boolean variable:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "c048751e-0ad2-41f5-b262-1650c02a1344",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n"
     ]
    }
   ],
   "source": [
    "test = True\n",
    "print(not test)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b6dd4bf3-86dd-4097-abb2-e4d3a4cd5083",
   "metadata": {},
   "source": [
    "This can be used as:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "ff7a51c9-9654-444e-9684-eb9250f40573",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "First implementation\n",
      "a is not equal to b\n",
      "\n",
      "Second implementation\n",
      "a is not equal to b\n"
     ]
    }
   ],
   "source": [
    "a=10\n",
    "b=12\n",
    "\n",
    "if a!=b:\n",
    "   print(\"First implementation\")\n",
    "   print(\"a is not equal to b\")\n",
    "\n",
    "if not(a==b):\n",
    "   print(\"\\nSecond implementation\")\n",
    "   print(\"a is not equal to b\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9c35a32f",
   "metadata": {},
   "source": [
    "## Cycles\n",
    "\n",
    "**How to perform one or more instructions several times, in a *cycle*?** \n",
    "\n",
    "The most common way is to use a **for** *loop*:  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "9f4a32ff",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a\n",
      "b\n",
      "c\n"
     ]
    }
   ],
   "source": [
    "a=['a', 'b', 'c']\n",
    "\n",
    "# The 'for' loop goes on all the elements of the list 'a'\n",
    "# and executes the instruction(s) written within it\n",
    "# (that is: all the instructions written below with the appropriate\n",
    "# indentation). The variable 'ia' is named 'the loop variable' and,\n",
    "# for each i-th cycle, takes the value a[i-th]\n",
    "\n",
    "for ia in a:\n",
    "    print(ia)   # Do it for all of the elements in the list 'a'"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2cef762d",
   "metadata": {},
   "source": [
    "Here is another way of *looping*:\n",
    "- we have our list *a*; \n",
    "- we find the *size* (number of elements) of it; \n",
    "- we build a list of integers from 0 to the size of the list (diminished by 1, as we start indexing the list from 0...)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "571c213f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "range(0, 3) [0, 1, 2]\n"
     ]
    }
   ],
   "source": [
    "size=len(a)\n",
    "ll=range(size)\n",
    "print(ll, list(ll))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dee0b30a",
   "metadata": {},
   "source": [
    "... then we make a *loop* over all the indexes (integers in the list *ll*); we use those indexes to retrieve the values of the elements in the list *a* (and we print them):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "1cf952e6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a\n",
      "b\n",
      "c\n"
     ]
    }
   ],
   "source": [
    "for ia in ll:\n",
    "    print(a[ia])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d323f911",
   "metadata": {},
   "source": [
    "Here is another example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "9e9829fc",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "abc\n"
     ]
    }
   ],
   "source": [
    "ss=''\n",
    "for ia in a:\n",
    "    ss=ss+ia\n",
    "\n",
    "print(ss)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "07dff497",
   "metadata": {},
   "source": [
    "Let's compute the *factorial* of a number: $n! = n(n-1)(n-2)\\cdots 2\\cdot 1$ "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "7e6742b6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3628800\n"
     ]
    }
   ],
   "source": [
    "n=10\n",
    "factorial=1\n",
    "\n",
    "for i in range(n+1):\n",
    "    if i != 0:\n",
    "       factorial=factorial*i\n",
    "\n",
    "print(factorial)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0e5e4929",
   "metadata": {},
   "source": [
    "A more efficient way avoids the use of a conditional at every step of the cycle... "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "74a896f4",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n",
      "factorial of  10:    3628800\n"
     ]
    }
   ],
   "source": [
    "n=10\n",
    "factorial=1\n",
    "ll=range(1,n+1)   # range from 1 to n+1\n",
    "print(list(ll))\n",
    "\n",
    "for i in ll:\n",
    "    factorial=factorial*i\n",
    "\n",
    "print(\"factorial of %3i: %10i\" % (n, factorial))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "882ec82d",
   "metadata": {},
   "source": [
    "### *Breaking* cycles\n",
    "\n",
    "**break** and **continue**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "ba32775c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "I do not stop as I did not find any 0 till now!\n",
      "2\n",
      "I do not stop as I did not find any 0 till now!\n",
      "\n",
      "I landed outside of the cycle as I found a 0\n"
     ]
    }
   ],
   "source": [
    "# Use of break\n",
    "\n",
    "a=[1,2,0,3,4]\n",
    "\n",
    "for ia in a:\n",
    "    if ia != 0:\n",
    "        print(ia)\n",
    "    else:\n",
    "        break\n",
    "        \n",
    "    print(\"I do not stop as I did not find any 0 till now!\")\n",
    "    \n",
    "print(\"\\nI landed outside of the cycle as I found a 0\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "062b2c6e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Value of the element  1:  4\n",
      "I proceed to the next step\n",
      "Value of the element  2:  2\n",
      "I proceed to the next step\n",
      "\n",
      "*** I found a 0 in position:  3\n",
      "Never mind of the zero: I proceed to the next step anyway\n",
      "\n",
      "Value of the element  4:  1\n",
      "I proceed to the next step\n",
      "\n",
      "*** I found a 0 in position:  5\n",
      "Never mind of the zero: I proceed to the next step anyway\n",
      "\n",
      "Value of the element  6:  2\n",
      "I proceed to the next step\n",
      "\n",
      "End of the cycle\n"
     ]
    }
   ],
   "source": [
    "# Use of continue\n",
    "\n",
    "a=[4,2,0,1,0,2]\n",
    "\n",
    "ipos=0\n",
    "for ia in a:\n",
    "    ipos=ipos+1\n",
    "    if ia != 0:\n",
    "        print(\"Value of the element %2i: %2i\" % (ipos, ia))\n",
    "    else:\n",
    "        print(\"\\n*** I found a 0 in position: %2i\" % ipos)\n",
    "        print(\"Never mind of the zero: I proceed to the next step anyway\\n\")\n",
    "        continue\n",
    "        \n",
    "    print(\"I proceed to the next step\")\n",
    "    \n",
    "print(\"\\nEnd of the cycle\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5a21f7c2",
   "metadata": {},
   "source": [
    "### The *while* cycle"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "b8d87bda",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "jn, product:  1 1\n",
      "jn, product:  2 2\n",
      "jn, product:  3 6\n",
      "jn, product:  4 24\n",
      "jn, product:  5 120\n",
      "jn, product:  6 720\n",
      "\n",
      "Factorial of   6:        720\n"
     ]
    }
   ],
   "source": [
    "n=6\n",
    "factorial=1\n",
    "\n",
    "jn=1\n",
    "while jn <= n:\n",
    "    factorial=factorial*jn   \n",
    "    print(\"jn, product: \", jn, factorial)\n",
    "    jn=jn+1\n",
    "    \n",
    "print(\"\\nFactorial of %3i: %10i\" % (n,factorial))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "18b67f7c",
   "metadata": {},
   "source": [
    "### A different way to write a *for* loop... \n",
    "\n",
    "We already encountered a situation like this one:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "d8a90ddd",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[12, 23, 34, 45]\n"
     ]
    }
   ],
   "source": [
    "a=[10, 20, 30, 40]\n",
    "b=[2, 3, 4, 5]\n",
    "c=[]\n",
    "\n",
    "for ia, ib in zip(a, b):\n",
    "    ic=ia+ib\n",
    "    c.append(ic)\n",
    "    \n",
    "print(c)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6c8c40e0",
   "metadata": {},
   "source": [
    "This calculation can also be coded in another way:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "69bb7264",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[12, 23, 34, 45]\n"
     ]
    }
   ],
   "source": [
    "c=list(ia + ib for ia, ib in zip(a,b))\n",
    "print(c)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ba8bec21",
   "metadata": {},
   "source": [
    "Note a few things..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "1ffa538a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The type of d is:  <class 'generator'>\n"
     ]
    }
   ],
   "source": [
    "a=[10, 20, 30, 40]\n",
    "d=(ia for ia in a)\n",
    "\n",
    "print(\"The type of d is: \", type(d))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6912d2f7",
   "metadata": {},
   "source": [
    "We can get the list generated by the generator *d* with:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "2cba5ed9",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[10, 20, 30, 40]"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(d)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dd01d41c",
   "metadata": {},
   "source": [
    "#### The function next \n",
    "\n",
    "used to *generate* values from the *generators* (one value at a time):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "2a23895f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<generator object <genexpr> at 0x000001DFC8C08380>\n",
      "10\n",
      "20\n",
      "30\n",
      "40\n"
     ]
    }
   ],
   "source": [
    "d=(ia for ia in a)\n",
    "print(d)\n",
    "\n",
    "print(next(d))\n",
    "print(next(d))\n",
    "print(next(d))\n",
    "print(next(d))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "da874256",
   "metadata": {},
   "source": [
    "Another way to get same result using a cycle:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "f4bd8a38",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n",
      "20\n",
      "30\n",
      "40\n"
     ]
    }
   ],
   "source": [
    "d=(ia for ia in a)\n",
    "\n",
    "for _ in a:\n",
    "    print(next(d))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "58d0b18b",
   "metadata": {},
   "source": [
    "Note that when we generated all the possible values from the given generator, a new call to the function *next* will produce an error: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "04e777c2",
   "metadata": {},
   "outputs": [
    {
     "ename": "StopIteration",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mStopIteration\u001b[0m                             Traceback (most recent call last)",
      "Cell \u001b[1;32mIn[33], line 1\u001b[0m\n\u001b[1;32m----> 1\u001b[0m \u001b[38;5;28mnext\u001b[39m(d)\n",
      "\u001b[1;31mStopIteration\u001b[0m: "
     ]
    }
   ],
   "source": [
    "next(d)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3f086c55",
   "metadata": {},
   "source": [
    "Note:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "dbc8ad8a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'list'>\n",
      "<class 'generator'>\n",
      "<class 'list'>\n"
     ]
    }
   ],
   "source": [
    "c=list(ia + ib for ia, ib in zip(a,b))\n",
    "d=(ia + ib for ia, ib in zip(a,b))\n",
    "e=[ia + ib for ia, ib in zip(a,b)]\n",
    "\n",
    "print(type(c))\n",
    "print(type(d))\n",
    "print(type(e))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "42dd44da",
   "metadata": {},
   "source": [
    "that is... \n",
    "\n",
    "- c is a *list*\n",
    "- d is a *generator of a list*; you can get the *list* itself by using *list(d)*\n",
    "- e is a *list* (note the use of the *square brackets* instead of *parentheses*). \n",
    "\n",
    "Also the function *range* returns a *generator*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "dd55f7f1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "range(0, 5) <class 'range'>\n",
      "[0, 1, 2, 3, 4]\n"
     ]
    }
   ],
   "source": [
    "f=range(5)\n",
    "\n",
    "print(f, type(f))\n",
    "print(list(f))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a731bacd",
   "metadata": {},
   "source": [
    "Let's have a look at the function *enumerate*:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "12409a83",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "b:  <enumerate object at 0x000001DFC8C585E0> <class 'enumerate'>\n",
      "c:  [(0, 'a'), (1, 'b'), (2, 'c'), (3, 'd')] <class 'list'>\n"
     ]
    }
   ],
   "source": [
    "a=['a', 'b', 'c', 'd']\n",
    "b=enumerate(a)\n",
    "c=list(b)\n",
    "\n",
    "print(\"b: \", b, type(b))\n",
    "print(\"c: \", c, type(c))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "a26cd1be",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(0, 'a')\n",
      "(1, 'b')\n",
      "(2, 'c')\n",
      "(3, 'd')\n"
     ]
    }
   ],
   "source": [
    "a=['a', 'b', 'c', 'd']\n",
    "b=enumerate(a)\n",
    "\n",
    "for _ in a:\n",
    "    print(next(b))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f27724db",
   "metadata": {},
   "source": [
    "Elements generated by the *enumerator* are *tuples* (*immutable lists*) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "id": "91ff61ca",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(0, 'a') <class 'tuple'>\n"
     ]
    }
   ],
   "source": [
    "a=['a', 'b', 'c', 'd']\n",
    "b=enumerate(a)\n",
    "\n",
    "c=next(b)\n",
    "print(c, type(c))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c8764b5d",
   "metadata": {},
   "source": [
    "Indeed, we can address those elements, like:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "id": "d5309ce6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a\n"
     ]
    }
   ],
   "source": [
    "print(c[1])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1820e229",
   "metadata": {},
   "source": [
    "but we cannot reassign them:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "id": "370c9a71",
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "'tuple' object does not support item assignment",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "Cell \u001b[1;32mIn[40], line 1\u001b[0m\n\u001b[1;32m----> 1\u001b[0m c[\u001b[38;5;241m1\u001b[39m]\u001b[38;5;241m=\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mb\u001b[39m\u001b[38;5;124m'\u001b[39m\n",
      "\u001b[1;31mTypeError\u001b[0m: 'tuple' object does not support item assignment"
     ]
    }
   ],
   "source": [
    "c[1]='b'"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a5e96e86-341d-4823-acdc-4797b9050113",
   "metadata": {},
   "source": [
    "Or, if you want, you can implement a *try/except* construct to get an *easy to understand* error message:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "id": "c96181e2-c8fe-40a8-9b48-933a594776d5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "You are trying to modify a tuple\n"
     ]
    }
   ],
   "source": [
    "try:\n",
    "    c[1]='b'\n",
    "except TypeError:\n",
    "    print(\"You are trying to modify a tuple\")"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.11.5"
  },
  "latex_envs": {
   "LaTeX_envs_menu_present": true,
   "autoclose": false,
   "autocomplete": true,
   "bibliofile": "biblio.bib",
   "cite_by": "apalike",
   "current_citInitial": 1,
   "eqLabelWithNumbers": true,
   "eqNumInitial": 1,
   "hotkeys": {
    "equation": "Ctrl-E",
    "itemize": "Ctrl-I"
   },
   "labels_anchors": false,
   "latex_user_defs": false,
   "report_style_numbering": false,
   "user_envs_cfg": false
  },
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}