1-intro-python -con-salidas.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Tutorial 1: Conceptos Básicos de Python"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Prof: Oscar E. Ramos Ponce, Universidad de Ingeniería y Tecnología - UTEC\n",
    "\n",
    "Nota: este (primer) tutorial es una introducción a Python de manera muy directa. No cubre de forma exhaustiva todos los conceptos básicos de Python, pero puede ser útil como repaso o como una primera vista (bastante práctica y rápida) de este lenguaje. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Sugerencias:__ \n",
    "\n",
    "- Para ejecutar el código de una celda, presionar Ctrl-Enter.\n",
    "- Para crear una celda, presionar Ctrl-m seguido de b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1. Variables\n",
    "\n",
    "En Python, al igual que en Matlab u Octave, no es necesario indicar el tipo de variable. Simplemente se realiza la asignación utilizando `=`.\n",
    "\n",
    "Las variables básicas en Python son de tipo entero, punto flotante, cadenas de caracteres (strings), y Booleanas. Python es sensible a mayúsculas y minúsculas, por lo que una variable \"Var\" será diferente de otra variable \"var\"."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2 3.5 hola True\n"
     ]
    }
   ],
   "source": [
    "# Variables de distinto tipo (notar que no se especifica el tipo de la variable)\n",
    "a = 2\n",
    "b = 3.5\n",
    "c = 'hola'  # También se puede usar comillas dobles \"hola\"\n",
    "d = True\n",
    "print(a, b, c,d)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'int'>\n",
      "<class 'float'>\n",
      "<class 'str'>\n",
      "<class 'bool'>\n"
     ]
    }
   ],
   "source": [
    "# La función \"type\" indica el tipo de variable que se tiene\n",
    "print(type(a))\n",
    "print(type(b))\n",
    "print(type(c))\n",
    "print(type(d))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2. Operaciones sobre Variables"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.1 Operadores Matemáticos y Booleanos\n",
    "\n",
    "Los operadores matemáticos (`+`, `-`, `*`, `/`) funcionan como se espera. El operador `**` se utiliza para elevar un número a un exponente (no se utiliza ^). Para encontrar el residuo al realizar una división se utiliza `%`. Para operaciones rápidas se puede usar `+=`, `-=`, `*=`, `/=`.\n",
    "\n",
    "También existen operadores Booleanos (`==`, `!=`, `>`, `>=`, `<`, `<=`) que comparan cantidades y retornan una variable de tipo `bool`. Igualmente se puede utilizar `and`, `or`, `not`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "7\n",
      "10\n",
      "-3\n",
      "32\n",
      "0.4\n",
      "0\n"
     ]
    }
   ],
   "source": [
    "# Operadores matemáticos sobre variables\n",
    "a = 2\n",
    "b = 5\n",
    "print(a + b)\n",
    "print(a * b)\n",
    "print(a - b)\n",
    "print(a ** b)  # a elevado a b (a^b hace algo completamente diferente)\n",
    "print(a / b)   # Nota: en Python 2, / devuelve una división entera\n",
    "print(a // b)  # División entera (solo devuelve la parte entera de la división)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "7\n"
     ]
    }
   ],
   "source": [
    "a = 3\n",
    "a += 4    # De igual manera se puede usar -=, *=, /=\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hola utec\n",
      "Hola Hola Hola Hola \n"
     ]
    }
   ],
   "source": [
    "# Operadores aplicados a cadenas de caracteres\n",
    "print('Hola' + ' utec')     # Concatena\n",
    "print('Hola ' * 4)          # Repite la cadena el número indicado de veces"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n",
      "True\n",
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "# Operadores Booleanos\n",
    "a = (2 > 4)      # False \n",
    "b = (6 == 6)     # True\n",
    "print(a)\n",
    "print(b)\n",
    "print(a or b)    # False or True\n",
    "print(a and b)   # False and True"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.2 Aplicación de funciones\n",
    "\n",
    "Existen varias funciones por defecto que pueden operar sobre las variables. Sin embargo, otras funciones no se encuentran por defecto y para usarlas es necesario importar el módulo (biblioteca) que las contiene. Para importar se puede utilizar `import`.\n",
    "\n",
    "__Sugerencia:__ \n",
    "- Para saber qué hace una función se puede escribir el nombre seguido de \"?\" (aparecerá una ventana con ayuda)\n",
    "- Se puede autocompletar usando `tab`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'int'>\n",
      "5\n",
      "3.14\n"
     ]
    }
   ],
   "source": [
    "# round?    # Descomentar para observar la \"ayuda\" de esta función\n",
    "print(type(3))                 # type: obtiene el tipo de la variable\n",
    "print(len('hello'))            # len: obtiene el tamaño de la cadena\n",
    "print(round(3.141592, 2))      "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2.0\n",
      "3.141592653589793\n",
      "1.2246467991473532e-16\n"
     ]
    }
   ],
   "source": [
    "# Importando el módulo \"numpy\" bajo el nombre np (se puede usar otro nombre, pero np es común)\n",
    "import numpy as np\n",
    "# Ejemplos básicos de numpy en variables\n",
    "print(np.sqrt(4))\n",
    "print(np.pi)              # Valor de Pi\n",
    "print(np.sin(np.pi))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.3 Métodos\n",
    "\n",
    "Python es un lenguaje orientado a objetos, y los objetos tienen funciones (llamados métodos) que operan sobre sus \"datos\". Por ejemplo, las cadenas de caracteres \"string\" son objetos cuyos datos son los caracteres, pero también poseen métodos que operan sobre estos caracteres.\n",
    "\n",
    "En estos casos, la sintaxys es `variable.metodo(argumentos)`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hola lima\n",
      "HOLA LIMA\n",
      "hola lima\n",
      "hol(x) Lim(x)\n"
     ]
    }
   ],
   "source": [
    "# Una cadena de caracteres es un objeto\n",
    "s = 'hola Lima'\n",
    "# Métodos sobre el objeto s\n",
    "print(s.capitalize())  # Convierte a mayúscula la primera letra\n",
    "print(s.upper())       # Convierte a mayúsculas\n",
    "print(s.lower())       # Convierte a minúsculas\n",
    "print(s.replace('a', '(x)'))  # Reemplaza \"a\" con \"(x)\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3. Estructuras de Control de Flujo"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.1 Condicionales\n",
    "\n",
    "Los condicionales utilizan las palabras clave `if`, `elif`, `else`. En Python es importante la indentación ya que indica lo que se encuentra dentro del condicional."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "aprobado\n"
     ]
    }
   ],
   "source": [
    "nota = 17\n",
    "if (nota < 11):\n",
    "    print(\"desaprobado\")\n",
    "elif (nota == 11):\n",
    "    print(\"aprobado a las justas\")\n",
    "else:\n",
    "    print(\"aprobado\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Indentación**: Siempre debe haber una indentación en un condicional. Cada elemento dentro del condicional se indica solamente por la indentación (no se abre ni cierra llaves como en otros lenguajes, ni existe un comando end). Esta regla de indentación también se aplica a funciones y bucles.\n",
    "\n",
    "Si no hay una indentación correcta, se obtendrá un error llamado `IndentationError` o no se obtendrá error, dependiendo del caso, pero el código no funcionará como se espera.\n",
    "\n",
    "Algunos editores añaden por defecto 4 espacios. Algunos otros añaden una tabulación en lugar de los espacios. Si se mezcla tabulaciones con espacios también se generará errores."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.2 Bucles\n",
    "\n",
    "Los bucles utilizan las palabras clave `for` y `while`. Al igual que en otros lenguajes de programación, también se puede utilizar `break` y `continue` para salir de un bucle o para continuar con la siguiente iteración, respectivamente."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "for i in range(5):\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4\n",
      "3\n",
      "2\n",
      "1\n"
     ]
    }
   ],
   "source": [
    "i = 4\n",
    "while (i > 0):\n",
    "    print(i)\n",
    "    i -= 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4. Listas"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4.1 Operaciones Básicas\n",
    "\n",
    "Las listas son un tipo de contenedores (los otros tipos de contendedores son `tuple`, `set` y `dictionary`).\n",
    "\n",
    "Las lista se declaran utilizando `[]`. Una lista puede cambiar de tamaño, se puede modificar el valor de sus elementos, y puede contener elementos de diferentes tipos.\n",
    "\n",
    "Los elementos individuales de una lista se pueden seleccionar con la sintaxis `a[indice]`. El primer índice siempre es 0. Si se comienza desde el final, el último índice es -1, el penúltimo -2, y así sucesivamente."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['gatos', 'perros', 'elefantes', 'tigres', 'leones']\n",
      "<class 'list'>\n"
     ]
    }
   ],
   "source": [
    "# Creación de una lista\n",
    "x = ['gatos', 'perros', 'elefantes', 'tigres', 'leones']\n",
    "print(x)\n",
    "print(type(x))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Primer elemento: gatos\n",
      "Segundo elemento perros\n",
      "Último elemento: leones\n",
      "Penúltimo elemento: tigres\n"
     ]
    }
   ],
   "source": [
    "# Las listas (y todos los contenedores) se indexan con []\n",
    "print('Primer elemento:', x[0])\n",
    "print('Segundo elemento', x[1])\n",
    "## Se puede indexar desde el último elemento usando índices negativos\n",
    "print('Último elemento:', x[-1])\n",
    "print('Penúltimo elemento:', x[-2])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['gatos', 'perros', 'elefantes', 'tigres', 'leones', 'cerdo']\n",
      "['gatos', 'perros', 'elefantes', 'tigres', 'leones', 'cerdo', [1, 2]]\n",
      "['gatos', 'perros', 'elefantes', 'tigres', 'leones', 'cerdo']\n"
     ]
    }
   ],
   "source": [
    "# Las listas tienen métodos como por ejemplo: append, pop\n",
    "# Para ver todos los métodos, escribir el nombre de la lista seguida de . y presionar tab\n",
    "x = ['gatos', 'perros', 'elefantes', 'tigres', 'leones']\n",
    "\n",
    "x.append('cerdo')  # Añade un elemento \"cerdo\" al final de la lista\n",
    "print(x)\n",
    "x.append([1,2])    # Añade [1,2] al final de la lista\n",
    "print(x)\n",
    "x.pop()            # Elimina el último elemento\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Nota:__ Es importante que muchos contenedores, incluidas las listas, son en realidad punteros a los datos, y no los datos por sí mismos. Así, al asignarse a otra variable, se está creando otro puntero a los mismos datos, y no se está copiando los datos. Para copiar se debe usar `copy`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "b original:  [2, 3, 4]\n",
      "b luego de modificar a: [100, 3, 4]\n"
     ]
    }
   ],
   "source": [
    "a = [2, 3, 4]              # a es en realidad un puntero a la lista\n",
    "b = a                      # b es un puntero a los mismos datos de a (NO es una copia)\n",
    "print('b original: ', b)\n",
    "a[0] = 100                   \n",
    "print('b luego de modificar a:', b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "b original:  [2, 3, 4]\n",
      "b luego de modificar a: [2, 3, 4]\n"
     ]
    }
   ],
   "source": [
    "a = [2, 3, 4]\n",
    "b = a.copy()              # El método \"copy\" copia los valores \n",
    "print('b original: ', b)\n",
    "a[0] = 100\n",
    "print('b luego de modificar a:', b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4.2 Slicing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x = ['gatos', 'perros', 'elefantes', 'tigres', 'leones', 'cerdo']\n",
      "Primeros dos elementos: ['gatos', 'perros']\n"
     ]
    }
   ],
   "source": [
    "# Se puede acceder a múltiples elementos de una lista usando \":\"\n",
    "# Nota: el valor final (después de :) no es inclusivo\n",
    "print('x =', x)\n",
    "print('Primeros dos elementos:', x[0:2])    # ïndice 0 y 1 (no incluye el índice 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['gatos', 'perros', 'elefantes']\n",
      "['elefantes', 'tigres', 'leones', 'cerdo']\n",
      "['gatos', 'perros', 'elefantes', 'tigres', 'leones', 'cerdo']\n",
      "['gatos', 'perros', 'elefantes', 'tigres', 'leones']\n"
     ]
    }
   ],
   "source": [
    "# Se puede dejar en blanco el inicio o el fin\n",
    "print(x[:3])      # Índices 0, 1, 2 (sin incluir el índice 3)\n",
    "print(x[2:])      # Índices 2, 3, ... (hasta el final) \n",
    "print(x[:])       # Es la lista completa\n",
    "print(x[:-1])     # Índices 0, 1, ..., -2 (no incluye el índice -1 que es el último elemento)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4.3 Bucles con Listas\n",
    "\n",
    "Dada una lista, e puede iterar cada elemento de una lista usando `for i in lista:`, donde en cada iteración la variable `i` tendrá cada elemento de la lista.\n",
    "\n",
    "Para tener acceso al índice de cada elemento dentro del bucle se utiliza la función `enumerate`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "gato\n",
      "perro\n",
      "tigre\n"
     ]
    }
   ],
   "source": [
    "x = ['gato', 'perro', 'tigre']\n",
    "for animal in x:\n",
    "    print(animal)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "#1: gato\n",
      "#2: perro\n",
      "#3: tigre\n"
     ]
    }
   ],
   "source": [
    "x = ['gato', 'perro', 'tigre']\n",
    "for idx, animal in enumerate(x):\n",
    "    print('#%d: %s' % (idx + 1, animal))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4.4. Listas por Comprensión\n",
    "\n",
    "Es una forma concisa de crear una lista y se realiza utilizando una instrucción `for` y, opcionalmente, algunos condicionales `if` dentro de los corchetes `[]`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 4, 9, 16, 25, 36]\n"
     ]
    }
   ],
   "source": [
    "lista1 = [1, 2, 3, 4, 5, 6]           # Lista inicial\n",
    "# Declaración de la lista por comprensión\n",
    "lista2 = [x**2 for x in lista1]   # Creación de una lista que contiene los cuadrados de la lista original\n",
    "print(lista2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[4, 16, 36]\n"
     ]
    }
   ],
   "source": [
    "# Se puee incluir condiciones \n",
    "lista1 = [1, 2, 3, 4, 5, 6]\n",
    "# Lista que contiene los cuadrados pares (si son divisibles por 2)\n",
    "lista2 = [x**2 for x in lista1 if x % 2 == 0]\n",
    "print(lista2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 5 Diccionarios\n",
    "\n",
    "Un diccionario almacena pares `(key, value)` donde se suele denominar \"clave\" a \"key\". Son un contenedor que se utiliza cuando se desea tener acceso a los elementos a través de sus \"nombres\" (o algún otro tipo de valor genérico) más que a través de su posición.\n",
    "\n",
    "### 5.1 Inicialización"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'gravedad': 9.81, 'pi': 3.1415}\n",
      "9.81\n"
     ]
    }
   ],
   "source": [
    "# Creación de un diccionario\n",
    "constantes = {'gravedad' : 9.81,\n",
    "              'pi' : 3.1415}\n",
    "\n",
    "print(constantes)\n",
    "print(constantes['gravedad'])\n",
    "# print(constantes['avogadro'])  # Si no existe la clave (key) se obtendrá un error"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'gravedad': 9.81, 'pi': 3.1415, 'masa_electron': 9.1e-31}\n",
      "{'gravedad': 9.81, 'pi': 3.1415}\n"
     ]
    }
   ],
   "source": [
    "## Añadir un nuevo par (key, value)\n",
    "constantes['masa_electron'] = 9.1e-31\n",
    "print(constantes)\n",
    "\n",
    "# Se borra un elemento con \"del\"\n",
    "del constantes['masa_electron']         # Borra un elemento del diccionario\n",
    "print (constantes)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "# Se puede usar \"in\" para verificar si una clave (key) se encuentra en el diccionario\n",
    "print('gravedad' in constantes)     # Verifica si el diccionario tiene la clave \"gravedad\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "N/A\n",
      "3.1415\n"
     ]
    }
   ],
   "source": [
    "# El método \"get\" permite obtener un valor por defecto en caso que no se encuentre la clave\n",
    "print(constantes.get('avogadro', 'N/A'))\n",
    "print(constantes.get('pi', 'N/A'))      "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 5.2 Bucles y Comprensión"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Un humano tiene 2 patas\n",
      "Un gato tiene 4 patas\n",
      "Un hexápodo tiene 6 patas\n"
     ]
    }
   ],
   "source": [
    "# Iteración sobre los elementos de un diccionario\n",
    "d = {'humano': 2, 'gato': 4, 'hexápodo': 6}\n",
    "for elemento in d:\n",
    "    patas = d[elemento]\n",
    "    print('Un %s tiene %d patas' % (elemento, patas))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Un humano tiene 2 patas\n",
      "Un gato tiene 4 patas\n",
      "Un hexápodo tiene 6 patas\n"
     ]
    }
   ],
   "source": [
    "# Para recuperar la clave (key) y el valor, se usa \"items\"\n",
    "d = {'humano': 2, 'gato': 4, 'hexápodo': 6}\n",
    "for elemento, patas in d.items():\n",
    "    print('Un %s tiene %d patas' % (elemento, patas))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n",
      "{1: 1, 3: 9, 5: 25, 7: 49, 9: 81}\n"
     ]
    }
   ],
   "source": [
    "# Creación de diccionarios por comprensión\n",
    "lista = list(range(10))\n",
    "d = {x: x ** 2 for x in lista if x % 2 != 0}\n",
    "print(lista)\n",
    "print(d)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 6. Tuplas y Conjuntos"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 6.1 Tuplas\n",
    "\n",
    "Las tuplas son similares a las listas pero con dos excepciones:\n",
    "\n",
    "1. Se declara tuplas usando `()` en lugar de `[]`\n",
    "2. Una tupla es inmutable: una vez creada, no se puede cambiar su contenido\n",
    "\n",
    "Se suelen usar en lugar de las listas principalmente cuando se desea prevenir la modificación accidenal de sus valores. Además, una tupla puede ser utilizada como clave (key) en un diccionario, mientras que una lista no."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "('a', 3, [3, 5])\n"
     ]
    }
   ],
   "source": [
    "# Creación de una tupla\n",
    "t = (2, \"a\", 3, [3,5], 7)     # Notar que los elementos pueden ser de distintos tipos  \n",
    "\n",
    "print(t[0])\n",
    "print(t[1:4])\n",
    "# t[0] = 5    # La asignación no funciona con una tupla"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 6.2 Conjuntos (sets)\n",
    "\n",
    "Un conjunto es un contenedor cuyos valores no se encuentran ordenados. Se crean usando `{}`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "# Creación\n",
    "animales = {'perro', 'gato'}\n",
    "\n",
    "print('gato' in animales)    # Verifica si un elemento se encuentra en el conjunto\n",
    "print('tigre' in animales)   "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "2\n"
     ]
    }
   ],
   "source": [
    "# Añadir y eliminar un elemento\n",
    "animales.add('elefante')        # Añade un elemento al conjunto\n",
    "animales.remove('perro')        # Elimina un elemento del conjunto\n",
    "\n",
    "print('elefante' in animales)\n",
    "print(len(animales))            # Número de elementos en el conjunto"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "#1: tigre\n",
      "#2: perro\n",
      "#3: gato\n",
      "#4: elefante\n"
     ]
    }
   ],
   "source": [
    "# Bucles con conjuntos: los datos no se encuentran almacenados en orden\n",
    "animales = {'gato', 'perro', 'tigre', 'elefante'}\n",
    "for idx, animal in enumerate(animales):\n",
    "    print('#%d: %s' % (idx + 1, animal))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 7. Funciones\n",
    "\n",
    "Las funciones en Python se definen usando la palabra `def`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "negativo\n",
      "cero\n",
      "positivo\n"
     ]
    }
   ],
   "source": [
    "def sgn(x):\n",
    "    if (x > 0):\n",
    "        return 'positivo'\n",
    "    elif x < 0:\n",
    "        return 'negativo'\n",
    "    else:\n",
    "        return 'cero'\n",
    "\n",
    "for x in [-1, 0, 1]:\n",
    "    print(sgn(x))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hola Firulais\n",
      "Hola desconocido\n"
     ]
    }
   ],
   "source": [
    "# Se puede utilizar parámetros por defecto en las funciones\n",
    "\n",
    "def saludar(nombre=\"desconocido\"):\n",
    "    print('Hola', nombre)\n",
    "    \n",
    "saludar('Firulais')\n",
    "saludar()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 8. Clases\n",
    "\n",
    "Las clases en Python se crean con la palabra `class`. El constructor de la clase se define utilizando `__init__`. Todos los métodos de la clase deben tener como primer parámetro a `self`, el cual además, almacena los atributos de la clase."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Saldo: 20\n",
      "Saldo: 15\n"
     ]
    }
   ],
   "source": [
    "class Cuenta(object):\n",
    "\n",
    "    # Constructor\n",
    "    def __init__(self, cantidad_inicial=0):\n",
    "        self.cantidad = cantidad_inicial\n",
    "\n",
    "    # Método de la clase\n",
    "    def depositar(self, valor):\n",
    "        self.cantidad += valor\n",
    "        print(\"Saldo:\", self.cantidad)\n",
    "    def retirar(self, valor):\n",
    "        if (self.cantidad-valor < 0):\n",
    "            print(\"No se puede retirar \", valor)\n",
    "        else:\n",
    "            self.cantidad -= valor\n",
    "            print(\"Saldo:\", self.cantidad)\n",
    "\n",
    "cuenta1 = Cuenta()       # Construye un objeto de la clase Cuenta, con cantidad inicial 0 (por defecto)\n",
    "cuenta1.depositar(20)    # Uso del método \"depositar\"\n",
    "cuenta1.retirar(5)       # Uso del método \"retirar\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Saldo: 120\n",
      "Saldo: 115\n"
     ]
    }
   ],
   "source": [
    "cuenta2 = Cuenta(100)    # Construcción del objeto con cantidad inicial 100\n",
    "cuenta2.depositar(20)\n",
    "cuenta2.retirar(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.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}