Clase1a-Introduccion_Python_preclase.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Clase 1a : Elementos básicos de Python\n",
    "Referencia: Capítulo 2 de \"Python for Data Analysis\", Wes McKinney."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Python, iPython y Jupyter Notebooks"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a=1\n",
    "b=2\n",
    "a+b\n",
    "a-b\n",
    "a*b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a+b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Python**: Lenguaje de programación (ejecuta comandos, generalmente de un archivo)\n",
    "\n",
    "**IPython**: Interprete de python con cosas practicas\n",
    "\n",
    "**Jupyter Notebooks**: Interface Web para desplegar texto (Markdown) y comandos IPython (y otro lenguajes)\n",
    "\n",
    "(*Markdown*: formato de escritura con estilos, usado en multiples plataformas (wikipedia, github, Whatsapp))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ventajas de IPython:\n",
    "- Completación de variables o módulos/funciones (con tab)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "variable_primal = 14\n",
    "variable_otra = \"Perro\"\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "variable_otra"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Ayuda en linea (con \"?\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "variable_primal?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Integración con `matplotlib` para gráficos"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "plt.plot([1,10,5,4])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Conceptos básicos de Python"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Semantica"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Espacios, no llaves\n",
    "A diferencias de otros lenguajes, en vez de definir el scope de un comando usando llaves, se usa la identación (espacio inicial) y \":\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for x in [1,2,3]:\n",
    "    if x < 2:\n",
    "        print(\"Hola\")\n",
    "    else:\n",
    "        print(x**2)\n",
    "print(\"chao\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Comentarios:  con signo ```#```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for x in [1,2,3]:\n",
    "    # si es menor que 2 dice hola\n",
    "    if x < 2:\n",
    "        print(\"Hola\")\n",
    "    # si no lo eleva al cuadrado\n",
    "    else:\n",
    "        print(x**2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"Hola\")  # comentario al final\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Variables y argumentos\n",
    "Se definen con el signo igualdad `=`. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 2\n",
    "a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "En Python, todo es un `objeto`, por lo que tienen atributos y métodos, llamados con un `.<metodo>` despues de la variable."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = \"perro\"\n",
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a.count(\"r\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a.capitalize()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Atención:** al hacer igualdad entre dos variables, se crea una \"referencia\" al objeto, no una copia de este. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = [1, 2, 3]\n",
    "b = a\n",
    "b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a.append(4)\n",
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "b.append('H')\n",
    "b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Algunos objetos pueden copiarse. Por ejemplo, una lista tiene una función \".copy()\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "?a.copy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = [1, 2, 3]\n",
    "b=a.copy()\n",
    "a.append(4)\n",
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Tipos y referencias fuertes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A diferencia de otros lenguajes, Python no tiene \"tipos\" asociado a una variable. Una variable puede ser un entero, un string, o cambiar de una a otra, a veces sin siquiera darnos cuenta."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 5\n",
    "type(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "b = 'foo'\n",
    "type(b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "'5' + 5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "'5'+'5'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "b*10"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Algunas conversiones son automaticas:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 4.5\n",
    "type(a)\n",
    "b = 2\n",
    "type(b)\n",
    "a/b\n",
    "type(a/b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Atributos y métodos"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```python\n",
    "In [1]: a = 'foo'\n",
    "\n",
    "In [2]: a.<Tab>\n",
    "a.capitalize  a.format      a.isupper     a.rindex      a.strip\n",
    "a.center      a.index       a.join        a.rjust       a.swapcase\n",
    "a.count       a.isalnum     a.ljust       a.rpartition  a.title\n",
    "a.decode      a.isalpha     a.lower       a.rsplit      a.translate\n",
    "a.encode      a.isdigit     a.lstrip      a.rstrip      a.upper\n",
    "a.endswith    a.islower     a.partition   a.split       a.zfill\n",
    "a.expandtabs  a.isspace     a.replace     a.splitlines\n",
    "a.find        a.istitle     a.rfind       a.startswith\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = '36'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a.replace('3','H')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Operaciones binarias:\n",
    "\n",
    "Operacion | Descripción\n",
    "----------|------------\n",
    "a + b | Suma\n",
    "a - b | Resta\n",
    "a * b | Multiplicacion\n",
    "a / b | División\n",
    "a // b | División entera\n",
    "a % b | Módulo o resto de la división entera\n",
    "a ** b | Potencia\n",
    "a & b | Y lógico\n",
    "a \\| b | O lógico\n",
    "a ^ b | O-exclusivo lógico\n",
    "a == b | True si son iguales\n",
    "a != b | True si no son iguales\n",
    "a <= b | True si a es menor o igual que b (también con  <=, <, >)\n",
    "a is b | Trues si a y b son una referencia al mismo objeto\n",
    "a is not b | Trues si a y b no son una referencia al mismo objeto\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "True ^ True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "5 - 7\n",
    "12 + 21.5\n",
    "5 <= 2 & 7>3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = [1, 2, 3]\n",
    "b = a\n",
    "c = a.copy()\n",
    "c"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a is c\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 2\n",
    "a is None"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###  Types (Tipos) básicos de Python\n",
    "Los tipos mas relevantes son:\n",
    "- `None` : nulo, para identificar algo que no existe \n",
    "- `str` : String, texto\n",
    "- `bytes`: datos en formato ASCII\n",
    "- `bool`: booleano, puede ser verdadero (True) o falso (False)\n",
    "- `int` : número entero\n",
    "- `float` : número \"real\" (mas bien, doble-precision 64 bits)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Números"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ival = 17239871\n",
    "ival ** 6"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fval = 7.243\n",
    "fval2 = 6.78e-5\n",
    "fval2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "3 / 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "3 // 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Strings (Texto)\n",
    "Puede usarse comillas (\") o apostrofe (').  Si son múltiples lineas, usar triple comillas o triple apostrofe"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 'one way of writing a string'\n",
    "b = \"another way\"\n",
    "b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "c = \"\"\"\n",
    "This is a longer string that\n",
    "spans multiple lines\n",
    "\"\"\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "c"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(c)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Se pude convertir de un tipo a otro (usualmente, un número en un string)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 5.6\n",
    "str(a)\n",
    "print(\"vale \"+str(a))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a='6.7'\n",
    "float(a)+1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Booleanos\n",
    "Verdadero o Falso"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "True & True\n",
    "False or True"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Type casting \n",
    "Las funciones `float()`, `int()`, `bool()` y `str()` nos permiten cambiar entre estos tipos"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "s = '3.14159'\n",
    "fval = float(s)\n",
    "type(fval)\n",
    "int(fval)\n",
    "bool(fval)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### None\n",
    "Tipo especial para representar algo que no existe"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = None\n",
    "a is None\n",
    "b = 5\n",
    "b is not None"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Una gracia de Python es que una operación se interpreta de acuerdo al tipo de la variable.**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "5 + 7"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "'5' + '7'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "'5' * 5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Otros tipos\n",
    "#### Fechas y horas\n",
    "A través de las librerias de Python, podemos acceder a nuevos tipos, que incluyen sus propias funciones y métodos. Por ejemplo, para datos es muy util para manejar fechas. En este caso, importando la libreria `datetime`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from datetime import datetime, date, time\n",
    "dt = datetime(2011, 10, 29, 20, 30, 21)\n",
    "dt.date()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dt.date()\n",
    "dt.time()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dt.strftime('%d/%m/%Y %H:%M')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "datetime.strptime('2009-10-31', '%Y-%m-%d')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dt.replace(minute=0, second=10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dt2 = datetime(2011, 11, 15, 22, 30)\n",
    "delta = dt2 - dt\n",
    "delta"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "delta.total_seconds()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "17*24*60*60+7179"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Control de Flujo"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### if, elif, y else\n",
    "Ejecuta un comando si (`if`) se cumple una condición, o si (`elif`) otra condicion se cumple, y si ninguna se cumple (`else`) ejecutar otro comando"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = -1\n",
    "if x < 0:\n",
    "    print('Negativo')\n",
    "else:\n",
    "    print('No negativo')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 1.3\n",
    "if x < 0:\n",
    "    print('Negativo')\n",
    "elif x == 0:\n",
    "    print('igual a cero')\n",
    "elif 0 < x < 5:\n",
    "    print('positivo menor que 5')\n",
    "else:\n",
    "    print('positivo mayor o igual que 5')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### ciclos for \n",
    "Ejecuta una serie de comando para (`for`) un grupo de elementos de un conjunto."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in [4, [2,3] , \"Perro\"]:\n",
    "    print(i+i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in [4,\"Perro\",2,1]:\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Puedo interrumpir un ciclo usando `break`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in [1,2,3,4]:\n",
    "    for j in [1,2,3,4]:\n",
    "        if i==j:\n",
    "            break\n",
    "        print((i, j))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**comando util**: `range`: Algo muy util para ciclos de `for` es el comando `range()`, que entrega una secuencia de números"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(list(range(4,10,2)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "range?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "range(10)\n",
    "list(range(10))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in range(5):\n",
    "    print (i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "list(range(0, 20, 2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "list(range(5, 0, -2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Expresiones Ternarias  (Ternary expression)\n",
    "Python permite poner expresiones como `if` o `for` dentro de una linea, o una definición de una variable."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = -2\n",
    "y = \"Hola\"  if x > 0  else \"Chao\"\n",
    "y"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "para hacer listas (estructura que veremos pronto) mas facilmente "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = [i**2 for i in range(5) ]\n",
    "x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**EJERCICIO**: Genere un código calcule la suma de los números del 1 al 1 millon, que no son divisibles por 7."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Extra: texto en idioma español (u otros idiomas)\n",
    "#### Trabajo con acentos y eñes\n",
    "El texto, por defecto, es un código llamado ASCII. Este código no considera caracteres especiales como ñ, acentos, u otras letras. Estas tipicamente se \"codifican\" como string, siendo el mas común el UTF8. Sin embargo, hay varios encoding distintos (por ejemplo, _UTF16_, o _Latin1_).  A veces, al leer datos, pueden estar en la codificación incorrecta, pero podemos codificarlos (`encode`) o decodificarlos (`decode`) como queramos.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = \"baño\"\n",
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a8 = a.encode('utf8')\n",
    "a16 = a.encode('utf16')\n",
    "a32 = a.encode('latin1')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(a32)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(a8.decode('utf8'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3.7.7 64-bit",
   "language": "python",
   "name": "python37764bitbf82ff8733e44256b381353da7db86a3"
  },
  "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.9.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}