clases/clase_2/202_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": [
    "# Sintaxis básica (continuación)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Contenido\n",
    "\n",
    "* [PEP 8 - guía de estilo](#PEP-8-\\--guia-de-estilo)\n",
    "* [Introducción a estructuras de control de flujo](#Introduccion-a-estructuras-de-control-de-flujo)\n",
    "    * [Estructuras condicionales](#Estructuras-condicionales)\n",
    "    * [Estructura condicional - if-elif-else](#Estructura-condicional---if-elif-else)\n",
    "* [Funciones Built-in II](#Funciones-Built-in-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",
    "* [Referencias usadas en el notebook](#Referencias-usadas-en-el-notebook)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Objetivos del notebook \n",
    "\n",
    "* Introducir a estructuras de control de flujo.\n",
    "* Conocer más de funciones integradas en Python.\n",
    "* Avanzar en el uso de variables."
   ]
  },
  {
   "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": [
    "## Introduccion a estructuras de control de flujo\n",
    "\n",
    "En el caso más simple, nuestro script sigue una ruta lineal (una instrucción se ejecuta después de otra en el orden en que aparecen en el script, de manera secuencial). \n",
    "\n",
    "![](http://i.imgur.com/JAj9Z7v.png)\n",
    "\n",
    "Si quisieramos agregar bifurcaciones a nuestro script debemos recurrir a **estructuras esenciales** como ser **bucles** y los **condicionales**. En el caso de los **bucles** es un contador que permite ejecutar varias tareas idénticas secuencialmente con la variación de diversos índices; se pueden encapsular con otros contadores y con otras estructuras. Por otra parte, los **condicionales** permite incluir variaciones en la ejecución del código según el cumplimiento de ciertas condiciones lógicas. Estas no son las únicas estructuras de programación, tan solo son las más básicas. A partir de ellas se derivan estructuras más específicas."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "En el caso particular de Python, para hablar de estructuras de control de flujo es imprescindible primero, hablar de **indentación**.\n",
    "\n",
    "En la [guia de estilo PEP8](202_sintaxis_basica_continuacion.ipynb#PEP-8---guia-de-estilo) ya se habá mencionado, pero ¿Qué es la indentación? En un lenguaje de programación, **la indentación es lo que la sangría** al lenguaje escrito. 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**. Pero en el caso de Python, la indentación es obligatoria, ya que de ella dependerá su estructura."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "n = 4\n",
    "r = 1\n",
    "while n > 0:\n",
    "    r *= n\n",
    "    n -= 1\n",
    "print(r)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ventajas del indentado:\n",
    "\n",
    "* La **estructura visual** del código refleja la **estructura real**.\n",
    "* **No más missing braces** (cerrar las estructuras, llaves en C++).\n",
    "* Uniformidad en la **estética del código**.\n",
    "\n",
    "> **Nota:** *errorEOF* (end of file), refiere a un error (falta de) en la identación."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Estructuras condicionales\n",
    "\n",
    "Las estructuras de control condicionales, son aquellas que nos **permiten evaluar si una o más condiciones se cumplen**, para decir qué acción vamos a ejecutar. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Estructura condicional - if-elif-else\n",
    "\n",
    "La evaluación de condiciones, solo puede arrojar 1 de 2 resultados: **verdadero** o **falso** (`True` o `False`). Las estructuras de control de flujo condicionales, se definen mediante el uso de tres palabras claves reservadas del lenguaje: `if` (si), `elif `(sino, si) y `else` (sino).\n",
    "\n",
    "![](http://i.imgur.com/fqJOBUS.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para describir la evaluación a realizar sobre una condición, se utilizan:\n",
    "\n",
    "#### Operadores de comparación"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'A' == 'a'  # Igual a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1 != 0  # Distinto"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "-12 < 2  # Menor que"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "31 > 1  # Mayor que"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "21 <= 2  # Menor o igual que"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "3 >= 1  # Mayor o igual que"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`is, is not` identidad del objeto: útil para saber si dos variables referencian al mismo objeto."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para evaluar más de una condición simultáneamente, se utilizan:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Operadores logicos"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(6 > 10) & (10 > 6)  # Conjunción (ampersand)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "(1) y (1) == 1  # Conjunción (ampersand) 2**2=4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(False, True)"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(6 > 10), not (6 > 10)  # Negación"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "(6 < 10) and (10 > 6)  # Conjunción *alternativa"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "(0 > 5) | (0 < 5)  # Disyunción"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "(0 > 5) or (0 < 5)  # Disyunción *alternativa"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Si el semáforo esta en verde, cruzar la calle. Sino, esperar.\n",
    "\n",
    "semaforo = \"rojo\"\n",
    "\n",
    "if semaforo == \"verde\": \n",
    "    print (\"Cruzar la calle\")\n",
    "    \n",
    "else: \n",
    "    print (\"Esperar\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Veamos un ejemplo para completar."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "'''\n",
    "Si gasto hasta $100, pago con dinero en efectivo. \n",
    "Si no, si gasto más de $100 pero menos de $300, pago con tarjeta de débito. \n",
    "Si no, pago con tarjeta de crédito.\n",
    "'''\n",
    "compra = 50 \n",
    "\n",
    "if compra : # completar! \n",
    "    print (\"Pago en efectivo\")\n",
    "    \n",
    "elif compra : # completar!  \n",
    "    print (\"Pago con tarjeta de débito\") \n",
    "    \n",
    "else: \n",
    "    print (\"Pago con tarjeta de crédito\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Funciones Built-in 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": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = \"Monty Python\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Monty P'"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x[0:7] # Un slice de un string, es otro string"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Monty P'"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x[-12:7]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Monty P'"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x[-12:-5]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Monty P'"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x[0:-5]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Monty P'"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x[:-5]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'onty Pytho'"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x[1:-1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Monty Python'"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x[:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Mny'"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x[0:5:2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'noh'"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x[-1:-4:-1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'nohtyP ytnoM'"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x[::-1]"
   ]
  },
  {
   "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",
    "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
}