3. Métodos y estructuras de control.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 3. Funciones y estructuras de control en python"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Consideremos el ejemplo del notebook anterior que calcula el área de un rectángulo:\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "15"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def area_rectangulo(l, a):\n",
    "  return l*a #vemos que esto está definido dentro del método\n",
    "\n",
    "area_rectangulo(3,5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La definición del método que calcula el área de un rectángulo constituye un bloque de código (en python se llama suite) que inicia con la palabra def y termina en la línea 2 con la instrucción ```return l*a```. Python utiliza la indentación para definir suites. Una forma rápida de identificar una suite en python es porque inicia con ```:```. \n",
    "\n",
    "A parte de definir métodos, se utilizan los dos puntos ```:``` para definir las estructuras de control condicional ```if else elif``` y las estructuras de control cíclico ```for while```.\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Estructuras de control condicional\n",
    "\n",
    "Es posible determinar que suite de código ejecutar especificando estructuras de control condicional. Por ejemplo para determinar si un número es par podríamos decir que un número par es aquel cuyo residuo entre 2 es igual a cero, de otro modo es impar.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "digite un número: 7385783\n",
      "7385783 es impar\n"
     ]
    }
   ],
   "source": [
    "num = int(input('digite un número: '))\n",
    "\n",
    "if num % 2 == 0:\n",
    "    print(num, 'es par') #está en la suite que identifica que el residuo del número dado entre 2 es igual a cero\n",
    "else:\n",
    "    print(num, 'es impar') #está definido en la suite en caso de que el residuo del número dado entre 2 no sea igual a cero"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Se puede hacer lo mismo con máscaras de bits:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "7385783 es impar\n"
     ]
    }
   ],
   "source": [
    "if num & 1 == 0:\n",
    "    print(num, 'es par') #está en la suite que identifica que el último bit del número es un 1\n",
    "else:\n",
    "    print(num, 'es impar') #está definido en la suite en caso de que el último bit del número es un 0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Si esta pieza de código se requiere para realizar algo más avanzado se puede definir como método desarrollando un código de forma modular. Al definirlo como método, el if va a quedar en la suite del método es_par y eso se indica mediante la indentación."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "digite un número: 54\n",
      "54 es par\n"
     ]
    }
   ],
   "source": [
    "def es_par(num):\n",
    "  if num % 2 == 0:\n",
    "    print(num, 'es par')\n",
    "  else:\n",
    "    print(num, 'es impar')\n",
    "\n",
    "num = int(input('digite un número: '))\n",
    "es_par(num)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Después de ejecutar la celda anterior (con shift + enter). Puedo llamar mi método con otros valores:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3 es impar\n"
     ]
    }
   ],
   "source": [
    "es_par(3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5 es impar\n"
     ]
    }
   ],
   "source": [
    "es_par(5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "823957923857924769276979 es impar\n"
     ]
    }
   ],
   "source": [
    "es_par(823957923857924769276979)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "823957923857924769276979483583498539854 es par\n"
     ]
    }
   ],
   "source": [
    "es_par(823957923857924769276979483583498539854)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La función que permite calcular el valor absoluto de un número real es una función que recibe como parámetro de entrada un número real y retorna la distancia de ese valor al origen. Esta función matemáticamente se define en casos de la siguiente forma:\n",
    "\n",
    "\\begin{align*}\n",
    "\tvalor\\_absoluto: \\mathbb{R} &\\to \\mathbb{R} \\\\\n",
    "\t(x) &\\mapsto \n",
    "\t\\begin{cases}\n",
    "\t\\phantom{-}x,& \\text{si } x \\geq 0;\\\\\n",
    "\t-x,& \\text{en otro caso}.\n",
    "\t\\end{cases}\n",
    "\t\\end{align*}\n",
    "  \n",
    "  Y en Python quedaría:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "digite un número: -3\n",
      "valor absoluto de x es 3\n"
     ]
    }
   ],
   "source": [
    "def valor_absoluto(x):\n",
    "  if x >= 0:\n",
    "    return x\n",
    "  else:\n",
    "    return -x\n",
    " \n",
    "numero = int(input('digite un número: '))\n",
    "print('valor absoluto de x es' , valor_absoluto(numero))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Es posible tener más de dos casos en una estructura de control condicional, como veremos en el siguiente ejemplo: La empresa Tqm ofrece la siguiente promocion: por compras mayores a 10000 lleva un 10% de descuento. Por compras mayores a 20000 lleva un 20% de descuento. Dado el valor de la compra halle el valor a pagar y diga de cuanto fue el descuento."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "digite el valor total de su compra:25000\n",
      "valor a pagar 20000.0 y ahorró: 5000.0\n"
     ]
    }
   ],
   "source": [
    "def descuento(vc):\n",
    "  if vc > 10000 and vc <= 20000:\n",
    "    print(\"valor a pagar\", vc-vc*0.1, \"y ahorró:\" , vc*0.1)\n",
    "  elif vc > 20000: # en otro caso si\n",
    "    print(\"valor a pagar\", vc-vc*0.2, \"y ahorró:\" , vc*0.2)\n",
    "  else: #en otro caso\n",
    "    print(\"usted compró muy poco y no tiene descuentos.\")\n",
    "  \n",
    "vc = int(input('digite el valor total de su compra:'))\n",
    "descuento(vc)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Ejercicio: Prueba de selección\n",
    "\n",
    "Leer 4 valores enteros A, B, C y D. Si B es mayor que C y D es mayor que A y si la suma de C y D es mayor que la suma de A y B y si C y D fueran valores positivos y si A es par, escriba el mensaje “Valores aceptados”. De lo contrario, escriba el mensaje “Valores no aceptados”.\n",
    "\n",
    "![](https://raw.githubusercontent.com/arleserp/cursopython/master/images/valores.png \"valores\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Cajero\n",
    "\n",
    "Un cajero, requiere calcular la mínima cantidad de billetes para repartir dinero a sus clientes. Se tiene un retiro de máximo \\\\$1.600.000 y dicho valor debe ser múltiplo de \\\\$10.000 ya que no reparte monedas. El valor a retirar se entrega en billetes de \\\\$100.000, \\\\$50.000, \\\\$20.000 o \\\\$10.000.\n",
    "\n",
    "Elabore un programa que realice dicha validación y muestre la distribución del dinero.\n",
    "La salida debe ser como la de los siguientes 3 ejemplos:\n",
    "\n",
    "![](https://raw.githubusercontent.com/arleserp/cursopython/master/images/cajero.png \"valores\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Estructuras de control cíclico"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### El ciclo while \n",
    "\n",
    "El ciclo ```while``` permite ejecutar un bloque de instrucciones mientras que una expresión booleana dada se cumpla, es decir, mientras su evaluación dé como resultado verdadero. La expresión booleana se denomina condición de parada y siempre se evalúa antes de ejecutar el bloque de instrucciones. Si la condición no se cumple, el bloque no se ejecuta. Si la condición se cumple, el bloque se ejecuta, después de lo cual la instrucción vuelve a empezar, es decir, la condición se vuelve a evaluar.\n",
    "\n",
    "En el caso en que la condición se evalúe la primera vez como falsa, el bloque de instrucciones no será ejecutado, lo cual quiere decir que el número de repeticiones o iteraciones de este bloque será cero. Si la condición siempre evalúa a verdadero, la instrucción se ejecutará indefinidamente, es decir, un número infinito de veces.\n",
    "\n",
    "La estructura de un ciclo ```while``` se da en el siguiente fragmento de código:\n",
    "\n",
    "```\n",
    "<suite_prev>\n",
    "<inicia>\n",
    "while(<cond>):\n",
    "  <suite_while>\n",
    "  <actualiza>\n",
    "<suite_siguiente>\n",
    "\n",
    "```\n",
    "\n",
    "Donde: \n",
    "\n",
    "- El fragmento suite_prev es la suite instrucciones previas que han sido ejecutadas antes del ciclo.\n",
    "\n",
    "- El fragmento inicia es la suite de instrucciones donde se inicializan las variables que intervienen en la condición de parada.\n",
    "\n",
    "- El fragmento cond es la condición de parada que se evalúa cada vez que se inicia o se reinicia el ciclo.\n",
    "\n",
    "- El fragmento suite_while es el bloque de instrucciones principal del ciclo que se ejecuta mientras la condición se  cumpla.\n",
    "\n",
    "- El fragmento actualiza es el bloque que se utiliza para actualizar las variables que son utilizadas para evaluar la condición de parada cuando se intenta reiniciar el ciclo.\n",
    "\n",
    "- El fragmento suite_siguiente es el bloque de instrucciones que se  ejecutan después de terminar de ejecutar el ciclo.\n",
    "\n",
    "A continuación se muestra un ejemplo de funcionamiento del ciclo while. Se utilizarán métodos para introducir al lector en la programación modular."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2 , 25\n",
      "4 , 35\n",
      "8 , 45\n",
      "16 , 55\n",
      "32 , 65\n",
      "64 , 75\n",
      "the end.\n",
      "128 , 85\n",
      "esto es parte de la función\n",
      "Wall time: 3 s\n"
     ]
    }
   ],
   "source": [
    "%%time \n",
    "#mide el tiempo de ejecución de una celda\n",
    "\n",
    "import time #es para usar sleep\n",
    "\n",
    "def ejemplo_while():\n",
    "  #sirve para determinar el tiempo de ejecución de un programa \n",
    "  i = 2 #inicializa a i en 2\n",
    "  j = 25 # inicializa a j en 25\n",
    "  while i < j: #mientras i sea menor a j\n",
    "      print(i, \",\", j) #va a imprimir los valores de i , j\n",
    "      time.sleep(0.5) #función que interrumpe \n",
    "      i*=2 # i = i*2 como a i lo va multiplicando por 2 en cada paso se espera que supere a j en un punto\n",
    "      j+=10 # j = j + 10 se incrementa de 10 en 10\n",
    "  print(\"the end.\") #esta es una instrucción que se ejecuta al terminar el ciclo while\n",
    "  print(i, \",\", j) #imprime los valores finales de i y de j\n",
    "  print(\"esto es parte de la función\")\n",
    "\n",
    "\n",
    "ejemplo_while() #aquí se llama el método\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Poblaciones\n",
    "\n",
    "En el año 2010, el país A tiene una población de n (1 <=n <= 10^8) y el país B tiene una población de m (1 <= m <= n). Las tasas de crecimiento anual es de 2% y 3% respectivamente. Desarrollar un algoritmo para informar en que año la población del país B iguala o supera a la del país A.\n",
    "\n",
    "![](https://raw.githubusercontent.com/arleserp/cursopython/master/images/poblaciones2.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### El ciclo for"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Fueron ideados en python para recorrer estructuras de datos. En este caso se presenta un ejemplo con una lista."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "apple\n",
      "banana\n",
      "cherry\n"
     ]
    }
   ],
   "source": [
    "fruits = [\"apple\", \"banana\", \"cherry\"]\n",
    "\n",
    "for f in fruits: #para cada elemento f en la lista de frutas\n",
    "  print(f)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### La sentencia break\n",
    "\n",
    "Nos permite detener el ciclo antes de iterar sobre toda la colección de elementos:\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "apple\n",
      "orange\n",
      "kiwi\n",
      "banana\n"
     ]
    }
   ],
   "source": [
    "fruits = [\"apple\", \"orange\", \"kiwi\", \"banana\", \"cherry\"]\n",
    "\n",
    "for x in fruits:\n",
    "  print(x)\n",
    "  if x == \"banana\":\n",
    "    break"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter data or press 0 to quit :1\n",
      "Enter data or press 0 to quit :2\n",
      "Enter data or press 0 to quit :3\n",
      "Enter data or press 0 to quit :4\n",
      "Enter data or press 0 to quit :0\n",
      "sum: 10\n"
     ]
    }
   ],
   "source": [
    "sum = 0\n",
    "while True:\n",
    "    data = int(input('Enter data or press 0 to quit :'))\n",
    "    if(data == 0):\n",
    "        break\n",
    "    sum += data\n",
    "print('sum: '+ str(sum))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### La clase range\n",
    "\n",
    "Genera una secuencia de números desde ```start``` hasta ```stop``` con un incremento de ```step```. Maneja una sintaxis de la siguiente forma ```(start, stop, step)```\n",
    "\n",
    "- El valor ```start``` permite controlar donde empieza el rango\n",
    "- El valor ```stop``` define cuando termina el rango. Es posible crear un rango con una sola variable. En este caso se asumirá que corresponde al valor de parada y se asumirá que ```start=0```\n",
    "- El valor ```step``` permite definir como se genera el rango. Por defecto se asume un incremento de 1 en 1 (ejemplo: 0,1,2,3,4...). También se puede utilizar un valor negativo para ajustar la dirección del rango.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 1, 2, 3, 4]"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(range(5)) #genera una lista con valores desde 0 a 4 incrementando de a uno en uno\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 1, 2, 3, 4]"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(range(0,5,1)) #mismo ejemplo que el anterior pero especificando start en 0 e incrementando de a uno en uno"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[10, 8, 6, 4, 2]"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#generar una lista con los números desde 10 hasta 2 saltando de dos en dos\n",
    "list(range(10,1,-2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[2, 4, 6, 8, 10]"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#generar una con los números de 2 a 10 incrementando de 2 en 2\n",
    "list(range(2,11,2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Los rangos se combinan perfectamente con la instrucción ```for``` para esto se define una variable que se utilizará para recorrer cada elemento en el rango utilizando la palabra reservada ```in```. En español se podría pensar como: Para cada elemento i en el rango dado.   "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n",
      "9\n",
      "8\n",
      "7\n",
      "6\n",
      "5\n",
      "4\n",
      "3\n",
      "2\n",
      "1\n"
     ]
    }
   ],
   "source": [
    "def f():\n",
    "    for i in range(10, 0, -1):\n",
    "      print(i)\n",
    "f()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hola\n",
      "hola\n",
      "hola\n"
     ]
    }
   ],
   "source": [
    "for i in range(3):\n",
    "    print(\"hola\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Ejercicios"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Generar una lista con los elementos de 99 a 1 en orden descendente: 99, 98, 97, 96, ..., 3, 2, 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Generar una lista con los múltiplos de 5 de 0 a 45: 0, 5, 10, 15, ..., 30, 35, 40, 45"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 5, 10, 15, 20, 25, 30, 35, 40, 45]"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\n",
    "   "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Generar una lista con los números impares de 123 a 140: 123, 125, ..., 139"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[123, 125, 127, 129, 131, 133, 135, 137, 139]"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Múltiplos de un número\n",
    "\n",
    "Dado un número entero n y otro entero m, escriba un programa que muestre los múltiplos de m hasta n.\n",
    "El programa debe mostrar una salida similar a las siguientes ejecuciones:\n",
    "\n",
    "![](https://raw.githubusercontent.com/arleserp/cursopython/master/images/multiplos.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Positivo, negativo o cero \n",
    "\n",
    "Realizar (utilizando funciones) un programa que, al digitar un número, diga si es positivo, negativo o cero:\n",
    "\n",
    "Entrada: En la primera línea se digita el número de casos, seguido a esto, vienen los n números que el usuario digite\n",
    "\n",
    "Salida: La salida es “Positivo, Negativo o Cero” dependiendo del caso\n",
    "\n",
    "![](https://raw.githubusercontent.com/arleserp/cursopython/master/images/ciclosposneg.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6\n",
      "hola\n",
      "hola\n",
      "hola\n",
      "hola\n",
      "hola\n",
      "hola\n"
     ]
    }
   ],
   "source": [
    "casos = int(input())\n",
    "\n",
    "for x in range(casos):\n",
    "    print(\"hola\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Referencias: \n",
    "\n",
    "Barry, P. (2016). Head First Python: A Brain-Friendly Guide. \" O'Reilly Media, Inc.\".\n",
    "\n",
    "Guttag, John. Introduction to Computation and Programming Using Python: With Application to Understanding Data Second Edition. MIT Press, 2016. ISBN: 9780262529624.\n",
    "\n",
    "\n",
    "https://www.w3schools.com/PYTHON/\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.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}