notebooks/102_sintaxis_basica_continuacion.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[comment]: <> (los titulares se generan en el siguiente link: https://docs.google.com/drawings/d/1TLM83sTn9w2Jmq0l0Jy1ivIeLRVO_rKBCamm5Tq11Yo/edit?usp=sharing)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![](../img/titulo_sintaxis_basica.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Contenido\n",
    "\n",
    "* [PEP 8 - guía de estilo](#PEP-8-\\--guia-de-estilo)\n",
    "* [Funciones integradas II](#Funciones-integradas-II)\n",
    "    * [Función help](#Funcion-help)\n",
    "    * [Función type](#Funcion-type)\n",
    "    * [Función print](#Funcion-print)\n",
    "    * [Funciones mágicas](#Funciones-magicas)\n",
    "    * [Otras funciones](#Otras-funciones)\n",
    "* [Variables II](#Variables-II)\n",
    "    * [Asignacion múltiple](#Asignacion-multiple)\n",
    "    * [Operadores in-place](#Operadores-in\\-place)\n",
    "* [Indexado II](#Indexado-II)\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",
    "* [Referencias usadas en el notebook](#Referencias-usadas-en-el-notebook)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Objetivos del notebook \n",
    "\n",
    "* Conocer más de funciones integradas en Python.\n",
    "* Avanzar en el uso de variables.\n",
    "* Aprender sobre estructuras de datos: `lista`.\n",
    "* Introducir a estructuras de control iterativas: `for` y `while`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## PEP 8 - guia de estilo\n",
    "\n",
    "![](../img/elegante_100x200.png)\n",
    "\n",
    "La elegancia de la sintaxis de Python, \"obliga\" de alguna manera cumplir con una cantidad de **reglas de escritura**. Para esto existe PEP “Propuestas de Mejora Python” (**Python Enhancement Proposals**). Existen muchos Peps, el [PEP 8](https://www.python.org/dev/peps/pep-0008/#type-variable-names) en concreto es la propuesta del estándar de programación y buenas prácticas para el lenguaje. Es en general una guía para mejorar la legibilidad del código y hacerlo tan consistente como se pueda."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> **PEP 8 - Indentado:** una indentación de 4 (cuatro) espacios en blanco, indicará que las instrucciones indentadas, forman parte de una misma estructura de control. **Esta regla es obligatoria**.\n",
    "\n",
    "> **PEP 8 - Comentarios:** comentarios en la misma línea del código deben separarse con dos espacios en blanco. Luego del símbolo # debe ir un solo espacio en blanco.\n",
    "\n",
    "``` python\n",
    "# Correcto\n",
    "a = 15  # Edad de María\n",
    " \n",
    "# Incorrecto\n",
    "a = 15 # Edad de María\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Funciones integradas II\n",
    "\n",
    "A continuación se presenta más **funciones útiles**, que vienen **integradas en Python** (sin necesidad de importar ningún módulo), utiles para resolver las guias de ejercicios."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Funcion `help`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "help (int)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "help (3.1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from numpy import pi \n",
    "help (pi)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "str??"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Funcion `type`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 42\n",
    "type(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "type(\"Python\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "type(3.14)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podemos incluso preguntar si un dato es de un tipo particular."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "isinstance('Maxi', str)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "isinstance('Maxi', int)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Función muy útil para controlar ingresos de usuarios o argumentos de funciones."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Funcion `print`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "En Python hay varias formas de formatear las salidas de un `print`. Acá tan solo mostramos la más básica de todas, para más info la [documentación oficial](http://docs.python.org.ar/tutorial/3/inputoutput.html#formateo-elegante-de-la-salida).\n",
    "\n",
    "El operador `%` también puede usarse para formateo de cadenas. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import math\n",
    "print('El valor de PI es aproximadamente %1.5f ' % math.pi,2*math.pi)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print??"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Funciones `magicas`\n",
    "\n",
    "Tanto Jupyter como IPython tienen un conjunto de funciones predefinidas llamadas **mágicas** que representa una de las mejoras más importantes que aporta en relación al intérprete de Python por defecto (solo en el ámbito del IPython funcionan). Hay dos tipos de funciones mágicas:\n",
    "\n",
    "* Orientadas a **líneas**, trabajan en una sola línea.\n",
    "* Orientadas a **celdas**, trabajan en varias líneas.\n",
    "\n",
    "En nuestro caso ya utilizamos la función mágica `%matplotlib inline` que nos permite imprimir una figura en una celda, a continuación de las líneas de código que la definen.\n",
    "\n",
    "> **Nota:** todas las funciones mágicas llevan por delante un signo `%` en el caso de las orientadas a líneas y `%%` en el caso de las orientadas a celdas.\n",
    "\n",
    "Para listar todas las funciones mágicas disponibles:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%lsmagic"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%time?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Otras funciones"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Devuelve una tupla formada por el cociente y el resto de la división \n",
    "divmod(13, 4) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Devuelve x elevado a y\n",
    "pow(2, 3)\n",
    "2**3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Calcula el valor absoluto\n",
    "abs(-6)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Devuelve el argumento redondeado al entero más próximo\n",
    "round(4.35)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Idem, redondeado en la posición indicada por el segundo argumento\n",
    "round(4.3527, 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Calcula el valor máximo de un conjunto de valores (numéricos o alfabéticos)\n",
    "#max(4, 5, -2, 8, 3.5, -10)\n",
    "max(\"David\", \"Alicia\", \"Tomás\", \"Emilio\")\n",
    "max('z','bd') # Probar!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Calcula el valor mínimo de un conjunto de valores (numéricos o alfabéticos)\n",
    "min(4, 5, -2, 8, 3.5, -10)\n",
    "min(\"David\", \"Alicia\", \"Tomás\", \"Emilio\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Calcula la suma de un conjunto de valores, \n",
    "# debe ser un tipo de datos iterable (tupla, rango, lista, conjunto o diccionario)\n",
    "sum([1, 2, 3, 4, 5])\n",
    "#sum(range(6))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Ordena un conjunto de valores,\n",
    "# debe ser un tipo de datos iterable (tupla, rango, lista, conjunto o diccionario)\n",
    "sorted((10, 2, 8, -3, 6))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Longuitud de datos\n",
    "len((1,2,3,4))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Variables II\n",
    "\n",
    "Retomando el tema del etiquetado de las variables, para tener en cuenta con respecto a los nombres, son **Case sensitive** (valor explicito)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 5\n",
    "A = 3\n",
    "a + A"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> **PEP 8 - Nombre de variables (etiquetas):** utilizar nombres descriptivos y en minúsculas. Para nombres compuestos, separar las palabras por guiones bajos. Antes y después del signo =, debe haber uno (y solo un) espacio en blanco.\n",
    "\n",
    "``` python\n",
    "# Correcto\n",
    "mi_variable = 12\n",
    " \n",
    "# Incorrectos\n",
    "MiVariable = 12\n",
    "mivariable = 12\n",
    "mi_variable=12\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#1a = 4  # Primer carácter debe ser una letra"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Algunos **nombres** no pueden ser usados porque estan **reservados**:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import keyword\n",
    "print(keyword.kwlist)\n",
    "\n",
    "False = 'pirulo'\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Utilización de la opción **autocompletar** (TAB) (valor implícito)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "altura_triangulo = 3\n",
    "base_triangulo = 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# area_triangulo = "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Asignacion multiple\n",
    "\n",
    "Se puede asignar varias etiquetas a un mismo objeto de manera simultáneamente:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = b = c = 1\n",
    "a, b, c"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "También se pueden asignar varias etiquetas a múltiples objetos:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a, b, c = 1, 2, \"Maxi\"\n",
    "a, b, c"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Operadores in-place"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "i = 1\n",
    "i"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "i += 1\n",
    "i"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "i = i + 1\n",
    "i"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`i += 1` equivale a `i = i + 1`. En el segundo Python, realiza la operación `i + 1` creando un nuevo objeto con ese valor y luego lo asigna a la variable `i`; es decir, existe una reasignación. En el primero, sin embargo, el incremento se produce sobre la propia variable. Esto puede conducirnos a mejoras en velocidad. \n",
    "Otros operadores **in-place** son: `-=`, `*=`, `/=` "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Indexado II\n",
    "\n",
    "Recordar que Python indexa **comenzando en 0, no en 1** como en MATLAB. Veamos ejemplos de slice aplicado a string."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = \"Monty Python\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x[0:7] # Un slice de un string, es otro string"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x[-12:7]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x[-12:-5]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x[0:-5]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x[:-5]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x[1:-1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x[:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x[0:5:2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x[-1:-4:-1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "x[::-1]"
   ]
  },
  {
   "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",
    "\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, 'AdUNTREF', 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\n"
   ]
  },
  {
   "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\n"
   ]
  },
  {
   "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 condición**.\n",
    "\n",
    "En Python se dispone de dos estructuras cíclicas:\n",
    "\n",
    "* El bucle `for`.\n",
    "* El bucle `while`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Estructura de control iterativa - 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": "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": {
    "jupyter": {
     "source_hidden": true
    }
   },
   "outputs": [],
   "source": [
    "# en listas\n",
    "mi_lista = [1.0, 2.0, 'Pedro', 'Herminio'] \n",
    "for nombre in mi_lista:\n",
    "    mi_lista.append(1)\n",
    "    print (nombre)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "jupyter": {
     "source_hidden": true
    }
   },
   "outputs": [],
   "source": [
    "# en tuplas\n",
    "mi_tupla = ('rosa', 'verde', 'celeste', 'amarillo') \n",
    "for color in mi_tupla: \n",
    "    print (color)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "En los ejemplos anteriores, **i**, **nombre** y **color**, son **variables declaradas en tiempo de ejecución** (es decir, se declaran dinámicamente durante el bucle), asumiendo como valor, el de cada elemento de la lista, tupla o rango en cada iteración."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# para iterar sobre los indices de una secuencia\n",
    "numeros = [-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": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5 2\n",
      "-4 2\n",
      "8 9\n",
      "7 0\n",
      "-3 2\n"
     ]
    }
   ],
   "source": [
    "# de a pares\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": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "2\n",
      "4\n",
      "6\n"
     ]
    }
   ],
   "source": [
    "for i in range(4):\n",
    "    i *= 2\n",
    "    print(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": 3,
   "metadata": {},
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "invalid syntax (<ipython-input-3-c897236c3929>, line 8)",
     "output_type": "error",
     "traceback": [
      "\u001b[0;36m  File \u001b[0;32m\"<ipython-input-3-c897236c3929>\"\u001b[0;36m, line \u001b[0;32m8\u001b[0m\n\u001b[0;31m    if:  # completar!\u001b[0m\n\u001b[0m      ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m invalid syntax\n"
     ]
    }
   ],
   "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()   # 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": [
    "## Referencias usadas en el notebook\n",
    "\n",
    "* Cano, Juan Luis. Curso Aero Python. Extraido de [GitHub](https://github.com/AeroPython/Curso_AeroPython), 2016.\n",
    "* G. Van Rossum. El tutorial de Python. PyAr http://docs.python.org.ar/tutorial/\n",
    "* Datos y variables. 2009\n",
    "* Nogueras, Guillem. Introducción informal a Matlab y Octave. Universidad Politecnica de Madrid, 2007\n",
    "* Massimo Di Pierro. Web2py - Manual de Referencia. Extraido de [www.web2py.com](http://www.web2py.com/books/default/chapter/36/02/el-lenguaje-python), 2018.\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",
    "© 2019. 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.7.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}