Py1.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",
    "# `Py1` - *Funciones y librerías estándar*\n",
    "\n",
    "> Dentro de las librerías estándar de Python hay herramientas útiles para operaciones numéricas básicas, para el manejo de archivos como los que se van a aplicar en el curso y otras funciones útiles para programación en general.\n",
    "\n",
    "*Fabián Abarca Calderón*\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Funciones, librerías y métodos\n",
    "\n",
    "En programación generalmente se acepta que \"no hay que reinventar la rueda\" y también que \"no hay que repetirse\", y además que \"hay que mantenerlo sencillo\". Para no olvidarlo, existen estos acrónimos:\n",
    "\n",
    "* **DRY**, *don't repeat yourself*\n",
    "* **KISS**, *keep it simple, st#pid*\n",
    "\n",
    "Una forma de seguir estos buenos consejos es creando funciones que se invocan cuando hay que hacer tareas repetitivas, y también utilizando piezas de código (\"librerías\") que ya han sido desarrolladas para resolver aplicaciones específicas.\n",
    "\n",
    "La existencia de funciones y librerías (con sus módulos y métodos asociados), desarrollados por una inmensa comunidad global, agregan muchas funcionalidades poderosas a Python."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "## 1.1 - Funciones\n",
    "\n",
    "En Python, la sintaxis para la creación de una función es:\n",
    "\n",
    "```python\n",
    "def nombre():\n",
    "    <acción de la función>\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def suma(x, y):\n",
    "    z = x + y\n",
    "    return z\n",
    "\n",
    "print(suma(1, 2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "## 1.2 - Librerías, módulos, métodos y atributos\n",
    "\n",
    "Las librerías son grupos de funciones predefinidas, que se pueden importar al código en conjunto y utilizarlas para realizar tareas de foma más sencilla, reduciendo así el tamaño del código propio y simplificándolo.\n",
    "\n",
    "Para llamarlas se utiliza\n",
    "\n",
    "```python\n",
    "import <libreria>\n",
    "```\n",
    "\n",
    "donde también se utiliza un \"alias\": un nombre corto (muy corto, como `np` para `numpy`) para referirse a este por el resto del programa.\n",
    "\n",
    "```python\n",
    "import <libreria> as <alias>\n",
    "```\n",
    "\n",
    "Sin embargo en ocasiones no se desea importar toda la librería sino solo algunos componentes o \"módulos\":\n",
    "\n",
    "```python\n",
    "from <libreria> import <modulo o metodo>\n",
    "```\n",
    "\n",
    "Luego de importarlas, se invocan sus atributos y métodos con la notación del punto. Por ejemplo, la función coseno de la librería NumPy es `np.cos()` (un método) y el número $\\pi$ es `np.pi` (un atributo). Si se importa un método directamente, no es necesaria la notación del punto, por ejemplo: `randint()` (una función de `random`)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import math\n",
    "import numpy as np\n",
    "from random import randint\n",
    "from scipy.constants import c\n",
    "\n",
    "print('4! =', math.factorial(4))\n",
    "print('C/D =', np.pi)\n",
    "print('Un número aleatorio =', randint(50, 60))\n",
    "print('Velocidad de la luz =', c)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1.2.1 - Librería `math`\n",
    "\n",
    "Estas son funciones matemáticas comunes. Hay una gran [variedad](https://docs.python.org/3/library/math.html), entre las que se incluyen:\n",
    "\n",
    "##### Redondeo\n",
    "\n",
    "* `math.ceil(x)`: retorna el \"techo\" de `x`, el entero más pequeño mayor o igual que `x`.\n",
    "* `math.floor(x)`: retorna el \"piso\" de `x`, el entero más grande menor o igual que `x`.\n",
    "\n",
    "##### Análisis combinatorio\n",
    "\n",
    "* `math.comb(n, k)`: retorna el coeficiente binomial $C(n,k)$, correspondiente al número de combinaciones de `k` elementos que se pueden obtener de un grupo de `n` elementos, donde el **orden no importa**.\n",
    "\n",
    "$$\n",
    "n \\choose k\n",
    "$$\n",
    "\n",
    "* `math.perm(n, k)`: retorna el número de formas de elegir `k` elementos de `n` elementos sin repetición, donde el **orden sí importa**.\n",
    "\n",
    "##### Otras funciones útiles\n",
    "\n",
    "* `math.factorial(x)`: retorna el factorial de `x`: $x!$.\n",
    "* `math.pow(x, y)`: retorna el valor de $x^y$.\n",
    "* `math.sqrt(x)`: retorna la raíz cuadrada de `x`: $\\sqrt{x}$.\n",
    "* `math.erf(x)`: retorna el valor de la función de error (la función de distribución normal estándar) evaluada en `x`. Esta función será de gran utilidad en este curso."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import math\n",
    "\n",
    "print(math.ceil(2.3))\n",
    "print(math.floor(2.3))\n",
    "print(math.erf(1.1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1.2.2 - Librería `random`\n",
    "\n",
    "Generación de números pseudo-aleatorios, con distintas distribuciones. Hay una gran [variedad](https://docs.python.org/3/library/random.html), entre las que se incluyen:\n",
    "\n",
    "* `random.randint(a, b)`: retorna un número aleatorio entero entre `a` y `b` (intervalo cerrado).\n",
    "* `random.uniform(a, b)`: retorna un número aleatorio flotante para una distribución uniforme entre `a` y `b`.\n",
    "* `random.sample(population, k)`: retorna una lista con `k` muestras aleatorias tomadas de la lista `population`.\n",
    "* `random.expovariate(lambd)`: retorna un número aleatorio flotante para una distribución exponencial con parámetro `lambd`.\n",
    "* `random.gauss(mu, sigma)`: retorna un número aleatorio (flotante) para una distribución normal con media `mu` y desviación estándar `sigma`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import random as rd\n",
    "print(rd.gauss(1,3))\n",
    "print(rd.randint(0,100))\n",
    "print(rd.uniform(0,100))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1.2.3 - Librería `statistics`\n",
    "\n",
    "Herramientas estadísticas para aplicar a un conjunto de datos. Hay una gran [variedad](https://docs.python.org/3/library/statistics.html), entre las que se incluyen:\n",
    "\n",
    "* `statistics.mean(data)`: retorna el valor esperado de un conjunto de datos `data`.\n",
    "* `statistics.pstdev(data)`: retorna la desviación estándar de la población para el conjunto de datos `data`.\n",
    "* `statistics.stdev(data)`: retorna la desviación estándar de una muestra para el conjunto de datos `data`.\n",
    "* `statistics.pvariance(data)`: retorna la varianza de la población para el conjunto de datos `data`.\n",
    "* `statistics.variance(data)`: retorna la varianza de una muestra para el conjunto de datos `data`.\n",
    "\n",
    "Entre otros. Consultar la documentación adjunta."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import statistics\n",
    "\n",
    "data = range(1, 60)\n",
    "\n",
    "print(statistics.mean(data))\n",
    "print(statistics.variance(data))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1.2.4 - Librería `collections`\n",
    "\n",
    "Presenta alternativas a las listas, sets, tuplas y diccionarios que incluye Python por defecto. Incluye diferentes estructuras para almacenar y manejar datos, definidas por clases, cada una con sus métodos específicos Hay una gran [variedad](https://docs.python.org/3/library/collections.html), entre las que se incluyen:\n",
    "\n",
    "* `collections.deque`: Agrega funcionalidades a una lista convencional, como pops y appends.\n",
    "* `collections.OrderedDict`: Diccionario que registra el orden en que fueron agregados los objetos.\n",
    "* `collections.UserString`: Agrega funcionalidades para manejo de objetos tipo `String`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "El siguiente es un ejemplo para la solución \"elegante\" de un problema común.\n",
    "\n",
    "> ¿Cuál es la probabilidad de que, al lanzar dos dados, la suma de los dados sea 7? [2]\n",
    "\n",
    "(El resultado es fácil de deducir: de 36 combinaciones posibles, seis suman siete (1 + 6, 2 + 5, 3 + 4, 4 + 3, 5 + 2, 6 + 1), entonces 6/36 = 1/6 $\\approx$ 0.16667).\n",
    "\n",
    "Primero, el objeto `defaultdict` del [módulo](https://docs.python.org/2/library/collections.html) `collections` crea diccionarios con valores predeterminados cuando encuentra una nueva clave. Su uso práctico es el de **\"diccionario rellenable\"**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from collections import defaultdict"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ahora, es posible crear un diccionario con todas las combinaciones posibles y la suma de cada una, con un doble bucle `for`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "d = {(i,j) : i+j for i in range(1, 7) for j in range (1, 7)}\n",
    "print(d)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Seguidamente se crea un `defaultdict` vacío. Este implica que, más adelante, si una clave no es encontrada en el diccionario, en lugar de un `KeyError` se crea una nueva entrada (un nuevo `key:value`)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dinv = defaultdict(list)\n",
    "print(dinv)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Es posible extraer del diccionario las combinaciones que suman 7. El método `.items()` genera una lista de pares de \"tuplas\" (una tupla es un conjunto ordenado e inmutable de elementos) a partir del diccionario de combinaciones creado en `d`. \"Rellenamos\" el `defaultdict` con los elementos en el diccionario creado anteriormente y el método `.append()`, esto con un bucle `for` en donde los índices `i,j` representan los pares de combinaciones y su suma. La ventaja es que ahora están todos agrupados."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print('Antes...\\n')\n",
    "print(d.items())\n",
    "\n",
    "for i,j in d.items(): \n",
    "        dinv[j].append(i)\n",
    "\n",
    "print('\\nDespués...')        \n",
    "dinv"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "El `for` anterior puede leerse como: \"para cada par en la lista de ítemes, en la posición `j` (la suma de las combinaciones) añada la combinación correspondiente (en `i`)\".\n",
    "\n",
    "Extraemos los pares que suman siete y obtenemos la cantidad de estos."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print('Combinaciones que suman 7:', dinv[7])\n",
    "print('Elementos:', len(dinv[7]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Finalmente, y más en general, se obtiene la probabilidad para todas las sumas en forma de un solo diccionario:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "probabilidades = {i : len(j)/36 for i,j in dinv.items()}\n",
    "print('El vector de probabilidades de suma es =', probabilidades)\n",
    "print('La probabilidad de que la suma sea 7 es =', probabilidades[7])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1.2.5 - Librería `csv`\n",
    "\n",
    "Esta librería implementa clases para el manejo de archivos tipo CSV (*Comma Separated Values*), con actividades típicas como *leer* datos desde y *escribir* datos en un archivo CSV u otros similares. \n",
    "\n",
    "Entre sus funciones se encuentran:\n",
    "\n",
    "* `csv.reader(csvfile, dialect='excel', **fmtparams)`: crea un objeto tipo `reader` con los datos del archivo `csvfile` para el \"dialecto\" (formato) especificado. `fmtparams` son \"parámetros de formato\" adicionales para modificar la configuración del formato.\n",
    "* `csv.writer(csvfile, dialect='excel', **fmtparams)`: crea un objeto tipo `writer` para escribir datos al archivo `csvfile` con el \"dialecto\" (formato) especificado. `fmtparams` son \"parámetros de formato\" adicionales para modificar la configuración del formato.\n",
    "\n",
    "La [documentación](https://docs.python.org/3/library/csv.html) completa tiene todos los detalles.  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import csv\n",
    "\n",
    "unos = [1]*10\n",
    "\n",
    "with open('unos.csv', 'w', newline='') as archivo:\n",
    "    escribir = csv.writer(archivo)\n",
    "    escribir.writerow(unos)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1.2.6 - Librería `os`\n",
    "\n",
    "Permite manejar archivos y rutas del sistema operativo como si fueran comandos en terminal. La lista completa de funciones se presenta en la [documentación](https://docs.python.org/3/library/os.html). Los métodos más importantes son:\n",
    "\n",
    "* `os.getcwd()`: retorna el directorio de trabajo actual.\n",
    "* `os.chdir(path)`: Cambia el directorio de trabajo al especificado por `path`.\n",
    "* `os.path` es un módulo para manipulación de direcciones (rutas) del sistema."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "\n",
    "print(os.getcwd())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1.2.7 - Otras librerías\n",
    "\n",
    "#### 1.2.7.1 - Librería `datetime`\n",
    "\n",
    "Presenta clases para manipulación de fechas y tiempo. Tiene dos módulos: `calendar` y `time`, cada uno con sus funciones, y permiten generar información como la fecha y hora actuales, la zona horaria, entre otros. La documentación completa se encuentra [aquí](https://docs.python.org/3/library/datetime.html) y excelentes ejemplos en [Programiz](https://www.programiz.com/python-programming/datetime)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import datetime\n",
    "\n",
    "ahora = datetime.datetime.now()\n",
    "\n",
    "print(ahora)\n",
    "print(ahora.month)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 1.2.7.2 - Módulo `calendar`\n",
    "\n",
    "Presenta una clase `Calendar` que permite crear objetos que representen calendarios, e incluye métodos para manipularlos. La documentación completa se encuentra [aquí](https://docs.python.org/3/library/calendar.html)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import calendar\n",
    "import datetime\n",
    "\n",
    "ahora = datetime.datetime.now()\n",
    "\n",
    "es_bisiesto = calendar.isleap(ahora.year)\n",
    "calendario = calendar.month(ahora.year, ahora.month)\n",
    "\n",
    "print('Año bisiesto:', bisiesto)\n",
    "print(calendario)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "## 1.3 - ¿Cómo crear una librería propia?\n",
    "\n",
    "Una librería consiste simplemente en una serie de archivos de código (extensión `.py`) con definiciones de las funciones a utilizar. Luego de importar la librería a un código, estas funciones se pueden acceder y utilizar. Los archivos de la libería se pueden distribuir de una forma jerárquica, teniendo de esta forma \"sublibrerías\" y permitiendo así clasificar las funciones. \n",
    "\n",
    "Para crear un paquete se requieren dos elementos:\n",
    "* Todos los archivos `.py` con las funciones en una única carpeta, con el nombre de la librería\n",
    "* Un archivo `__init__.py` (que normalmente se deja vacío) para que el intérprete identifique la carpeta como una librería\n",
    "\n",
    "Hay muchos [recursos](https://www.tutorialsteacher.com/python/python-package) en línea que explican y ejemplifican este procedimiento."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "### Más información\n",
    "\n",
    "* [Documentación oficial de Python](https://docs.python.org/3/)\n"
   ]
  },
  {
   "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",
    "---"
   ]
  }
 ],
 "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
}