Modulo04_EstructurasControlFlujo.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h1 align=\"center\">Pensamiento Algorítmico</h1>\n",
    "<h1 align=\"center\">Módulo 04: Estructuras de control de flujo</h1>\n",
    "<h1 align=\"center\">2024/01</h1>\n",
    "<h1 align=\"center\">MEDELLÍN - COLOMBIA </h1>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*** \n",
    "|[![Gmail](https://img.shields.io/badge/Gmail-D14836?style=plastic&logo=gmail&logoColor=white)](mailto:carlosalvarezh@gmail.com)|<carlosalvarezh@gmail.com>|[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/carlosalvarezh/Pensamiento_Algoritmico/blob/main/Modulo04_EstructurasControlFlujo.ipynb)\n",
    "|-:|:-|--:|\n",
    "|[![LinkedIn](https://img.shields.io/badge/linkedin-%230077B5.svg?style=plastic&logo=linkedin&logoColor=white)](https://www.linkedin.com/in/carlosalvarez5/)|[![@alvarezhenao](https://img.shields.io/twitter/url/https/twitter.com/alvarezhenao.svg?style=social&label=Follow%20%40alvarezhenao)](https://twitter.com/alvarezhenao)|[![@carlosalvarezh](https://img.shields.io/badge/github-%23121011.svg?style=plastic&logo=github&logoColor=white)](https://github.com/carlosalvarezh)|\n",
    "\n",
    "<table>\n",
    " <tr align=left><td><img align=left src=\"https://github.com/carlosalvarezh/Curso_CEC_EAFIT/blob/main/images/CCLogoColorPop1.gif?raw=true\" width=\"25\">\n",
    " <td>Text provided under a Creative Commons Attribution license, CC-BY. All code is made available under the FSF-approved MIT license.(c) Carlos Alberto Alvarez Henao</td>\n",
    "</table>\n",
    "\n",
    "***"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Estructuras de Control de Flujo"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "- Una estructura de control, es un bloque de código que permite agrupar instrucciones de manera controlada.\n",
    "\n",
    "  * Estructura de control condicionales\n",
    "\n",
    "  * Estructura de control iterativas\n",
    "\n",
    "\n",
    "- En *Python*, antes es necesario comentar acerca de la *indentación*."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Indentación:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "- En un lenguaje informático, la *identación* es lo que la sangría al lenguaje humano escrito (a nivel formal). Así como para el lenguaje formal, cuando uno redacta una carta, debe respetar ciertas sangrías, los lenguajes informáticos requieren una identación.\n",
    "\n",
    "\n",
    "- No todos los lenguajes de programación, necesitan de una indentación, aunque, sí se estila implementarla a fin de otorgar mayor legibilidad al código fuente. \n",
    "\n",
    "\n",
    "- En *Python*, la indentación es ***OBLIGATORIA***, ya que de ella, dependerá su estructura.\n",
    "\n",
    "\n",
    "- ***[PEP8](https://www.python.org/dev/peps/pep-0008 \"Guia de Estilo Python\"):*** Guía de Estilo para Codificación en *Python*. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "<p float=\"center\">\n",
    "  <img src=\"https://github.com/carlosalvarezh/Programacion_Python/blob/master/images/blocks.png?raw=true\" width=\"250\" />\n",
    "</p>\n",
    "\n",
    "Ref: http://www.python-course.eu/python3_blocks.php"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Estructura de Control"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "<div style=\"background-color:rgba(0, 0, 0, 0.0470588); padding:10px 0;font-family:monospace;\">\n",
    "Estructura de control <font color = \"red\">:</font><br>\n",
    "&nbsp;&nbsp;&nbsp;&nbsp; <font color = \"orange\">Expresiones </font><br>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Encoding"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "- El *encoding* (codificación) es otro de los elementos del lenguaje que no puede omitirse a la hora de hablar de *estructuras de control*.\n",
    "\n",
    "\n",
    "- El *encoding* no es más que una directiva que se coloca al inicio de un archivo *Python*, a fin de indicar al sistema, la codificación de caracteres utilizada en el archivo."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "#-*- coding: utf-8 -*-"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "- `utf-8` podría ser cualquier codificación de caracteres. Si no se indica una codificación de caracteres, *Python* podría producir un error si encontrara caracteres “extraños”:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Condicionales"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "<div style=\"background-color:rgba(0, 0, 0, 0.0470588); padding:10px 0;font-family:monospace;\">\n",
    "si <font color = \"red\">$<condicion$>:</font><br>\n",
    "&nbsp;&nbsp;&nbsp;&nbsp; <font color = \"orange\">Acción por Verdadero</font><br>\n",
    "sino <font color = \"red\">:</font><br>\n",
    "&nbsp;&nbsp;&nbsp;&nbsp; <font color = \"orange\">Acción por Falso</font><br>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "- El condicional es uno de los controles de flujo más usados.\n",
    "\n",
    "\n",
    "- Permite al programa evaluar si cierta condición es alcanzada y realizar la acción apropiada basada en el resultado de dicha evaluación.\n",
    "\n",
    "\n",
    "- Los tipos de datos booleans y relacionales cobran vital importancia.\n",
    "\n",
    "\n",
    "- La evaluación solo puede arrojar uno de dos resultados: `True` o `False`\n",
    "\n",
    "en `python` la estructura general es, por ejemplo:\n",
    "\n",
    "```python\n",
    "if <condicion 1>:\n",
    "    acción cuando condición 1 es True\n",
    "elif <condición 2>: \n",
    "    acción cuando condición 2 es True\n",
    "else:\n",
    "    acción cuando condición 1  y condición 2 son False\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### `if`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "<p float=\"center\">\n",
    "  <img src=\"https://github.com/carlosalvarezh/Programacion_Python/blob/master/images/Condicionales.png?raw=true\" width=\"350\" />\n",
    "</p>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Veamos el siguiente ejemplo en donde se solicita al usuario que ingrese dos valores enteros `a` y `b`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = int(input(\"Ingrese el valor de a: \"))\n",
    "b = int(input(\"Ingrese el valor de b: \"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La manera más simplista de evaluar si `a` es mayor, menor o igual a `b` sería: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a == b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Como se puede observar, dependiendo del tipo de operador lógico que se presente la respuesta es `True` o `False`, pero no podemos obtener mayor información.\n",
    "\n",
    "Otra forma es emplear la estructura simple del `if` de la siguiente manera"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "if a > b:\n",
    "    print (\"a es mayor que b\")\n",
    "\n",
    "if a < b:\n",
    "    print (\"b es mayor que a\")\n",
    "    \n",
    "if a == b:\n",
    "    print(\"a y b son iguales\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Se observan dos características importantes que se diferencian de otros lenguajes de programación:\n",
    "\n",
    "\n",
    "- El bloque `if` se determina por la indentación debajo del condicional `if`\n",
    "\n",
    "\n",
    "- La línea del condicional `if` finaliza siempre con `:` (dos puntos o colon)\n",
    "\n",
    "\n",
    "La sentencia print solo se ejecutará si el resultado de la evaluación del condicional es `True`\n",
    "\n",
    "\n",
    "- Si se deseara ejecutar más de una sentencia en el casi de que la condición no se cumpliera, habría qué añadir otra sentencia `if`, esto hace el código poco legible y muy dispendioso."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "En esta forma se observa que siempre se ejecutarán cada una de las tres sentencias `if`, esto porque se presentan de forma separada y en cada una de ellas se deberá realizar su evaluación, así la condición `True` se alla dado en la primera sentencia y se sepa que el resto serán `False`. Esto hace con que el código sea ineficiente."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### `if ... else`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ahora veamos la siguiente estructura en donde se presenta la forma completa en `Python` `if... else` (que en seudocódigo sería la conocida estructura: `if... then ... else` (el `then` en `Python` serían los `:`)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "if a > b:\n",
    "    print (\"a es mayor que b\")\n",
    "else:\n",
    "    print (\"a es menor o igual que b\")  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "- La primera sentencia se ejecuta si el resultado de su evaluación es verdadero (`True`), sino (`else`) se ejecuta la segunda sentencia cuando la evaluación es falso (`False`)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### `if ... elif ... else`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "- Cuando se tienen várias sentencias condicionales anidadas para evaluarse, la estructura más recomendada es `if ... elif...elif...else`.\n",
    "\n",
    "\n",
    "- `elif` es una contracción de `else if` (*si no, si...*).\n",
    "\n",
    "\n",
    "- Se evalúa la primera condición, si es cierta, se ejecutan las sentencias debajo de ella, si no, se evalúa una segunda condición, si es verdadera, se ejecutan las sentencias de esta segunda, si no, si.... hasta que ya no queden más condiciones que evaluar.\n",
    "\n",
    "\n",
    "- El último condicional será un `else`, que no tiene condicional a evaluar y se ejecutará si la evaluación de todos los anteriores fue `False`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "scrolled": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "<p float=\"center\">\n",
    "  <img src=\"https://github.com/carlosalvarezh/Programacion_Python/blob/master/images/Condicional_if_else.png?raw=true\" width=\"500\" />\n",
    "</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "if a > b:\n",
    "    print(\"a es mayor que b\") #se evalúa si la condición a > b es True\n",
    "elif a < b:\n",
    "    print(\"a es menor que b\") #se evalúa si la condición a < b es True\n",
    "else:\n",
    "    print(\"a y b son iguales\") #se evalúa la condición, o condiciones, restantes que no fueron tenidas en cuenta anteriormente"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = input()\n",
    "\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Una estructura más compleja para evaluar tres datos podría ser:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "<p float=\"center\">\n",
    "  <img src=\"https://github.com/carlosalvarezh/Programacion_Python/blob/master/images/Condicional_if_elif_else.png?raw=true\" width=\"900\" />\n",
    "</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "a = int(input(\"Ingrese el valor de a: \"))\n",
    "b = int(input(\"Ingrese el valor de b: \"))\n",
    "c = int(input(\"Ingrese el valor de c: \"))\n",
    "\n",
    "if a > b:\n",
    "    if a > c:\n",
    "        print (\"a es mayor que b y c\")\n",
    "    else:\n",
    "        print (\"c es mayor que a y b\")\n",
    "else:\n",
    "    if b > c:\n",
    "        print (\"b es mayor que a y c\")\n",
    "    else:\n",
    "        print (\"c es mayor que a y b\") "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "> Cómo sería el algoritmo para determinar si los valores `a`, `b`, y/o `c`, son iguales?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Ciclos (Bucles o Loops)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p float=\"center\">\n",
    "  <img src=\"https://github.com/carlosalvarezh/Fundamentos_Programacion/blob/main/images/mobiusescher.gif?raw=true\" width=\"300\" />\n",
    "</p>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Permiten ejecutar un mismo fragmento de código un cierto número de veces, mientras se cumpla una determinada condición.\n",
    "\n",
    "`Python` suministra dos tipos de ciclos: \n",
    "\n",
    "- ***Ciclo controlado por una condición:*** El ciclo se repite hasta que cambie una condición dada (de `True` a `False`, por ejemplo, o viceversa) dependiendo del tipo de ciclo.\n",
    "\n",
    "\n",
    "- ***Ciclo controlado por una colección:*** Esta es una construcción especial que permite recorrer los elementos de una \"*colección*\", que puede ser una matriz, una lista u otra secuencia ordenada. Al igual que el bucle for del shell bash (por ejemplo, `para i in *, do echo $ i; done`) o el bucle `foreach` de `Perl` "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Contadores, acumuladores e indicadores"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "De los usos más empleados en ciclos es para acumular o contar valores. La estructura general es:\n",
    "\n",
    "<div style=\"background-color:rgba(0, 0, 0, 0.0470588); padding:10px 0;font-family:monospace;\">\n",
    "variable <font color = \"red\">inicializacion</font><br>\n",
    "ciclo <font color = \"red\">desde:hasta</font><br>\n",
    "&nbsp;&nbsp;&nbsp;&nbsp; <font color = \"orange\">variable = variable + [contador o acumulador] </font><br>\n",
    "</div>\n",
    "\n",
    "Estas estructuras por lo general van incorporadas a las estructuras de ciclos `while` o `for`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Contador"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Un contador es una ***variable entera*** que se utiliza para contar la ocurrencia de un suceso. \n",
    "\n",
    "- ***inicialización:*** variable con un valor inicial. Usualmente es cero, pero dependerá del tipo de problema a realizar. Por ejemplo:\n",
    "\n",
    "<div style=\"background-color:rgba(0, 0, 0, 0.0470588); padding:10px 0;font-family:monospace;\">\n",
    "inicio = <font color = \"red\">0</font><br>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- ***incremento:*** valor que estipula la forma en que se incrementa el valor inicial cada vez. Lo usual es que sea de a $1$, pero dependerá del tipo de problema a realizar. Por ejemplo:\n",
    "\n",
    "<div style=\"background-color:rgba(0, 0, 0, 0.0470588); padding:10px 0;font-family:monospace;\">\n",
    "inicio = <font color = \"red\">inicio + 1</font><br>\n",
    "</div>\n",
    "    \n",
    "Observe algo importante, el valor incrementado (lado derecho) se almacena nuevamente en la misma variable incremento (lado izquierdo) de la asignación. Esto se hace para ahorrar espacio en memoria, pero eventualmente puede ser necesario realizar esta operación empleando una nueva variable.\n",
    "\n",
    "La escritura `pythonist` de realizar esto es:\n",
    "\n",
    "<div style=\"background-color:rgba(0, 0, 0, 0.0470588); padding:10px 0;font-family:monospace;\">\n",
    "inicio += <font color = \"red\">1</font><br>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "inicio = 0\n",
    "print(\"valor inicial: \", inicio)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "inicio += 1 #pasarlo a la forma pythonist\n",
    "print(\"valor inicial: \", inicio)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Acumulador"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Un acumulador es una ***variable numérica*** que permite ir acumulando operaciones, permitiendo ir haciendo operaciones parciales. Un acumulador:\n",
    "\n",
    "- ***Se inicializa*** a un valor inicial según la operación que se va a acumular: a 0 si es una suma o a 1 si es un producto.\n",
    "\n",
    "\n",
    "- ***Se acumula*** un valor intermedio.\n",
    "\n",
    "presenta la misma estructura del contador, pero el sentido para el que se aplica es diferente."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Indicador"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Un indicador, o bandera (flag en inglés), es una ***variable lógica***, que usamos para recordar o indicar algún suceso. Un indicador:\n",
    "\n",
    "- ***Se inicializa*** a un valor lógico que indica que el suceso no ha ocurrido.\n",
    "\n",
    "<div style=\"background-color:rgba(0, 0, 0, 0.0470588); padding:10px 0;font-family:monospace;\">\n",
    "indicador = <font color = \"red\">False</font><br>\n",
    "</div>\n",
    "\n",
    "\n",
    "- ***Cuando ocurre el suceso que queremos recordar*** cambiamos su valor.\n",
    "\n",
    "<div style=\"background-color:rgba(0, 0, 0, 0.0470588); padding:10px 0;font-family:monospace;\">\n",
    "indicador = <font color = \"red\">True</font><br>\n",
    "</div>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Ciclo mientras (`while`)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "- Ejecuta repetidamente un mismo código ***mientras*** se cumple una condición."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "<p float=\"center\">\n",
    "  <img src=\"https://github.com/carlosalvarezh/Fundamentos_Programacion/blob/main/images/while-loop.PNG?raw=true\" width=\"450\" />\n",
    "</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "# cuenta n primeros numeros\n",
    "\n",
    "n = 11 #int(input('Ingrese el número de veces que quiere realizar el ciclo: '))\n",
    "\n",
    "i = 0\n",
    "suma = 0\n",
    "\n",
    "while i < n :\n",
    "    i += 1    # Contador\n",
    "    suma += i # acumulador\n",
    "    \n",
    "print(\"la suma de los {0:d} primeros números es {1:d}\".format(n,suma))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "a = int(input('ingrese el valor de a: '))\n",
    "\n",
    "while a > 0:\n",
    "    print('el valor de a es', a)\n",
    "    a = int(input('ingrese el valor de a: '))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "year = 1897\n",
    "while year <= 2021:\n",
    "    print(\"estamos en el año\", year)\n",
    "    year += 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "- Este ciclo se ejecutará las veces que sea necesario mientras que se cumpla la condición especificada, es decir, mientras que la variable `year` sea menor o igual que el valor `2012`.\n",
    "\n",
    "\n",
    "- La última línea del código `year += 1` se refiere al incremento. La variable `year` se incrementa `1` en cada paso del ciclo."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Salida prematura de un ciclo while"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "> Una situación especial es cuando el valor que condiciona la iteración no es numérico, por ejemplo, y no puede incrementarse o es \"infinito\". En este caso, podremos utilizar una estructura de control condicional, anidada dentro del ciclo, y frenar la ejecución cuando el condicional deje de cumplirse, empleando lo que se conoce como una bandera (flag) que cambia de estado (de `True` a `False` o viceversa) en alguna parte dentro del ciclo o con la palabra clave reservada `break`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "#Empleando un flag\n",
    "\n",
    "salida = True\n",
    "while salida == True:\n",
    "    entrada = input(\"desea salir (y/n)? \")\n",
    "    if entrada == \"y\" or entrada == \"Y\":\n",
    "        salida = False\n",
    "    else:\n",
    "        print(entrada)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Emplenado la palabra reservada break\n",
    "salida = True\n",
    "while salida == True:\n",
    "    entrada = input(\"desea salir (y/n)? \")\n",
    "    if entrada == \"y\" or entrada == \"Y\":\n",
    "        break\n",
    "    else:\n",
    "        print(entrada)\n",
    "print(\"interrumpió ciclo\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import random\n",
    "n = 20\n",
    "aleatorio = int(n * random.random()) + 1\n",
    "adivinar = 0\n",
    "while adivinar != aleatorio:\n",
    "    adivinar = int(input(\"Ingrese un nuevo número: \"))\n",
    "    if adivinar > 0:\n",
    "        if adivinar > aleatorio:\n",
    "            print(\"Número muy grande\")\n",
    "        elif adivinar < aleatorio:\n",
    "            print(\"Número muy pequeño\")\n",
    "    else:\n",
    "        print(\"Te rendiste!\")\n",
    "        break\n",
    "else:\n",
    "    print(\"Lo conseguiste!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Otra situación que se puede encontrar dentro de un ciclo es pasar directamente a la siguiente iteración. Esto se hace con otra palabra reservada: `continue`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "numero = 0\n",
    "while numero < 10:\n",
    "    numero += 1\n",
    "    if numero % 2 == 2:\n",
    "        print(\"el número es\", numero)\n",
    "        continue\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Ciclo *hasta* (`for`)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "El ciclo `for` ejecuta un bloque de código repetidamente ***hasta que*** la condición en la sentencia `for` no sea más válida."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "```python\n",
    "for <variable> in <sequence>:\n",
    "\t<statements>\n",
    "else:\n",
    "    <statements>\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "![Imagen](https://github.com/carlosalvarezh/Programacion_Python/blob/master/images/Ciclo_for.png?raw=true \"\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Exemplo de un ciclo simple en `Python` empleando unas variables dentro de una secuencia (realmente es una lista, pero esto se verá más adelante)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "lenguajes = [\"C\", \"C++\", \"Perl\", \"Python\"] \n",
    "for x in lenguajes:\n",
    "    print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Se puede iterar sobre una cadena de caracteres"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "palabra = \"parangaricutirimicuaro\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in palabra:\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "o sobre una porción de una cadena de caracteres"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in palabra[2:11:2]:\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Al igual que en el ciclo `while` podemos terminar de forma anticipada el ciclo empleando la palabra `break`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "comestibles = [\"jamón\", \"carne\",\"huevos\",\"tocineta\",\"frutas\"]\n",
    "for comida in comestibles:\n",
    "    if comida == \"huevos\":\n",
    "        print(\"No quiero huevos por favor!\")\n",
    "        break\n",
    "    print(\"Genial, Deliciosa \" + comida)\n",
    "else:\n",
    "    print(\"Estoy satisfecho, no hay huevos\")\n",
    "print(\"Finalmente, estoy satisfecho\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## La funcion `range()`\n",
    "\n",
    "La función incorporada `range()` es la función correcta para iterar sobre una secuencia de números. Genera un iterador de progresiones aritméticas. La estructura de la función es: \n",
    "\n",
    "```python\n",
    "range(start,stop,step)\n",
    "```\n",
    "\n",
    "en donde\n",
    "\n",
    "- ***`start`:*** valor entero que indica donde se quiere empezar la secuencia. Si se omite, por defecto es cero, `0`.\n",
    "\n",
    "\n",
    "- ***`stop`:*** valor entero que indica hasta donde se quiere crear la secuencia. Debe tenerse en cuenta que como empieza en cero, la secuencia finalizará en `stop - 1`. Es el único parámetro obligatorio de los tres.\n",
    "\n",
    "\n",
    "- ***`step`:*** valor entero que indica el incremento de la secuencia. Si se omite, por defecto es uno, `1`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### `range(stop)`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = range(10)\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para visualizar el resultado, coloquémoslo en una estructura de lista (esto se verá más adelante)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "list(range(10))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ahora volvieno a la estructura del ciclo `for`, podemos mostrar cada valor generado por la funcion, de forma independiente"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in range(10):\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Obséverese que se empleó un único argumente en la función. Este argumento por defecto es el `stop`, y los valores por defecto de `start=0` y `step=1`, pero podemos modificarlos según nuestra conveniencia o necesidad. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### `range(start,stop)`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ahora empleemos la función `range`con los parámetros de inicio de la secuencia, `start`, y fin `stop`. El valor por defecto del parámetro del paso `step=1`. Como ejemplo, imprimamos los elementos de una lista de valores de `1` a `10`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in range(5,10):\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Observe que se generó una secuencia de valores de `1` hasta `9` (`stop-1`). "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### `range(start,stop,step)`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Como ejemplo de su uso, mostremos los elementos de una lista de valores entre `1 - 10` con un paso de a `2`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in range(0,11,2):\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Observe que se generó la secuencia de valores impares desde el `1` hasta el `9`. Como actividad, modifique los parámetros para generar los elementos pares.\n",
    "\n",
    "Podemos también presentar los elementos de la lista en forma invertida."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in range(10,-1,-1):\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "En este caso, el valor del parámetro `start` es el mayor valor de la lista que se desea generar. El valor del parámetro `stop` debe ser el menor valor, y el valor del parámetro `step` debe ser negativo, para indicar un decrecimiento.\n",
    "\n",
    "Observe que, al igual que los ejemplos anteriores, el parámetro `stop` solo va hasta el valor `stop-1`, por lo que, si queremos mostrar el cero, debemos incrementar un valor en el sentido negativo, que en este caso sería ir hasta que `stop=-1`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in range(10,-1,-1):\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "tenga presente que el valor de `step` puede ser cualquier entero diferente de `0` (cero), pues esto ocasionará un error `ValueError`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in range(10,-1,0):\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Los tres parámetros `start`, `stop` y `step` también pueden ser todos negativos."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in range(-10,-20,-1):\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "la función `range` no soporta parámetros tipo `float`. Esto generará un error `TypeError`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in range(-10.,-20.,-1.):\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Operaciones con secuencias en la función `range`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Algunas operaciones comunes que se pueden realizar en conjunto con la función range son:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Prueba de pertenencia"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La prueba de pertenencia se puede realizar utilizando `in` y `not` en el operador.\n",
    "\n",
    "Por ejemplo, dada una secuencia de valores `s`\n",
    "\n",
    "```python\n",
    "x in s\n",
    "```\n",
    "- devolverá el valor `True` si un elemento de `s` es igual a `x`, de lo contrario devolverá el valor `False`\n",
    "\n",
    "```python\n",
    "x not in s\n",
    "```\n",
    "- devolverá `False` si un elemento de `s` es igual a `x`, de lo contrario devolverá el valor `True`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "s = range(5)\n",
    "print (3 in s)\n",
    "print (5 not in s)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### `len()`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Devolverá la cantidad de elementos generados por la función `range`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "r = range(235,52698,3)\n",
    "n = len(r)\n",
    "print(n)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Esta función es bastante útil cuando se quiere iterar sobre una secuencia de datos generados y no se sabe cuántos datos hay. Tener este conocimiento evitará sobrepasarnos de los límites de iteraciones. Por ejemplo:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "r = range(1, 10, 2)\n",
    "n = len(r)\n",
    "for i in range(n):\n",
    "    print(r[i])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "r = range(1, 10, 2)\n",
    "for i in range(10):\n",
    "    print(r[i])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### `min()`, `max()`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Devuelve el elemento más pequeño, `min()`, o más grande, `max()`, generados en la función `range`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "r = range(2,10,2)\n",
    "print (min(r))\n",
    "print(max(r))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "r = range(-10,-20,-2)\n",
    "print(min(r))\n",
    "print(max(r))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "## Laboratorio"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1. ***Números Pitagóricos:*** Tres números que satisfacen la relación $a^{2}+b^{2}=c^{2}$ son llamados *Numeros Pitagóricos*. Realice un programa que calcule todos los *números pitagóricos* menores que un número máximo.\n",
    "\n",
    "\n",
    "2. ***Sucesión de Fibonacci:*** En matemática, la $\\it{Sucesión}$ $\\it{de}$ $\\it{Fibonacci}$ es la siguiente sucesión infinita de números naturales: $0, 1, 1, 2, 3, 5, 8, 13, 21, ...$. La sucesión comienza con los números $0$ y $1$ y a partir de estos, «*cada término es la suma de los dos anteriores*», es la relación de recurrencia que la define. Realice un programa que entregue los primeros $n$ números de la $\\it{Sucesión}$ $\\it{de}$ $\\it{Fibonacci}$. Realice ambos programas con *for* y *while*. Cuál sería la diferencia?\n",
    "\n",
    "\n",
    "3. En el ejercicio del cálculo del área por el método de Herón, implemente la desigualdad triangular: \"*En todo triángulo la suma de las longitudes de dos lados cualquiera es siempre mayor a la longitud del lado restante*\". Implemente también un criterio que evite el ingreso de valores negativos de alguno de los lados.\n",
    "\n",
    "\n",
    "4. ***Suma según Gauss:*** Realizar un programa que calcule la suma de los 100 primeros números, pero como fue realizado por *Gauss* según la leyenda."
   ]
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "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.3"
  },
  "latex_envs": {
   "LaTeX_envs_menu_present": true,
   "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": true,
   "user_envs_cfg": true
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": true,
   "title_cell": "Tabla de Contenidos",
   "title_sidebar": "Contenidos",
   "toc_cell": false,
   "toc_position": {
    "height": "calc(100% - 180px)",
    "left": "10px",
    "top": "150px",
    "width": "182.167px"
   },
   "toc_section_display": true,
   "toc_window_display": 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": 2
}