├── README.md ├── LICENSE ├── .gitignore └── Introducción a Python.ipynb /README.md: -------------------------------------------------------------------------------- 1 | # python-101 2 | Basics of python programming language 3 | -------------------------------------------------------------------------------- /LICENSE: -------------------------------------------------------------------------------- 1 | MIT License 2 | 3 | Copyright (c) 2019 Future Lab 4 | 5 | Permission is hereby granted, free of charge, to any person obtaining a copy 6 | of this software and associated documentation files (the "Software"), to deal 7 | in the Software without restriction, including without limitation the rights 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 9 | copies of the Software, and to permit persons to whom the Software is 10 | furnished to do so, subject to the following conditions: 11 | 12 | The above copyright notice and this permission notice shall be included in all 13 | copies or substantial portions of the Software. 14 | 15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 21 | SOFTWARE. 22 | -------------------------------------------------------------------------------- /.gitignore: -------------------------------------------------------------------------------- 1 | # Byte-compiled / optimized / DLL files 2 | __pycache__/ 3 | *.py[cod] 4 | *$py.class 5 | 6 | # C extensions 7 | *.so 8 | 9 | # Distribution / packaging 10 | .Python 11 | build/ 12 | develop-eggs/ 13 | dist/ 14 | downloads/ 15 | eggs/ 16 | .eggs/ 17 | lib/ 18 | lib64/ 19 | parts/ 20 | sdist/ 21 | var/ 22 | wheels/ 23 | *.egg-info/ 24 | .installed.cfg 25 | *.egg 26 | MANIFEST 27 | 28 | # PyInstaller 29 | # Usually these files are written by a python script from a template 30 | # before PyInstaller builds the exe, so as to inject date/other infos into it. 31 | *.manifest 32 | *.spec 33 | 34 | # Installer logs 35 | pip-log.txt 36 | pip-delete-this-directory.txt 37 | 38 | # Unit test / coverage reports 39 | htmlcov/ 40 | .tox/ 41 | .coverage 42 | .coverage.* 43 | .cache 44 | nosetests.xml 45 | coverage.xml 46 | *.cover 47 | .hypothesis/ 48 | .pytest_cache/ 49 | 50 | # Translations 51 | *.mo 52 | *.pot 53 | 54 | # Django stuff: 55 | *.log 56 | local_settings.py 57 | db.sqlite3 58 | 59 | # Flask stuff: 60 | instance/ 61 | .webassets-cache 62 | 63 | # Scrapy stuff: 64 | .scrapy 65 | 66 | # Sphinx documentation 67 | docs/_build/ 68 | 69 | # PyBuilder 70 | target/ 71 | 72 | # Jupyter Notebook 73 | .ipynb_checkpoints 74 | 75 | # pyenv 76 | .python-version 77 | 78 | # celery beat schedule file 79 | celerybeat-schedule 80 | 81 | # SageMath parsed files 82 | *.sage.py 83 | 84 | # Environments 85 | .env 86 | .venv 87 | env/ 88 | venv/ 89 | ENV/ 90 | env.bak/ 91 | venv.bak/ 92 | 93 | # Spyder project settings 94 | .spyderproject 95 | .spyproject 96 | 97 | # Rope project settings 98 | .ropeproject 99 | 100 | # mkdocs documentation 101 | /site 102 | 103 | # mypy 104 | .mypy_cache/ 105 | -------------------------------------------------------------------------------- /Introducción a Python.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": { 6 | "colab_type": "text", 7 | "id": "OpSHrtcJLQEU" 8 | }, 9 | "source": [ 10 | "# Introducción a Python\n", 11 | "\n", 12 | "A lo largo de este _Jupyter Notebook_ explicaré algunos básicos de Python. Los tópicos específicos a cubrir en este cuaderno interactivo son los siguientes:\n", 13 | "\n", 14 | "> - ¿Qué es Python? \n", 15 | "> - _Variables_ – Tipos, conversión y operación\n", 16 | "> - Control de flujo I – _Condicionales_ y _ciclos_\n", 17 | "> - Objetos avanzados – _Listas_\n", 18 | "> - Control de flujo II – _Ciclos_\n", 19 | "\n", 20 | "\n", 21 | "## ¿Qué es Python?\n", 22 | "\n", 23 | "
\n", 24 | " \n", 25 | "
\n", 26 | "\n", 27 | "Python es un lenguaje de programación **interpretado**, lo que significa que un _intérprete_ corre y ejecuta tu código línea por línea en vez compilar un programa para crear un archivo ejecutable, esto permite que podamos utilizar un cuaderno interactivo como éste. Python cuenta con una elegante sintaxis que nos obliga a **_indentar_ nuestro código para escribir bloques**, lo que significa que Python no utiliza `{ }` para bloques de código (como otros lenguajes). Con Python no es común utilizar `;` al final de caa sentencia. Otra cosa cool acerca de Python es que no necesitas declarar variables, sino que sólo las defines, y sucede que Python es de **tipado dinámico**.\n", 28 | "\n", 29 | "En esencia, Python es un lenguaje muy sencillo de aprender con el cual pueden realizarse muchas cosas. Es por ello que el lenguaje se utiliza en diversas instituciones y compañías como Harvard, Google o Instagram, en temas que van desde Introducción a la Programación, hasta Ciencia de Datos e Inteligencia Artificial.\n", 30 | "\n", 31 | "### `¡Hola mundo!` en Python\n", 32 | "\n", 33 | "`input()` y `print()` son las funciones de entrada y salida (respectivamente) de información en Python. `input()` tiene como argumento una cadena de texto que da las instrucciones que se deseas desplegar y lo que retorna (la respuesta) siempre es una cadena de texto; mientras que `print()` tiene como argumentos cadenas de texto o variables que se desean desplegar.\n", 34 | "\n", 35 | "Vamos a utilizar las funciones de entrada y salida para crear nuestro primer programa, el famoso `¡Hola mundo!` en Python.\n", 36 | "\n", 37 | "Para ello, sólo basta correr la siguiente celda de código presionando el botón _play_ o presionando `Shift + Enter` en tu teclado." 38 | ] 39 | }, 40 | { 41 | "cell_type": "code", 42 | "execution_count": null, 43 | "metadata": { 44 | "colab": {}, 45 | "colab_type": "code", 46 | "id": "lBy00gJgHaQo" 47 | }, 48 | "outputs": [], 49 | "source": [ 50 | "# ¡Hola mundo! en Python:\n", 51 | "tu_nombre = input(\"Porfa ingresa tu nombre: \")\n", 52 | "print(f\"¡Saluda al mundo, {tu_nombre}!\")" 53 | ] 54 | }, 55 | { 56 | "cell_type": "markdown", 57 | "metadata": { 58 | "colab_type": "text", 59 | "id": "RSJW87sPXOAh" 60 | }, 61 | "source": [ 62 | "## Variables\n", 63 | "\n", 64 | "Podemos pensar que una variable es como un contenedor de información. Python puede albergar distintos tipos de datos, como valores numéricos, _booleanos_ y cadenas de texto. Al ser Python de tipado dinámico, no hace falta declarar el tipo de variable, sino que sólo basta con definir sus valores.\n", 65 | "\n", 66 | "Comenzando con variables numéricas, Python tiene números enteros, números de punto flotante y números complejos. También cuenta con cadenas de caracteres para definir palabras y otro tipo de variables llamadas _booleanas_ para almacenar variables binarias.\n", 67 | "\n", 68 | "La manera en la que definimos variables es como sigue:\n", 69 | "\n", 70 | "```python\n", 71 | "nombre_de_variable = \n", 72 | "```\n", 73 | "\n", 74 | "El nombre de la variable no puede contener espacios, debe comenzar con una letra, y puede contener letras mayúsculas o números en el nombre.\n", 75 | "\n", 76 | "#### Ejemplo:\n", 77 | "\n", 78 | "```python\n", 79 | "mi_perrito = \"Mirlo\"\n", 80 | "```\n", 81 | "\n", 82 | "Para obener el tipo de una variable, podemos utilizar la función `type()` y pasarle como argumento la variable sobre la cual queremos conocer el nombre.\n", 83 | "\n", 84 | "#### Ejemplo:\n", 85 | "\n", 86 | "```python\n", 87 | "type(mi_perrito)\n", 88 | "```\n", 89 | "\n", 90 | "¿Qué sucede si estos códigos de ejemplo son ejecutados?" 91 | ] 92 | }, 93 | { 94 | "cell_type": "code", 95 | "execution_count": null, 96 | "metadata": { 97 | "colab": {}, 98 | "colab_type": "code", 99 | "id": "8i5sDqw-XUJP" 100 | }, 101 | "outputs": [], 102 | "source": [ 103 | "# TODO.\n", 104 | "# Declara una variable llamada mi_perrito y almacena el nombre de un perrito\n", 105 | "# Imprime el tipo de esa variable\n" 106 | ] 107 | }, 108 | { 109 | "cell_type": "markdown", 110 | "metadata": { 111 | "colab_type": "text", 112 | "id": "nlMAcIGEYIef" 113 | }, 114 | "source": [ 115 | "Existen diversos tipos de variables en Python, ¡incluso números complejos!\n", 116 | "\n", 117 | "#### Ejercicio:\n", 118 | "\n", 119 | "Define e imprime el tipo y valor de variables llamadas:\n", 120 | "- `nombre`, debe ser de tipo `` conteniendo cualquier nombre\n", 121 | "- `edad`, debe ser de tipo `` conteniendo cualquier edad\n", 122 | "- `pi`, debe ser de tipo ``conteniendo tu mejor aproximación de pi" 123 | ] 124 | }, 125 | { 126 | "cell_type": "code", 127 | "execution_count": null, 128 | "metadata": { 129 | "colab": {}, 130 | "colab_type": "code", 131 | "id": "RmbbjQIqYT6i" 132 | }, 133 | "outputs": [], 134 | "source": [ 135 | "# TODO.\n", 136 | "# Define variables ejemplo e imprime cada tipo y valor\n" 137 | ] 138 | }, 139 | { 140 | "cell_type": "markdown", 141 | "metadata": {}, 142 | "source": [ 143 | "## Operaciones básicas\n", 144 | "\n", 145 | "En esencia hay tres tipos de operaciones que pueden realizarse con variables para declarar sentencias:\n", 146 | "\n", 147 | "- **Operaciones aritméticas.** Operan a nivel matemático-aritmético sobre los valores de las variables (`+, -, *, /, //, **, %`).\n", 148 | "- **Operaciones de comparación.** Operan a nivel matemático-de-comaración sobre los valores de las variables (`<, >, <=, >=, ==, !=`).\n", 149 | "- **Operaciones lógicas.** Operan a nivel matemático-lógico sobre los valores de las variables (`and, or, not`).\n", 150 | "\n", 151 | "\n", 152 | "#### Ejemplo:\n", 153 | "\n", 154 | "```python\n", 155 | "print(34 ** 5)\n", 156 | "print(5 ** 2)\n", 157 | "print(12345678 % 2)\n", 158 | "print(26 >= 18)\n", 159 | "```\n", 160 | "\n", 161 | "¿Qué sucede si ejecutamos esas líneas de código?\n" 162 | ] 163 | }, 164 | { 165 | "cell_type": "code", 166 | "execution_count": null, 167 | "metadata": {}, 168 | "outputs": [], 169 | "source": [ 170 | "# TODO.\n", 171 | "# Imprime las operaciones con variables mencionadas\n", 172 | "# Experimenta con otras operaciones\n" 173 | ] 174 | }, 175 | { 176 | "cell_type": "markdown", 177 | "metadata": { 178 | "colab_type": "text", 179 | "id": "U_cKNLU3YnP8" 180 | }, 181 | "source": [ 182 | "## Control de flujo – Condicionales\n", 183 | "\n", 184 | "Los condicionales los utilizaremos para validar si se cumple una o más condiciones para ejecutar cierto bloque de código, en esencia nos ayuda a tomar decisiones sobre el flujo de nuestro código.\n", 185 | "\n", 186 | "Hasta ahora sabemos cómo definir variables, así que debemos ser capaces de crear bloques de código un poco más complejos. La primera cosa que haremos es crear una nueva variable llamada `menor_de_edad` y la definiremos con una expresión condicional. Para ello, será util recordar operadores de comparación (`<, >, <=, >=, ==, !=`).\n", 187 | "\n", 188 | "La idea es la siguiente: si una persona es menor de edad, el valor de la variable será `True`, y será `False` en caso contrario.\n", 189 | "\n", 190 | "Para declarar una expresión condicional, utilizamos la siguiente sintaxis de código:\n", 191 | "\n", 192 | "```python\n", 193 | "if condicion:\n", 194 | " # Bloque de código para una condición satisfecha\n", 195 | "else:\n", 196 | " # Bloque de código para una condición NO satisfecha\n", 197 | "```\n", 198 | "\n", 199 | "#### Ejemplo:\n" 200 | ] 201 | }, 202 | { 203 | "cell_type": "code", 204 | "execution_count": null, 205 | "metadata": { 206 | "colab": {}, 207 | "colab_type": "code", 208 | "id": "9oJook66anxJ" 209 | }, 210 | "outputs": [], 211 | "source": [ 212 | "color_del_perrito = \"negro\"\n", 213 | "if color == \"negro\":\n", 214 | " print(\"Es correcto, este perrito es negro.\")\n", 215 | "else:\n", 216 | " print(\"No, definitivamente no es un perrito negro.\")" 217 | ] 218 | }, 219 | { 220 | "cell_type": "markdown", 221 | "metadata": { 222 | "colab_type": "text", 223 | "id": "XYjNLN8VjFfK" 224 | }, 225 | "source": [ 226 | "Para el caso en que queramos verificar más de una condición, podemos utilizar sentencias `elif`:\n", 227 | "\n", 228 | "```python\n", 229 | "if condicion_uno:\n", 230 | " # Bloque de código para una condición uno satisfecha\n", 231 | "elif condicion_dos:\n", 232 | " # Bloque de código para una condición dos satisfecha\n", 233 | "...\n", 234 | "elif condicion_n:\n", 235 | " # Bloque de código para una condición n-ésima satisfecha\n", 236 | "else:\n", 237 | " # Bloque de código para condiciones NO satisfechas\n", 238 | "```\n", 239 | "\n", 240 | "#### Ejercicio:\n", 241 | "\n", 242 | "Ahora crea una condición para definir la variable `menor_de_edad` que compare si una edad es mayor o igual a 18 para definirla como `False` o `True` en caso contrario." 243 | ] 244 | }, 245 | { 246 | "cell_type": "code", 247 | "execution_count": null, 248 | "metadata": { 249 | "colab": {}, 250 | "colab_type": "code", 251 | "id": "xcu423b2liUI" 252 | }, 253 | "outputs": [], 254 | "source": [ 255 | "# TODO.\n", 256 | "# Escribe un condicional para definir una edad\n", 257 | "\n", 258 | "edad = input(\"Introduce tu edad: \")\n", 259 | "edad = int(edad)" 260 | ] 261 | }, 262 | { 263 | "cell_type": "markdown", 264 | "metadata": { 265 | "colab_type": "text", 266 | "id": "rhmQtvUmnNNx" 267 | }, 268 | "source": [ 269 | "Antes de continuar a la segunda parte sobre control de flujo (ciclos), será útil entender qué es una lista en Python.\n", 270 | "\n", 271 | "## Listas y colecciones de datos\n", 272 | "\n", 273 | "Una lista es una colección ordenada de cualquier tipo de variable. La sintaxis utilizada para ello es la siguiente:\n", 274 | "\n", 275 | "```python\n", 276 | "nombre_de_lista = [primer_elemento, segundo_elemento, etcetera]\n", 277 | "```\n", 278 | "\n", 279 | "Las reglas para nombrar listas son las mismas que para nombrar variables. \n", 280 | "\n", 281 | "También podemos declarar listas vacías y llenarlas conforme se realiza un proceso o añadir un elemento nuevo conforme se realiza un proceso. Una lista vacía se define con corchetes vacíos `[]`. Si queremos agregar un nuevo elemento al final de una lista, utilizaremos la función `.append(x)`, donde `x` sería el elemento a insertar.\n", 282 | "\n", 283 | "#### Ejemplo:" 284 | ] 285 | }, 286 | { 287 | "cell_type": "code", 288 | "execution_count": null, 289 | "metadata": { 290 | "colab": {}, 291 | "colab_type": "code", 292 | "id": "5f8xkD-VoerM" 293 | }, 294 | "outputs": [], 295 | "source": [ 296 | "# Ejemplo de una lista:\n", 297 | "numeros_primos = [2, 3, 5, 7, 11]\n", 298 | "print(\"Lista inicial de números primos:\")\n", 299 | "print(numeros_primos)" 300 | ] 301 | }, 302 | { 303 | "cell_type": "code", 304 | "execution_count": null, 305 | "metadata": {}, 306 | "outputs": [], 307 | "source": [ 308 | "numeros_primos.append(13)\n", 309 | "print(\"Lista editada de números primos:\")\n", 310 | "print(numeros_primos)" 311 | ] 312 | }, 313 | { 314 | "cell_type": "markdown", 315 | "metadata": { 316 | "colab_type": "text", 317 | "id": "yP1GTen8ovX9" 318 | }, 319 | "source": [ 320 | "Para acceder a los valores o elementos de una lista usamos un sistema de _indexación_, lo que significa que cada elemento tiene un índice asociado. Para acceder al elemento asociado, usaremos el índice dentro de corchetes.\n", 321 | "\n", 322 | "#### Ejemplo:\n", 323 | "\n", 324 | "En nuestra lista `numeros_primos` obtendríamos los siguientes elementos como sigue:" 325 | ] 326 | }, 327 | { 328 | "cell_type": "code", 329 | "execution_count": null, 330 | "metadata": { 331 | "colab": {}, 332 | "colab_type": "code", 333 | "id": "xAevC47uqN7i" 334 | }, 335 | "outputs": [], 336 | "source": [ 337 | "# Accedemos a los elementos:\n", 338 | "print(\"Primer elemento:\", numeros_primos[0])\n", 339 | "print(\"Segundo elemento:\", numeros_primos[1])\n", 340 | "print(\"Tercer elemento:\", numeros_primos[2])\n", 341 | "\n", 342 | "# Podemos incluso acceder a los elementos utilizando índices negativos:\n", 343 | "print(\"Último elemento: \", numeros_primos[-1])" 344 | ] 345 | }, 346 | { 347 | "cell_type": "markdown", 348 | "metadata": { 349 | "colab_type": "text", 350 | "id": "WaNJemIwq419" 351 | }, 352 | "source": [ 353 | "#### Ejercicio:\n", 354 | "\n", 355 | "Deberíamos ser capaces de crear una lista llamada `open_data` conteniendo los nombres de los asistentes.\n" 356 | ] 357 | }, 358 | { 359 | "cell_type": "code", 360 | "execution_count": null, 361 | "metadata": { 362 | "colab": {}, 363 | "colab_type": "code", 364 | "id": "nMCLlFAerDWG" 365 | }, 366 | "outputs": [], 367 | "source": [ 368 | "# TODO.\n", 369 | "# Crear una nueva lista con todos los nombres\n", 370 | "open_data = []" 371 | ] 372 | }, 373 | { 374 | "cell_type": "markdown", 375 | "metadata": { 376 | "colab_type": "text", 377 | "id": "Gz2JkK8DrRIc" 378 | }, 379 | "source": [ 380 | "Ahora añade a dos nuevos estudiantes (puedes inventar los nombres)." 381 | ] 382 | }, 383 | { 384 | "cell_type": "code", 385 | "execution_count": null, 386 | "metadata": { 387 | "colab": {}, 388 | "colab_type": "code", 389 | "id": "1d-CEterrZL6" 390 | }, 391 | "outputs": [], 392 | "source": [ 393 | "# TODO.\n", 394 | "# Usa la función append para añadir a dos nuevos estudiantes\n" 395 | ] 396 | }, 397 | { 398 | "cell_type": "markdown", 399 | "metadata": { 400 | "colab_type": "text", 401 | "id": "hkoa6UOarhBD" 402 | }, 403 | "source": [ 404 | "> Hasta este punto haremos una pausa para hacer énfasis en la utilidad de listas como una colección de objetos. Los datos abiertos que estaremos trabajando seguirán (en esencia) éste formato.\n", 405 | "\n", 406 | "## Control de flujo – Ciclos\n", 407 | "\n", 408 | "**Iterar** significa ejecutar el mismo bloque de código una y otra vez, potencialmente muchas veces. Una estructura de programación que implementa una iteración o un bloque de iteraciones es llamada un **ciclo**.\n", 409 | "\n", 410 | "### Ciclo `for`\n", 411 | "\n", 412 | "Python tiene un ciclo basado en colecciones. Este tipo de ciclo itera sobre una colección de objetos, en lugar de especificar valores o condiciones numéricos:\n", 413 | "\n", 414 | "```python\n", 415 | "for elemento in coleccion:\n", 416 | " \n", 417 | "```\n", 418 | "\n", 419 | "#### Ejemplo:\n", 420 | "\n", 421 | "Podemos iterar e imprimir los elementos de una lista:" 422 | ] 423 | }, 424 | { 425 | "cell_type": "code", 426 | "execution_count": null, 427 | "metadata": { 428 | "colab": {}, 429 | "colab_type": "code", 430 | "id": "RFk0YLulqOQW" 431 | }, 432 | "outputs": [], 433 | "source": [ 434 | "from time import sleep\n", 435 | "\n", 436 | "meses = [\n", 437 | " 'Enero',\n", 438 | " 'Febrero',\n", 439 | " 'Marzo',\n", 440 | " 'Abril',\n", 441 | " 'Mayo',\n", 442 | " 'Junio',\n", 443 | " 'Julio',\n", 444 | " 'Agosto',\n", 445 | " 'Septiembre',\n", 446 | " 'Octubre',\n", 447 | " 'Noviembre',\n", 448 | " 'Diciembre',\n", 449 | "]\n", 450 | "\n", 451 | "for mes in meses:\n", 452 | " print(f\"> El mes actual es {mes}.\")\n", 453 | " sleep(3)" 454 | ] 455 | }, 456 | { 457 | "cell_type": "markdown", 458 | "metadata": { 459 | "colab_type": "text", 460 | "id": "OHMgj3aavIqc" 461 | }, 462 | "source": [ 463 | "O podemos simplemente iterar sobre un rango de números:" 464 | ] 465 | }, 466 | { 467 | "cell_type": "code", 468 | "execution_count": null, 469 | "metadata": { 470 | "colab": {}, 471 | "colab_type": "code", 472 | "id": "nevHbKcsvIBa" 473 | }, 474 | "outputs": [], 475 | "source": [ 476 | "for numero in range(10):\n", 477 | " print(f\"El número actual es {numero}.\")" 478 | ] 479 | }, 480 | { 481 | "cell_type": "markdown", 482 | "metadata": { 483 | "colab_type": "text", 484 | "id": "7Ko9pJ0_vrnb" 485 | }, 486 | "source": [ 487 | "##### Nota: \n", 488 | "*¿Qué hay acerca de las tuplas u otro tipo de colecciones?*\n", 489 | "\n", 490 | "Ahora que sabemos iterar sobre elementos en una lista, imprimamos de manera ordenada los elementos de nuestra lista `open_data`, previamente definida." 491 | ] 492 | }, 493 | { 494 | "cell_type": "code", 495 | "execution_count": null, 496 | "metadata": { 497 | "colab": {}, 498 | "colab_type": "code", 499 | "id": "PZTz7Shhrs1M" 500 | }, 501 | "outputs": [], 502 | "source": [ 503 | "# TODO.\n", 504 | "# Usa un ciclo para imprimir los nombres de los asistentes en open_data\n" 505 | ] 506 | } 507 | ], 508 | "metadata": { 509 | "colab": { 510 | "collapsed_sections": [], 511 | "include_colab_link": true, 512 | "name": "Intro to Python", 513 | "provenance": [], 514 | "version": "0.3.2" 515 | }, 516 | "kernelspec": { 517 | "display_name": "Python 3", 518 | "language": "python", 519 | "name": "python3" 520 | }, 521 | "language_info": { 522 | "codemirror_mode": { 523 | "name": "ipython", 524 | "version": 3 525 | }, 526 | "file_extension": ".py", 527 | "mimetype": "text/x-python", 528 | "name": "python", 529 | "nbconvert_exporter": "python", 530 | "pygments_lexer": "ipython3", 531 | "version": "3.7.4" 532 | } 533 | }, 534 | "nbformat": 4, 535 | "nbformat_minor": 4 536 | } 537 | --------------------------------------------------------------------------------