14_iteraciones.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[![pythonista.io](imagenes/pythonista.png)](https://www.pythonista.io)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "# Iteraciones con ```for```... ```in```.\n",
    "\n",
    "\n",
    "## Objetos iterables.\n",
    "\n",
    "Una de las grandes fortalezas de Python es la de poder de realizar iteraciones de forma dinámica a partir de diversos objetos \"iterables\", los cuales son colecciones de objetos con métodos capaces de regresar elementos de uno en uno.\n",
    "\n",
    "Algunos tipos iterables son:\n",
    "\n",
    "* ```str```.\n",
    "* ```list```.\n",
    "* ```tuple```.\n",
    "* ```dict```.\n",
    "* ```set```.\n",
    "* ```frozenset```.\n",
    "* ```bytes```.\n",
    "* ```bytearray```."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Iteradores y generadores.\n",
    "\n",
    "Además de los objetos iterables existen otros objetos capaces de regresar otros objetos de uno en uno. Estos objetos son los iteradores y los generadores, los cuales se estudiarán más adelante."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## La estructura ```for``` ... ```in```.\n",
    "\n",
    "Para iterar un objeto iterable se utiliza la siguiente sintaxis:\n",
    "\n",
    "```\n",
    "for <nombre> in <iterable>:\n",
    "    ...\n",
    "    ...\n",
    "```\n",
    "Donde: \n",
    "\n",
    "* ```<iterable>``` puede ser un objeto iterable, un iterador o un generador.\n",
    "\n",
    "* ```<nombre>``` es el nombre al que se le asignará cada objeto entregado por el objeto iterable en cada iteración. Al final, dicho estará ligado al último objeto entregado."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Ejemplos:**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* La siguiente celda asignará al nombre ```letra``` cada caracter del objeto ```'Chapultepec'```, el cual será desplegado por la función ```print()```. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for letra in \"Chapultepec\":\n",
    "    print(letra)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* El nombre ```letra``` queda ligado al objeto ```'c'```, el cual es el útlimo elemento del objeto ```'Chapultepec'```."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "letra"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* La siguiente celda asignará al nombre ```item``` cada elemento contenido en el objeto ```['uno', 'dos', 3]```, el cual será desplegado por la función ```print()```. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for item in ['uno', 'dos', 3]:\n",
    "    print(item)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* El nombre ```item``` queda ligado al objeto ```'3'```, el cual es el útlimo elemento del objeto ```['uno', 'dos', 3]\n",
    "```."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "item"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Iteraciones con  la función ```range()```.\n",
    "\n",
    "La forma más común de realizar iteraciones en otros lenguajes de programación es por medio de rangos numéricos de forma similar a lo que hace la función ```range()```.\n",
    "\n",
    "Esta función es un generador que regresa una sucesión de números en un rango definido.\n",
    "\n",
    "```\n",
    "range(<m>, <n>, <s>)\n",
    "```\n",
    "\n",
    "Donde:\n",
    "\n",
    "* ```<m>``` es el primer número del rango.\n",
    "* ```<n>``` es el valor límite del rango. La sucesión llegará a un número previo a ```n```.\n",
    "* ```<s>``` es a magnitud de los inrementos o decrementos del rango.\n",
    "\n",
    "Si sólo se ingresa un argumento, ese valor se le asignará a ```n```, mientras que ```<m>``` será igual a ```0``` y ```<s>``` será igual a ```1```.\n",
    "\n",
    "Si sólo se ingresan 2 argumentos, el primero se le asignará a ```m```, el segundo a ```<n>``` y ```<s>``` será igual a ```1```.\n",
    "\n",
    "Es posible que el valor de ```<s>``` sea negativo siempre que ```m```, sea menor que ```<n>```."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Ejemplos:**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* La siguiente celda desplegará una sucesión de números del ```0``` al  ```7``` en incrmentos de  ```1```."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"\"\" Cuenta del 0 hasta 7 en incrementos de a 1.\"\"\"\n",
    "for contador in range(8):\n",
    "    print(contador)\n",
    "print()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* La siguiente celda desplegará una sucesión de números del ```5``` al  ```9``` en incrementos de  ```1```."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"\"\" Cuenta del 5 hasta antes de 9 en incrementos de a 1. \"\"\"\n",
    "for contador in range(5, 9):\n",
    "    print(contador)\n",
    "print()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* La siguiente celda desplegará una sucesión de números del ```3``` al  ```9``` en incrementos de  ```2```."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"\"\" Cuenta de 3 hasta antess de 11 en incrementos de a 2. \"\"\"\n",
    "for contador in range(3, 11, 2):\n",
    "    print(contador)\n",
    "print()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* La siguiente celda desplegará una sucesión de números del ```26``` al  ```14``` en decrementos de  ```-4```."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"\"\" Cuenta del 26 hasta más de 10 en decrementos de a -4. \"\"\"\n",
    "for contador in range(26, 10, -4):\n",
    "    print(contador)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Desempaquetado.\n",
    "\n",
    "Python permite el uso de expresiones capaces de asignar valores a mas de un nombre a partir de una colección.\n",
    "\n",
    "Si el número de nombres coincide con el número de objetos contenidos en la colección, entonces se asignará el primer valor al primer nombre y así sucesivamente. \n",
    "\n",
    "```\n",
    "<nombre 1>, <nombre 2>, ..., <nombre n> = <colección de tamaño n> \n",
    "```\n",
    "\n",
    "En caso de que el número de nombres y el tamaño de la colección no coincida, se desencadenará un error de tipo ```ValueError```."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Ejemplo:**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* La siguiente celda asignará a cada uno de los 3 nombres definidos el valor de cada elemento del objeto tipo ```list``` cuyo tamaño es igual a ```3```."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "nombre, apellido, calificacion = 'Juan', 'Pérez', 7.5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "nombre"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "apellido"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "calificacion"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* En la siguiente celda se intentarán asignar 3 nombres a partir de una colección con 4 elementos, lo que desencadenará un error de tipo ```ValueError```."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "nombre, apellido, calificacion = ['Juan', 'Pérez', 'Erroneo', 7.5]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Desempaquetado con ```for```... ```in```.\n",
    "\n",
    "La declaración  ```for``` ... ```in```  es capaz de realizar el desempaquetado de colecciones contenidas dentro de un objeto iterable cuando se definen más de un nombre. La condición es que el tamaño de las colecciones que regrese el objeto iterable sea igual al numero de nombres definidos después del ```for```.\n",
    "\n",
    "```\n",
    "for <nombre 1>, <nombre 2>, ..., <nombre n> in <iterable>:\n",
    "    ...\n",
    "    ...\n",
    "    \n",
    "```\n",
    "\n",
    "Donde:\n",
    "\n",
    "* ```<iterable>``` es un objeto capaz de regresar colecciones de tamaño ```n``` en cada iteración.\n",
    "* ```<nombre x>``` es el nombre al que se le asignará el elemento con índice ```x``` a partir de la colección de tamaño ```n ```."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Ejemplo:**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* El objeto ```palabras``` es un objeto de tipo ```list``` que contiene objetos de tipo ```str``` de 4 letras."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "palabras = [\"gato\", \"pato\", \"zeta\", \"cita\"]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* La siguiente celda hará una iteración para cada objeto contenido por ```palabras```, el cual será asignado a ```item``` en cada iteración."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for item in palabras:\n",
    "    print(item)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* La siguiente celda realizará una iteración para cada elemento contenido en ```palabras```. \n",
    "* Para cada elemento obtenido en la iteración desempacará los 4 caracteres que contiene y los asignará de forma consecutiva a:\n",
    "    * ```primera```\n",
    "    * ```segunda```\n",
    "    * ```tercera```\n",
    "    * ```cuarta```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for primera, segunda, tercera, cuarta in palabras:\n",
    "    print(primera)\n",
    "    print(segunda)\n",
    "    print(tercera)\n",
    "    print(cuarta)\n",
    "    print(\"----------\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"text-align: center\"><a rel=\"license\" href=\"http://creativecommons.org/licenses/by/4.0/\"><img alt=\"Licencia Creative Commons\" style=\"border-width:0\" src=\"https://i.creativecommons.org/l/by/4.0/80x15.png\" /></a><br />Esta obra está bajo una <a rel=\"license\" href=\"http://creativecommons.org/licenses/by/4.0/\">Licencia Creative Commons Atribución 4.0 Internacional</a>.</p>\n",
    "<p style=\"text-align: center\">&copy; José Luis Chiquete Valdivieso. 2020.</p>"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}