python_workflow.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Control flow\n",
    "\n",
    "In this notebook we will study several statements to control the order in which the code is executed."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##  Conditionals\n",
    "\n",
    "Conditionals are control structures which enable the user to run certain pieces of code if a condition is met. For example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "number = 8\n",
    "if number % 2 == 0:\n",
    "    print(f\"{number} is even.\")\n",
    "else:\n",
    "    print(f\"{number} is odd.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notice that if/else blocks are delimited by indentation. To avoid problems with indentation one can use the **pass** statement: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "condition = True\n",
    "if condition:\n",
    "    print(\"Condition is satisfied\")\n",
    "else:\n",
    "    pass\n",
    "\n",
    "print(\"Keeping with the code flow\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "More than one condition can be evaluated with elif clauses:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "grade = 8.5\n",
    "if (grade >= 9) and (grade <= 10):\n",
    "    print(\"You got an A\")\n",
    "elif (grade >= 7) and (grade < 9):\n",
    "    print(\"You got a B\")\n",
    "elif (grade >= 6) and (grade < 7):\n",
    "    print(\"You got a C\")\n",
    "elif (grade >= 5) and (grade < 6): \n",
    "    print(\"You got a D\")\n",
    "elif (grade >= 0) and (grade < 5):\n",
    "    print(\"You failed\")\n",
    "else:\n",
    "    print(f\"{grade} is not a valid grade.\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In python there is also a conditional operator or ternary operator:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "raining = False\n",
    "print(\"Let's go to the\", 'beach' if not raining else 'library')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "m = a if a > b else b\n",
    "print(f\"{m = }\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_maximum(a, b):\n",
    "    return a if a > b else b\n",
    "\n",
    "get_maximum(a, b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "####  Structural Pattern Matching\n",
    "\n",
    "In other programming languages such as C, matlab, there is another structure to execute different chunks of code given the possible values that a variable can have, the switch-case statement. For example:\n",
    "```C\n",
    "switch (grade){\n",
    "    case 'A':\n",
    "        printf(\"You got an excellent grade\");\n",
    "        break;\n",
    "    case 'B':\n",
    "        printf(\"You got a good grade\");\n",
    "        break;\n",
    "    case 'C':\n",
    "        printf(\"You got an average grade\");\n",
    "        break;\n",
    "    default:\n",
    "        printf(\"You didn't meet the course minimum grade\");\n",
    "        break;\n",
    "}\n",
    "```\n",
    "\n",
    "Python did not have an equivalent structures in versions previous to **python 3.10** (realeased in October 2021). A workaround could be to use multiple elif statements:\n",
    "```python\n",
    "if grade == 'A':\n",
    "    print(\"You got an excellent grade\")\n",
    "elif grade == 'B':\n",
    "    print(\"You got a good grade\")\n",
    "elif grade == 'C':\n",
    "    print(\"You got an average grade\")\n",
    "else:\n",
    "    print(\"You didn't meet the course minimum grade\")\n",
    "```\n",
    "or dictionaries:\n",
    "```python\n",
    "d_grades = {'A': \"You got an excellent grade\", \n",
    "            'B': \"You got a good grade\",\n",
    "            'C': \"You got an average grade\",}\n",
    "\n",
    "print(d.get(grade, \"You didn't meet the course minimum grade\"))\n",
    "```\n",
    "\n",
    "\n",
    "The new match-case statement has the functionalities of the switch-case statement:\n",
    "```python\n",
    "match grade:\n",
    "    case 'A':\n",
    "        print(\"You got an excellent grade\")\n",
    "    case 'B':\n",
    "        print(\"You got a good grade\")\n",
    "    case 'C':\n",
    "        print(\"You got an average grade\")\n",
    "    case _:\n",
    "        print(\"You didn't meet the course minimum grade\")\n",
    "```\n",
    "And more:\n",
    "```python\n",
    "class Person:\n",
    "    def __init__(self, name, age):\n",
    "        self.name = name\n",
    "        self.age = age\n",
    "        \n",
    "    def __repr__(self):\n",
    "        return f\"Person({self.name}, {self.age})\"\n",
    " \n",
    "def has_discount(person):\n",
    "    match person:\n",
    "        case Person(age=age) if (age <= 25) or (age >= 65):\n",
    "            return True\n",
    "        case Person():\n",
    "            return False\n",
    "        case _:\n",
    "            return ValueError(f\"{person} is not an instance of class Person\")\n",
    "```\n",
    "\n",
    "I wouldn't recommend downloading now python 3.10 if you use third party python libraries as they probably won't be compatible with this version yet."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##  Iterations \n",
    "\n",
    "Iteration means executing the same block of code over and over, potentially many times. A programming structure that implements iteration is called a loop. There are two types of iteration:\n",
    "\n",
    "* Definite iteration, in which the number of repetitions is specified explicitly in advance (**for loops**).\n",
    "* Indefinite iteration, in which the code block executes until some condition is met (**while loops**).\n",
    "\n",
    "Moreover, python can iterate over native structures such as lists or dicitionaries. These type of iterations are called **comprehensions**.\n",
    "\n",
    "* ### while loops\n",
    "\n",
    "The python while loop has the following structure:\n",
    "```python\n",
    "while <expression>:\n",
    "    <statements>\n",
    "```\n",
    "If  \\<expression\\> is **True**, the loop body (\\<statements\\>) is executed. Then \\<expression\\> is checked again, and if still true, the body is executed again. This continues until \\<expression\\> becomes false, at which point program execution proceeds to the first statement beyond the loop body. Example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "total = 105, i = 15\n"
     ]
    }
   ],
   "source": [
    "total = 0\n",
    "i = 1\n",
    "while total < 100:\n",
    "    total += i\n",
    "    i += 1\n",
    "print(f\"{total = }, {i = }\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "While loops can include more advance features like the **break** and **continue** statements. **break** terminates the loop completely and proceeds to the first statement following the loop and **continue** terminates the current iteration and proceeds to the next iteration."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "total = 55, i = 11\n"
     ]
    }
   ],
   "source": [
    "total = 0\n",
    "i = 1\n",
    "while total < 100:\n",
    "    if i > 10:\n",
    "        break\n",
    "    total += i\n",
    "    i += 1\n",
    "print(f\"{total = }, {i = }\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "total = 110, i = 16\n"
     ]
    }
   ],
   "source": [
    "total = 0\n",
    "i = 1\n",
    "while total < 100:\n",
    "    if i == 10:\n",
    "        i += 1 # comment this line to enter an infinite loop\n",
    "        continue\n",
    "    total += i\n",
    "    i += 1\n",
    "print(f\"{total = }, {i = }\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The **break** and **continue** statements work the same way with for loops as with while loops.\n",
    "\n",
    "A while loop can include an else clause:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Perenganito not found in list.\n"
     ]
    }
   ],
   "source": [
    "names = [\"Fulanito\", \"Menganito\", \"Zutanito\"]\n",
    "target = \"Perenganito\"\n",
    "while i < len(names):\n",
    "    if names[i] == target:\n",
    "        # Processing for item found\n",
    "        break\n",
    "    i += 1\n",
    "else:\n",
    "    # Processing for item not found\n",
    "    print(target, 'not found in list.')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "While loops can also be written in one line of code:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4 3 2 1 0 "
     ]
    }
   ],
   "source": [
    "n = 5\n",
    "while n > 0: n -= 1; print(n, end=' ')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* ### for loops\n",
    "\n",
    "Python implements collection-based or iterator-based for loops, i.e., the loop iterates over a collection of objects. For example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "students = [\"Diego Álvarez\", \"Samir Belaoui\", \"Dario González\", \"Pablo Herreros\", \"Rubén López\", \n",
    "            \"Luis Fernando Mejía\", \"Conrado Muñoz\", \"Abram Pérez\", \"Miguel Ruiz\"]\n",
    "\n",
    "for student in students:\n",
    "    print(f\"Welcome to programming with python {student.title()}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The for loops over an iterable, in this case a list. Each time through the loop, student takes on a successive item in students. \n",
    "\n",
    "In python, iterable means an object can be used in iteration. If an object is iterable, it can be passed to the built-in Python function iter(), which returns something called an iterator. Examples:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "iter_string = iter('foobar')\n",
    "print(next(iter_string), end=''); print(next(iter_string), end=''); print(next(iter_string), end='');\n",
    "#print(next(iter_string), end=''); print(next(iter_string), end=''); print(next(iter_string), end='')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "iter_set = iter({'foo', 'bar', 'baz'}) \n",
    "print(next(iter_set))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "iter_dict = iter({'foo': 1, 'bar': 2, 'baz': 3})\n",
    "print(next(iter_dict))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When there are no more elements left in the iterator a **StopIteration** exception is raised. You can only obtain values from an iterator in one direction. You can’t go backward. There is no prev() function.\n",
    "\n",
    "All the data types you have encountered so far that are collection or container types are iterable. These include the string, list, tuple, dict, set. But these are by no means the only types that you can iterate over. Many objects that are built into Python or defined in modules are designed to be iterable. Even user-defined objects can be designed in such a way that they can be iterated over. \n",
    "\n",
    "To carry out the iteration in the **for loop** example above, python does the following:\n",
    "\n",
    "1. Calls iter() to obtain an iterator for students\n",
    "2. Calls next() repeatedly to obtain each item from the iterator \n",
    "3. Terminates the loop when next() raises the StopIteration exception\n",
    "\n",
    "The loop body is executed once for each item next() returns, with loop variable student set to the given item for each iteration.\n",
    "\n",
    "Numeric range loops can be easily implemented using the range() function which returns an iterable that yields a sequence of integers."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in range(5):\n",
    "    print(i, end=' ')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in range(3,24,7):\n",
    "    print(i, end=' ')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A for loop can have an else clause as well. The interpretation is analogous to that of a while loop. The else clause will be executed if the loop terminates through exhaustion of the iterable:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "foo. bar. baz. qux. \n",
      "Loop is finished.\n"
     ]
    }
   ],
   "source": [
    "for value in ['foo', 'bar', 'baz', 'qux']:\n",
    "    print(value, end='. ')\n",
    "else:\n",
    "    print('\\nLoop is finished.')  # Will execute"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "foo. bar. "
     ]
    }
   ],
   "source": [
    "for value in ['foo', 'bar', 'baz', 'qux']:\n",
    "    if 'z' in value:\n",
    "        break\n",
    "    print(value, end='. ')\n",
    "else:\n",
    "    print('\\nLoop is finished.')  # Won't execute"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Several values can be iterated at the same time:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Fulanito is 26 years old.\n",
      "Menganito is 22 years old.\n",
      "Zutanito is 31 years old.\n",
      "Perenganito is 38 years old.\n"
     ]
    }
   ],
   "source": [
    "names = [\"Fulanito\", \"Menganito\", \"Zutanito\", \"Perenganito\"]\n",
    "ages = [26, 22, 31, 38]\n",
    "for name, age in zip(names, ages):\n",
    "    print(f\"{name.capitalize()} is {age} years old.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "One can also keep the number of the iteration:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1. Elena is 26 years old.\n",
      "2. Isabel is 24 years old.\n",
      "3. Carmen is 22 years old.\n"
     ]
    }
   ],
   "source": [
    "for i, (name, age) in enumerate(zip(names, ages)):\n",
    "    print(f\"{i+1}. {name.capitalize()} is {age} years old.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* ### comprehensions\n",
    "\n",
    "Instead of creating a list by means of a loop, one can make use of a list comprehension with a rather self-explaining syntax."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 1, 4, 9, 16]\n"
     ]
    }
   ],
   "source": [
    "list1 = [i**2 for i in range(5)]\n",
    "print(list1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "One can add if/else clause to the comprehensions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 4, 16]\n"
     ]
    }
   ],
   "source": [
    "list2 = [i**2 for i in range(5) if i % 2 == 0]\n",
    "print(list2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 1, 4, 27, 16]\n"
     ]
    }
   ],
   "source": [
    "list3 =  [i**2 if i % 2 == 0 else i**3 for i in range(5) ]\n",
    "print(list3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Comprehensions can be used with all types of containers:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "d_names[Fulanito] = 0\n",
      "d_names[Menganito] = 1\n",
      "d_names[Zutanito] = 2\n",
      "d_names[Perenganito] = 3\n"
     ]
    }
   ],
   "source": [
    "names = [\"Fulanito\", \"Menganito\", \"Zutanito\", \"Perenganito\"]\n",
    "d_names = {name:i for i,name in enumerate(names)}\n",
    "\n",
    "for key in d_names:\n",
    "    print(f\"d_names[{key}] = {d_names[key]}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{0, 1, 2}\n"
     ]
    }
   ],
   "source": [
    "s = {i % 3 for i in range(6)}\n",
    "print(s)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.8.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}