Py0.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "\n",
    "**Universidad de Costa Rica** | Escuela de Ingeniería Eléctrica\n",
    "\n",
    "*IE0405 - Modelos Probabilísticos de Señales y Sistemas*\n",
    "\n",
    "### `PyX` - Serie de tutoriales de Python para el análisis de datos\n",
    "\n",
    "\n",
    "# `Py0` - *Introducción a Python*\n",
    "\n",
    "\n",
    "> Python es un lenguaje de programación de uso general, en la actualidad el más popular para análisis de datos. Su sintaxis fue pensada desde el inicio para ser más legible.\n",
    "\n",
    "*Fabián Abarca Calderón*\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Instalación\n",
    "\n",
    "Para este curso vamos a utilizar las herramientas provistas con la instalación de [Anaconda](https://www.anaconda.com/) en cualquier plataforma (Linux, Windows, macOS). Una vez instalado, se pueden \"correr\" *scripts* `.py` desde la terminal (también llamada línea de comandos o consola o CLI, de *Command Line Interface*).\n",
    "\n",
    "* Ejecutando el código fuente con Python:\n",
    "\n",
    "```bash\n",
    "$ python script.py`\n",
    "```\n",
    "\n",
    "* O usarlo en modo interactivo en la CLI:\n",
    "\n",
    "```bash\n",
    "$ python\n",
    ">>> print('Hola')\n",
    "```\n",
    "\n",
    "o desde cualquiera de los muchos **IDE** (entornos de desarrollo integrado, *Integrated Development Environments*) disponibles, como: \n",
    "\n",
    "* [Eclipse](https://www.eclipse.org/ide/)\n",
    "* [PyCharm](https://www.jetbrains.com/es-es/pycharm/)\n",
    "* [Sublime](https://www.sublimetext.com/)\n",
    "* [Visual Studio Code](https://code.visualstudio.com/)\n",
    "* [Atom](https://atom.io/)\n",
    "\n",
    "### Más información\n",
    "\n",
    "La información más precisa sobre los aspectos básicos del lenguaje Python están en el [manual de referencia](https://docs.python.org/3/library/) de la Librería Estándar de Python. Sin embargo, es posible encontrar muchas otras buenas referencias en internet, desde cursos en línea, páginas de referencia (ver final del documento), preguntas en foros y hasta el muy buen [Wikibook de Python](https://en.wikibooks.org/wiki/Python_Programming).\n",
    "\n",
    "#### Antes de empezar...\n",
    "\n",
    "**Nota 0**: Para ejecutar una celda de código en Jupyter se utilizan las teclas `shift` + `enter`, o \"Run\" en el panel superior cuando la celda está seleccionada.\n",
    "\n",
    "**Nota 1**: La función `print()` muestra el resultado de la evaluación de su(s) argumento(s).\n",
    "\n",
    "**Nota 2**: Los comentarios en el código fuente de Python se hacen con `#` en una sola línea o con `''' (comentario) '''` en varias líneas.\n",
    "\n",
    "**Nota 3**: En Python el índice comienza en 0.\n",
    "\n",
    "**Nota 4**: Como lenguaje orientado a objetos, Python utiliza la \"notación del punto\": `objeto.atributo` o bien `objeto.método()`, que son *variables* y *funciones* asociadas con un objeto.\n",
    "\n",
    "**Nota 5**: La forma \"pitónica\" de programar en Python (*the Pythonic way*) son convenciones que hacen el código más legible y sencillo."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "## 0.1 - Variables\n",
    "\n",
    "\n",
    "En Python, la asignación de un dato a una variable no requiere la indicación explícita del *tipo de dato*. Por tanto, basta con escribir:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "numero = 12\n",
    "caracteres = 'hola'\n",
    "a, b, c = 1, 2, 3\n",
    "print(numero, caracteres, a + b + c)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "## 0.2 - Valores booleanos y comparaciones\n",
    "\n",
    "\n",
    "Los dos valores lógicos en Python son `True` o `1` y `False` o `0`, sobre los cuales se aplican las operaciones lógicas `or`, `and` y `not`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = True and not False\n",
    "b = 0 or 0 or not 0\n",
    "print(a, b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Comparaciones entre números\n",
    "\n",
    "La evaluación de las comparaciones retorna `True` o `False`.\n",
    "\n",
    "| Operación   | Significado                 |\n",
    "|-------------|-----------------------------|\n",
    "|     `<`     | es estrictamente menor que  |\n",
    "|     `<=`    | es menor o igual que        |\n",
    "|     `>`     | es estrictamente mayor que  |\n",
    "|     `>=`    | es mayor o igual que        |\n",
    "|     `==`    | es igual a                  |\n",
    "|     `!=`    | no es igual a               |\n",
    "|     `is`    | identidad                   |\n",
    "|   `is not`  | identidad negada            |\n",
    "\n",
    "**Nota 1**: `=` es de asignación, `==` es de comparación.\n",
    "\n",
    "**Nota 2**: las operaciones pueden concatenarse, por ejemplo: `x < y < z`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(12 < 24)\n",
    "print(2019 != 2020)\n",
    "print(34 >= 21 > 13 > 8)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "## 0.3 - Tipos de datos numéricos y sus operadores\n",
    "\n",
    "En Python hay tres tipos distintos de datos numéricos:\n",
    "\n",
    "* `int`: número entero, positivo o negativo\n",
    "* `float`: número de punto flotante (decimal) positivo o negativo \n",
    "* `complex`: números con una \"parte real\" y una \"parte imaginaria\" de punto flotante\n",
    "\n",
    "**Nota 1**: Las funciones respectivas `int()`, `float()` y `complex(a, b)` permiten convertir de un tipo a otro.\n",
    "\n",
    "**Nota 2**: La función `type()` permite corroborar el tipo de dato numérico o de cualquier dato de una variable en Python."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 2\n",
    "print(a, 'es', type(a))\n",
    "\n",
    "b = 3.0\n",
    "print(b, 'es', type(b))\n",
    "\n",
    "c = 5 + 8j\n",
    "print(c, 'es', type(c))\n",
    "\n",
    "d = int(b)\n",
    "e = float(a)\n",
    "f = complex(d, e)\n",
    "print(d, e, f)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Operaciones básicas sobre datos numéricos\n",
    "\n",
    "| Operación         | Resultado                         |\n",
    "|-------------------|-----------------------------------|\n",
    "| `x + y`           | suma de `x` y `y`                 | \n",
    "| `x - y`           | resta de `x` y `y`                |\n",
    "| `x * y`           | producto de `x` y `y`             |\n",
    "| `x / y`           | cociente de `x` y `y`             |\n",
    "| `x // y`          | piso del cociente de `x` y `y`    |\n",
    "| `x % y`           | residuo de `x / y`                |\n",
    "| `-x`              | `x` negativo                      |\n",
    "| `+x`              | `x` sin cambio de signo           |\n",
    "| `abs(x)`          | magnitud de `x`                   |\n",
    "| `int(x)`          | `x` convertido a entero           |\n",
    "| `float(x)`        | `x` convertido a punto flotante   |\n",
    "| `complex(re, im)` | número complejo                   |\n",
    "| `c.conjugate()`   | conjugado del número complejo `c` |\n",
    "| `divmod(x, y)`    | el par `(x // y, x % y)`          |\n",
    "| `pow(x, y)`       | `x` a la potencia de `y`          |\n",
    "| `x ** y`          | `x` a la potencia de `y`          |"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(10/3)\n",
    "print(10//3)\n",
    "print(10%3)\n",
    "\n",
    "a, b = divmod(10, 3)\n",
    "print(a, b, 3*a + b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "## 0.4 - Números binarios, octales, hexadecimales y sus operaciones\n",
    "\n",
    "Para declarar un número **binario** se inicia con `0b`, para declarar un número **octal** se inicia con `0o`, para declarar un número **hexadecimal** se inicia con `0x`. Para convertir entre un tipo y otro y también `int` se utilizan las funciones `bin()`, `oct()`, `hex()` e `int()`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 42\n",
    "b = 0b11111100100\n",
    "c = 0o31\n",
    "\n",
    "print(bin(a))\n",
    "print(hex(a))\n",
    "print(int(b))\n",
    "print(int(c))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Operaciones binarias (bit a bit) sobre números enteros\n",
    "\n",
    "| Operación   | Resultado                       |\n",
    "|-------------|---------------------------------|\n",
    "| `x [barra] y`    | **OR** de `x` y `y`                 |\n",
    "| `x ^ y`     | **XOR** de `x` y `y`                |\n",
    "| `x & y`     | **AND** de `x` y `y`                |\n",
    "| `x << n`    | Desplazamiento izquierdo de `x` en `n` bits        |\n",
    "| `x >> n`    | Desplazamiento derecho de `x` en `n` bits |\n",
    "| `~x`        | **NOT** (inversión) de `x`          |"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 0b10101 & 0b01010\n",
    "b = ~a\n",
    "c = 13 | 21\n",
    "d = 0x4a << 2\n",
    "print(a, b, c, d)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "## 0.5 - Tipos de secuencias de datos y sus operadores\n",
    "\n",
    "Las variables del tipo \"secuencia\" permiten almacenar **grupos de datos**. También son llamados \"contenedores\" (ver también `dict`, más adelante).\n",
    "\n",
    "* `list`: secuencia **mutable** (*que puede cambiar*) típicamente utilizada para almacenar elementos *homogéneos* (de un mismo tipo de datos o secuencias).\n",
    "* `tuple`: secuencia **inmutable** (*que **no** puede cambiar*) típicamente utilizada para almacenar elementos *heterogéneos* (de diferente tipo).\n",
    "* `range`: secuencia **inmutable** de **números** típicamente utilizada para iterar en un bucle.\n",
    "\n",
    "**Nota**: Es útil recordarlos como: `[list]`, `(tuple)` y `{dict}`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 0.5.1 Cómo crear secuencias\n",
    "\n",
    "#### 0.5.1.1 Creación de listas\n",
    "\n",
    "Todas estas opciones crean listas:\n",
    "\n",
    "* `[]` (lista vacía)\n",
    "* `[a]`, `[a, b, c]`\n",
    "* `[x for x in iterable]` (*list comprehension*)\n",
    "* `list()` o `list(iterable)`\n",
    "\n",
    "**Nota**: Como en algunos lenguajes de computación científica (Matlab, R...), las listas pueden ser utilizadas para crear \"vectores\" y \"matrices\"."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "L1 = ['ja']\n",
    "L2 = L1 * 3\n",
    "L3 = ['alfa', 'beta', 'gama']\n",
    "L4 = [x for x in range(6)]\n",
    "L5 = [x for x in range(6) if x % 3 != 0]\n",
    "L6 = [[1,2,3],[4,5,6],[7,8,9]]\n",
    "\n",
    "print(L1, L2, L3)\n",
    "print(L4)\n",
    "print(L5)\n",
    "print(L6)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 0.5.1.2 Creación de tuplas\n",
    "\n",
    "* `()`\n",
    "* `a`, o `(a,)`\n",
    "* `a, b, c` o `(a, b, c)`\n",
    "* `tuple()` o `tuple(iterable)`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "T1 = (1,)\n",
    "T2 = 1, 2, 3\n",
    "T3 = ('En', 'un', 'lugar', 'de', 'La', 'Mancha')\n",
    "T4 = tuple([x for x in range(3)])\n",
    "\n",
    "print(type(T1))\n",
    "print(T2, T3, T4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 0.5.1.3 Creación de rangos\n",
    "\n",
    "* `range(stop)` (empieza en 0 y **no** incluye a `stop`)\n",
    "* `range(start, stop[, step])` (como en `start:step:stop`)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "range(1000)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 0.5.2 Operaciones sobre secuencias\n",
    "\n",
    "| Operación              | Resultado                                                                                         |\n",
    "|------------------------|---------------------------------------------------------------------------------------------------|\n",
    "| `x in s`               | `True` si un elemento de `s` es igual a `x` , de lo contrario `False`                             |\n",
    "| `x not in s`           | `False` si un elemento de `s` es igual a `x` , de lo contrario `True`                             |\n",
    "| `s + t`                | la concatenación de `s` y `t`                                                                     |\n",
    "| `s * n` o `n * s`      | equivalente a agregar `s` a sí mismo `n` veces                                                    |\n",
    "| `s[i]`                 | `i`-ésimo elemento de `s` , origen en 0                                                          |\n",
    "| `s[i:j]`               | rebanada de `s` de `i` a `j`                                                                      |\n",
    "| `s[i:j:k]`             | rebanada de s de `i` a `j` con el paso `k`                                                        |\n",
    "| `len(s)`               | longitud de `s`                                                                                   |\n",
    "| `min(s)`               | elemento más pequeño de `s`                                                                       |\n",
    "| `max(s)`               | elemento más grande de `s`                                                                        |\n",
    "| `s.index(x[, i[, j]])` | índice de la primera aparición de `x` en `s` (en o después del índice `i` y antes del índice `j`) |\n",
    "| `s.count(x)`           | número total de ocurrencias de `x` en `s`                                                         |\n",
    "\n",
    "**Nota**: La forma \"pitónica\" de acceder al último elemento de la secuencia es con el índice `-1`, es decir, `s[-1]`. De esta forma no hay que conocer *a priori* la cantidad de elementos en `s`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "inicio = 0, 1, 1, 2, 3, 5, 8, 13, 21, 34\n",
    "continuacion = 55, 89, 144, 233\n",
    "secuencia = inicio + continuacion\n",
    "\n",
    "print(secuencia)\n",
    "print(secuencia[4])\n",
    "print(secuencia[0:-1:2])\n",
    "print(secuencia.count(1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 0.5.3 Operaciones sobre secuencias *mutables*\n",
    "\n",
    "| Operación             | Resultado                                                                                 |\n",
    "|-----------------------|-------------------------------------------------------------------------------------------|\n",
    "| `s[i] = x`            | el elemento `i` de `s` se reemplaza por `x`                                               |\n",
    "| `s[i:j] = t`          | una porción de `s` de `i` a `j` se reemplaza por el contenido de la `t` iterable          |\n",
    "| `del s[i:j]`          | igual que `s[i:j] = []`                                                                   |\n",
    "| `s[i:j:k] = t`        | los elementos de `s[i:j:k]` son reemplazados por los de `t`                               |\n",
    "| `del s[i:j:k]`        | elimina los elementos `s[i:j:k]` de la lista                                              |\n",
    "| `s.append(x)`         | agrega `x` al final de la secuencia (igual que `s[len(s):len(s)] = [x]`)                 |\n",
    "| `s.clear()`           | elimina todos los elementos de `s` (igual que `del s[:]`)                                |\n",
    "| `s.copy()`            | crea una copia superficial de `s` (igual que `s[:]`)                                      |\n",
    "| `s.extend(t) o s += t`| extiende `s` con el contenido de `t` (en su mayor parte igual que) `s[len(s):len(s)] = t` |\n",
    "| `s *= n`              | actualiza `s` con su contenido repetido `n` veces                                         |\n",
    "| `s.insert(i, x)`      | inserta `x` en `s` en el índice dado por `i` (igual que ) `s[i:i] = [x]`                  |\n",
    "| `s.pop([i])`          | recupera el elemento en `i` y también lo elimina de `s`                                   |\n",
    "| `s.remove(x)`         | eliminar el primer elemento de `s` donde `s[i]` es igual a `x`                            |\n",
    "| `s.reverse()`         | invierte los elementos de `s` en su lugar                                                 |"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "frase = ['all', 'you', 'need', 'is', 'love']\n",
    "print(frase)\n",
    "\n",
    "necesidad = 'food'\n",
    "frase[-1] = necesidad\n",
    "print(frase)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "## 0.6 - Secuencias de texto (*strings*) y sus operadores\n",
    "\n",
    "Las \"cadenas\" de texto o *strings* `str` son secuencias inmutables de caracteres alfanuméricos.\n",
    "\n",
    "### 0.6.1 Creación de secuencias de texto\n",
    "\n",
    "* `'hola'` (puede tener comillas dobles adentro)\n",
    "* `\"hola\"` (puede tener comillas sencillas adentro)\n",
    "* `'''hola'''` u `\"\"\"hola\"\"\"` (múltiples líneas)\n",
    "* Con la función `str()` a partir de otro tipo de dato\n",
    "\n",
    "**Nota**: Las secuencias de texto permiten todas las operaciones aplicadas sobre secuencias, pero es inmutable entonces no admite las operaciones sobre secuencias mutables (como las sustituciones o la remoción de elementos)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print('Hola \"mundo\"' + \", \" + '''saludos.''')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 0.6.2 Algunas funciones (\"métodos\") sobre hileras de caracteres\n",
    "\n",
    "Es posible hacer operaciones específicas de texto sobre un `str`. La lista completa de métodos está disponible [aquí](https://docs.python.org/3/library/stdtypes.html#string-methods).\n",
    "\n",
    "* `str.capitalize()`: Regresa una copia de la cadena con su primer carácter en mayúscula y el resto en minúscula.\n",
    "* `str.endswith( sufijo [ , inicio [ , fin ] ] )`: Regresa `True` si la cadena termina con el sufijo especificado, de lo contrario regresa `False`.\n",
    "* `str.lower()`: Regresa una copia de la cadena con todos los caracteres en mayúsculas convertidos a minúsculas."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "texto = 'hOlA, buENoS dÍaS'\n",
    "\n",
    "print(texto)\n",
    "print(texto.capitalize())\n",
    "print(texto.lower().endswith('as'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 0.6.3 Dar formato al texto al imprimir\n",
    "\n",
    "Un [método](https://docs.python.org/3/library/string.html#formatstrings) importante aplicado en hileras de caracteres permite insertar valores en un texto, con ciertas especificaciones.\n",
    "\n",
    "* `str.format( *args , **kwargs )`: Realiza una operación de formateo de la cadena. La cadena para la que se llama a este método puede contener texto literal o **campos de reemplazo** delimitados por llaves `{}`. Cada campo de reemplazo contiene el índice numérico de un argumento posicional o el nombre de un argumento de palabra clave. `str.format` devuelve una copia de la cadena donde cada campo de reemplazo se reemplaza con el valor de cadena del argumento correspondiente.\n",
    "\n",
    "**Nota 1**: `*args` es un número variable de argumentos que se pasan a una función. Por ejemplo, una función `multiplicar(*args)` que multiplica todos los argumentos que se le pasan puede ser `multiplicar(3,3,2,7)` o `multiplicar(2,3)`.\n",
    "\n",
    "**Nota 2**: ``**kwargs`` es un número variable de argumentos del tipo `clave = argumento`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "palabra = 'hola'\n",
    "\n",
    "print('¡Hola {}!'.format(palabra))\n",
    "print('{a} entre {b} es cerca de {c:0.2f}'.format(a=5, b=3, c=a/b))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "## 0.7 - Diccionarios\n",
    "\n",
    "Un diccionario es un tipo especial de secuencia mutable que hace un *mapeo* de valores a una clave, del tipo `clave : valor` (usualmente en inglés como `key : value`). El nombre es una analogía con los diccionarios que tienen pares **palabra: definición**.\n",
    "\n",
    "#### Creación de diccionarios\n",
    "\n",
    "* Los diccionarios se pueden crear colocando una lista de pares separados por comas entre llaves `{}`.\n",
    "* Con el constructor `dict()`.\n",
    "\n",
    "**Nota**: El orden de los pares no importa. Si dos o más diccionarios comparten exactamente los mismos pares (aunque hayan sido creados en diferente orden) entonces son iguales."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Con las llaves\n",
    "a = {'uno': 1, 'dos': 2, 'tres': 3}\n",
    "\n",
    "# Con la función dict()\n",
    "b = dict(uno=1, dos=2, tres=3)\n",
    "\n",
    "# Con la función zip() que \"parea\" dos listas\n",
    "c = dict(zip(['uno', 'dos', 'tres'], [1, 2, 3]))\n",
    "\n",
    "# Con una lista de tuplas (distinto orden)\n",
    "d = dict([('dos', 2), ('uno', 1), ('tres', 3)])\n",
    "\n",
    "# Creación redundante, con dict({})\n",
    "e = dict({'tres': 3, 'uno': 1, 'dos': 2})\n",
    "\n",
    "# Verificar igualdad\n",
    "print(a == b == c == d == e)\n",
    "\n",
    "# Mostrar alguno de los diccionarios\n",
    "print(c)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Algunas funciones útiles en diccionarios\n",
    "\n",
    "* `list(d)`: Regresa una lista de todas las claves utilizadas en el diccionario `d`.\n",
    "\n",
    "* `len(d)`: Regresa el número de elementos en el diccionario `d`.\n",
    "\n",
    "* `d[key]`: Regresa el artículo de `d` con la clave `key`. Genera una clave `KeyError` si no está en el mapa (diccionario)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "d = {'IE0305':'Matemática Superior',\n",
    "     'IE0409':'Análisis de Sistemas',\n",
    "     'IE0405':'Modelos Probabilísticos de Señales y Sistemas'}\n",
    "\n",
    "print(list(d))\n",
    "print(len(d))\n",
    "print(d['IE0405'])\n",
    "print('MA1001' in d)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "## 0.8 - Controles de flujo\n",
    "\n",
    "Los controles de flujo determinan las acciones del programa ante la evaluación de \"declaraciones\" tales como comparaciones. La documentación [oficial](https://docs.python.org/3/tutorial/controlflow.html) explica sus detalles.\n",
    "\n",
    "### 0.8.1 Controles de flujo `if` - `elif` - `else`\n",
    "\n",
    "Posiblemente el más importante o conocido, `if` evalúa una declaración y prosigue con líneas de ejecución distintas según el resultado. En Python su sintaxis es:\n",
    "\n",
    "```python\n",
    "if <declaracion>:\n",
    "     <accion cuando es verdadero>\n",
    "```\n",
    "\n",
    "Cuando el resultado es `False` puede haber otra acción posible, y la sintaxis es:\n",
    "\n",
    "```python\n",
    "if <declaracion>:\n",
    "    <accion cuando es verdadero>\n",
    "else:\n",
    "    <accion cuando es falso>\n",
    "```\n",
    "\n",
    "Si al evaluarse la primera declaración hay otras posibilidades entonces deben evaluarse otras declaraciones con la sintaxis:\n",
    "\n",
    "```python\n",
    "if <declaracion_1>:\n",
    "    <accion cuando 1 es verdadero>\n",
    "elif <declaracion_2>:\n",
    "    <accion cuando 1 es falso y 2 es verdadero>\n",
    "else:\n",
    "    <accion cuando 1 y 2 son falsos>\n",
    "```\n",
    "\n",
    "**Nota**: la *indentación* es **obligatoria** en Python, y es también suficiente para delimitar qué está contenido dentro de un curso de acción. Por ejemplo, en el siguiente fragmento, `print(a)` está dentro del `if` y `print(b)` no.\n",
    "\n",
    "```python\n",
    "if a < b:\n",
    "    print(a)\n",
    "    \n",
    "print(b)\n",
    "```\n",
    "\n",
    "**Nota**: este ejemplo incluye una **librería** de Python (`datetime`) para conocer la hora actual. El uso e importación de librerías es presentado en `Py1`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import datetime\n",
    "\n",
    "# Hora actual\n",
    "H = datetime.datetime.now().hour\n",
    "\n",
    "# Saludo según la hora del día\n",
    "if H < 12:\n",
    "    print('Buenos días')\n",
    "elif H < 18:\n",
    "    print('Buenas tardes')\n",
    "else:\n",
    "    print('Buenas noches')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 0.8.2 Controles de flujo `try` - `except` para manejo de errores\n",
    "\n",
    "Python termina la ejecución de un programa cuando encuentra un error. Esto a diferencia de un lenguaje compilado (como C y C++) que no ejecutan el programa hasta descartar errores en una compilación previa.\n",
    "\n",
    "Cuando una instrucción puede contener un error, es posible hacer una prueba con la instrucción `try`.\n",
    "\n",
    "El comando `except` permite actuar en caso de error.\n",
    "\n",
    "Otras opciones con `else` y `finally` pueden encontrarse [aquí](https://www.w3schools.com/python/python_try_except.asp)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# x = 3\n",
    "\n",
    "# Si x está \"comentada\"\n",
    "try:\n",
    "    print(x)\n",
    "except:\n",
    "    print('La variable no existe')\n",
    "    \n",
    "# Ahora se puede probar \"descomentando\" x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "## 0.9 - Bucles\n",
    "\n",
    "Un tipo especial de controles de flujo son los que **repiten** una acción en \"bucle\" o \"lazo\" (*loop*).\n",
    "\n",
    "### 0.9.1 Bucle `while`\n",
    "\n",
    "Repite una operación **indefinidamente** mientras una condición se cumpla.\n",
    "\n",
    "```python         \n",
    "while <declaracion>:\n",
    "    <accion siempre que sea verdadero>\n",
    "```\n",
    "\n",
    "### 0.9.2 Bucle `for`\n",
    "\n",
    "Repite una operación por **un número determinado de veces**, al iterar *sobre* una secuencia de datos.\n",
    "\n",
    "```python         \n",
    "for i in (a,b,c,d,e,f):\n",
    "    <accion para i = a, luego i = b, despues i = c...>\n",
    "```\n",
    "\n",
    "**Nota 1**: la secuencia `range()` es útil cuando se quiere iterar sobre una larga consecución de números (por ejemplo, desde 10 hasta 100).\n",
    "\n",
    "**Nota 2**: El operador `a += n` es equivalente a `a = a + n`. También existen `-=` y `*=`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "i = 1\n",
    "while i % 5 != 0:\n",
    "    print(i)\n",
    "    i += 1\n",
    "\n",
    "for j in (8,13,21,34):\n",
    "    print(j)\n",
    "\n",
    "for k in range(5):\n",
    "    print(k)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Otros comandos especiales\n",
    "\n",
    "* `break`: Sale del ciclo actual.\n",
    "* `yield`: Continúa con la siguiente iteración del bucle."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "## 0.10 - Algunas funciones nativas\n",
    "\n",
    "Ya son conocidas algunas funciones de la [Librería Estándar de Python](https://docs.python.org/3/library/functions.html) como `print()`, `type()`, `int()`, `len()`, `list()`. Algunas otras funciones útiles de interés son:\n",
    "\n",
    "* `abs(a)`: Valor absoluto de un número.\n",
    "* `all()`: `True` si todos los elementos de una secuencia son `True`\n",
    "* `enumerate(iterable[, start=n])`: \"adhiere\" numeración a una secuencia iterable, empezando en `start=n` (por defecto `start=0`).\n",
    "* `help()`: Invoca la ayuda de un objeto (función o comando o variable).\n",
    "* `input([prompt])`: Habilita el ingreso de datos con un `[prompt]`.\n",
    "* `map(función, iterable)`: Aplica `función` sobre cada elemento de `iterable`.\n",
    "* `round(n[, dígitos])`: Redondea `n` con una precisión de `dígitos`\n",
    "* `zip(*iterables)`: Crea un nuevo iterador con la unión de tantos `*iteradores` como se agreguen. El `i`-ésimo elemento de `zip(*iterables)` es una tupla con los `i`-ésimos elementos de cada argumento iterable.\n",
    "\n",
    "**Nota**: Jupyter algunas veces no despliega el ingreso de datos. Para eso puede probar en el menú Kernel > Restart (se borrarán las variables almacenadas)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "nombre = input('Digite su nombre: ')\n",
    "\n",
    "print('Hola {}. Ayuda de la función \"abs\":\\n'.format(nombre))\n",
    "help(abs)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "## Filosofía de Python\n",
    "\n",
    "*Tim Peters*\n",
    "\n",
    "- Bello es mejor que feo.\n",
    "- Explícito es mejor que implícito.\n",
    "- Simple es mejor que complejo.\n",
    "- Complejo es mejor que complicado.\n",
    "- Plano es mejor que anidado.\n",
    "- Disperso es mejor que denso.\n",
    "- La legibilidad importa.\n",
    "- Los casos especiales no son tan especiales como para quebrantar las reglas.\n",
    "- Lo práctico gana a lo puro.\n",
    "- Los errores nunca deberían dejarse pasar silenciosamente.\n",
    "- A menos que hayan sido silenciados explícitamente.\n",
    "- Frente a la ambigüedad, rechace la tentación de adivinar.\n",
    "- Debería haber una —y preferiblemente solo una— manera obvia de hacerlo.\n",
    "- Aunque esa manera puede no ser obvia al principio a menos que usted sea holandés.\n",
    "- Ahora es mejor que nunca.\n",
    "- Aunque nunca es a menudo mejor que ya mismo.\n",
    "- Si la implementación es difícil de explicar, es una mala idea.\n",
    "- Si la implementación es fácil de explicar, puede que sea una buena idea.\n",
    "- Los espacios de nombres (*namespaces*) son una gran idea, ¡hagamos más!\n",
    "\n",
    "**Nota**: Un *namespace* es una forma de asegurarse de que no hay nombres de variables o funciones o métodos repetidos entre el *script* y las librerías y módulos utilizados."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import this"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "### Más información\n",
    "\n",
    "* [Documentación oficial de Python](https://docs.python.org/3/)\n",
    "* [RealPython](https://realpython.com/)\n",
    "* [w3schools](https://www.w3schools.com/python/)\n",
    "* [Wikibook de Python](https://en.wikibooks.org/wiki/Python_Programming)\n",
    "* (...muchas otras referencias en la web y libros...)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "**Universidad de Costa Rica** | Facultad de Ingeniería | Escuela de Ingeniería Eléctrica\n",
    "\n",
    "&copy; 2021\n",
    "\n",
    "---"
   ]
  },
  {
   "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.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}