01-IntroAPython.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Introducción a Python\n",
    "Python es un lenguaje interpretado multiparadigma y de tipado dinámico. Python provee soporte:\n",
    "\n",
    "* Orientación a Objetos.\n",
    "* Estructurada.\n",
    "* Funcional\n",
    "\n",
    "En este curso utilizaremos notebook Python, como el precente. Un notebook Python es un ambiente interactivo que permite integrar código Python, con texto, notación matemática, gráficos y otros contenidos multimedia. Los notebooks utilizados en este curso pueden ser corridos en un ambiente local mendiante el uso de [Jupyther](http://jupyter.org/) o en el Cloud de Google mediante [Google Colab](https://colab.research.google.com). A continuación se presenta un ejemplo de código Python que puede ser ejecutado:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 10 #a es de tipo int\n",
    "print(a + 10)\n",
    "print(type(a))\n",
    "\n",
    "a = 'Hola Mundo' #Ahora a es de tipo str\n",
    "print(a + '!!!')\n",
    "print(type(a))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La filosofía de Python se puede resumir como el resultado de ejecutar el siguiente código:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import this"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Estructuras de datos\n",
    "Python prevee diversas estructuras de datos que se pueden utilizar inmediatamente. En particular, Python prevee de:\n",
    "* __Listas__: Una colección de elementos indexados por su posición.\n",
    "* __Conjuntos__: Una colección de elementos no repetidos. Solo se puede acceder de forma sequencial.\n",
    "* __Diccionarios__: Una colección de elementos indexados por claves.\n",
    "* __Tuplas__: Una colección de elementos inmutable indexados por su posición.\n",
    "### Listas\n",
    "Las listas están indexadas numéricamente. De izquierda a derecha los indices comienzan en 0 e incrementan de a uno. En Python también se puede acceder a las listas de derecha a izquierda. En este caso, los indices comienzan en -1, y se decrementan en -1 cuando nos movemos a izquierda. Finalmente, Python también permite hacer slicing de las listas, es decir, obtener sublistas usando indices especiales.\n",
    "* `[X:Y]` Retorna una sublista con con los elementos comprendidos entre el índice X (inclusive) y el Y (excluyente).\n",
    "* `[X:]` Retorna una sublista con con los elementos a partir del índice X (inclusive)\n",
    "* `[:Y]` Retorna una sublista con con los elementos hasta el Y (excluyente).\n",
    "* `[X:Y:S]` Retorna una sublista con con los elementos comprendidos entre el índice X (inclusive) y el Y (excluyente), tomados de a S."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Una lista en Python\n",
    "lista = ['hola', 'mundo', 'lista', 'Python', 'con', 'muchas', 'palabras', 'representadas', 'por', 'strings'] \n",
    "#Accediendo a los elementos\n",
    "print('lista[1]: {}'.format(lista[1])) #Obtiene el elemento indexado con 1 (segundo de la lista)\n",
    "print('lista[-1]: {}'.format(lista[-1])) #Obtiene el elemento indexado con -1 (último de la lista)\n",
    "print('lista[1:3]: {}'.format(lista[1:3])) #Obtiene la sublista que contiene desde el 1 (inclusivo) hasta el 3 (exclusivo)\n",
    "print('lista[:-2]: {}'.format(lista[:-2])) #Obtiene la sublista que contiene hasta el ante-último elemento (exclusivo)\n",
    "print('lista[-2:]: {}'.format(lista[-2:])) #Obtiene la sublista que contiene desde el ante-último elemento (inclusivo)\n",
    "print('lista[4:]: {}'.format(lista[4:])) #Obtiene la sublista que contiene desde el 4 elemento (inclusivo)\n",
    "print('lista[1:8:3]: {}'.format(lista[1:8:3])) #Obtiene la sublista que contiene desde el 1 elemento (inclusivo), hasta el 8 (exclusivo) tomados de a 3."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Operaciones sobre las listas\n",
    "Las listas permiten realizar diversas operaciones sobre ella:\n",
    "* `lista.append(elem)`: agrega un elemento a la lista.\n",
    "* `lista.insert(ind, elem)`: inserta el elemento en el indice dado.\n",
    "* `lista.extend(iterable)`: agrega todos los elementos del iterable a la lista.\n",
    "* `elem in lista`: verifica si el elemento está en la lista.\n",
    "* `elem not in lista`: verifica si el elemento no está en la lista.\n",
    "* `del lista[ind]`: elimina el indice (puede ser un slice) de la lista.\n",
    "* `len(lista)`: retorna el tamaño de la lista.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print('Agregando un elemento' + '*' * 30)\n",
    "lista.append('agregado')\n",
    "print(lista)\n",
    "print('Insertando un elemento' + '*' * 30)\n",
    "lista.insert(1, 'agregado_en_1')\n",
    "print(lista)\n",
    "print('Expandiendo la lista' + '*' * 30)\n",
    "lista.extend(['otra', 'lista'])\n",
    "print(lista)\n",
    "print('Verificando si \\'hola\\' está en la lista' + '*' * 30)\n",
    "print('hola' in lista)\n",
    "print('Verificando si \\'palabra\\' no está en la lista' + '*' * 30)\n",
    "print('palabra' not in lista)\n",
    "print('Borrando un elemento' + '*' * 30)\n",
    "del lista[1]\n",
    "print(lista)\n",
    "print('Tamaño de la lista' + '*' * 30)\n",
    "print(len(lista))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Conjuntos\n",
    "Los conjuntos son colecciones de elementos no repetidos sin ningún orden en particular. Pueden ser definidos por extensión utilizando llaves.\n",
    "* `{elem1, elem2, ...}`: inicializa un conjunto por extensión. `{}` no puede ser utilizado para inicializar un conjunto vacio, ya que está asignado al diccionario vacio.\n",
    "* `set()` o `set(iterable)`: inicaliza el conjunto vacio, o con todos los elementos no repetidos de un iterable, por ejemplo otro conjunto o una lista.\n",
    "* `elem in conjunto`: verifica si el elemento está en el conjunto.\n",
    "* `elem not in conjunto`: verifica si el elemento no está en el conjunto.\n",
    "* `conjunto.isdisjoint(iterable)`: verifica si ninguno de los elementes del conjunto está en el iterable.\n",
    "* `conjunto.issubset(iterable)`: verifica si todos los elementos del conjunto están en el iterable.\n",
    "* `conjunto <= conjunto2`: verifica si todos los elementos del conjunto están en contenidos en otro _conjunto_.\n",
    "* `conjunto < conjunto2`: verifica si todos los elementos del conjunto están en contenidos en otro _conjunto_ y que el mismo tenga más elementos que el primero.\n",
    "* `conjunto.issuperset(iterable)`: verifica si todos los elementos del iterable están en el conjunto. \n",
    "* `conjunto >= conjunto2`: verifica si todos los elementos del segundo _conjunto_ están en contenidos en el primer conjunto.\n",
    "* `conjunto > conjunto2`: \n",
    "* `conjunto.intersection(iterable)`: retorna la intersección del conjunto un los elementos de un iterable.\n",
    "* `conjunto & conjunto2`: retorna la intersección del conjunto otro _conjunto_.\n",
    "* `conjunto.union(iterable)`: retorna la unión del conjunto un los elementos de un iterable.\n",
    "* `conjunto | conjunto2`: retorna la unión del conjunto otro _conjunto_.\n",
    "* `conjunto.difference(iterable)`: retorna los elementos del conjunto que no esten en el iterable.\n",
    "* `conjunto - conjunto2`: retorna los elementos del conjunto que no esten en el segundo _conjunto_.\n",
    "* `conjunto.symmetric_difference(iterable)`: retorna los elementos que esten en el conjunto o en el iterable, pero no en ambos.\n",
    "* `conjunto ^ conjunto2`: retorna los elementos que esten en el conjunto o en el segundo _conjunto_, pero no en ambos.\n",
    "* `len(conjunto)`: retorna la cantidad de elementos en un conjunto.\n",
    "* `conjunto.add(elem)`: agrega un elemento en el conjuntos.\n",
    "* `conjunto.remove(elem)`: elimina un elemento del conjuntos.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "vocales = {'a', 'e', 'i', 'o', 'u', 'A', 'E', 'I', 'O', 'U'}\n",
    "mayusculas = set('ABCDEFGHIJKLMNOPQRSTUVXYZ')\n",
    "print('Vocales: {}'.format(vocales))\n",
    "print('Mayúsculas: {}'.format(mayusculas))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Ejercicios\n",
    "1. A partir de los conjuntos anteriores obtenga todas las vocales mayúsculas.\n",
    "2. Verifique si 'a' es mayúscula.\n",
    "3. Verifique si 'a' es vocal.\n",
    "4. ¿Cuantás vocales mayúsculas hay?\n",
    "5. Construya un conjunto con todas las vocales minúsculas y las consonantes mayúsculas."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Complete en código\n",
    "print('Resultado ejecicio 1:')\n",
    "res = {} # su código va aquí\n",
    "print(res)\n",
    "print('Resultado ejecicio 2:')\n",
    "res = {} # su código va aquí\n",
    "print(res)\n",
    "print('Resultado ejecicio 3:')\n",
    "res = {} # su código va aquí\n",
    "print(res)\n",
    "print('Resultado ejecicio 4:')\n",
    "res = {} # su código va aquí\n",
    "print(res)\n",
    "print('Resultado ejecicio 5:')\n",
    "res = {} # su código va aquí\n",
    "print(res)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Diccionarios\n",
    "Los diccionarios son estructuras que indexan sus elementos a través de claves (que deben ser objetos [hashable](https://docs.python.org/3/glossary.html#term-hashable)).\n",
    "* `d[clave]`: retorna el valor asociado a la clave. Si la clave no tiene valor asociado dispara [KeyError](https://docs.python.org/3/library/stdtypes.html#set). Las subclases de diccionario pueden redefinir el método `__missing(self, key)__`.\n",
    "* `d[clave] = elem`: asigna un elemento a la clave. Si la clave ya tiene un elemento asignado se sobreescribe.\n",
    "* `del d[clave]`: elimina una clave del diccionario.\n",
    "* `clave in d`: verifica si la clave está entre las claves del diccionario.\n",
    "* `clave not in d`: verifica si la clave no está entre las claves del diccionario.\n",
    "* `len(d)`: retorna la cantidad de elementos mapeados por el diccionario.\n",
    "* `d.items()`: retorna una vista iterable de tuplas (clave, elemento) mapeados en el diccionario.\n",
    "* `d.keys()`: retorna una vista de las claves asignadas en el diccionario.\n",
    "* `d.values()`: retorna una vista iterable de los elementos mapeados por claves en el diccionario."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "diccionario = {'juan': 23231, 'paula': 23543, 'christian': 23468}\n",
    "print(diccionario['juan'])\n",
    "print(diccionario.keys())\n",
    "print(diccionario.values())\n",
    "print(diccionario.items())\n",
    "print(len(diccionario))\n",
    "diccionario['manuel'] = 23245\n",
    "print(diccionario)\n",
    "diccionario['manuel'] = 11111\n",
    "print(diccionario)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Tuplas\n",
    "Las tuplas son secuencas [inmutables](https://docs.python.org/3/glossary.html#term-immutable) de elementos heterogenios que pueden ser accedidos a través de indices o desempaquetado. Un ejemplo de la utilización de tuplas está dado por el método `items(self)` de los diccionarios."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "tupla = ('Tupla', 10, 'Elemento')\n",
    "print('Tupla es {} y tiene {} elementos'.format(type(tupla), len(tupla)))\n",
    "stg0, int1, stg2 = tupla\n",
    "print('El primer elemento de la tupla es {}'.format(stg0))\n",
    "print('El segundo elemento de la tupla es {}'.format(int1))\n",
    "print('El tercer elemento de la tupla es {}'.format(stg2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Estructuras de control\n",
    "Al igual que lenguages como C, Pascal o Java, Python cuenta con estructuras de control del tipo _if_, _while_ y _for_. Como en C o Java, también posee las sentencias _break_ y _continue_, que permiten controlar los fujos de los _while_ y _for_. \n",
    "### Senencias _if_ \n",
    "Las sentencias _if_ permiten seleccionar ramas de ejecución a través del valor de verdad de expresiones lógicas. Python no provee estructuras del tipo _case_-_switch_, pero pueden ser emuladas utilizando _if_ y _elif_. Para definir el alcance de una rama de un _if_ se utilizan bloques de código. A diferencia de C o Java, un bloque de código no se define por delimitadores como llaves o palabras claves, sino que mediante identación. Python soporta identación por medio de tabuladores o espacios, pero no combinación de los dos. Sobre estos dos métodos, el recomendado por el [PEP8: Style Guide for Python Code](https://www.python.org/dev/peps/pep-0008/) son 4 espacios."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = int(input('Ingrese un número '))\n",
    "if x < 0:\n",
    "    print('x es menor que cero, x pasará a ser 0')\n",
    "    x = 0\n",
    "elif x == 0:\n",
    "    print('x es cero')\n",
    "elif x == 1:\n",
    "    print('x es uno')\n",
    "else:\n",
    "    print('x es mayor que 1')\n",
    "print('x = {}'.format(x))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Sentencias _while_\n",
    "Las sentencias _while_ ejecutan un bloque de código hasta que se cumpla una condición."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = int(input('Ingrese un número '))\n",
    "y = int(input('Ingrese otro número '))\n",
    "while x != y:\n",
    "    if x > y:\n",
    "        x -= y\n",
    "    else:\n",
    "        y -= x\n",
    "print('El MCD de los números ingresados es {}'.format(x))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "También se puede usar la sentencia _break_:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = int(input('Ingrese un número '))\n",
    "y = int(input('Ingrese otro número '))\n",
    "while True:\n",
    "    if x > y:\n",
    "        x -= y\n",
    "    elif x < y:\n",
    "        y -= x\n",
    "    else:\n",
    "        break\n",
    "print('El MCD de los números ingresados es {}'.format(x))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Sentencias _for_\n",
    "A diferencia de C o Java, las sentencias _for_ trabajan como un for-each, que permite recorrer los elementos de un iterable."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "lista = ['elemento 0', 'elemento 1', 'elemento 2', 'elemento 3', 'elemento 4']\n",
    "for i in lista:\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "En caso de que se quiera iterar una secuencia de enteros, exite la función _range_ que retorna un iterable.\n",
    "* `range(x)`: un iterable que retorna los enteros desde cero hasta _x-1_, con un incremento de a 1.\n",
    "* `range(y, x)`: un iterable que retorna los enteros desde _y_ hasta _x-1_, con un incremento de a 1.\n",
    "* `range(y, x, s)`: un iterable que retorna los enteros desde _y_ hasta _x-1_, con un incremento de a _s_."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in range(10, 20, 2):\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La sentencia _for_ permite hacer desempaquetado de tuplas. Por ejemplo, esto es útil para recorrer todos los items de un diccionario."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for k, v in diccionario.items():\n",
    "    print('La clave {} está asociada al valor {}'.format(k, v))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python provee otras funciones útiles que aprobechan esta carácteristica:\n",
    "* `enumerate(iterable)`: retorna un nuevo iterable que retorna tuplas del tipo (index, elemento). Por defecto, empieza a enumerar en 0.\n",
    "* `enumerate(iterable, start)`: retorna un nuevo iterable que retorna tuplas del tipo (index, elemento). La enumeración comienza con el valor _start_.\n",
    "* `zip(*iterables)`: retorna un iterable retorna tuplas donde la i-esima tupla corresponde con i-esimo valor de todos los iterables pasados como parámetro."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i, e in enumerate(lista):\n",
    "    print('Indice: {} - Elemento: {}'.format(i, e))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#keys y values aseguran que los elementos se obtengan en el mismo orden\n",
    "claves = list(diccionario.keys())\n",
    "valores = list(diccionario.values())\n",
    "print(claves)\n",
    "print(valores)\n",
    "for k, v in zip(claves, valores):\n",
    "    print('La clave {} está asociada al valor {}'.format(k, v))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Funciones\n",
    "Las funciones se definen utilizando la palabra clave `def`. Al igual que las sentencias de control, la identación define los bloques de código. Las funciones permiten:\n",
    "* Los parámetros pueden ser pasados posicionalmente.\n",
    "* Los parámetros pueden ser pasados por su nombre.\n",
    "* Los parámetros pueden ser tener un valor por defecto.\n",
    "* Los parámetros pueden ser variables en cantidad y en nombre.\n",
    "\n",
    "\n",
    " _Nota_: Una vez que un parámetro es pasado por nombre, todos los siguientes deben ser pasados por nombre."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def cuadrado(a):\n",
    "    return a ** 2\n",
    "\n",
    "print(cuadrado(10))\n",
    "c = cuadrado\n",
    "print(c(10))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def potencia(a, p=2):\n",
    "    return a ** p\n",
    "\n",
    "print('El cuadrado de 10 es {}'.format(potencia(10)))\n",
    "print('El cubo de 10 es {}'.format(potencia(10, 3)))\n",
    "print('El cubo de 10 es {}'.format(potencia(p=3, a=10)))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Los parámetros por defecto son inicializados la primera vez que se parsea la función, por lo que es recomendable que sean inmutables."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#l se inicializa como una lista vacía. Esto puede tener problemas.\n",
    "def agregar(a, l=[]):\n",
    "    l.append(a)\n",
    "    return l\n",
    "\n",
    "#¿Qué sucede cuando agrego varios elementos al parámetro por defecto?\n",
    "print(agregar(10))\n",
    "print(agregar(20))\n",
    "print(agregar(30))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Si este no es el efecto deseado, puede ser solucionado:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def agregar(a, l=None):\n",
    "    if l is None:\n",
    "        l = []\n",
    "    l.append(a)\n",
    "    return l\n",
    "\n",
    "#¿Qué sucede cuando agrego varios elementos al parámetro por defecto?\n",
    "print(agregar(10))\n",
    "print(agregar(20))\n",
    "print(agregar(30))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Parámetros de longitud variable y nombrados.\n",
    "* Los parámetros de longitud variable se ponen despues de todos los parámetros formales. Se indican que son de longitud variable con un asterisco al principio del nombre, y van despues de los parámetros obligatorios. Generalmente se los nombra _\\*args_.\n",
    "* Los parámetros con nombre se indican un doble asterisco y van al final de todo. Generalmente se los nombre _\\*\\*kwargs_."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def fun1(a, b_def=10, *args, **kwargs):\n",
    "    print('a: {}'.format(a))\n",
    "    print('b_def: {}'.format(b_def))\n",
    "    print('args: {}'.format(args))\n",
    "    print('kwargs: {}'.format(kwargs))\n",
    "    print('*' * 80)\n",
    "\n",
    "fun1(1)\n",
    "fun1(1, 2, 3, 4, 5)\n",
    "fun1(1, 2, 3, 4, 5, n1='n1v', n2='n2v', n3='n3v')\n",
    "fun1(1, n1='n1v', n2='n2v', n3='n3v')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Asterisco y doble asterisco pueden ser usados para desempacar listas y diccionarios cuando se pasan por parámetros.\n",
    "\n",
    "¿Cuál es la diferencia entre las siguientes llamadas? ¿Son todas posibles? \n",
    "```\n",
    "fun1(lista)\n",
    "fun1(diccionario)\n",
    "fun1(*lista)\n",
    "fun1(**diccionario)\n",
    "```\n",
    "En caso de que una llamada falle, proponga una solución para el problema."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Pruebe el código aquí despues de contestar"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Generadores\n",
    "Funciones como `enumerate` son conocidas como generadores (`range` es un caso partícular que se discutirá más adelante). Esto significa que, en vez de calcular todos los valores cuando es llamada, calcula el valor cada vez que es necesario extraer uno de ellos. En particular, existen dos maneras de que un generador retorne su próximo valor. La primera es en una sentencia `for`, donde los valores se extraidos de forma implícita cada vez que se realiza una iteración. La segunda es explícitamente, llamando a la función `next` sobre el iterador."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "gen = enumerate(['V1', 'V2', 'V3'])\n",
    "#Imprimo el generador\n",
    "print(gen)\n",
    "#Imprimo el primer valor\n",
    "print(next(gen))\n",
    "#Imprimo el segundo valor\n",
    "print(next(gen))\n",
    "#Imprimo el tercer valor\n",
    "print(next(gen))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Ejercicio\n",
    "Vuelva a invocar la función `next` sobre el generador y conteste: ¿Cómo sabe `next` cuando termina un generados? "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Ejercicio\n",
    "Escriba un generador que dada una lista con valores númericos retorne el acumulado. Considere:\n",
    "* `yield`: es una palabra clave que funciona como `return` salvo que puede ser llamada más de una vez. Cada vez que se llama retorna un valor y bloquea la ejecución de la función hasta que `next` sea invocado sobre el iterador.\n",
    "* `raise ExceptionName`: dispara una excepción. ¿Para qué podría ser util?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def acumulado(lista):\n",
    "    #Escriba su código aquí.\n",
    "    pass\n",
    "\n",
    "l = [10, 1, 2, 3, 5]\n",
    "for v in acumulado(l):\n",
    "    print('El acumulado hasta aquí es:'.format(v))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Clases\n",
    "Python provee la posibilidad de definir clases donde se empaquetan tanto datos como atributos. Python provee soporte para herencia multiple, sobreescritura de métodos, llamado a super métodos y modificación dinámica de los atributos de una clase.\n",
    "* Todos los métodos de instancia reciben el parámetro `self`, que es automáticamente pasado. Es el equivalente al `this` de C++ o Java.\n",
    "* Los atributos no se definene cuando se realiza la primera asignación, puede ser en el constructor `__init__(self, ....)` o en cualquier otro método.\n",
    "* Se puede chequear si una clase tiene o no un atributo con la función `hasattr(obj, nombre_att)`. Notese que si el atributo está definido como `None`, el atributo está definido.\n",
    "* `__str__(self)` es el equivalente al método `toString()` de Java."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class A:\n",
    "    #Constructor\n",
    "    def __init__(self, param):\n",
    "        #Iniciliza un parametro en la clase\n",
    "        self._param = param \n",
    "    \n",
    "    def set(self, p):\n",
    "        self._param = p\n",
    "    \n",
    "    def get(self):\n",
    "        return self._param\n",
    "    \n",
    "    def __str__(self):\n",
    "        return 'Clase A -> param = {}'.format(self._param)\n",
    "    \n",
    "ins = A('Param')\n",
    "print(ins)\n",
    "ins.set('P Nuevo')\n",
    "print(ins.get())\n",
    "print(ins)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Herencia\n",
    "Como otros lenguajes de programación orientados a objetos, Python soporta herencia. La herencia es múltiple, lo que implica que una clase puede extender varias clases. El orden de búsqueda de los métodos es primero en la clase actual, luego en el primer padre (en profundidad), despues el segundo, y así en DFS. \n",
    "Otra diferencia importante con C++ o Java, es que si una clase debe implementar una interfaz o método abstracto, este no debe estár definido de forma abstracta ya que las variables son no tipadas. Por ejemplo, para que una clase pueda ser usada como clave en un diccionario solo debe implementar el método `__hash(self)__`, pero no existe ninguna clase abstracta o interfaz en el sentido de Java o C++.\n",
    "#### Ejemplos de Herencia"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class A:\n",
    "    def m1(self):\n",
    "        print('Soy A')\n",
    "        \n",
    "class B:\n",
    "    def m1(self):\n",
    "        print('Soy B')\n",
    "\n",
    "class C(A, B):\n",
    "    pass\n",
    "\n",
    "class D(B, A):\n",
    "    pass\n",
    "\n",
    "class E(A, B):\n",
    "    def m1(self):\n",
    "        super().m1() #llama al método m1 que se encuentra primero en la búsqueda\n",
    "        A.m1(self) #llama estáticamente al método m1 de A, indicando explicitamente cual es el self\n",
    "        B.m1(self) #llama estáticamente al método m1 de B, indicando explicitamente cual es el self\n",
    "        print('Soy E')\n",
    "        \n",
    "        \n",
    "print('Clase A')\n",
    "a = A()\n",
    "a.m1()\n",
    "print('Clase B')\n",
    "b = B()\n",
    "b.m1()\n",
    "print('Clase C')\n",
    "c = C()\n",
    "c.m1()\n",
    "print('Clase D')\n",
    "d = D()\n",
    "d.m1()\n",
    "print('Clase E')\n",
    "e = E()\n",
    "e.m1()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Algunos métodos interesante\n",
    "Python permite definir el comportamiento de un objeto ante el uso de ciertos operadores, como `==`, `in`, `[k]`, `()`. Algunos de estos son descriptos a continuación, para más detalles [Python data model](https://docs.python.org/3/reference/datamodel.html).\n",
    "* `__iter__(self)`: permite obtener un iterador asociado al objeto (comportamiento del objeto `range`). Es invocado por la función `iter(obj)`\n",
    "* `__next__(self)`: hace que el objeto se comporte como un generador. A diferencia de las funciones generador, este método tiene que realizar un `return` cada vez que retorna un valor. Puede ser invocado por las sentencias `for` o por la función `next(gen)`.\n",
    "* `__len__(self)`: se usa en el caso de colecciones, por ejemplo listas, para retornar la cantidad de elementos. Es invocado por la función `len(obj)`.\n",
    "* `__setitem__(self, key, value)`: utilizado para colecciones indexadas para realizar una asignación. Es invocado de la siguiente forma `obj[key] = value`.\n",
    "* `__getitem__(self, key, value)`: utilizado para colecciones indexadas para obtener un valor. Es invocado de la siguiente forma `obj[key]`.\n",
    "* `__deltitem__(self, key, value)`: utilizado para colecciones indexadas eliminar un valor. Es invocado de la siguiente forma `del obj[key]`.\n",
    "* `__contains__(self, item)`: utilizado para verificar si un valor está en una colección. Es invocado de la siguiente forma `value in obj`.\n",
    "* `__call__(self, ...)`: permite que el objeto emule a una función, permitiendo utilizar una instancia para invocarlo.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Ejemplo:\n",
    "    \n",
    "    def __len__(self):\n",
    "        return 10\n",
    "    \n",
    "    def __setitem__(self, k, v):\n",
    "        print('Setando {} en {}'.format(v, k))\n",
    "        \n",
    "    def __getitem__(self, k):\n",
    "        print('Obteniendo valor para {}'.format(k))\n",
    "        return 'Valor {}'.format(k)\n",
    "    \n",
    "    def __contains__(self, val):\n",
    "        return isinstance(val, int) and 0 <= val < 10\n",
    "    \n",
    "    def __call__(self):\n",
    "        print('Llamando al objeto como función')\n",
    "        \n",
    "class MiIterador:\n",
    "    def __init__(self):\n",
    "        self.index = 0\n",
    "        \n",
    "    def __iter__(self):\n",
    "        return self\n",
    "    \n",
    "    def __next__(self):\n",
    "        if (self.index == 10):\n",
    "            self.index = 0\n",
    "            raise StopIteration\n",
    "        i = self.index\n",
    "        self.index += 1\n",
    "        return i\n",
    "\n",
    "ins = Ejemplo()\n",
    "ins()\n",
    "ins[10] = 'Hola'\n",
    "print(ins[20])\n",
    "print(5 in ins)\n",
    "print('Hola' in ins)\n",
    "print(len(ins))\n",
    "ite = MiIterador()\n",
    "for i in ite:\n",
    "    print(i)\n",
    "        "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Numpy y compania\n",
    "En este curso se realizarán muchas operaciones de álgebra lineal. Si bien Python es un lenguaje muy poderoso, ciertas operaciones puede ser muy lentas cuando se comparan con su contrapartida en lenguajes como C o Java. Para resolver este problema, existen muchas librería para Python que permiten acelerar ciertas operación. Una de estas librerías es Numpy, la cual provee implementación eficiente a diversa operaciones con matrices y arreglos."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np #Importa numpy y lo renombra a np por comodidad\n",
    "a = [[1,2], [3, 4]] #Lista de listas normales de Python\n",
    "print('Imprimendo \\'a\\'')\n",
    "for i in range(0, len(a)):\n",
    "    for j in range(0, len(a[i])):\n",
    "        print(a[i][j], end=' ') #Notese que se accede a cada indice por separado\n",
    "    print()\n",
    "print('Utilizando Numpy')\n",
    "anp = np.asarray(a) #convierte 'a' a una matriz de numpy.\n",
    "print(anp.shape) #Las matrices numpy tienen la propiedad shape, que indica el tamaño\n",
    "print('Imprimendo \\'anp\\'')\n",
    "for i in range(0, len(a)):\n",
    "    for j in range(0, len(a[i])):\n",
    "        print(anp[i, j], end=' ') #Notese que se accede a cada indice utilizando una tupla de indices\n",
    "    print()\n",
    "print('Permite operaciones arimeticas básicas como:')\n",
    "print('Sumar un número a todos los valores de la matriz:')\n",
    "print(anp + 10)\n",
    "print('Multiplicar un número a todos los valores de la matriz (multiplicación escalar):')\n",
    "print(anp * 10)\n",
    "print('También se puede hacer operaciones elemento a elemento entre dos matrices:')\n",
    "bnp = np.asarray([[10, 20], [30, 40]])\n",
    "print(anp + bnp)\n",
    "print('Otras operaciones útiles son:')\n",
    "print('Producto interno entre matrices')\n",
    "print(np.dot(anp, bnp))\n",
    "print('Obtener la diagonal')\n",
    "print(np.diag(anp))\n",
    "print('O vectorizar operaciones para aplicarlas a toda la matriz al mismo tiempo')\n",
    "def operacion(x):\n",
    "    return (x + x) * x\n",
    "operacion_vectorizada = np.vectorize(operacion)\n",
    "print(operacion_vectorizada(anp))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Ejercicio\n",
    "Considere la función sigmoide:\n",
    "\n",
    "$sigmoid(x)=1/(1+e^{-x})$\n",
    "\n",
    "La cual puede ser visual en el siguiente código:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt #Librería para plotear\n",
    "%matplotlib inline  \n",
    "from math import exp #Función exponencial de la librería math\n",
    "\n",
    "\n",
    "def sigmoid(x):\n",
    "    return 1 / (1 + exp(-x))\n",
    "\n",
    "vals = np.linspace(-5, 5, 100) #Genera un vector con 100 valores equidistantes entre -5 y 5\n",
    "sig_vals = np.asarray([sigmoid(x) for x in vals]) #Esto no es eficiente, está hecho así para no revelar la respuesta\n",
    "plt.plot(vals, sig_vals)\n",
    "plt.title('Sigmoide')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Implemente variantes de la funcion `sigmoid_py` definida abajo para mejorar la velociada. Considere que la función dad es para matrices implementadas como listas de listas, utilice la librería numpy.\n",
    "\n",
    "__Nota__: Utilice la función `timeit` para medir la velocidad.\n",
    "\n",
    "__Nota__: Concidere `np.vectorize`.\n",
    "\n",
    "__Nota__: Concidere `np.exp`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from timeit import timeit #Librería para medir tiempos de ejecución\n",
    "\n",
    "np.random.seed(1234) # Por consistencia se configura siempre el mismo seed\n",
    "mat = np.random.rand(1000, 1000) # Genera una matriz de 1000*1000 con valores aleatorios\n",
    "mat_py = mat.tolist() # Transforma la matriz a una lista de lista\n",
    "\n",
    "def sigmoid(x):\n",
    "    return 1 / (1 + exp(-x))\n",
    "\n",
    "def sigmoid_py(x):\n",
    "    ret = [[sigmoid(v) for v in row] for row in x] #Fors inlines\n",
    "    return ret\n",
    "\n",
    "print('Tiempos')\n",
    "t = timeit('sigmoid_py(mat_py)', number=10, globals={'mat_py': mat_py, 'sigmoid_py': sigmoid_py})\n",
    "print('sigmoid_py(mat_py): {}'.format(t))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Práctico\n",
    "En este práctico desarrollaremos un clasificador básico. En este ejercicio el objetivo es implementar el clasificador, no comprender completamente su funcionamiento. Como primera medida generaremos un conjunto de datos aleatoreos para entrenar nuestro clasificados y otros datos para probar nuestro clasificador, para esto ejecutaremos el siguiente código:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.datasets import make_classification\n",
    "x, y = make_classification(n_samples=1000, n_features=200, n_informative=150, n_redundant=50, n_repeated=0, n_classes=2, n_clusters_per_class=2, weights=None, flip_y=0.01, class_sep=1.0, hypercube=True, shift=0.0, scale=1.0, shuffle=True, random_state=None)\n",
    "#Estandarizamos x\n",
    "x = (x - np.average(x, axis=0)) / np.std(x, axis=0)\n",
    "\n",
    "from sklearn.model_selection import train_test_split\n",
    "x_train, x_test, y_train, y_test = train_test_split(x, y, train_size=0.7)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "El clasificador que utilizaremos se llama regresión lineal, y calcula la probabilidad de que una instancia en $x$ pertenezca a una clase $y$ de la siguiente forma:\n",
    "\n",
    "$$h(x)=sigmoid(x*w + b)$$\n",
    "\n",
    "Donde $w$ es un vector de pesos de la misma dimensionalidad que caractéristicas tiene $x$ y $b$ es un escalar. Implemente esta función:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def logistic_regresion(x, w, b):\n",
    "    return np.random(x.shape[0]) #Completar"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Inicializamos $w$ y $b$ al azar y probamos la performance del clasificador."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "w = np.random.rand(200)\n",
    "b = np.random.rand()\n",
    "\n",
    "from sklearn.metrics import confusion_matrix\n",
    "print(confusion_matrix(y_test, logistic_regresion(x_test, w, b) > 0.5))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para que la regresión logística funcione es necesario minimizar una función de error. La función de error usas se llama error de entropía cruzada y se define de la siguiente manera:\n",
    "\n",
    "$$e(y, x, w, b) = -\\frac{\\sum y.log(h(x, w, b)) + (1-y).log(1-h(x, w, b))}{N}$$\n",
    "\n",
    "_NOTA_: Para evitar problemas de precisión, la salida de la regresión logística se limita entre 1e-6 y 1-1e-6. Considere utilizar la función `clip` de `numpy`.\n",
    "\n",
    "Implemente la función de error:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def error(y, x, w, b):\n",
    "    return 0  #Completar"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Finalmente, utilizamos el siguiente código para obtener el $w$ y $b$ que minimizan la función de error utilizando nuestros datos de entrenamiento y evaluaremos la regresión lineal con los datos de test."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "w_b = np.concatenate((w, np.asarray([b])), axis=0) #Para minimizar es necesario poner todo en el mismo arreglo\n",
    "\n",
    "#Minimizo\n",
    "from scipy.optimize import minimize\n",
    "\n",
    "res = minimize(lambda w_b: error(y_train, x_train, w_b[:200], w_b[200]), w_b)\n",
    "#Extraigo los valores obtenidos\n",
    "w = res.x[:200]\n",
    "b = res.x[200]\n",
    "\n",
    "#Evaluo\n",
    "print(confusion_matrix(y_test, logistic_regresion(x_test, w, b) > 0.5))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.6.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}