clases/clase_3/300_estructuras.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Estructuras"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Contenido\n",
    "\n",
    "* [Estructura de datos II](#Estructura-de-datos-II)\n",
    "    * [Listas](#Listas)\n",
    "* [Introducción a estructuras de control de flujo II](#Introduccion-a-estructuras-de-control-de-flujo-II)\n",
    "    * [Estructuras de control iterativas](#Estructuras-de-control-iterativas)\n",
    "* [Funciones Built-in (iterables)](#Funciones-Built-in-(iterables))\n",
    "* [Referencias usadas en el notebook](#Referencias-usadas-en-el-notebook)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Objetivos del notebook\n",
    "\n",
    "* Aprender sobre estructuras de datos: `lista`.\n",
    "* Introducir a estructuras de control iterativas: `for` y `while`.\n",
    "* Funciones Built-in sobre iterables."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Estructura de datos II\n",
    "\n",
    "Python tiene varios tipos de datos compuestos, usados para agrupar otros valores de igual tipo o no."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Listas\n",
    "\n",
    "Las [listas](http://docs.python.org.ar/tutorial/3/introduction.html#listas) son una estructura de datos muy versátil, la cual puede ser escrita como una lista de valores separados por coma (ítems) entre corchetes. Las listas pueden contener **datos mutables** (los cuales pueden ser modificados una vez creados) de tipos diferentes, pero usualmente los datos son del mismo tipo. Usaremos listas para poder modelar datos compuestos pero cuya cantidad y valor varían a lo largo del tiempo.\n",
    "\n",
    "![](../img/listas.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = [1,2,3]  # Una lista vacía\n",
    "\n",
    "x.append(4)\n",
    "x.append(5)\n",
    "x.insert(0,0)\n",
    "\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "y = [0,1,2,3,4,5]  # Una lista de enteros\n",
    "\n",
    "# Listas heterogéneas\n",
    "s = [32, \"a\", -5, -2.349, [1,2,3], \"te\", \"crees\", \"muy\", \"lista?\"] \n",
    "\n",
    "l = [x,y]  # Lista de listas"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "type(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Verificar las variables creadas\n",
    "s"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "s[4][2] # Acceso a un dato de la lista dentro de la lista"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = [\"primero\", \"segundo\", \"tercero\", \"cuarto\", \"quinto\"]\n",
    "\n",
    "# Podemos indexar de igual manera que lo hicimos con el string.\n",
    "x[0]\n",
    "x[-1]\n",
    "x[0:5:2]\n",
    "x[::-1] # Al reves"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Las listas son **mutables** (como habíamos mencionado anteriormente). Esto implica que su **estructura puede cambiar**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x[1] = 2\n",
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x[0:2] = [\"hh\", \"tt\"]  # slicing también funciona\n",
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x[0:3] = [\"???\"]\n",
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x[1:1] = [\"333\"]\n",
    "x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Metodos de las listas\n",
    "\n",
    "Las listas en Python  tienen muchos métodos que podemos utilizar, entre todos ellos vamos a nombrar los más importantes. Para esto utilizaremos esta lista de ejemplo."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_list = [2, 5, 'UNTREF', 1.2, 5]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Permite agregar nuevos elementos a una lista\n",
    "my_list.append(\"cuatro\") # equivalente a x[len(x):] = [\"cuatro\"]\n",
    "my_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "y = [5,6,7]\n",
    "my_list.append(y) # equivalente a x[len(x):] = [y]\n",
    "my_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Extiende la lista agregándole todos los ítems del iterable\n",
    "y = [5,6,7]\n",
    "my_list.extend(y)  # equivalente a x[len(x):] = y\n",
    "my_list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Nota:** `extend` también nos permite agregar elementos dentro de una lista, pero a diferencia de `append` al momento de agregar una lista, cada elemento de esta lista se agrega como un elemento más dentro de la otra lista."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Quita el primer ítem de la lista cuyo valor sea x\n",
    "my_list.remove('hola')\n",
    "my_list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Otras operaciones en listas"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Quitar un ítem de una lista dado su índice en lugar de su valor\n",
    "del my_list[0]  # equivalente a x[0:1] = []\n",
    "my_list\n",
    "del my_list[2:5] # equivalente a x[2:5] = []\n",
    "my_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = [1,2,3]\n",
    "y = [4,5,6]\n",
    "x + y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "6 in x # parecido a find en MATLAB."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "4 in x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "5 not in x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = [None]*10\n",
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = [1,2]*3\n",
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "input --> lista\n",
    "sabemos que las listas solo son 1 dim f 1, c inf\n",
    "\n",
    "np.array = list\n",
    "\n",
    "np ~= list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "bs = [5,2,4,2]\n",
    "cs = sorted(bs) # ordenar en una nueva variable\n",
    "cs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ds = [5,3,4,5]\n",
    "ds.sort() # ordena en la misma variable\n",
    "ds"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "help(my_list.extend)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "help(my_list.reverse)\n",
    "# probar también help(list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[Más información](http://docs.python.org.ar/tutorial/3/datastructures.html?highlight=listas) respecto a listas."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Range\n",
    "\n",
    "Las estructuras de datos del tipo `range` es una **lista inmutable de números enteros en sucesión aritmética**. Inmutable significa que, a diferencia de las listas, los `range` no se pueden modificar.\n",
    "\n",
    "> **Nota:** En Python 2, `range()` se consideraba una función, pero en Python 3 no se considera una función, sino un tipo de datos, aunque se utiliza como si fuera una función.\n",
    "\n",
    "En Python tenemos tipos *mutables* (como **listas**, **diccionarios**) e *inmutables* (como los **numéricos**, **tuplas**, **string**, **range**)\n",
    "\n",
    "En resumen, recordar:\n",
    "* **Mutable:** el valor del objeto puede cambiar durante la vida del objeto como **listas**, **diccionarios**).\n",
    "* **Inmutable:** el valor del objeto no puede cambiar durante la vida del objeto (**tuplas**, **string**, **range**)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = range(10)\n",
    "y = range(10, 21)\n",
    "z = list(x) + list(y)\n",
    "print(z)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Introduccion a estructuras de control de flujo II\n",
    "\n",
    "### Estructuras de control iterativas \n",
    "\n",
    "A diferencia de las estructuras de control condicionales, las iterativas (también llamadas cíclicas o bucles), nos **permiten ejecutar un mismo código, de manera repetida, mientras se cumpla una iterables**.\n",
    "\n",
    "En Python se dispone de dos estructuras cíclicas:\n",
    "\n",
    "* El bucle `for` atado a una **secuencia**.\n",
    "* El bucle `while` atado a una **condición**."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### For\n",
    "\n",
    "El bucle `for`, en Python, es aquel que **nos permitirá iterar sobre estructuras de datos**. Es una estructura de control **destinada a realizar un número finito de ciclos y una o varias acciones**. Es decir, para una determinada variable, que avanza de 1 en 1 (o no...) desde el límite inferior hasta el límite superior ejecutamos el cuerpo de la sentencia. Pero a diferencia de otros lenguajes **no necesariamente es una progresión aritmética de números, lo hace sobre elementos de cualquier secuencia**, como veremos en los ejemplos.\n",
    "\n",
    "El cuerpo puede depender o no de la variable contador, ésta puede ser un contador aparte, que simplemente nos imponga que una determinada sentencia que se ejecute un número j de veces. **La mayoría de las veces nuestro cuerpo dependerá de la variable que usemos como contador, es decir, será un índice de nuestro cuerpo.** \n",
    "\n",
    "> **Nota:** se puede usar sobre tipos de datos iterables (tupla, rangos, lista o diccionario)\n",
    "\n",
    "``` python\n",
    "for item in sequence:\n",
    "    statement\n",
    "else:\n",
    "    post-code # no se ejecuta en caso de un break en el body\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "##### ¿Cómo iterar?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# en string\n",
    "s = 'Hola a todos'\n",
    "for i in s:\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# en listas\n",
    "mi_lista = [1.0, 2.0, 'Pedro', 'Herminio'] \n",
    "for item in mi_lista:\n",
    "    print (item)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# en range\n",
    "for i in range(5):\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "for i in range(4):\n",
    "    i *= 2\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# en tuplas\n",
    "mi_tupla = ('rosa', 'verde', 'celeste', 'amarillo') \n",
    "for color in mi_tupla: \n",
    "    print (color)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# de a pares, en tuplas\n",
    "pares = [(5,2),(-4,2),(8,9),(7,0),(-3,2)]\n",
    "for x,y in pares:\n",
    "    print(x,y)\n",
    "    #print(x**y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# en diccionarios\n",
    "mi_diccionario = {'nombre' : 'Carlos', 'edad' : 22, 'cursos': ['Python','Django','JavaScript'] }\n",
    "for clave in mi_diccionario: \n",
    "    print (clave)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Valor negativo de la lista: -1\n",
      "Valor negativo de la lista: -4\n",
      "Valor negativo de la lista: -1\n"
     ]
    }
   ],
   "source": [
    "# para iterar sobre los indices de una secuencia (MUY MALA PRÁCTICA)\n",
    "numerocs = [-1,-4,3,9,0,-1,7]\n",
    "for i in range(len(numeros)):\n",
    "    if numeros[i] < 0:\n",
    "        print(\"Valor negativo de la lista:\" ,numeros[i])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Negativo en índice: -1\n",
      "Negativo en índice: -4\n",
      "Negativo en índice: -1\n"
     ]
    }
   ],
   "source": [
    "# para iterar sobre los indices de una secuencia (Pytonico)\n",
    "numeros = [-1,-4,3,9,0,-1,7]\n",
    "for numero in numeros:\n",
    "    if numero < 0:\n",
    "        print(\"Valor negativo de la lista:\" ,numero)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Negativo en índice: 0\n",
      "Negativo en índice: 1\n",
      "Negativo en índice: 5\n"
     ]
    }
   ],
   "source": [
    "# para iterar sobre los indices de una secuencia \n",
    "numerocs = [-1,-4,3,9,0,-1,7]\n",
    "for i in range(len(numeros)):\n",
    "    if numeros[i] < 0:\n",
    "        print(\"Negativo en índice:\" ,i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> **Nota :** es importante evitar en lo posible el uso de bucles en Python, ya que consumen mucho tiempo, pudiéndose en muchos casos realizar las mismas operaciones de una forma más eficiente y compacta (vectorización)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Estructura de control iterativa - While\n",
    "\n",
    "Este bucle, **se encarga de ejecutar una misma acción \"mientras que\" una determinada condición se cumpla**. Sólo debemos tener en cuenta cuando programamos, que el uso de un `while` es mucho más crítico que el uso de un `for`. Esto es porque la condición lógica que controla el bucle debe aplicarse sobre una variable interna en el bucle. Entonces es probable que si programamos mal, la variable que usamos como control nunca llegue a cumplir la condición que nos para la ejecución. También debemos tener en cuenta que los bucles controlados por una condición lógica no permiten la paralelización en el caso que tengamos varios procesadores [Nogueras, Guillem, 2007].\n",
    "\n",
    "La sintaxis de la estructura:\n",
    "``` python\n",
    "while condition:\n",
    "    statement\n",
    "else:\n",
    "    post-code # no se ejecuta en caso de un break en el statement\n",
    "``` "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "while True:\n",
    "    nombre = input(\"Indique su nombre: \")\n",
    "    if nombre==\"max\":\n",
    "        break"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Un ejemplo para completar:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# El programa calcula un logaritmo natural a partir del numero ingresado, mayor que cero.\n",
    "# Si el número es menor, el programa se detiene.\n",
    "import math \n",
    "\n",
    "a = input(\"Ingrese un numero mayor de 0:\")\n",
    "a = float(a)   # completar!\n",
    "while a:  # completar! \n",
    "    if:  # completar!\n",
    "        print(\"Debe ingresar un número mayor a cero\")\n",
    "        print(\"Este programa terminara\")\n",
    "        break\n",
    "    print([\"El logaritmo natural de \" + str(a) + \" es: \" + str(math.log(a))])\n",
    "    a = input(\"\")  # completar!\n",
    "    a =  # completar! \n",
    "print(\"Debe ingresar un número mayor a cero\")\n",
    "print(\"Este programa terminara\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%run ../code/while.py # respuesta"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> *Para aquellos que vienen de otro lenguaje de scripting, algunas cosas les resulten un poco más familiares y otras no tanto. De todas formas muchos elementos los iremos profundizando a lo largo del curso. Por lo tanto, no entrar en pánico y disfrutar el viaje.* "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Funciones Built-in (iterables)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-2.5"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "min([100, -1, .25, -2.5])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "100"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "max([100, -1, .25, -2.5])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'3'"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "max(['100', '3', '.25', '-2.5'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "96.75"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sum([100, -1, .25, -2.5])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[100, 0.25]"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(filter(lambda x: x>=0, [100, -1, .25, -2.5]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Referencias usadas en el notebook\n",
    "\n",
    "* Eugenia Bahit. Python para principiante. Extraido de [Libros Web](http://librosweb.es/libro/python/), 2018.\n",
    "* INTI - Electrónica e Informática, UT Comunicaciones. Introducción al Procesamiento Digital de Señales, 2017."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Licencia\n",
    "\n",
    "<a rel=\"license\" href=\"http://creativecommons.org/licenses/by-sa/4.0/\"><img alt=\"Licencia de Creative Commons\" style=\"border-width:0\" src=\"https://i.creativecommons.org/l/by-sa/4.0/88x31.png\" /></a><br />Este documento se destribuye con una <a rel=\"license\" href=\"http://creativecommons.org/licenses/by-sa/4.0/\">licencia Atribución CompartirIgual 4.0 Internacional de Creative Commons</a>.\n",
    "\n",
    "Material adaptado del curso [Introducción a Python](https://github.com/infiniemlabs-acustica/python_introduccion)\n",
    "\n",
    "© 2020. Infiniem Labs Acústica. infiniemlab.dsp@gmail.com (CC BY-SA 4.0))"
   ]
  }
 ],
 "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.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}