Clase 3 - Bucles.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Bucles\n",
    "\n",
    "Así como podemos necesitar que uno u otro fragmento de código dependiendo de ciertas condiciones, también podemos necesitar que un fragmento de código se repita tantas veces como se cumpla una condición. Para ello utilizamos los **Bucles**.\n",
    "\n",
    "De **Python para todos** de _Raúl Gonzalez Duque_:\n",
    "\n",
    "> Mientras que los condicionales nos permiten ejecutar distintos fragmentos de código dependiendo de ciertas condiciones, los bucles nos permiten ejecutar un mismo fragmento de código un cierto número de veces, mientras se cumpla una determinada condición.\n",
    "\n",
    "En Python encontraremos dos tipos de bucles: `for` y `while`.\n",
    "\n",
    "### `while`\n",
    "\n",
    "`While` (_mientras_ en inglés) nos permite ejecutar fragmento un código, **mientras** vez que se cumpla una condición.\n",
    "\n",
    "Veamos un ejemplo:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n",
      "6\n",
      "7\n",
      "8\n",
      "9\n",
      "10\n"
     ]
    }
   ],
   "source": [
    "n = 1\n",
    "\n",
    "while n <= 10:\n",
    "    print(n)\n",
    "    n = n+1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Si representaramos el fragmento de código con un flujograma tendríamos:\n",
    "\n",
    "![Bucle while](./Diagramas/Ejemplo-while.png)\n",
    "\n",
    "Para definir entonces un bucle utilizando `while` debemos comenzar la linea con `while`, seguido de la condición que queremos (aquí `n <= 10`) y finalizamos la linea con `:`.\n",
    "\n",
    "Después escribimos el bloque de código que queremos que se ejecute indendado a 4 espacios.\n",
    "\n",
    "Para el caso de este bucle, tenemos que agregar al final una linea que incremente la variable (`n = n+1`), para que el bucle pueda finalizar en algún momento. Si no el bucle se repetería una y otra vez sin nunca lograr terminar (lo que se llama un _bucle infinito_).\n",
    "\n",
    "Como este tipo de operaciones son muy comunes, en python se puede ocupar el operador `+=`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n",
      "6\n",
      "7\n",
      "8\n",
      "9\n",
      "10\n"
     ]
    }
   ],
   "source": [
    "n = 1\n",
    "\n",
    "while n <= 10:\n",
    "    print(n)\n",
    "    n += 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "También existen los operadores `*=`, `-=`, etc.\n",
    "\n",
    "Muchas veces los bucles infinitos pueden llegar a ser útiles en un programa, por ejemplo:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Ingrese un número positivo:  -5\n",
      "Error. Por favor ingrese un número positivo:  -2\n",
      "Error. Por favor ingrese un número positivo:  0\n",
      "Error. Por favor ingrese un número positivo:  4\n"
     ]
    }
   ],
   "source": [
    "numero = int(input(\"Ingrese un número positivo: \"))\n",
    "\n",
    "while numero <= 0:\n",
    "    numero = int(input(\"Error. Por favor ingrese un número positivo: \"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "En este caso el bucle se repite hasta que el usuario ingrese un número correcto.\n",
    "\n",
    "También se pueden utilizar `else` en los bucles (tanto `while` como `for`) que son fragmentos de código que se ejecutan al finalizar el bucle:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n",
      "6\n",
      "7\n",
      "8\n",
      "9\n",
      "10\n",
      "Fin\n"
     ]
    }
   ],
   "source": [
    "n = 1\n",
    "\n",
    "while n <= 10:\n",
    "    print(n)\n",
    "    n += 1\n",
    "else:\n",
    "    print(\"Fin\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## `for`\n",
    "\n",
    "La secuencia`for` (_para_ en inglés) nos permite iterar sobre los elementos de una secuencia. Así se ejecutará el mismo bloque de código, **para todos los elementos** de la secuencia. Por ejemplo:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n",
      "6\n",
      "7\n",
      "8\n"
     ]
    }
   ],
   "source": [
    "numeros = 1, 2, 3, 4, 5, 6, 7, 8\n",
    "\n",
    "for elemento in numeros:\n",
    "    print(elemento)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Vemos entonces que para crear un bucle debemos comenzar la linea con `for`, luego poner el nombre de la variable que almacenará los valores del la secuencia dentro del bucle (en nuestro caso `elemento`), la palabra `in`(_en_ en inglés), y la secuencia sobre la que queremos iterar."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### `range`\n",
    "\n",
    "A medida que las secuencias con elementos a iterar crece, se vuelve tedioso escribir todos los valores a mano. Para evitarnos este trabajo python tiene la función `range()`:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Sin embargo, a medida que la lista con elementos a iterar crece, se vuelve tedioso escribir una lista con todos los valores. Para evitarnos este trabajo python tiene la función `range()`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "El cubo de 0 es 0\n",
      "El cubo de 1 es 1\n",
      "El cubo de 2 es 8\n",
      "El cubo de 3 es 27\n",
      "El cubo de 4 es 64\n",
      "El cubo de 5 es 125\n",
      "El cubo de 6 es 216\n",
      "El cubo de 7 es 343\n",
      "El cubo de 8 es 512\n",
      "El cubo de 9 es 729\n"
     ]
    }
   ],
   "source": [
    "for i in range(10):\n",
    "    print(\"El cubo de\", i, \"es\", i**3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Vemos que `range()` genera una secuencia que va desde el 0 hasta el número que especificamos, **sin incluirlo**. Si queremos, entonces, crear una lista que vaya del uno al número que queremos, tenemos dos opciones:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "El cubo de 0 es 0\n",
      "El cubo de 1 es 1\n",
      "El cubo de 2 es 8\n",
      "El cubo de 3 es 27\n",
      "El cubo de 4 es 64\n",
      "El cubo de 5 es 125\n",
      "El cubo de 6 es 216\n",
      "El cubo de 7 es 343\n",
      "El cubo de 8 es 512\n",
      "El cubo de 9 es 729\n",
      "El cubo de 10 es 1000\n"
     ]
    }
   ],
   "source": [
    "for i in range(11):\n",
    "    print(\"El cubo de\", i, \"es\", i**3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "El cubo de 0 es 0\n",
      "El cubo de 1 es 1\n",
      "El cubo de 2 es 8\n",
      "El cubo de 3 es 27\n",
      "El cubo de 4 es 64\n",
      "El cubo de 5 es 125\n",
      "El cubo de 6 es 216\n",
      "El cubo de 7 es 343\n",
      "El cubo de 8 es 512\n",
      "El cubo de 9 es 729\n",
      "El cubo de 10 es 1000\n"
     ]
    }
   ],
   "source": [
    "for i in range(10+1):\n",
    "    print(\"El cubo de\", i, \"es\", i**3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La segunda nos puede llegar a ser útil en alguno de los casos que el número final lo ingrese el usuario.\n",
    "\n",
    "También podemos ingresar el número en el que queremos que empiece la función `range`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Los números pares entre 1 y 10 son:\n",
      "2\n",
      "4\n",
      "6\n",
      "8\n",
      "10\n"
     ]
    }
   ],
   "source": [
    "print(\"Los números pares entre 1 y 10 son:\")\n",
    "\n",
    "for x in range(1, 11):\n",
    "    if x%2 == 0:\n",
    "        print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Así también podemos especificar el incremento de la función:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Los números múltiplos de 3 entre 1 y 20 son:\n",
      "3\n",
      "6\n",
      "9\n",
      "12\n",
      "15\n",
      "18\n"
     ]
    }
   ],
   "source": [
    "print(\"Los números múltiplos de 3 entre 1 y 20 son:\")\n",
    "\n",
    "for x in range(3, 21, 3):\n",
    "    print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Veamos ahora un ejemplo del uso de un bucle for con funciones.\n",
    "\n",
    "##### Ejemplo 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def masa_alcano(cant_carbonos):\n",
    "    \"\"\"Calcula la masa de un alcano linea, ingresando la cantidad de carbonos de la cadena\n",
    "    \"\"\"\n",
    "    cant_hidrogenos = 2*cant_carbonos + 2\n",
    "    masa_molecular = 12*cant_carbonos + 1*cant_hidrogenos\n",
    "    return masa_molecular"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "En ese caso podemos calcular la masa de los distintos compuestos de la cadena de alcanos llamando a la función `masa_alcano`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(16, 30)"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "masa_alcano(1), masa_alcano(2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Si queremos calcular la masa molecular de los primeros 10 alcanos de la serie, podríamos hacer lo siguiente:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "La masa del alcano con 1 carbonos es 16\n",
      "La masa del alcano con 2 carbonos es 30\n",
      "La masa del alcano con 3 carbonos es 44\n",
      "La masa del alcano con 4 carbonos es 58\n",
      "La masa del alcano con 5 carbonos es 72\n",
      "La masa del alcano con 6 carbonos es 86\n",
      "La masa del alcano con 7 carbonos es 100\n",
      "La masa del alcano con 8 carbonos es 114\n",
      "La masa del alcano con 9 carbonos es 128\n",
      "La masa del alcano con 10 carbonos es 142\n"
     ]
    }
   ],
   "source": [
    "for cantidad in range(1, 11):\n",
    "    print(\"La masa del alcano con\", cantidad, \"carbonos es\", masa_alcano(cantidad))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Acumuladores y contadores\n",
    "\n",
    "En muchos programas necesitaremos incluir distintas variables dentro de los bucles, de modo tal de que estas se modifiquen a medida de que se ejecute el código. Para distintos casos necesitaremos entonces **Acumuladores** y **Contadores**.\n",
    "\n",
    "#### Acumuladores\n",
    "\n",
    "Los contadores son un tipo de variable que se incrementa (o decrementa) en un cierto valor a medida que se ejecuta un fragmento de código. Veamos un ejemplo:\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Ejemplo 2\n",
    "Cree un programa que calcule la suma desde 1 hasta el número ingresado por el usuario"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "collapsed": true
   },
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Ingrese un número:  4\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n"
     ]
    }
   ],
   "source": [
    "final = int(input(\"Ingrese un número: \"))\n",
    "\n",
    "sumatoria = 0\n",
    "\n",
    "for numero in range(1, final+1):\n",
    "    sumatoria += numero\n",
    "\n",
    "print(sumatoria)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "En este ejemplo, la variable `sumatoria` es un _acumulador_.\n",
    "\n",
    "Lo primero que obsevamos es que esta variable está definida _fuera del bucle_ con el valor 0. A esto se denomina _\"inicializar el acumulador\"_ y siempre tiene que hacerse, ya que si no python no va a saber a que valor sumarle la variable `i` dentro del bucle. \n",
    "\n",
    "Además **nunca** debe hacerse `acumulador = 0` dentro del bucle, ya que esto resetearía el valor a cero en cada iteración."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pensemos ahora en qué hace la siguiente línea:\n",
    "\n",
    "```python\n",
    "sumatoria += numero\n",
    "```\n",
    "\n",
    "Como ya lo vimos arriba, este fragmento es igual a escribir:\n",
    "\n",
    "```python\n",
    "sumatoria = sumatoria + numero\n",
    "```\n",
    "\n",
    "Allí al valor de `sumatoria` se le suma el valor de `numero`, y se lo guarda en `sumatoria` nuevamente (de allí el nombre **acumulador**).\n",
    "\n",
    "Veamos ahora un ejemplo de acumulador dentro de una función:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Ejemplo 2\n",
    "\n",
    "Defina una función que calcule el factorial de un número dado"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def factorial(nro):\n",
    "    \"\"\"Calcula el factorial del número ingresado\n",
    "    \"\"\"\n",
    "    factorial=1\n",
    "    for i in range(1, nro+1):\n",
    "        factorial *= i\n",
    "        \n",
    "    return factorial"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "720"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "factorial(6)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Contadores\n",
    "\n",
    "Los contadores son un tipo de variable que tienen una función especial, incrementarse cada vez que se cumpla una determinada condición. Por ejemplo, cuando vimos el ejemplo con `while` teníamos una variable `n` que se incrementaba en uno en cada ciclo del bucle (`n += 1`).  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para aprender más de acumuladores y contadores puedes consultar el libro, así como también ver esta publicación en el blog [10 goto 10](https://medium.com/10-goto-10/algoritmos-variables-contadores-y-acumuladores-6d8f7d1bfbc7)"
   ]
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "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.6.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}