diff --git a/TareasClase2.ipynb b/TareasClase2.ipynb deleted file mode 100644 index 20816336a7523acbd6cdaf77b9afa433f4be77c2..0000000000000000000000000000000000000000 --- a/TareasClase2.ipynb +++ /dev/null @@ -1,426 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Ejercicio 1\n", - "En la primera celda tomamos una lista de entrada del usuario. En la segunda usamos la función `.split` para crear una lista con cada palabra, la ordenamos con `sorted`, y finalmente la juntamos de nuevo con `.join` (siempre tenemos en cuenta que el separador es -)." - ] - }, - { - "cell_type": "code", - "execution_count": 18, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Palabras de entrada (separadas por guiones): último-intento-ya-después-de-haber-renombrado-la-variable\n" - ] - } - ], - "source": [ - "inStr = str(input(r\"Palabras de entrada (separadas por guiones): \"))" - ] - }, - { - "cell_type": "code", - "execution_count": 19, - "metadata": {}, - "outputs": [], - "source": [ - "inStr = \"-\".join(sorted(inStr.split(\"-\")))" - ] - }, - { - "cell_type": "code", - "execution_count": 20, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "de-después-haber-intento-la-renombrado-variable-ya-último\n" - ] - } - ], - "source": [ - "print(inStr)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Ejercicio 2\n", - "## Parte 1\n", - "Para la primera parte importamos la función `factorial` y definimos una función que retorna el coeficiente binomial $n\\choose k$." - ] - }, - { - "cell_type": "code", - "execution_count": 16, - "metadata": {}, - "outputs": [], - "source": [ - "from math import factorial" - ] - }, - { - "cell_type": "code", - "execution_count": 17, - "metadata": {}, - "outputs": [], - "source": [ - "binomCoef = lambda n, k: factorial(n)/(factorial(k)*factorial(n-k))" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "El usuario inserta $n$ deseado: si el valor de la entrada es igual sin importar si se transforma a un float o a un int, entonces podemos concluir que $n \\in \\mathbb{Z}$." - ] - }, - { - "cell_type": "code", - "execution_count": 41, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "¿Número de la fila?8\n" - ] - } - ], - "source": [ - "N = float(input(r\"¿Número de la fila?\"))\n", - "if N != int(N):\n", - " print(\"Error: n no es entero\")\n", - "N = int(N)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Finamente, poblamos la lista `nRow` con los coeficientes de la fila correspondiente en el triángulo de Pascal e imprimimos." - ] - }, - { - "cell_type": "code", - "execution_count": 44, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[1.0, 8.0, 28.0, 56.0, 70.0, 56.0, 28.0, 8.0, 1.0]\n" - ] - } - ], - "source": [ - "nRow = []\n", - "for k in range(N+1):\n", - " nRow.append(binomCoef(N, k))\n", - "print(nRow)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Parte 2\n", - "Para la segunda parte reusamos una lÃnea del primer punto, e insertamos los números de las filas separados por puntos; esto ayuda a que no se puedan insertar números no enteros. Luego convertimos cada elemento en un int." - ] - }, - { - "cell_type": "code", - "execution_count": 52, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Inserte los números de las filas separados por puntos: 0.1.2.3.4.5\n" - ] - } - ], - "source": [ - "manyN = input(\"Inserte los números de las filas separados por puntos: \")\n", - "manyN = [int(n) for n in manyN.split(\".\")]" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Reusamos el código de la parte anterior, salvo que esta vez está dentro de otro loop que itera sobre cada fila $n_i$. Las filas que se obtienen se adicionan a una lista `rows`." - ] - }, - { - "cell_type": "code", - "execution_count": 53, - "metadata": {}, - "outputs": [], - "source": [ - "rows = []\n", - "for N in manyN:\n", - " nRow=[]\n", - " for k in range(N+1):\n", - " nRow.append(binomCoef(N, k))\n", - " rows.append(nRow)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Finalmente imprimimos cada fila en orden de entrada. En este caso se muestran las filas de la 0 a la 5" - ] - }, - { - "cell_type": "code", - "execution_count": 54, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[1.0]\n", - "[1.0, 1.0]\n", - "[1.0, 2.0, 1.0]\n", - "[1.0, 3.0, 3.0, 1.0]\n", - "[1.0, 4.0, 6.0, 4.0, 1.0]\n", - "[1.0, 5.0, 10.0, 10.0, 5.0, 1.0]\n" - ] - } - ], - "source": [ - "for i in range(len(manyN)):\n", - " print(rows[i])" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Ejercicio 3\n", - "Con la función `newEntry` se puede poblar el diccionario.\n", - "\n", - "* reyesf/Felipe/Reyes/Colombia/Cali/22/Univalle/Gimnasio\n", - "* varelaj/Jalil/Varela/Colombia/Palmira/21/Univalle/Age of mythology\n", - "* vargass/Sasiri/Vargas/Colombia/Cali/20/Univalle/Bailar" - ] - }, - { - "cell_type": "code", - "execution_count": 105, - "metadata": {}, - "outputs": [], - "source": [ - "def newEntry(d):\n", - " info = input(r\"Info de nueva entrada (sep. por /)\")\n", - " info = info.split(\"/\")\n", - " print(info)\n", - " #info = matter/nombre/apellido/pais/residencia/edad/institucion/hobbie\n", - " subd = {\"nombre\": info[1], \"apellido\":info[2], \"paÃs\":info[3], \"residencia\":info[4], \"edad\":info[5], \"institución\":info[6], \"hobbie\":info[7]}\n", - " d[info[0]] = subd" - ] - }, - { - "cell_type": "code", - "execution_count": 106, - "metadata": {}, - "outputs": [], - "source": [ - "compas = {}" - ] - }, - { - "cell_type": "code", - "execution_count": 109, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Info de nueva entrada (sep. por /)vargass/Sasiri/Vargas/Colombia/Cali/20/Univalle/Bailar\n", - "['vargass', 'Sasiri', 'Vargas', 'Colombia', 'Cali', '20', 'Univalle', 'Bailar']\n" - ] - } - ], - "source": [ - "newEntry(compas)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Definimos las tres funciones que se piden. Todas usan el mismo principio de iterar sobre las llaves de `compas`, e inspeccionar los contenidos de cada una. En la función que retorna las instituciones usamos un set para evitar entradas duplicadas." - ] - }, - { - "cell_type": "code", - "execution_count": 113, - "metadata": {}, - "outputs": [], - "source": [ - "def sortPais(d, pais):\n", - " names = []\n", - " for matter in d:\n", - " if d[matter][\"paÃs\"] == pais: \n", - " names.append(matter)\n", - " ## En caso de necesitar tabular de otra manera se deja asÃ.\n", - " ## De lo contrario se puede hacer un solo loop.\n", - " for matter in names:\n", - " print(d[matter])\n", - " \n", - "def edadMedia(d):\n", - " prom = []\n", - " for matter in d:\n", - " prom.append(float(compas[matter][\"edad\"]))\n", - " print(sum(prom)/len(prom)) \n", - " \n", - "def instit(d):\n", - " instituciones = set()\n", - " for matter in d:\n", - " instituciones.add(compas[matter][\"institución\"])\n", - " print(instituciones) " - ] - }, - { - "cell_type": "code", - "execution_count": 114, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'nombre': 'Felipe', 'apellido': 'Reyes', 'paÃs': 'Colombia', 'residencia': 'Cali', 'edad': '22', 'institución': 'Univalle', 'hobbie': 'Gimnasio'}\n", - "{'nombre': 'Jalil', 'apellido': 'Varela', 'paÃs': 'Colombia', 'residencia': 'Palmira', 'edad': '21', 'institución': 'Univalle', 'hobbie': 'Age of mythology'}\n", - "{'nombre': 'Sasiri', 'apellido': 'Vargas', 'paÃs': 'Colombia', 'residencia': 'Cali', 'edad': '20', 'institución': 'Univalle', 'hobbie': 'Bailar'}\n" - ] - } - ], - "source": [ - "sortPais(compas, \"Colombia\")" - ] - }, - { - "cell_type": "code", - "execution_count": 122, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "21.0\n" - ] - } - ], - "source": [ - "edadMedia(compas)" - ] - }, - { - "cell_type": "code", - "execution_count": 126, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'Univalle'}\n" - ] - } - ], - "source": [ - "instit(compas)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.7.3" - } - }, - "nbformat": 4, - "nbformat_minor": 4 -} diff --git a/ejercicio1_reyesf.ipynb b/ejercicio1_reyesf.ipynb new file mode 100644 index 0000000000000000000000000000000000000000..3f6a047ea10bf272ae48328282c8eb57ade56c30 --- /dev/null +++ b/ejercicio1_reyesf.ipynb @@ -0,0 +1,85 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "##### Felipe Reyes Osorio (@reyesf)\n", + "\n", + "# Ejercicio 1\n", + "En la primera celda tomamos una lista de entrada del usuario. En la segunda usamos la función `.split` para crear una lista con cada palabra, la ordenamos con `sorted`, y finalmente la juntamos de nuevo con `.join` (siempre tenemos en cuenta que el separador es -)." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Palabras de entrada (separadas por guiones): esta-es-una-serie-de-palabras-que-serviran-como-prueba-para-el-código\n" + ] + } + ], + "source": [ + "inStr = str(input(r\"Palabras de entrada (separadas por guiones): \"))" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "inStr = \"-\".join(sorted(inStr.split(\"-\")))" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "como-código-de-el-es-esta-palabras-para-prueba-que-serie-serviran-una\n" + ] + } + ], + "source": [ + "print(inStr)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.7.3" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/ejercicio2_reyesf.ipynb b/ejercicio2_reyesf.ipynb new file mode 100644 index 0000000000000000000000000000000000000000..6e8edb663631fba099dd51114c0f87aeea640af5 --- /dev/null +++ b/ejercicio2_reyesf.ipynb @@ -0,0 +1,201 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "##### Felipe Reyes Osorio (@reyesf)\n", + "\n", + "# Ejercicio 2\n", + "## Parte 1\n", + "Para la primera parte importamos la función `factorial` y definimos una función que retorna el coeficiente binomial $n\\choose k$." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "from math import factorial\n", + "\n", + "def binomCoef(n, k): return factorial(n)/(factorial(k)*factorial(n-k))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "El usuario inserta $n$ deseado: si el valor de la entrada es igual sin importar si se transforma a un float o a un int, entonces podemos concluir que $n \\in \\mathbb{Z}$." + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "¿Número de la fila? 8\n" + ] + } + ], + "source": [ + "N = float(input(r\"¿Número de la fila? \"))\n", + "if N != int(N):\n", + " print(\"Error: n no es entero\")\n", + "N = int(N)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Finamente, poblamos la lista `nRow` con los coeficientes de la fila correspondiente en el triángulo de Pascal e imprimimos. Usamos una comprensión de lista (en lugar de un for) para mayor eficiencia." + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[1.0, 8.0, 28.0, 56.0, 70.0, 56.0, 28.0, 8.0, 1.0]\n" + ] + } + ], + "source": [ + "nRow = [binomCoef(N, k) for k in range(N+1)]\n", + "print(nRow)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Parte 2\n", + "Para la segunda parte reusamos una lÃnea del **Ejercicio 1**, e insertamos los números de las filas separados por puntos; esto ayuda a que _no se puedan insertar números no enteros_. Luego convertimos cada elemento en un int." + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Inserte los números de las filas separados por puntos: 0.1.2.3.4.5\n" + ] + } + ], + "source": [ + "manyN = input(\"Inserte los números de las filas separados por puntos: \")\n", + "manyN = [int(n) for n in manyN.split(\".\")]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Reusamos el código de la parte anterior, salvo que esta vez está dentro de un loop que itera sobre cada fila $n_i$. Las filas que se obtienen se adicionan a una lista `rows`. Se podrÃa usar una comprensión de lista dentro de la otra (**ver comentario**) pero usamos un for para mejor legibilidad." + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [], + "source": [ + "rows = []\n", + "for N in manyN:\n", + " nRow = [binomCoef(N, k) for k in range(N+1)]\n", + " rows.append(nRow)\n", + "\n", + "#También funcionarÃa\n", + "\n", + "#rows=[[binomCoef(N, k) for k in range(N+1)] for N in manyN]\n", + "\n", + "#pero es menos legible." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Finalmente imprimimos cada fila en orden de entrada. En este caso se muestran las filas de la 0 a la 5" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[1.0]\n", + "[1.0, 1.0]\n", + "[1.0, 2.0, 1.0]\n", + "[1.0, 3.0, 3.0, 1.0]\n", + "[1.0, 4.0, 6.0, 4.0, 1.0]\n", + "[1.0, 5.0, 10.0, 10.0, 5.0, 1.0]\n" + ] + } + ], + "source": [ + "for i in range(len(manyN)):\n", + " print(rows[i])" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.7.3" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/ejercicio3_reyesf.ipynb b/ejercicio3_reyesf.ipynb new file mode 100644 index 0000000000000000000000000000000000000000..f4c66dcf151aa97a2610248d03528e4b3b9bfe74 --- /dev/null +++ b/ejercicio3_reyesf.ipynb @@ -0,0 +1,234 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "##### Felipe Reyes Osorio (@reyesf)\n", + "\n", + "# Ejercicio 3\n", + "Con la función `newEntry` se puede poblar el diccionario. No era parte del ejercicio pero me facilitó el proceso.\n", + "\n", + "* reyesf/Felipe/Reyes/Colombia/Cali/22/Univalle/Gimnasio\n", + "* varelaj/Jalil/Varela/Colombia/Palmira/21/Univalle/Age of mythology\n", + "* vargass/Sasiri/Vargas/Colombia/Cali/20/Univalle/Bailar" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "def newEntry(d):\n", + " info = input(r\"Info de nueva entrada (sep. por /)\")\n", + " info = info.split(\"/\")\n", + " print(info)\n", + " #info = matter/nombre/apellido/pais/residencia/edad/institucion/hobbie\n", + " subd = {\"nombre\": info[1],\n", + " \"apellido\":info[2],\n", + " \"paÃs\":info[3],\n", + " \"residencia\":info[4],\n", + " \"edad\":info[5],\n", + " \"institución\":info[6],\n", + " \"hobbie\":info[7]\n", + " }\n", + " d[info[0]] = subd" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "compas = {}" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Info de nueva entrada (sep. por /)vargass/Sasiri/Vargas/Colombia/Cali/20/Univalle/Bailar\n", + "['vargass', 'Sasiri', 'Vargas', 'Colombia', 'Cali', '20', 'Univalle', 'Bailar']\n" + ] + } + ], + "source": [ + "newEntry(compas)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Definimos las tres funciones que se piden. Todas usan el mismo principio de iterar sobre las llaves de `compas`, e inspeccionar los contenidos de cada una. \n", + "\n", + "* La primera retorna una lista con los miembros del paÃs seleccionado. Esta lista está lista para tabular.\n", + "* La segunda promedia las edades de todos en `compas`.\n", + "* La tercera retorna las instituciones de los `compas` y usamos un set para evitar entradas duplicadas." + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [], + "source": [ + "def sortPais(d, pais):\n", + " names = []\n", + " for matter in d:\n", + " if d[matter][\"paÃs\"] == pais: \n", + " names.append(matter)\n", + " final = []\n", + " for matter in names:\n", + " datos = [d[matter][datum] for datum in d[matter]]\n", + " datos.append(matter)\n", + " final.append(datos)\n", + " return final\n", + " \n", + "def edadMedia(d):\n", + " prom = []\n", + " for matter in d:\n", + " prom.append(float(compas[matter][\"edad\"]))\n", + " print(sum(prom)/len(prom)) \n", + " \n", + "def instit(d):\n", + " instituciones = set()\n", + " for matter in d:\n", + " instituciones.add(compas[matter][\"institución\"])\n", + " print(instituciones) " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Para tabular importamos la librerÃa `tabular` y definimos un array con los tÃtulos. Para ello iteramos sobre las llaves de cualquier entrada de `compas`." + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [], + "source": [ + "from tabulate import tabulate" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " nombre | apellido | paÃs | residencia | edad | institución | hobbie | mattermost\n", + "----------+------------+----------+--------------+--------+---------------+------------------+--------------\n", + " Felipe | Reyes | Colombia | Cali | 22 | Univalle | Gimnasio | reyesf\n", + " Jalil | Varela | Colombia | Palmira | 21 | Univalle | Age of mythology | varelaj\n", + " Sasiri | Vargas | Colombia | Cali | 20 | Univalle | Bailar | vargass\n" + ] + } + ], + "source": [ + "datosParaTabla = sortPais(compas, \"Colombia\")\n", + "titulos = [key for key in compas[\"reyesf\"]]\n", + "titulos.append(\"mattermost\")\n", + "\n", + "tabla = tabulate(datosParaTabla, headers = titulos,tablefmt='presto')\n", + "print(tabla)" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "21.0\n" + ] + } + ], + "source": [ + "edadMedia(compas)" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{'Univalle'}\n" + ] + } + ], + "source": [ + "instit(compas)" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.7.3" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +}