flow-control-1.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "subjective-quarter",
   "metadata": {
    "toc": true
   },
   "source": [
    "<h1>Flow Control 1<span class=\"tocSkip\"></span></h1>\n",
    "<h3>Table of Contents<span class=\"tocSkip\"></span></h3>\n",
    "<div class=\"toc\"><ul class=\"toc-item\"><li><span><a href=\"#Arithmetic-operators\" data-toc-modified-id=\"Arithmetic-operators-1\"><span class=\"toc-item-num\">1&nbsp;&nbsp;</span>Arithmetic operators</a></span></li><li><span><a href=\"#Assignment-operators\" data-toc-modified-id=\"Assignment-operators-2\"><span class=\"toc-item-num\">2&nbsp;&nbsp;</span>Assignment operators</a></span></li><li><span><a href=\"#Relational-operators\" data-toc-modified-id=\"Relational-operators-3\"><span class=\"toc-item-num\">3&nbsp;&nbsp;</span>Relational operators</a></span><ul class=\"toc-item\"><li><span><a href=\"#Extra:-equals-vs-is\" data-toc-modified-id=\"Extra:-equals-vs-is-3.1\"><span class=\"toc-item-num\">3.1&nbsp;&nbsp;</span>Extra: equals vs is</a></span></li></ul></li><li><span><a href=\"#Pseudocode\" data-toc-modified-id=\"Pseudocode-4\"><span class=\"toc-item-num\">4&nbsp;&nbsp;</span>Pseudocode</a></span></li><li><span><a href=\"#The-&quot;If&quot;-statement\" data-toc-modified-id=\"The-&quot;If&quot;-statement-5\"><span class=\"toc-item-num\">5&nbsp;&nbsp;</span>The \"If\" statement</a></span><ul class=\"toc-item\"><li><ul class=\"toc-item\"><li><span><a href=\"#Syntax-things-to-consider:\" data-toc-modified-id=\"Syntax-things-to-consider:-5.0.1\"><span class=\"toc-item-num\">5.0.1&nbsp;&nbsp;</span>Syntax things to consider:</a></span></li></ul></li><li><span><a href=\"#elif\" data-toc-modified-id=\"elif-5.1\"><span class=\"toc-item-num\">5.1&nbsp;&nbsp;</span>elif</a></span></li><li><span><a href=\"#else\" data-toc-modified-id=\"else-5.2\"><span class=\"toc-item-num\">5.2&nbsp;&nbsp;</span>else</a></span></li><li><span><a href=\"#Your-examples-🚀\" data-toc-modified-id=\"Your-examples-🚀-5.3\"><span class=\"toc-item-num\">5.3&nbsp;&nbsp;</span>Your examples 🚀</a></span></li></ul></li><li><span><a href=\"#Summary\" data-toc-modified-id=\"Summary-6\"><span class=\"toc-item-num\">6&nbsp;&nbsp;</span>Summary</a></span></li><li><span><a href=\"#Further-materials\" data-toc-modified-id=\"Further-materials-7\"><span class=\"toc-item-num\">7&nbsp;&nbsp;</span>Further materials</a></span></li></ul></div>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "italic-editor",
   "metadata": {},
   "source": [
    "# Control Flow    \n",
    "Let`s go with the flow"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "63c618c2",
   "metadata": {},
   "source": [
    "![](https://media.makeameme.org/created/im-just-going-ca4ce2c899.jpg)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "143f947d",
   "metadata": {
    "lang": "en"
   },
   "source": [
    "## Arithmetic operators"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9aecbca0",
   "metadata": {
    "lang": "en"
   },
   "source": [
    "Arithmetic operators are used to perform arithmetic operations, that is, to manipulate numerical data through mathematical operations such as addition, subtraction or multiplication..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8b428e9f",
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 10\n",
    "b = 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "acf7670d",
   "metadata": {},
   "outputs": [],
   "source": [
    "a + b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6ce9df2d",
   "metadata": {},
   "outputs": [],
   "source": [
    "a * b"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7dae48c3",
   "metadata": {},
   "source": [
    "`+`, `*`, bla bla bla"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e6aaec42",
   "metadata": {
    "lang": "en"
   },
   "source": [
    "## Assignment operators (Python tricks)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e3982cf4",
   "metadata": {},
   "source": [
    "![](https://i.pinimg.com/236x/2b/dd/c9/2bddc91accccb9b70178c49cf5684bed.jpg)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3e1e56bd",
   "metadata": {
    "lang": "en"
   },
   "source": [
    "Assignment operators are those that allow you to give a value to a variable or modify it. Python has eight different assignment operators: a simple assignment operator and seven compound assignment operators."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fc5d346e",
   "metadata": {
    "lang": "en"
   },
   "source": [
    "* `=` Simple assignment `a=b`\n",
    "* `+=` Addition assignment `a+=b` Simple equivalent `a=a+b`\n",
    "* `-=` Subtraction assignment `a-=b` Simple equivalent `a=a-b`\n",
    "* `*=` Multiplication Assignment `a*=b` Simple Equivalent `a=a*b`\n",
    "* `/=` Division assignment `a/=b` Simple equivalent `a=a/b`\n",
    "* `%=` Module mapping `a/=b` Simple equivalent `a=a%b`\n",
    "* `//=` Integer Division Assignment `a//=b` Simple Equivalent `a=a//b`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7dba4669",
   "metadata": {},
   "outputs": [],
   "source": [
    "a = a + 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cf20037c",
   "metadata": {},
   "outputs": [],
   "source": [
    "a += 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "32b08634",
   "metadata": {},
   "outputs": [],
   "source": [
    "a"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "89b42f24",
   "metadata": {
    "lang": "en"
   },
   "source": [
    "The simple assignment operator is the equals symbol (=) and operations performed on it always have the syntax: `variable = expression`. In this type of operation, first, the expression on the right is resolved and the resulting value is assigned to the variable on the left."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "709c2301",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Take some time, and practice"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "71a92117",
   "metadata": {
    "lang": "en"
   },
   "source": [
    "## Relational operators"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "38d5146c",
   "metadata": {
    "lang": "en"
   },
   "source": [
    "Relational operators are symbols used to compare two values ​​or expressions. The result of the evaluation with these two operators can be True, if the comparison is true, or False, if the comparison is false."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b7d7c2b5",
   "metadata": {
    "lang": "en"
   },
   "source": [
    "* `==` Equal to `a==b`\n",
    "* `!=` Not equal to `a!=b`\n",
    "* `>` Greater than `a>b`\n",
    "* `<` Lesser than `a<b` \n",
    "* `>=` Greater than or equal to `a>=b`\n",
    "* `<=` Less than or equal to `a<=b`"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6bb2bc2a",
   "metadata": {
    "lang": "en"
   },
   "source": [
    "Note the difference between a single equals sign (=), which is an assignment, and a double equals sign (==), which is a relational operator\n",
    "\n",
    "**Hint: Use parentheses to maintain the order of operations."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ac9ccfb3",
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6e28aea1",
   "metadata": {},
   "outputs": [],
   "source": [
    "a == 10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c00bf648",
   "metadata": {},
   "outputs": [],
   "source": [
    "a != 10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3dde583b",
   "metadata": {},
   "outputs": [],
   "source": [
    "a > b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4efdcce8",
   "metadata": {},
   "outputs": [],
   "source": [
    "a < b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "16a5b605",
   "metadata": {},
   "outputs": [],
   "source": [
    "a <= b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "de053fec",
   "metadata": {},
   "outputs": [],
   "source": [
    "b <= a"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0bf8a056",
   "metadata": {
    "lang": "en"
   },
   "source": [
    "With just these two `True`|`False` values ​​we can create a whole branch of mathematics called [Boolean Algebra](https://en.wikipedia.org/wiki/Boolean_algebra#Laws). While in regular Algebra the basic operations are addition and multiplication, the main operations in Boolean Algebra are conjunction (and), disjunction (or), and negation (not). **It is the formalism used to describe the logical operations**.\n",
    "\n",
    "In [Python we write these operations](https://www.geeksforgeeks.org/python-3-logical-operators/?ref=rp) as:\n",
    "\n",
    "- `==`\n",
    "* `x` and `y`\n",
    "* `x` or `y`\n",
    "* not `x`\n",
    "* Extra: `^` [caret operator](https://stackoverflow.com/questions/2451386/what-does-the-caret-operator-do)\n",
    "\n",
    "Although the meaning of these operations is clear, we can fully define them with the so-called \"truth table\":"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "coral-armenia",
   "metadata": {},
   "source": [
    "![tablas](http://elclubdelautodidacta.es/wp/wp-content/uploads/2012/11/python-logicos.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c39be317",
   "metadata": {
    "lang": "en"
   },
   "source": [
    "We can also include the EXCLUSIVE OR, which is true when one and only one of the operands is true, but strictly you must know that it is derived from the three basic ones. Its representation is ^, the hat or caret."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "244fb7c7",
   "metadata": {},
   "source": [
    "- **equals** vs **is**"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c2fc6ff2",
   "metadata": {},
   "source": [
    "[Some docs](https://towardsdatascience.com/whats-the-difference-between-is-and-in-python-dc26406c85ad)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e8287044",
   "metadata": {},
   "source": [
    "`==` -> points to the value <br>\n",
    "`is` -> looks for identity"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "873ada8d",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Ejemplo 1: Comparando números\n",
    "a = 5\n",
    "b = 5\n",
    "\n",
    "print(a == b) # True, porque los valores de 'a' y 'b' son iguales"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "44e6eefc",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(a is b) # True, porque 'a' y 'b' hacen referencia al mismo objeto en memoria (optimización de Python para números pequeños)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5a1aa6df",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Ejemplo 2: Comparando listas\n",
    "lista1 = [1, 2, 3]\n",
    "lista2 = [1, 2, 3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f714c908",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(lista1 == lista2) # True, porque los valores de 'lista1' y 'lista2' son iguales"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5a5f1e05",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(lista1 is lista2) # False, porque 'lista1' y 'lista2' hacen referencia a diferentes objetos en memoria"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "29d1ae12",
   "metadata": {},
   "source": [
    "- The **not** operator. The **not** operator is an operator that returns the opposite value of the evaluated expression. If the expression has the value True, it returns False. Conversely, if the expression has the value False, it returns True."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "70ecf121",
   "metadata": {},
   "outputs": [],
   "source": [
    "not(lista1 == lista2)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d5122028",
   "metadata": {
    "lang": "en"
   },
   "source": [
    "- The **and** operator evaluates whether both expressions are true. If both expressions are true, it returns True. If either expression is false, it returns False. These types of tables are formally known as \"truth tables\"."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6096259b",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Same to (lista1 == lista2) & (a == lista2) \n",
    "(lista1 == lista2) and (a == lista2) "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ddb3ca4d",
   "metadata": {
    "lang": "en"
   },
   "source": [
    "- The **or** operator evaluates whether either expression is true, that is, it returns True if either expression is true and False when both expressions are false."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3c409f34",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Same to (lista1 == lista2) | (a == lista2) \n",
    "(lista1 == lista2) or (a == lista2) "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e373cd72",
   "metadata": {},
   "source": [
    "### Exercise: Exploring Relational Operators\n",
    "\n",
    "In this exercise, we will explore the various relational operators available in Python. These operators are primarily used to establish relationships between different values and are essential in decision-making structures, although we won't be using them in that capacity in this exercise. Using these operators, please perform the following tasks:\n",
    "\n",
    "#### Task 1: Equal to Operator (==)\n",
    "1. Create two strings and check if they are equal using `==`. Print the result.\n",
    "2. Create two lists with equal elements and check if they are equal using `==`. Print the result.\n",
    "\n",
    "#### Task 2: Not Equal to Operator (!=)\n",
    "1. Create two integers and check if they are not equal using `!=`. Print the result.\n",
    "2. Use the `input()` function to get two inputs from the user and check if they are not equal using `!=`. Print the result.\n",
    "\n",
    "#### Task 3: Greater than and Lesser than Operators (>, <)\n",
    "1. Create two floating-point numbers and check if one is greater than the other using `>`. Print the result.\n",
    "2. Create two floating-point numbers and check if one is lesser than the other using `<`. Print the result.\n",
    "\n",
    "#### Task 4: Greater than or Equal to and Less than or Equal to Operators (>=, <=)\n",
    "1. Create two integers and check if one is greater than or equal to the other using `>=`. Print the result.\n",
    "2. Create two integers and check if one is less than or equal to the other using `<=`. Print the result."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5de219ad",
   "metadata": {},
   "outputs": [],
   "source": [
    "# your code here"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "attended-assurance",
   "metadata": {},
   "source": [
    "# Loops an stuff\n",
    "![](https://i1.sndcdn.com/artworks-SvzDuFfyt3AJ9fO1-iQrV9Q-t500x500.jpg)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3e0ac95f",
   "metadata": {
    "lang": "en"
   },
   "source": [
    "In programming, a **loop** is a fundamental concept that allows a block of code to be repeated multiple times. It facilitates the execution of repetitive tasks without needing to write the same lines of code over and over again, promoting both efficiency and readability. The basic idea is to loop through a block of code as long as a specified condition remains true.\n",
    "\n",
    "There are generally two types of loops you'll encounter:\n",
    "\n",
    "1. **For Loop**: Generally used to iterate over a collection of items, such as elements in a list, tuple, or string. It will execute a block of code for each item in the collection, hence making it simpler and cleaner to perform the same action on multiple items.\n",
    "\n",
    "2. **While Loop**: This type of loop continues to execute a block of code as long as a particular condition is met. It's crucial to update the variables influencing the condition inside the loop, to avoid creating an infinite loop.\n",
    "\n",
    "Loops are incredibly powerful tools in programming, helping to save time and reduce the potential for errors in your code. As you progress in your learning, you will find loops are essential components in many programming solutions, facilitating the creation of complex, efficient, and innovative solutions to a wide range of problems.\n",
    "\n",
    "In the following sections, we will explore both types of loops in more detail, with examples to illustrate their usage and versatility in programming tasks.\n",
    "\n",
    "Happy looping!"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c2a2b91b",
   "metadata": {
    "lang": "en"
   },
   "source": [
    "## Pseudocode\n",
    "\n",
    "Before we dive into the world of loops, let's take a moment to understand what \"Pseudocode\" is. Pseudocode is a high-level description of the functioning of a computer program or algorithm. It utilizes the structural conventions of programming languages but is designed to be read by humans rather than machines. \n",
    "\n",
    "In pseudocode, we are not concerned with precise syntax that a programming language might require. Instead, we focus on expressing the logic and the steps needed to solve a problem or accomplish a task, often in natural language mixed with some common programming structures. This means that pseudocode does not have a strict syntax and can vary widely.\n",
    "\n",
    "The main objective of writing pseudocode is to outline the structure of the program and delineate its logical flow without getting caught up in the specific details of a particular programming language. This makes it a useful tool for planning and designing programs, where the emphasis is on what to do rather than how to do it.\n",
    "\n",
    "Here are some general characteristics of pseudocode:\n",
    "1. **Simplicity**: It should be simple and easy to understand.\n",
    "2. **Clarity**: Each step is clearly defined without ambiguity.\n",
    "3. **Language-independent**: It does not adhere to the syntax of any specific programming language.\n",
    "4. **Focus on Logic**: The primary focus is on the logic and flow of the algorithm, rather than the specific syntax of a programming language.\n",
    "\n",
    "As you begin to work with loops and other programming structures, you'll find that creating pseudocode can be a valuable first step in the coding process, helping you to organize your thoughts and create a roadmap for your program before you start writing actual code."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a1b077ff",
   "metadata": {},
   "outputs": [],
   "source": [
    "# a list of elements\n",
    "# loop through the list \n",
    "# and check if the type is a number\n",
    "\n",
    "# if the type is a number\n",
    "# i do stuff\n",
    "\n",
    "# WHAT IS IT I HAVE?: LIST OF LISTS WITH NUMBERS\n",
    "    # original = [[1, 2], [3], [5, 6, 9]]\n",
    "        # 1. Create a new_list\n",
    "        # 2. GOAL: Take the element out\n",
    "            # 3. Access the element\n",
    "            # 4. loop original list: [1, 2]\n",
    "            # 5. loop the i/individual_list again\n",
    "            # 6: add to new_list\n",
    "            # 7: print\n",
    "    \n",
    "# GOAL: WHAT RESULT I NEED TO RETURN\n",
    "    # [1, 2, 3, 4, 5, 6]\n",
    "    \n",
    "# always print"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4690d4e0",
   "metadata": {},
   "source": [
    "Quick infor card:\n",
    "\n",
    "In Python, the `range()` function is used to generate a sequence of numbers over time. It is widely used in loops to control the number of iterations. The function has three parameters: start, stop, and step.\n",
    "\n",
    "- **Start**: This parameter specifies the starting point of the sequence. It is optional, and the default value is 0.\n",
    "- **Stop**: This parameter specifies the endpoint of the sequence. This value is not included in the sequence.\n",
    "- **Step**: This parameter specifies the increment between each number in the sequence. It is optional, and the default value is 1.\n",
    "\n",
    "Here is the syntax for the `range()` function:\n",
    "\n",
    "- range(start, stop, step)\n",
    "\n",
    "Some example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "89f2329b",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "for i in range(1, 6):\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9fdcf991",
   "metadata": {},
   "outputs": [],
   "source": [
    "# play here with range"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fee3afff",
   "metadata": {},
   "source": [
    "Let's do more complex stuff:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "23dd3aa0",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# This is the original list of lists where each element is a list containing integers.\n",
    "original = [[1, 2], [3], [5, 6, 9]]\n",
    "\n",
    "# A new empty list is initialized to store the individual elements after flattening the original list.\n",
    "new_list = []\n",
    "\n",
    "# The outer loop iterates through each individual list inside the original list.\n",
    "for individual_list in original:\n",
    "    # The inner loop iterates through each element in the currently selected individual list (from the outer loop).\n",
    "    for each_element in individual_list:\n",
    "        # The current element from the individual list is appended to the new list.\n",
    "        new_list.append(each_element)\n",
    "\n",
    "# Printing the new_list to see the final output.\n",
    "print(new_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8a77f835",
   "metadata": {},
   "source": [
    "Debug what is happenin:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a36780d7",
   "metadata": {},
   "outputs": [],
   "source": [
    "# We are defining a list named 'bigger_list' which contains several other lists, one of which is nested\n",
    "bigger_list = [[1, 2], [3], [5, 6, 9, [1, 2]]]\n",
    "\n",
    "# We are initiating a for loop to iterate over each 'small_list' present within the 'bigger_list'\n",
    "for small_list in bigger_list:\n",
    "    # Inside the loop, we are printing the current 'small_list' that the loop is iterating over\n",
    "    print(small_list)\n",
    "    # Once the end of the loop is reached, it goes back to the start to process the next 'small_list' in the 'bigger_list'"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "66a5e23a",
   "metadata": {},
   "source": [
    "### Exercise:\n",
    "\n",
    "You are working in the sales department of a company. At the end of each week, you need to generate a report of total sales made each day. You have a list where each element represents the sales made on each day of the week (from Monday to Sunday). Your task is to calculate the total sales of the week.\n",
    "\n",
    "To complete this exercise, you need to follow the given steps:\n",
    "\n",
    "1. **Initialize Variables**:\n",
    "    Before starting the loop, initialize a variable `total_sales` to 0. This will be used to accumulate the sales of each day. Additionally, initialize `max_sales` to 0.\n",
    "   \n",
    "   \n",
    "2. **Creating a Loop**:\n",
    "    Create a for loop where you iterate over each element in the `sales_data` list. You can use a loop structure like this: for day in sales_data:\n",
    "   \n",
    "   \n",
    "3. **Calculating Total Sales**:\n",
    "    Inside the loop, add the sales of the current day to `total_sales`. You can do this using an assignment statement like this: total_sales += day\n",
    "\n",
    "\n",
    "\n",
    "5. **Printing the Results**:\n",
    "    After the loop, print the `total_sales` along with appropriate messages to show the total sales of the week and the day with maximum sales."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3bd7d85f",
   "metadata": {},
   "outputs": [],
   "source": [
    "# List representing sales data for seven days (in units)\n",
    "sales_data = [200, 300, 400, 500, 600, 700, 800]\n",
    "\n",
    "# Initialize total_sales to 0 before starting the loop\n",
    "total_sales = 0\n",
    "\n",
    "# Initialize max_sales before starting the loop\n",
    "max_sales = 0\n",
    "\n",
    "# {YOUR CODE HERE}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0eaad548",
   "metadata": {
    "lang": "en"
   },
   "source": [
    "## The \"If\" statement\n",
    "This is the most popular option to control the flow of a program. Conditions allow you to choose between different paths depending on the value of an expression. When you want to execute an action only when some condition is `True`, an \"if\" statement is used:"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "580479b3",
   "metadata": {},
   "source": [
    "#### Syntax things to consider:\n",
    "- indentation: `tab / 5 spaces`\n",
    "- colon: `:`\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ef3ac3be",
   "metadata": {},
   "outputs": [],
   "source": [
    "age = 20\n",
    "\n",
    "if age >= 21:\n",
    "    print(\"Adult\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "305e83a6",
   "metadata": {
    "lang": "en"
   },
   "source": [
    "As we can see, the code block associated with the condition begins after the colon \":\", with an indentation that determines the code block. All statements belonging to the same block must have the same indentation. The block ends when the indent returns to the starting position of the if statement. Remember that Python uses indentation to identify blocks of code."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "baa11a80",
   "metadata": {
    "lang": "en"
   },
   "source": [
    "### elif\n",
    "Sometimes there are more than two possibilities. Think of something like:\n",
    "\"If Bob can get into the disco, let him in. If not, if he's over 16, recommend the nearby light disco. If not, send him home.\"\n",
    "\n",
    "We can achieve this with the `elif` clause and chained conditionals:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "82badc29",
   "metadata": {},
   "outputs": [],
   "source": [
    "age = 20\n",
    "\n",
    "if age >= 21:\n",
    "    print(\"Adult\")\n",
    "    \n",
    "elif age < 21:\n",
    "    print(\"Not an adult\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "770fbd1a",
   "metadata": {
    "lang": "en"
   },
   "source": [
    "### else\n",
    "Sometimes you want if the condition is not met (and only then) another action is executed. They are mutually exclusive actions. This is achieved with the `else` statement."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "median-injection",
   "metadata": {},
   "source": [
    "![if](https://www.tutorialspoint.com/scala/images/scala_decision_making.jpg)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5c7a1210",
   "metadata": {},
   "outputs": [],
   "source": [
    "age = 14\n",
    "\n",
    "if age >= 21:\n",
    "    print(\"Adult\")\n",
    "    \n",
    "elif age >= 16 and age < 21:\n",
    "    print(\"Not an adult\")\n",
    "    \n",
    "else:\n",
    "    print(\"not condition 1, not condition 2\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "50d43411",
   "metadata": {},
   "source": [
    "In Python programming, a nested if statement is an if statement that is the target of another if statement. Nested if statements mean an if statement inside another if statement. Yes, Python allows us to nest if statements within if statements. Here is the general form of a nested if statement."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "36b1c6ee",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 1. Takes the input of a user (controlling it's an int)\n",
    "age = int(input(\"Please input your age: \"))\n",
    "\n",
    "# 2. Based on conditions: return something or something else\n",
    "if age > 0:\n",
    "    if age < 16:\n",
    "        print(\"You CANNOT get in\")\n",
    "\n",
    "    elif age >= 16 and age < 18:\n",
    "        print(\"Alcohol free club\")\n",
    "\n",
    "\n",
    "    elif age >= 18:\n",
    "        print(\"You can get in\")\n",
    "        \n",
    "else:\n",
    "    print(\"Sorry, wrong info: negative value?\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f2fd273c",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Assign a string which is intended to represent a password to the variable 'password'\n",
    "password = \"12345678909876dcvbnhjytfgvb+\"\n",
    "\n",
    "# Check if the length of the password is greater than 8, if true, print \"ok\"\n",
    "if len(password) > 8:\n",
    "        print(\"ok\")\n",
    "\n",
    "# Check if the password contains any letters, if true, print \"startswith L\"\n",
    "# (Note: The current condition will always evaluate to True as it's checking if password is non-empty.\n",
    "#  To check for letters, you might need to modify the condition using any(x.isalpha() for x in password))\n",
    "if password: # has letters\n",
    "    print(\"startswith L\")\n",
    "    \n",
    "# Check if the password contains any numbers, if true, print \"Name is Lola\"\n",
    "# (Note: Similar to the previous note, the condition here checks if password is non-empty, \n",
    "#  to check for numbers you might want to modify the condition using any(x.isdigit() for x in password))\n",
    "if password: # has numbers:\n",
    "    print(\"Name is Lola\")\n",
    "    \n",
    "# (... modify the code for expected output\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "71dcc64c",
   "metadata": {
    "lang": "en"
   },
   "source": [
    "Quick tip:\n",
    "```python\n",
    "if I don't know what:\n",
    "    I don't know\n",
    "if else:\n",
    "    somethingelse\n",
    "```\n",
    "\n",
    "💩 It is computationally more efficient to use elif, although this code works, Python will go in and check all if"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "413a3013",
   "metadata": {},
   "outputs": [],
   "source": [
    "# IF & IF: when more than condition can be met at ONCE\n",
    "    # all the ifs are read\n",
    "    # aaaaal the ifs will be read\n",
    "    \n",
    "# IF & ELIFS: when only one should be met\n",
    "    # only the needed ones are read\n",
    "    # better: more conservative"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a62738d2",
   "metadata": {},
   "source": [
    "### Exercise extension:\n",
    "Now use if statements, to calculate on top of total sales, which day had the maximum sales."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "65c946ed",
   "metadata": {},
   "outputs": [],
   "source": [
    "# List representing sales data for seven days (in units)\n",
    "sales_data = [200, 300, 400, 500, 600, 700, 800]\n",
    "\n",
    "# Initialize total_sales to 0 before starting the loop\n",
    "total_sales = 0\n",
    "\n",
    "# Initialize max_sales before starting the loop\n",
    "max_sales = 0\n",
    "\n",
    "# {YOUR CODE HERE}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4119b21e",
   "metadata": {
    "lang": "en"
   },
   "source": [
    "# Challenge 🤔\n",
    "\n",
    "Write a simple program that prints if bob can get into the club\n",
    "for any two values ​​of the following variables:\n",
    "`print(age_bob,age_minimum)`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5d8caf12",
   "metadata": {},
   "outputs": [],
   "source": [
    "# age\n",
    "    # club\n",
    "    # cannot club\n",
    "    # club: 16-18"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a9b00fd8",
   "metadata": {
    "lang": "en"
   },
   "source": [
    "### Your examples 🚀"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0833207b",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "5f01cb54",
   "metadata": {
    "lang": "en"
   },
   "source": [
    "# Challenge 🤔\n",
    "Modify your schedule so that when Bob can't get into the club but is over the legal age (age=21)\n",
    "send it to disco light"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "transparent-nickname",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "b217ff64",
   "metadata": {
    "lang": "en"
   },
   "source": [
    "Let's imagine that we are building the program for a robot that sorts eggs by size. Our robot arm receives information from a scale, which indicates, in grams, the weight of the egg to be classified. The arm must, from the weight, place the egg in one box or another as follows:\n",
    "\n",
    "- **Box S** (small): weight less than 53 grams.\n",
    "- **Box M** (medium) : weight greater than or equal to 53 grams and less than 63 grams.\n",
    "- **Box L** (large): weight greater than or equal to 63 grams and less than 73 grams.\n",
    "- **XL box** (super large): weight greater than or equal to 73 grams."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "61cfbb7c",
   "metadata": {},
   "source": [
    "## Summary\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4524a456",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "7deb669c",
   "metadata": {},
   "source": [
    "[Rubber duck debugging](https://www.freecodecamp.org/news/rubber-duck-debugging/#:~:text=The%20idea%20behind%20the%20rubber,loud%20before%20you%20post%20it)\n",
    "\n",
    "The \"Rubber Duck Theory\" or \"Rubber Duck Debugging\" is a method used to find errors or bugs in a code. In this technique, the programmer explains their code, line by line, to an inanimate object such as a rubber duck. The act of explaining the code in detail often helps the programmer to see errors or improvements that they didn't notice before. This is similar to writing a message on social media and then reading it aloud before posting it, which can sometimes help in spotting errors or reconsidering the message's content."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "toxic-romance",
   "metadata": {},
   "source": [
    "## Further materials\n",
    "\n",
    "* [Python docs](https://docs.python.org/3/tutorial/controlflow.html)\n",
    "* Short tutorial on [Python Booleans](https://realpython.com/python-boolean/)\n",
    "* Just a nice [talk by Feynman](https://www.youtube.com/watch?v=EKWGGDXe5MA) on the principles of computation"
   ]
  }
 ],
 "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.9.13"
  },
  "nbTranslate": {
   "displayLangs": [
    "en",
    "es"
   ],
   "hotkey": "alt-a",
   "langInMainMenu": true,
   "sourceLang": "es",
   "targetLang": "en",
   "useGoogleTranslate": true
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": true,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": true,
   "toc_position": {
    "height": "calc(100% - 180px)",
    "left": "10px",
    "top": "150px",
    "width": "165px"
   },
   "toc_section_display": true,
   "toc_window_display": true
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}