├── .gitignore ├── LICENSE ├── README.md ├── clases ├── Clase 1 - Introduccion a Python.pdf └── Clase 2 - Introduccion a data analytics y data science.pdf ├── guia ├── Instalacion de Anaconda y Python.docx └── Instalacion de Anaconda y Python.pdf ├── images └── perfil Roberto Munoz.jpg └── tutoriales ├── 01_Como_usar_Python.ipynb ├── 02_Tipos_de_datos_nativos.ipynb ├── 03_Operaciones_y_funciones_nativas.ipynb ├── 04_Palabras_reservadas.ipynb ├── 05_Control_de_flujos.ipynb ├── 06_Creacion_de_funciones.ipynb ├── 07_Creacion_de_clases_y_objetos.ipynb ├── 08_Sobrecarga_de_operadores.ipynb ├── 09_Manipulacion_de_strings.ipynb ├── 10_Creacion_de_modulos.ipynb ├── 11_Introduccion_a_Numpy.ipynb ├── 12_Introduccion_a_Matplotlib.ipynb ├── 13_Introduccion_a_Pandas.ipynb ├── 14_Visualizacion_con_Pandas.ipynb ├── 15_Visualizacion_con_Seaborn_y_Pandas.ipynb ├── 16_Conexion_bases_de_datos.ipynb ├── data ├── Gobierno transparente - Registro atenciones - SML.csv ├── aerolineas.csv ├── aeropuertos.csv ├── airlines.dat ├── airports.dat ├── chile_comunas.csv ├── chile_demographic.csv ├── chile_demographic.xlsx ├── chile_demographic_database.sql ├── chile_demographic_merge.csv ├── chile_poblacion.csv ├── chile_poblacion_comuna.csv ├── chile_provincias.csv ├── chile_regiones.csv ├── conicyt doctorado nacional 2003-2017.csv ├── fondecyt iniciacion 2007-2017.csv ├── fondecyt postdoc 2007-2017.csv ├── galaxies_hcn_hco.dat ├── poema_15_Pablo_Neruda.txt ├── routes.dat └── rutas.csv ├── extras └── 10_Entrada_y_salida.ipynb ├── fibo.py ├── fibonacci.py ├── figures ├── banner metricarts.png ├── estadistica_proyectos_fondecyt_iniciacion.pdf ├── estadistica_proyectos_fondecyt_iniciacion.png ├── estadistica_proyectos_fondecyt_postdoc.pdf ├── estadistica_proyectos_fondecyt_postdoc.png ├── grafico1.pdf ├── grafico1.png └── perfil Roberto Munoz.jpg ├── images ├── IDE_jupyter_notebook.png ├── IDE_pycharm.png ├── IDE_spyder.png ├── Python_club_question_1.png ├── Python_club_question_2.png ├── Python_club_question_3.png ├── boolean_indexing.png ├── ipython-notebook-screenshot.jpg ├── ipython-screenshot.jpg ├── jupyter_notebook.png ├── listaSobrecargas.png ├── ml_classification.png ├── ml_regression.png ├── ml_statistics.png ├── ml_supervised_blackbox.png ├── ml_supervised_learning.png ├── ml_types.png ├── numpy_indexing.png ├── python-screenshot.jpg ├── python_builtin_functions.png ├── pythonclub_create_pullrequest.png ├── pythonclub_how_to_fork.png └── pythonclub_pullrequest.png ├── tools ├── plot_2d_separator.py ├── plot_forest.py ├── plot_tree.py └── tree_plotting.py └── tutorial_flask └── hello.py /.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 | env/ 12 | build/ 13 | develop-eggs/ 14 | dist/ 15 | downloads/ 16 | eggs/ 17 | .eggs/ 18 | lib/ 19 | lib64/ 20 | parts/ 21 | sdist/ 22 | var/ 23 | wheels/ 24 | *.egg-info/ 25 | .installed.cfg 26 | *.egg 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 | 49 | # Translations 50 | *.mo 51 | *.pot 52 | 53 | # Django stuff: 54 | *.log 55 | local_settings.py 56 | 57 | # Flask stuff: 58 | instance/ 59 | .webassets-cache 60 | 61 | # Scrapy stuff: 62 | .scrapy 63 | 64 | # Sphinx documentation 65 | docs/_build/ 66 | 67 | # PyBuilder 68 | target/ 69 | 70 | # Jupyter Notebook 71 | .ipynb_checkpoints 72 | 73 | # pyenv 74 | .python-version 75 | 76 | # celery beat schedule file 77 | celerybeat-schedule 78 | 79 | # SageMath parsed files 80 | *.sage.py 81 | 82 | # dotenv 83 | .env 84 | 85 | # virtualenv 86 | .venv 87 | venv/ 88 | ENV/ 89 | 90 | # Spyder project settings 91 | .spyderproject 92 | .spyproject 93 | 94 | # Rope project settings 95 | .ropeproject 96 | 97 | # mkdocs documentation 98 | /site 99 | 100 | # mypy 101 | .mypy_cache/ 102 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # Curso Intensivo de Python - 3ra edición 2 | 3 | Este repositorio contiene lecturas y talleres de Python desarrolladas por los investigadores Roberto Muñoz y Marco Antonio Ramirez. Este material forma parte del curso "Intesivo Python" ofrecido por la empresa Metric Learning. 4 | 5 | Entre los contenidos del curso se encuentran los siguientes: 6 | 7 | ## Bloque 1 8 | 9:00 - 11:00 9 | 10 | - Introducción 11 | 12 | - Python como lenguaje de programación 13 | - Uso de IDEs y notebooks 14 | - Instalación de distribución de Python Anaconda 15 | - Jupyter notebook: Uso de interfaz, Creación de scripts, Ejecución de comandos. 16 | 17 | - Fundamentos del lenguaje Python - Parte 1 18 | 19 | - Sintaxis básica 20 | - Tipos de datos 21 | - Expresiones condicionales y control de flujo 22 | - Loops e iteraciones 23 | 24 | ## Café 25 | 11:00 - 11:15 26 | 27 | ## Bloque 2 28 | 11:15 - 12:40 29 | 30 | - Fundamentos del lenguaje Python - Parte 2 31 | 32 | - Definición de funciones 33 | - Manipulación de Strings 34 | - Manipulación de Archivos 35 | 36 | - Estructuras de datos 37 | - Tuplas 38 | - Listas 39 | - Diccionarios 40 | - Sets 41 | 42 | ## Almuerzo 43 | 12:50 - 13:50 44 | 45 | ## Bloque 3 46 | 14:00 - 16:00 47 | 48 | - Análisis de datos con Python 49 | - Numpy: Creación de vectores y matrices, Operaciones vectoriales, indexación, Enmascarado booleano 50 | - Pandas: Creación de Series y Dataframes, Indexación y Selección, Agregación y Agrupamiento de datos 51 | 52 | ## Bloque 4 53 | 16:00 - 17:00 54 | 55 | - Obtención de datos con Python 56 | - Uso de Numpy y Pandas para obtención desde archivos CSV 57 | - Conexión a Bases de datos 58 | - Visualización de datos con Python 59 | - Uso de Matplotlib y Seaborn 60 | - Uso de Pandas 61 | 62 | ## Acerca del profesor 63 | 64 |
65 | 66 |

67 |

68 |

69 | 70 |

Roberto Muñoz es Licenciado en Astronomía y Doctor en Astrofísica de la Pontificia Universidad Católica de Chile.

71 | 72 |

Actualmente trabaja como Data Scientist en la empresa Metric Arts.

73 | 74 |

Cuenta con más de 5 años de experiencia en desarrollo de software y análisis de datos basado en SQL, Python y C ++. Se especializa en las áreas de Data Analytics, Astronfirmática y Visión computacional.

75 | 76 | 77 | ## License 78 | 79 | Copyright © 2018, [Roberto Muñoz, Marco Ramirez](https://github.com/rpmunoz). Released under the [GPLv3](https://github.com/MetricLearning/intensivo_python/blob/master/LICENSE) license. 80 | -------------------------------------------------------------------------------- /clases/Clase 1 - Introduccion a Python.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rpmunoz/intensivo_python_v3/509fbd8ef6a091b16b5f8c0f7b7b014545c96b4c/clases/Clase 1 - Introduccion a Python.pdf -------------------------------------------------------------------------------- /clases/Clase 2 - Introduccion a data analytics y data science.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rpmunoz/intensivo_python_v3/509fbd8ef6a091b16b5f8c0f7b7b014545c96b4c/clases/Clase 2 - Introduccion a data analytics y data science.pdf -------------------------------------------------------------------------------- /guia/Instalacion de Anaconda y Python.docx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rpmunoz/intensivo_python_v3/509fbd8ef6a091b16b5f8c0f7b7b014545c96b4c/guia/Instalacion de Anaconda y Python.docx -------------------------------------------------------------------------------- /guia/Instalacion de Anaconda y Python.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rpmunoz/intensivo_python_v3/509fbd8ef6a091b16b5f8c0f7b7b014545c96b4c/guia/Instalacion de Anaconda y Python.pdf -------------------------------------------------------------------------------- /images/perfil Roberto Munoz.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rpmunoz/intensivo_python_v3/509fbd8ef6a091b16b5f8c0f7b7b014545c96b4c/images/perfil Roberto Munoz.jpg -------------------------------------------------------------------------------- /tutoriales/01_Como_usar_Python.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# Cómo usar Python\n", 8 | "\n", 9 | "**Autor:** Roberto Muñoz
\n", 10 | "**E-mail:**
\n", 11 | "**Github:**
\n", 12 | "\n", 13 | "**Python** es un lenguaje de programación **abierto** que fue creado por Guido van Rossum el año 1991. Python es uno de los lenguajes más empleados por la comunidad de Data Science en el mundo y cuenta con un gran número de librerías para procesar, analizar y visualizar datos." 14 | ] 15 | }, 16 | { 17 | "cell_type": "markdown", 18 | "metadata": {}, 19 | "source": [ 20 | "La distribución Anaconda incluye binarios, librerías y kernel de Python. Los archivos binarios (ejecutables) permiten ejecutar código Python desde una terminal, mientras que los kernel permiten levantar una instancia de Python en un Jupyter notebook.\n", 21 | "\n", 22 | "Los modos más comunes para escribir y ejecutar código de Python son los siguientes,\n", 23 | "\n", 24 | "- Intérprete estándar de Python\n", 25 | "- Intérprete interactivo de Python\n", 26 | "- Jupyter notebook" 27 | ] 28 | }, 29 | { 30 | "cell_type": "markdown", 31 | "metadata": {}, 32 | "source": [ 33 | "## 1. Intérprete estándar de Python\n", 34 | "\n", 35 | "La manera más estandar para ejecutar código en Python es usar el intérprete de Python. El intérprete de Python es un programa que lee y ejecuta código de Python, ya sea tecleado directamente en la consola o desde un archivo previamente guardado.\n", 36 | "\n", 37 | "Para ejecutar el intérprete de Python, abra una consola del Sistema Operativo (*Anaconda command prompt* en Windows, *terminal* en Linux y OSX), luego escriba el comando `python` y presione `Enter`.\n", 38 | "\n", 39 | "```\n", 40 | "$ python\n", 41 | "```\n", 42 | "\n", 43 | "Ejecutaremos nuestro primer comando en el intérprete de Python. Escriba el comando `print(\"Hola mundo\")` y luego presione Enter.\n", 44 | "\n", 45 | "```\n", 46 | ">>> print(\"Hola mundo\")\n", 47 | "```\n", 48 | "\n", 49 | "Para salir del intérprete, simplemente ejecute el comando `exit()``\n", 50 | "\n", 51 | "```\n", 52 | ">>> exit()\n", 53 | "```\n", 54 | "\n", 55 | "\n", 56 | "\n", 57 | "El intérprete de Python es fácil de usar y permite ejecutar código de Python en modo batch. No es muy empleado en Data Science, pues tiene algunas limitaciones debido a su interfaz gráfica." 58 | ] 59 | }, 60 | { 61 | "cell_type": "markdown", 62 | "metadata": {}, 63 | "source": [ 64 | "## 2. Intérprete interactivo de Python\n", 65 | "\n", 66 | "El Intérprete interactivo de Python o IPython es una consola interactiva que soluciona algunas de las limitaciones del intérprete estándar de Python. IPython provee al usuario de una consola interactiva y hace mas amigable la ejecución de código Python.\n", 67 | "\n", 68 | "Para ejecutar el intérprete de Python, abra una consola del Sistema Operativo (*Anaconda command prompt* en Windows, *terminal* en Linux y OSX), luego escriba el comando `ipython` y presione `Enter`.\n", 69 | "\n", 70 | "```\n", 71 | "$ ipython\n", 72 | "```\n", 73 | "\n", 74 | "\n", 75 | "\n", 76 | "Algunas de las características que incluye IPython son las siguientes,\n", 77 | "\n", 78 | "- Historia de los comandos, la cual puede navegarse usando la flechas arriba y abajo del teclado.\n", 79 | "- Autocompletado de comandos y variables usando la tecla Tab.\n", 80 | "- Edición de comandos directamente en la consola\n", 81 | "- Revisión de objetos y extracción automática de documentación de objetos de Python como clases y funciones\n", 82 | "- Excelente capacidad de interacción con consola del sistema operativo\n", 83 | "- Soporte para múltiples procesos de back-end paralelos, los cuales pueden correr en clusters o servicios cloud." 84 | ] 85 | }, 86 | { 87 | "cell_type": "markdown", 88 | "metadata": {}, 89 | "source": [ 90 | "## 3. IDEs más populares de Python\n", 91 | "\n", 92 | "Los programadores y analistas de datos tienen costrumbre de usar aplicaciones IDE (Integrated development environment) para desarrollar algoritmos y software.\n", 93 | "\n", 94 | "Python no es la excepción y cuenta con múltiples IDEs. Entre ellos destacan\n", 95 | "\n", 96 | "- Jupyter notebook\n", 97 | "- Spyder\n", 98 | "- Pycharm" 99 | ] 100 | }, 101 | { 102 | "cell_type": "markdown", 103 | "metadata": {}, 104 | "source": [ 105 | "## 3.1 Jupyter notebook\n", 106 | "\n", 107 | "Jupyter notebook es una aplicación web que permite generar y compartir documentos (notebooks) que contienen código, ecuaciones, visualizaciones y textos explicativos. Su interfaz es similar a la que ofrece Mathematica o Mapple.\n", 108 | "\n", 109 | "Un notebook consiste de una serie de celdas, las cuales pueden crearse y organizarse de maera libre. Estas celdas pueden contener código o texto en formato Markdown. Una de sus principales ventajas es que se puede orgnaizar la información de una manera estructurada.\n", 110 | "\n", 111 | "Para ejecutar el Jupyter Notebook, abra una consola del Sistema Operativo (*Anaconda command prompt* en Windows, *terminal* en Linux y OSX), luego escriba el comando `jupyter-notebook` y presione `Enter`.\n", 112 | "\n", 113 | "```\n", 114 | "$ jupyter-notebook\n", 115 | "```\n", 116 | "\n", 117 | "\n", 118 | "\n", 119 | "\n", 120 | "Este comando abrirá una nueva ventana en su navegador web (o viñeta en caso de ya estar abierto el navegador) y mostrará el sistema de archivos del sistema. Usualmente, el URL del Jupyter notebook es " 121 | ] 122 | }, 123 | { 124 | "cell_type": "markdown", 125 | "metadata": { 126 | "collapsed": true 127 | }, 128 | "source": [ 129 | "## 3.2 Spyder\n", 130 | "\n", 131 | "Spyder es un IDE de código abierto y multi-plataforma que permite ejecutar código de Python en modo interactivo.\n", 132 | "\n", 133 | "La interfaz de Spyder es muy intuitiva y su curva de aprendizaje es baja. Para aquellas personas que tengan experiencia con R-studio notarán que la interfaz es muy similar.\n", 134 | "\n", 135 | "Spyder viene incluido en la distribución Anaconda y puede ser instalado fácilmente.\n", 136 | "Para aquellos que quieran instalarlo desde la terminal usando pip, simplemente deben ejecutar las siguientes líneas.\n", 137 | "\n", 138 | "```\n", 139 | "$ sudo pip3 install pyqt5\n", 140 | "$ sudo pip3 install spyder\n", 141 | "```\n", 142 | "\n", 143 | "" 144 | ] 145 | }, 146 | { 147 | "cell_type": "markdown", 148 | "metadata": {}, 149 | "source": [ 150 | "## 3.3 Pycharm\n", 151 | "\n", 152 | "Pycharm es un IDE desarrollado por la empresa JetBrains, la cual es famosa por el IDE de Java IntelliJ IDEA.\n", 153 | "\n", 154 | "PyCharm es perfecto para aquellas personas que tienen experiencia con otras aplicaciones de Jetbrains, pues su interfaz es similar a los otros IDEs que ofrece la empresa. PyCharm se integra fácilmente con la distribución Anaconda, permitiendo usar directamente las librerías como Numpy y Matplotlib.\n", 155 | "\n", 156 | "" 157 | ] 158 | }, 159 | { 160 | "cell_type": "code", 161 | "execution_count": null, 162 | "metadata": { 163 | "collapsed": true 164 | }, 165 | "outputs": [], 166 | "source": [] 167 | } 168 | ], 169 | "metadata": { 170 | "kernelspec": { 171 | "display_name": "Python 3", 172 | "language": "python", 173 | "name": "python3" 174 | }, 175 | "language_info": { 176 | "codemirror_mode": { 177 | "name": "ipython", 178 | "version": 3 179 | }, 180 | "file_extension": ".py", 181 | "mimetype": "text/x-python", 182 | "name": "python", 183 | "nbconvert_exporter": "python", 184 | "pygments_lexer": "ipython3", 185 | "version": "3.6.4" 186 | } 187 | }, 188 | "nbformat": 4, 189 | "nbformat_minor": 1 190 | } 191 | -------------------------------------------------------------------------------- /tutoriales/03_Operaciones_y_funciones_nativas.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# Operaciones y funciones nativas\n", 8 | "\n", 9 | "**Autor:** Roberto Muñoz
\n", 10 | "**E-mail:**
\n", 11 | "**Github:**
\n", 12 | "\n", 13 | "Sobre todos los tipos de objetos de Python se pueden aplicar operaciones. El tipo de operaciones varia dependiendo de cada tipo." 14 | ] 15 | }, 16 | { 17 | "cell_type": "markdown", 18 | "metadata": {}, 19 | "source": [ 20 | "## 1. Operadores booleanos\n", 21 | "\n", 22 | "- x **or** y: Si x es falso, entonces devuelve y. Sino, devuelve x \\\\\n", 23 | "- x **and** y: Si x es falso, entonces devuelve x. Sino, devuelve y \\\\\n", 24 | "- **not** x: Si x es falso, entonces devuelve True. Sino, devuelve False" 25 | ] 26 | }, 27 | { 28 | "cell_type": "code", 29 | "execution_count": null, 30 | "metadata": { 31 | "collapsed": true 32 | }, 33 | "outputs": [], 34 | "source": [ 35 | "x=False\n", 36 | "y=True\n", 37 | "x or y" 38 | ] 39 | }, 40 | { 41 | "cell_type": "code", 42 | "execution_count": null, 43 | "metadata": { 44 | "collapsed": true 45 | }, 46 | "outputs": [], 47 | "source": [ 48 | "x=False\n", 49 | "y=True\n", 50 | "x and y" 51 | ] 52 | }, 53 | { 54 | "cell_type": "code", 55 | "execution_count": null, 56 | "metadata": { 57 | "collapsed": true 58 | }, 59 | "outputs": [], 60 | "source": [ 61 | "x=True\n", 62 | "y=True\n", 63 | "x and y" 64 | ] 65 | }, 66 | { 67 | "cell_type": "code", 68 | "execution_count": null, 69 | "metadata": { 70 | "collapsed": true 71 | }, 72 | "outputs": [], 73 | "source": [ 74 | "x=False\n", 75 | "not x" 76 | ] 77 | }, 78 | { 79 | "cell_type": "markdown", 80 | "metadata": {}, 81 | "source": [ 82 | "## 2. Operadores de comparación\n", 83 | "\n", 84 | "- < : Estrictamente menor que\n", 85 | "- <= : Menor o igual que\n", 86 | "- \\>\t: Estrictamente mayor que\n", 87 | "- \\>= :\tMayor o igual que\n", 88 | "- == : Igual\n", 89 | "- != : No es igual\n", 90 | "- is : Identidad del objeto\n", 91 | "- is not : Negación de la identidad del objeto" 92 | ] 93 | }, 94 | { 95 | "cell_type": "code", 96 | "execution_count": null, 97 | "metadata": { 98 | "collapsed": true 99 | }, 100 | "outputs": [], 101 | "source": [ 102 | "x=4" 103 | ] 104 | }, 105 | { 106 | "cell_type": "code", 107 | "execution_count": null, 108 | "metadata": { 109 | "collapsed": true 110 | }, 111 | "outputs": [], 112 | "source": [ 113 | "x < 10" 114 | ] 115 | }, 116 | { 117 | "cell_type": "code", 118 | "execution_count": null, 119 | "metadata": { 120 | "collapsed": true 121 | }, 122 | "outputs": [], 123 | "source": [ 124 | "x == 10" 125 | ] 126 | }, 127 | { 128 | "cell_type": "code", 129 | "execution_count": null, 130 | "metadata": { 131 | "collapsed": true 132 | }, 133 | "outputs": [], 134 | "source": [ 135 | "x != 10" 136 | ] 137 | }, 138 | { 139 | "cell_type": "code", 140 | "execution_count": null, 141 | "metadata": { 142 | "collapsed": true 143 | }, 144 | "outputs": [], 145 | "source": [ 146 | "x is 4" 147 | ] 148 | }, 149 | { 150 | "cell_type": "code", 151 | "execution_count": null, 152 | "metadata": { 153 | "collapsed": true 154 | }, 155 | "outputs": [], 156 | "source": [ 157 | "isinstance(x,int)" 158 | ] 159 | }, 160 | { 161 | "cell_type": "code", 162 | "execution_count": null, 163 | "metadata": { 164 | "collapsed": true 165 | }, 166 | "outputs": [], 167 | "source": [ 168 | "x is not 4" 169 | ] 170 | }, 171 | { 172 | "cell_type": "markdown", 173 | "metadata": {}, 174 | "source": [ 175 | "## 3. Operadores para objetos del tipo numéricos\n", 176 | "\n", 177 | "- x + y: Suma de x e y\n", 178 | "- x - y: Diferencia de x e y\n", 179 | "- x * y: Multipliación de x e y\n", 180 | "- x / y: División de x e y\n", 181 | "- x // y: Numero entero inferior más próximo de división entre x e y\n", 182 | "- x % y: Módulo de x e y\n", 183 | "- -x: Negación del valor de x\n", 184 | "- +x: El valor de x no es alterado\n", 185 | "- x \\*\\* y: El valor de x a la potencia de y" 186 | ] 187 | }, 188 | { 189 | "cell_type": "code", 190 | "execution_count": null, 191 | "metadata": { 192 | "collapsed": true 193 | }, 194 | "outputs": [], 195 | "source": [ 196 | "x=4 ; y=3" 197 | ] 198 | }, 199 | { 200 | "cell_type": "code", 201 | "execution_count": null, 202 | "metadata": { 203 | "collapsed": true 204 | }, 205 | "outputs": [], 206 | "source": [ 207 | "x+y" 208 | ] 209 | }, 210 | { 211 | "cell_type": "code", 212 | "execution_count": null, 213 | "metadata": { 214 | "collapsed": true 215 | }, 216 | "outputs": [], 217 | "source": [ 218 | "x*y" 219 | ] 220 | }, 221 | { 222 | "cell_type": "code", 223 | "execution_count": null, 224 | "metadata": { 225 | "collapsed": true 226 | }, 227 | "outputs": [], 228 | "source": [ 229 | "x/y" 230 | ] 231 | }, 232 | { 233 | "cell_type": "code", 234 | "execution_count": null, 235 | "metadata": { 236 | "collapsed": true 237 | }, 238 | "outputs": [], 239 | "source": [ 240 | "x//y" 241 | ] 242 | }, 243 | { 244 | "cell_type": "code", 245 | "execution_count": null, 246 | "metadata": { 247 | "collapsed": true 248 | }, 249 | "outputs": [], 250 | "source": [ 251 | "x % y" 252 | ] 253 | }, 254 | { 255 | "cell_type": "code", 256 | "execution_count": null, 257 | "metadata": { 258 | "collapsed": true 259 | }, 260 | "outputs": [], 261 | "source": [ 262 | "-x" 263 | ] 264 | }, 265 | { 266 | "cell_type": "code", 267 | "execution_count": null, 268 | "metadata": { 269 | "collapsed": true 270 | }, 271 | "outputs": [], 272 | "source": [ 273 | "+x" 274 | ] 275 | }, 276 | { 277 | "cell_type": "code", 278 | "execution_count": null, 279 | "metadata": { 280 | "collapsed": true 281 | }, 282 | "outputs": [], 283 | "source": [ 284 | "x**y" 285 | ] 286 | }, 287 | { 288 | "cell_type": "markdown", 289 | "metadata": {}, 290 | "source": [ 291 | "La precedencia de operadores (en orden de precedencia)\n", 292 | "\n", 293 | "- ()\n", 294 | "- Exponenciación\n", 295 | "- Multiplicación, división y resto\n", 296 | "- Adición y substracción\n", 297 | "- Izquierda a derecha\n" 298 | ] 299 | }, 300 | { 301 | "cell_type": "markdown", 302 | "metadata": {}, 303 | "source": [ 304 | "## 4. Operadores para objetos del tipo secuencias\n", 305 | "\n", 306 | "La mayoría de estas operaciones se aplican a listas, tuplas, rangos, datos binarios y cadenas de caractéres.\n", 307 | "\n", 308 | "- x in s: True si algún item de s es igual a x. Sino, devuelve False.\n", 309 | "- x not in s: False si algún item de s es igual a x. Sino, devuelve True.\n", 310 | "- s + t: La concatenación de s y t\n", 311 | "- s * n: Equivalente a agregar s a sí mismo n veces\n", 312 | "- s[i]: Extrae el item i-ésimo de s. El primer elemento es 0\n", 313 | "- s[i:j]: Extrae un slice de s desde el índice i hasta el j\n", 314 | "- s[i:j:k]: Extrae un slice de s desde el índice i hasta el j con un espacio de k\n", 315 | "- len(s): Largo de s\n", 316 | "- min(s): Valor más pequeño de s\n", 317 | "- max(s): Valor más grande de s" 318 | ] 319 | }, 320 | { 321 | "cell_type": "code", 322 | "execution_count": null, 323 | "metadata": { 324 | "collapsed": true 325 | }, 326 | "outputs": [], 327 | "source": [ 328 | "s=[1,2,3,4] ; t=[5,6,7,8]" 329 | ] 330 | }, 331 | { 332 | "cell_type": "code", 333 | "execution_count": null, 334 | "metadata": { 335 | "collapsed": true 336 | }, 337 | "outputs": [], 338 | "source": [ 339 | "1 in s" 340 | ] 341 | }, 342 | { 343 | "cell_type": "code", 344 | "execution_count": null, 345 | "metadata": { 346 | "collapsed": true 347 | }, 348 | "outputs": [], 349 | "source": [ 350 | "5 in s" 351 | ] 352 | }, 353 | { 354 | "cell_type": "code", 355 | "execution_count": null, 356 | "metadata": { 357 | "collapsed": true 358 | }, 359 | "outputs": [], 360 | "source": [ 361 | "s+t" 362 | ] 363 | }, 364 | { 365 | "cell_type": "code", 366 | "execution_count": null, 367 | "metadata": { 368 | "collapsed": true 369 | }, 370 | "outputs": [], 371 | "source": [ 372 | "s*3" 373 | ] 374 | }, 375 | { 376 | "cell_type": "code", 377 | "execution_count": null, 378 | "metadata": { 379 | "collapsed": true 380 | }, 381 | "outputs": [], 382 | "source": [ 383 | "len(s)" 384 | ] 385 | }, 386 | { 387 | "cell_type": "code", 388 | "execution_count": null, 389 | "metadata": { 390 | "collapsed": true 391 | }, 392 | "outputs": [], 393 | "source": [ 394 | "min(s)" 395 | ] 396 | }, 397 | { 398 | "cell_type": "code", 399 | "execution_count": null, 400 | "metadata": { 401 | "collapsed": true 402 | }, 403 | "outputs": [], 404 | "source": [ 405 | "max(s)" 406 | ] 407 | }, 408 | { 409 | "cell_type": "code", 410 | "execution_count": null, 411 | "metadata": { 412 | "collapsed": true 413 | }, 414 | "outputs": [], 415 | "source": [] 416 | }, 417 | { 418 | "cell_type": "markdown", 419 | "metadata": {}, 420 | "source": [ 421 | "## 5. Funciones nativas de Python\n", 422 | "\n", 423 | "Python 3.6 cuenta con 68 funciones incluidas por defecto. Estas funciones son muy variadas y facilitan el análisis numérico y la evaluación de expresiones. A continuación se listan alfabéticamente.\n", 424 | "\n", 425 | "" 426 | ] 427 | }, 428 | { 429 | "cell_type": "code", 430 | "execution_count": null, 431 | "metadata": { 432 | "collapsed": true 433 | }, 434 | "outputs": [], 435 | "source": [ 436 | "x=-4\n", 437 | "print(x)" 438 | ] 439 | }, 440 | { 441 | "cell_type": "code", 442 | "execution_count": null, 443 | "metadata": { 444 | "collapsed": true 445 | }, 446 | "outputs": [], 447 | "source": [ 448 | "y=abs(x)\n", 449 | "print(y)" 450 | ] 451 | }, 452 | { 453 | "cell_type": "code", 454 | "execution_count": null, 455 | "metadata": { 456 | "collapsed": true 457 | }, 458 | "outputs": [], 459 | "source": [ 460 | "isinstance(x,int)" 461 | ] 462 | }, 463 | { 464 | "cell_type": "code", 465 | "execution_count": null, 466 | "metadata": { 467 | "collapsed": true 468 | }, 469 | "outputs": [], 470 | "source": [ 471 | "isinstance(x,float)" 472 | ] 473 | }, 474 | { 475 | "cell_type": "code", 476 | "execution_count": null, 477 | "metadata": { 478 | "collapsed": true 479 | }, 480 | "outputs": [], 481 | "source": [ 482 | "x=4.654321\n", 483 | "print(x)" 484 | ] 485 | }, 486 | { 487 | "cell_type": "markdown", 488 | "metadata": {}, 489 | "source": [ 490 | "La función round() recibe una variable numérica y el número de decimales al que se quiere aproximar el valor." 491 | ] 492 | }, 493 | { 494 | "cell_type": "code", 495 | "execution_count": null, 496 | "metadata": { 497 | "collapsed": true 498 | }, 499 | "outputs": [], 500 | "source": [ 501 | "round(x)" 502 | ] 503 | }, 504 | { 505 | "cell_type": "code", 506 | "execution_count": null, 507 | "metadata": { 508 | "collapsed": true 509 | }, 510 | "outputs": [], 511 | "source": [ 512 | "round(x,2)" 513 | ] 514 | }, 515 | { 516 | "cell_type": "markdown", 517 | "metadata": {}, 518 | "source": [ 519 | "La función zip() recibe variables iterables (puede ser cero o más), crea un iterador que agrega elements basados en los iterables, y retorna un iterador de tuplas." 520 | ] 521 | }, 522 | { 523 | "cell_type": "code", 524 | "execution_count": null, 525 | "metadata": { 526 | "collapsed": true 527 | }, 528 | "outputs": [], 529 | "source": [ 530 | "x = [1, 2, 3]\n", 531 | "y = ['one', 'two', 'three','four']\n", 532 | "\n", 533 | "result = zip(x,y)\n", 534 | "print(result)\n", 535 | "print(type(result))" 536 | ] 537 | }, 538 | { 539 | "cell_type": "code", 540 | "execution_count": null, 541 | "metadata": { 542 | "collapsed": true 543 | }, 544 | "outputs": [], 545 | "source": [ 546 | "result_list=list(result)\n", 547 | "print(result_list)" 548 | ] 549 | }, 550 | { 551 | "cell_type": "code", 552 | "execution_count": null, 553 | "metadata": { 554 | "collapsed": true 555 | }, 556 | "outputs": [], 557 | "source": [ 558 | "result_list[0][1]" 559 | ] 560 | }, 561 | { 562 | "cell_type": "markdown", 563 | "metadata": {}, 564 | "source": [ 565 | "---\n", 566 | "\n", 567 | "# Ejercicios\n", 568 | "\n", 569 | "Realice los siguientes ejercicios. En caso de tener dudas, puede apoyarse con sus compañeros, preguntarle al profesor y hacer búsquedas en internet.\n" 570 | ] 571 | }, 572 | { 573 | "cell_type": "markdown", 574 | "metadata": {}, 575 | "source": [ 576 | "1. Cree una variable llamada **x** que contenga el valor 3.141592 y una variable **y** que contenga el valor 4

\n", 577 | "2. Evalue si **x** es menor que **y**

\n", 578 | "3. Cree una variable llama **z** que contenga el valor de **x** a la potencia de **y**" 579 | ] 580 | }, 581 | { 582 | "cell_type": "code", 583 | "execution_count": null, 584 | "metadata": { 585 | "collapsed": true 586 | }, 587 | "outputs": [], 588 | "source": [] 589 | }, 590 | { 591 | "cell_type": "markdown", 592 | "metadata": {}, 593 | "source": [ 594 | "4. Cree una lista llamada **a** que contenga 30 veces repetido el valor de la variable **x**.

\n", 595 | "5. Cree un rango llamado **b** que parta desde el valor 0 (incluído) y llegue hasta el 30 (no incluído).

\n", 596 | "6. Transforme la varible **b** en una tipo lista y almacene el resultado en la variable **c**

\n" 597 | ] 598 | }, 599 | { 600 | "cell_type": "code", 601 | "execution_count": null, 602 | "metadata": { 603 | "collapsed": true 604 | }, 605 | "outputs": [], 606 | "source": [] 607 | }, 608 | { 609 | "cell_type": "markdown", 610 | "metadata": {}, 611 | "source": [ 612 | "7. Cree una lista llamada **d** la cual corresponda a la suma elemento a elemento entre las listas **a** y **c** (element wise sum)" 613 | ] 614 | }, 615 | { 616 | "cell_type": "code", 617 | "execution_count": null, 618 | "metadata": { 619 | "collapsed": true 620 | }, 621 | "outputs": [], 622 | "source": [] 623 | } 624 | ], 625 | "metadata": { 626 | "kernelspec": { 627 | "display_name": "Python 3", 628 | "language": "python", 629 | "name": "python3" 630 | }, 631 | "language_info": { 632 | "codemirror_mode": { 633 | "name": "ipython", 634 | "version": 3 635 | }, 636 | "file_extension": ".py", 637 | "mimetype": "text/x-python", 638 | "name": "python", 639 | "nbconvert_exporter": "python", 640 | "pygments_lexer": "ipython3", 641 | "version": "3.6.4" 642 | } 643 | }, 644 | "nbformat": 4, 645 | "nbformat_minor": 2 646 | } 647 | -------------------------------------------------------------------------------- /tutoriales/04_Palabras_reservadas.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# Palabras reservadas en Python\n", 8 | "\n", 9 | "Las palabras reservadas o keywords de Python son aquellos nombres que incorpora el lenguaje de programación y que no pueden ser reemplazados por un valor determinado o alterar su funcionamiento." 10 | ] 11 | }, 12 | { 13 | "cell_type": "markdown", 14 | "metadata": {}, 15 | "source": [ 16 | "En Python 2 existen 31 palabras reservadas\n", 17 | "\n", 18 | "| | | | |\n", 19 | "| :-: | :-: | :-: | :-: |\n", 20 | "| and | as | assert | break |\n", 21 | "| class | continue | def | del |\n", 22 | "| elif | else | except | exec |\n", 23 | "| finally | for | from | global |\n", 24 | "| if | import | in | is |\n", 25 | "| lambda | not | or | pass |\n", 26 | "| print | raise | return | try |\n", 27 | "| while | with | yield | |\n", 28 | "\n", 29 | "En Python 3 las palabras `exec` y `print` fueron eliminadas, mientras que fueron incoporadas las palabras `nonlocal`, `True`, `False` y `None`. De esta manera, en Python 3 existe 33 palabras reservadas\n", 30 | "\n", 31 | "| | | | |\n", 32 | "| :-: | :-: | :-: | :-: |\n", 33 | "| and | as | assert | break |\n", 34 | "| class | continue | def | del |\n", 35 | "| elif | else | except | False |\n", 36 | "| finally | for | from | global |\n", 37 | "| if | import | in | is |\n", 38 | "| lambda | None | nonlocal | not |\n", 39 | "| or | pass | raise | return |\n", 40 | "| True | try | while | with |\n", 41 | "| yield |" 42 | ] 43 | }, 44 | { 45 | "cell_type": "markdown", 46 | "metadata": {}, 47 | "source": [ 48 | "## 1. Uso del módulo keyword\n", 49 | "\n", 50 | "Se puede usar la función `kwlist` del módulo `keyword` para obtener la lista de palabras reservadas" 51 | ] 52 | }, 53 | { 54 | "cell_type": "code", 55 | "execution_count": null, 56 | "metadata": {}, 57 | "outputs": [], 58 | "source": [ 59 | "import keyword\n", 60 | "\n", 61 | "keyword.kwlist" 62 | ] 63 | }, 64 | { 65 | "cell_type": "markdown", 66 | "metadata": {}, 67 | "source": [ 68 | "Supongamos que queremos definir una variable de nombre None en nuestro código. Para verificar que no sea una palabra reservada, usamos la función `iskeyword`. Si la respuesta es True significa que la palabra es reservada del sistema." 69 | ] 70 | }, 71 | { 72 | "cell_type": "code", 73 | "execution_count": null, 74 | "metadata": {}, 75 | "outputs": [], 76 | "source": [ 77 | "keyword.iskeyword('None')" 78 | ] 79 | }, 80 | { 81 | "cell_type": "code", 82 | "execution_count": null, 83 | "metadata": {}, 84 | "outputs": [], 85 | "source": [ 86 | "keyword.iskeyword('dog')" 87 | ] 88 | }, 89 | { 90 | "cell_type": "markdown", 91 | "metadata": {}, 92 | "source": [ 93 | "## 2. Ejemplos de palabras reservadas\n", 94 | "\n", 95 | "A continuación una lista de palabras reservadas usadas comúnmente en Python\n", 96 | "\n", 97 | "- **True / False** : Representaciones booleanas de Verdadero y Falso" 98 | ] 99 | }, 100 | { 101 | "cell_type": "code", 102 | "execution_count": null, 103 | "metadata": { 104 | "collapsed": true 105 | }, 106 | "outputs": [], 107 | "source": [ 108 | "x=True\n", 109 | "y=False" 110 | ] 111 | }, 112 | { 113 | "cell_type": "markdown", 114 | "metadata": {}, 115 | "source": [ 116 | "- **and / or** : Representaciones lógicas de \"y\" y \"o\", respectivamente " 117 | ] 118 | }, 119 | { 120 | "cell_type": "code", 121 | "execution_count": null, 122 | "metadata": {}, 123 | "outputs": [], 124 | "source": [ 125 | "x= True and False\n", 126 | "print(x)" 127 | ] 128 | }, 129 | { 130 | "cell_type": "code", 131 | "execution_count": null, 132 | "metadata": { 133 | "collapsed": true 134 | }, 135 | "outputs": [], 136 | "source": [ 137 | "y= True or False\n", 138 | "print(y)" 139 | ] 140 | }, 141 | { 142 | "cell_type": "markdown", 143 | "metadata": {}, 144 | "source": [ 145 | "- **None** : None es utilizado para indicar la ausencia de un valor en un objeto determinado." 146 | ] 147 | }, 148 | { 149 | "cell_type": "code", 150 | "execution_count": null, 151 | "metadata": { 152 | "collapsed": true 153 | }, 154 | "outputs": [], 155 | "source": [ 156 | "x= None\n", 157 | "print(x)\n", 158 | "print(type(x))" 159 | ] 160 | }, 161 | { 162 | "cell_type": "code", 163 | "execution_count": null, 164 | "metadata": { 165 | "collapsed": true 166 | }, 167 | "outputs": [], 168 | "source": [ 169 | "x+1" 170 | ] 171 | }, 172 | { 173 | "cell_type": "markdown", 174 | "metadata": {}, 175 | "source": [ 176 | "- **assert** : Durante la depuración de un código `assert` permite especificar una expresión que lanzará `AssertionError` en caso de ser evaluada como falsa." 177 | ] 178 | }, 179 | { 180 | "cell_type": "code", 181 | "execution_count": null, 182 | "metadata": {}, 183 | "outputs": [], 184 | "source": [ 185 | "assert 1 == 2" 186 | ] 187 | }, 188 | { 189 | "cell_type": "code", 190 | "execution_count": null, 191 | "metadata": { 192 | "collapsed": true 193 | }, 194 | "outputs": [], 195 | "source": [ 196 | "assert 1 == 1" 197 | ] 198 | }, 199 | { 200 | "cell_type": "markdown", 201 | "metadata": {}, 202 | "source": [ 203 | "- **try / except / else / finally**:\n", 204 | "\n", 205 | "Las cláusula try / except permite capturar una **excepción** dentro de una determinada porción de código.\n", 206 | "Una **Excepción** es un error \"*en tiempo de ejecución*\", es decir, un error que el intérprete Python detecta mientras el programa se está ejecutando, y no antes, al revisar la sintaxis. En el siguiente ejemplo se ve que \"`result = x / y`\" está sintácticamente bien, pero su valor se puede indefinir de acuerdo al valor de `y`." 207 | ] 208 | }, 209 | { 210 | "cell_type": "code", 211 | "execution_count": null, 212 | "metadata": {}, 213 | "outputs": [], 214 | "source": [ 215 | "x=10\n", 216 | "y=0\n", 217 | "\n", 218 | "x/y" 219 | ] 220 | }, 221 | { 222 | "cell_type": "code", 223 | "execution_count": null, 224 | "metadata": {}, 225 | "outputs": [], 226 | "source": [ 227 | "x=10\n", 228 | "y=0\n", 229 | "\n", 230 | "try:\n", 231 | " result = x / y\n", 232 | "except ZeroDivisionError:\n", 233 | " print(\"División por cero!\")" 234 | ] 235 | }, 236 | { 237 | "cell_type": "markdown", 238 | "metadata": {}, 239 | "source": [ 240 | "En caso de no haberse propagado ninguna excepción, el flujo del programa seguirá luego del término `else` al finalizar la ejecución del bloque de código de `try`" 241 | ] 242 | }, 243 | { 244 | "cell_type": "code", 245 | "execution_count": null, 246 | "metadata": {}, 247 | "outputs": [], 248 | "source": [ 249 | "x=10\n", 250 | "y=2\n", 251 | "\n", 252 | "try:\n", 253 | " result = x / y\n", 254 | "except ZeroDivisionError:\n", 255 | " print(\"División por cero!\")\n", 256 | "else:\n", 257 | " print(\"Resultado de división entre \", x, \" y \", y, \" = \", result)" 258 | ] 259 | }, 260 | { 261 | "cell_type": "code", 262 | "execution_count": null, 263 | "metadata": {}, 264 | "outputs": [], 265 | "source": [ 266 | "x=input()" 267 | ] 268 | }, 269 | { 270 | "cell_type": "code", 271 | "execution_count": null, 272 | "metadata": {}, 273 | "outputs": [], 274 | "source": [ 275 | "x" 276 | ] 277 | }, 278 | { 279 | "cell_type": "markdown", 280 | "metadata": {}, 281 | "source": [ 282 | "Por último, el flujo será enviado luego del término finally al finalizar la ejecución del código anterior, independientemente si han surgido errores. Es decir, el código dentro del `finally` siempre se ejecuta." 283 | ] 284 | }, 285 | { 286 | "cell_type": "code", 287 | "execution_count": null, 288 | "metadata": {}, 289 | "outputs": [], 290 | "source": [ 291 | "x=10\n", 292 | "y=0\n", 293 | "\n", 294 | "try:\n", 295 | " result = 30/2\n", 296 | " result = x / y\n", 297 | "except ZeroDivisionError:\n", 298 | " print(\"División por cero!\")\n", 299 | "else:\n", 300 | " print(\"Resultado de división entre \", x, \" y \", y, \" = \", result)\n", 301 | "finally:\n", 302 | " print(\"La división ha finalizado\")" 303 | ] 304 | }, 305 | { 306 | "cell_type": "code", 307 | "execution_count": null, 308 | "metadata": {}, 309 | "outputs": [], 310 | "source": [ 311 | "result" 312 | ] 313 | }, 314 | { 315 | "cell_type": "markdown", 316 | "metadata": {}, 317 | "source": [ 318 | "- **raise**: Permite forzar la aparición de una excepción." 319 | ] 320 | }, 321 | { 322 | "cell_type": "code", 323 | "execution_count": null, 324 | "metadata": {}, 325 | "outputs": [], 326 | "source": [ 327 | "raise NameError(\"¡Hola Amigos!\")" 328 | ] 329 | }, 330 | { 331 | "cell_type": "code", 332 | "execution_count": null, 333 | "metadata": {}, 334 | "outputs": [], 335 | "source": [ 336 | "try:\n", 337 | " raise ZeroDivisionError('malo malo')\n", 338 | " \n", 339 | "except Exception as error:\n", 340 | " print('Estamos manejando un error: ' , error)\n", 341 | "else:\n", 342 | " print(\"No detectamos errores\")\n", 343 | "finally:\n", 344 | " print(\"Terminamos el trabajo\")" 345 | ] 346 | }, 347 | { 348 | "cell_type": "markdown", 349 | "metadata": {}, 350 | "source": [ 351 | "- **with:** Permite encapsular la ejecución de un bloque de código, de modo que la inicialización y finalización de un objeto es realizada automáticamente por Python, utilizando las funciones `__enter__` y `__exit__`" 352 | ] 353 | }, 354 | { 355 | "cell_type": "code", 356 | "execution_count": null, 357 | "metadata": {}, 358 | "outputs": [], 359 | "source": [ 360 | "with open(\"data/poema_15_Pablo_Neruda.txt\") as f:\n", 361 | " for line in f:\n", 362 | " print(line, end=\"\")" 363 | ] 364 | }, 365 | { 366 | "cell_type": "markdown", 367 | "metadata": { 368 | "collapsed": true 369 | }, 370 | "source": [ 371 | "- **pass**: Representa una operación nula. *Hace nada, literalmente*. Pero es útil en casos en que tenemos zonas del código que todavía no estamos implementando, de manera que podemos dejar el `pass` para implementar posteriormente " 372 | ] 373 | }, 374 | { 375 | "cell_type": "code", 376 | "execution_count": null, 377 | "metadata": {}, 378 | "outputs": [], 379 | "source": [ 380 | "# ¿Funcionará? La idea es que no he implementado el código dentro del if\n", 381 | "a = 1\n", 382 | "if a == 1:\n", 383 | " #aquí deberíamos implementar algo\n", 384 | "print(\"terminamos\")" 385 | ] 386 | }, 387 | { 388 | "cell_type": "code", 389 | "execution_count": null, 390 | "metadata": {}, 391 | "outputs": [], 392 | "source": [ 393 | "# ¿Y en este caso funcionará?\n", 394 | "a = 1\n", 395 | "if a == 1:\n", 396 | " #aquí deberíamos implementar algo\n", 397 | " pass\n", 398 | "print(\"terminamos\")" 399 | ] 400 | }, 401 | { 402 | "cell_type": "code", 403 | "execution_count": null, 404 | "metadata": { 405 | "collapsed": true 406 | }, 407 | "outputs": [], 408 | "source": [] 409 | } 410 | ], 411 | "metadata": { 412 | "kernelspec": { 413 | "display_name": "Python 3", 414 | "language": "python", 415 | "name": "python3" 416 | }, 417 | "language_info": { 418 | "codemirror_mode": { 419 | "name": "ipython", 420 | "version": 3 421 | }, 422 | "file_extension": ".py", 423 | "mimetype": "text/x-python", 424 | "name": "python", 425 | "nbconvert_exporter": "python", 426 | "pygments_lexer": "ipython3", 427 | "version": "3.6.4" 428 | } 429 | }, 430 | "nbformat": 4, 431 | "nbformat_minor": 2 432 | } 433 | -------------------------------------------------------------------------------- /tutoriales/05_Control_de_flujos.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# Uso de sentencias de control de flujo\n", 8 | "\n", 9 | "**Autor:** Roberto Muñoz
\n", 10 | "**E-mail:**
\n", 11 | "**Github:**
\n", 12 | "\n", 13 | "Python soporta las sentencias de control de flujo que podemos encontrar similarmente en otros lenguajes de programación tales como C, C++, C#, Basic, R, Java y varios otros.\n", 14 | "\n", 15 | "Las sentencias presentes en Python 3.6 son\n", 16 | "\n", 17 | "- If\n", 18 | "- Else\n", 19 | "\n", 20 | "- While\n", 21 | "- For\n", 22 | "- Break\n", 23 | "- Continue\n", 24 | "- Pass\n", 25 | "\n", 26 | "- Try\n", 27 | "- With\n" 28 | ] 29 | }, 30 | { 31 | "cell_type": "markdown", 32 | "metadata": {}, 33 | "source": [ 34 | "## 1. If\n", 35 | "\n", 36 | "La sentencia if es quizás la más conocida. Esta sentencia se usa para ejecución condicional de código.\n", 37 | "\n", 38 | "Puede haber cero o más bloques elif, y el bloque else es opcional. La palabra reservada ‘elif‘ es una abreviación de ‘else if’, y es útil para evitar un sangrado excesivo.\n", 39 | "\n", 40 | "Una secuencia if ... elif ... elif ... sustituye las sentencias switch o case encontradas en otros lenguajes." 41 | ] 42 | }, 43 | { 44 | "cell_type": "code", 45 | "execution_count": null, 46 | "metadata": {}, 47 | "outputs": [], 48 | "source": [ 49 | "x=0\n", 50 | "\n", 51 | "if x < 0:\n", 52 | " x = 0\n", 53 | " print('Negativo cambiado a cero')\n", 54 | "elif x == 0:\n", 55 | " print('Cero')\n", 56 | "elif x == 1:\n", 57 | " print('Igual a uno')\n", 58 | "else:\n", 59 | " print('Mayor a uno')\n", 60 | " \n", 61 | "print(\"Valor: \", x)" 62 | ] 63 | }, 64 | { 65 | "cell_type": "markdown", 66 | "metadata": {}, 67 | "source": [ 68 | "Podríamos hacer una comparativa entre Python y Java" 69 | ] 70 | }, 71 | { 72 | "cell_type": "code", 73 | "execution_count": null, 74 | "metadata": {}, 75 | "outputs": [], 76 | "source": [ 77 | "# Código en Python\n", 78 | "\n", 79 | "fav=\"color azul\"\n", 80 | "\n", 81 | "if fav == \"color azul\":\n", 82 | " print(\"Tienes buen gusto!\")\n", 83 | " print(\"Gracias\")" 84 | ] 85 | }, 86 | { 87 | "cell_type": "markdown", 88 | "metadata": {}, 89 | "source": [ 90 | " # Código en Java\n", 91 | "\n", 92 | "```java\n", 93 | "String fav = \"color azul\"\n", 94 | "if (fav.equals(\"color azul\")){\n", 95 | " System.out.println(\"Tienes buen gusto!\");\n", 96 | " System.out.println(\"Gracias\");\n", 97 | "}\n", 98 | "```" 99 | ] 100 | }, 101 | { 102 | "cell_type": "markdown", 103 | "metadata": {}, 104 | "source": [ 105 | "## 2. While\n", 106 | "\n", 107 | "La sentencia **while** es usada para repetir la ejecución de un código mientras la condición sea verdadera.\n", 108 | "\n", 109 | "El primer bloque corresponde al código que se ejecuta mientras la condición sea verdadera. Se puede crear un segundo bloque opcional con la sentencia else, la cual permite ejecutar ese bloque antes de terminar la ejecución del bucle while.\n", 110 | "\n", 111 | "Se pueden usar las sentencias **break** y **continue** en el primer bloque." 112 | ] 113 | }, 114 | { 115 | "cell_type": "code", 116 | "execution_count": null, 117 | "metadata": { 118 | "collapsed": true 119 | }, 120 | "outputs": [], 121 | "source": [ 122 | "a=0;b=1" 123 | ] 124 | }, 125 | { 126 | "cell_type": "code", 127 | "execution_count": null, 128 | "metadata": {}, 129 | "outputs": [], 130 | "source": [ 131 | "a=0\n", 132 | "while a<10:\n", 133 | " if a<5:\n", 134 | " print(a)\n", 135 | " a=a+1\n", 136 | " \n", 137 | "print(\"Fin\")" 138 | ] 139 | }, 140 | { 141 | "cell_type": "code", 142 | "execution_count": null, 143 | "metadata": {}, 144 | "outputs": [], 145 | "source": [ 146 | "a" 147 | ] 148 | }, 149 | { 150 | "cell_type": "code", 151 | "execution_count": null, 152 | "metadata": {}, 153 | "outputs": [], 154 | "source": [ 155 | "a, b = 0, 1\n", 156 | "while b < 1000:\n", 157 | " print(b, end=' - ')\n", 158 | " \n", 159 | " a, b = b, a+b" 160 | ] 161 | }, 162 | { 163 | "cell_type": "code", 164 | "execution_count": null, 165 | "metadata": {}, 166 | "outputs": [], 167 | "source": [ 168 | "a, b = 0, 1\n", 169 | "while b < 1000:\n", 170 | " print(b, end=',')\n", 171 | " a, b = b, a+b\n", 172 | "else:\n", 173 | " print(\"\\nEl valor de b es mayor que 1000\")" 174 | ] 175 | }, 176 | { 177 | "cell_type": "code", 178 | "execution_count": null, 179 | "metadata": {}, 180 | "outputs": [], 181 | "source": [ 182 | "a, b = 0, 1\n", 183 | "while b < 1000:\n", 184 | " print(b, end=',')\n", 185 | " a, b = b, a+b\n", 186 | " if b>100:\n", 187 | " break" 188 | ] 189 | }, 190 | { 191 | "cell_type": "markdown", 192 | "metadata": {}, 193 | "source": [ 194 | "## 3. For\n", 195 | "\n", 196 | "La sentencia for se usa para iterar sobre los elementos que pertenecen a una secuencia del tipo string, tupla, lista o cualquier otro objeto iterable.\n", 197 | "\n", 198 | "La sentencia for en Python difiere un poco de lo que uno puede estar acostumbrado en lenguajes como C o Pascal. En lugar de siempre iterar sobre una progresión aritmética de números (como en Pascal) o darle al usuario la posibilidad de definir tanto el paso de la iteración como la condición de fin (como en C), la sentencia for de Python itera sobre los ítems de cualquier secuencia (una lista o una cadena de texto), en el orden que aparecen en la secuencia." 199 | ] 200 | }, 201 | { 202 | "cell_type": "code", 203 | "execution_count": null, 204 | "metadata": {}, 205 | "outputs": [], 206 | "source": [ 207 | "palabras = ['gato', 'ventana', 'pájaro']\n", 208 | "for p in palabras:\n", 209 | " print(p, len(p))" 210 | ] 211 | }, 212 | { 213 | "cell_type": "code", 214 | "execution_count": null, 215 | "metadata": {}, 216 | "outputs": [], 217 | "source": [ 218 | "len(palabras)" 219 | ] 220 | }, 221 | { 222 | "cell_type": "code", 223 | "execution_count": null, 224 | "metadata": {}, 225 | "outputs": [], 226 | "source": [ 227 | "for i in range(len(palabras)):\n", 228 | " print(palabras[i])" 229 | ] 230 | }, 231 | { 232 | "cell_type": "markdown", 233 | "metadata": {}, 234 | "source": [ 235 | "## 4. Try\n", 236 | "\n", 237 | "La sentencia try se usa para el manejo de excepciones y/o la limpieza de código para un grupo de expresiones.\n", 238 | "\n", 239 | "Es posible escribir programas que manejen determinadas excepciones. En el siguiente ejemplo se le pide al usuario una entrada hasta que ingrese un entero válido, pero permite al usuario interrumpir el programa (usando Control-C o lo que sea que el sistema operativo soporte).\n", 240 | "\n", 241 | "Notar que una interrupción generada por el usuario se señaliza generando la excepción KeyboardInterrupt." 242 | ] 243 | }, 244 | { 245 | "cell_type": "code", 246 | "execution_count": null, 247 | "metadata": { 248 | "collapsed": true 249 | }, 250 | "outputs": [], 251 | "source": [ 252 | "while True:\n", 253 | " try:\n", 254 | " x = int(input(\"Por favor ingrese un número: \"))\n", 255 | " break\n", 256 | " except ValueError:\n", 257 | " print(\"Oops! No era válido. Intente nuevamente...\")" 258 | ] 259 | }, 260 | { 261 | "cell_type": "markdown", 262 | "metadata": {}, 263 | "source": [ 264 | "La declaración try funciona de la siguiente manera:\n", 265 | "\n", 266 | "- Primero, se ejecuta el bloque try (el código entre las declaración try y except).\n", 267 | "- Si no ocurre ninguna excepción, el bloque except se salta y termina la ejecución de la declaración try.\n", 268 | "- Si ocurre una excepción durante la ejecución del bloque try, el resto del bloque se salta. Luego, si su tipo coincide con la excepción nombrada luego de la palabra reservada except, se ejecuta el bloque except, y la ejecución continúa luego de la declaración try.\n", 269 | "- Si ocurre una excepción que no coincide con la excepción nombrada en el except, esta se pasa a declaraciones try de más afuera; si no se encuentra nada que la maneje, es una excepción no manejada, y la ejecución se frena con un mensaje como los mostrados arriba.\n", 270 | "\n", 271 | "Una declaración try puede tener más de un except, para especificar manejadores para distintas excepciones. A lo sumo un manejador será ejecutado.\n", 272 | "\n", 273 | "Sólo se manejan excepciones que ocurren en el correspondiente try, no en otros manejadores del mismo try. Un except puede nombrar múltiples excepciones usando paréntesis, por ejemplo:" 274 | ] 275 | }, 276 | { 277 | "cell_type": "code", 278 | "execution_count": null, 279 | "metadata": { 280 | "collapsed": true 281 | }, 282 | "outputs": [], 283 | "source": [ 284 | "while True:\n", 285 | " try:\n", 286 | " x = int(input(\"Por favor ingrese un número: \"))\n", 287 | " break\n", 288 | " except (ValueError, RuntimeError, TypeError, NameError):\n", 289 | " print(\"Oops! No era válido. Intente nuevamente...\")" 290 | ] 291 | }, 292 | { 293 | "cell_type": "markdown", 294 | "metadata": {}, 295 | "source": [ 296 | "Las declaraciones try ... except tienen un **bloque else** opcional, el cual, cuando está presente, debe seguir a los except. Es útil para aquel código que debe ejecutarse si el bloque try no genera una excepción. Por ejemplo," 297 | ] 298 | }, 299 | { 300 | "cell_type": "code", 301 | "execution_count": null, 302 | "metadata": { 303 | "collapsed": true 304 | }, 305 | "outputs": [], 306 | "source": [ 307 | "try:\n", 308 | " file='data/Gobierno transparente - Registro atenciones - SML.csv'\n", 309 | " f = open(file)\n", 310 | "except OSError:\n", 311 | " print(\"No se pudo abrir el archivo \", file)\n", 312 | "else:\n", 313 | " print(\"Archivo abierto de manera correcta \", file)\n", 314 | " print(\"El archivo tiene \", len(f.readlines()), 'lineas')\n", 315 | " f.close()" 316 | ] 317 | }, 318 | { 319 | "cell_type": "code", 320 | "execution_count": null, 321 | "metadata": { 322 | "collapsed": true 323 | }, 324 | "outputs": [], 325 | "source": [ 326 | "f" 327 | ] 328 | }, 329 | { 330 | "cell_type": "markdown", 331 | "metadata": {}, 332 | "source": [ 333 | "---\n", 334 | "\n", 335 | "# Ejercicios\n", 336 | "\n", 337 | "Realice los siguientes ejercicios. En caso de tener dudas, puede apoyarse con sus compañeros, preguntarle al profesor y hacer búsquedas en internet." 338 | ] 339 | }, 340 | { 341 | "cell_type": "markdown", 342 | "metadata": {}, 343 | "source": [ 344 | "1. Use una sentencia `for` para calcular la suma de todos los números entre el 1 y el 100.

\n", 345 | "2. Use alguna sentencia que permita calcular la suma de todos los números entre el 1 y 100 y que use un máximo de 50 iteraciones.

\n", 346 | "3. Use alguna sentencia que permita sumar los números primos entre el 1 y el 100." 347 | ] 348 | }, 349 | { 350 | "cell_type": "code", 351 | "execution_count": null, 352 | "metadata": { 353 | "collapsed": true 354 | }, 355 | "outputs": [], 356 | "source": [] 357 | }, 358 | { 359 | "cell_type": "code", 360 | "execution_count": null, 361 | "metadata": { 362 | "collapsed": true 363 | }, 364 | "outputs": [], 365 | "source": [] 366 | } 367 | ], 368 | "metadata": { 369 | "kernelspec": { 370 | "display_name": "Python 3", 371 | "language": "python", 372 | "name": "python3" 373 | }, 374 | "language_info": { 375 | "codemirror_mode": { 376 | "name": "ipython", 377 | "version": 3 378 | }, 379 | "file_extension": ".py", 380 | "mimetype": "text/x-python", 381 | "name": "python", 382 | "nbconvert_exporter": "python", 383 | "pygments_lexer": "ipython3", 384 | "version": "3.6.4" 385 | } 386 | }, 387 | "nbformat": 4, 388 | "nbformat_minor": 2 389 | } 390 | -------------------------------------------------------------------------------- /tutoriales/08_Sobrecarga_de_operadores.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# Sobrecarga de operadores\n", 8 | "\n", 9 | "**Autor:** Roberto Muñoz
\n", 10 | "**E-mail:**
\n", 11 | "**Github:**
\n", 12 | "\n", 13 | "Operadores típicos como la suma, resta y otros, pueden ser sobrecargados, es decir, se les puede asignar nueva funcionalidad, lo que posibilita que el programador interactúe con objetos de una manera natural." 14 | ] 15 | }, 16 | { 17 | "cell_type": "markdown", 18 | "metadata": {}, 19 | "source": [ 20 | "Los operadores que se pueden sobrecargar y las funciones especiales que los representan a la hora de programar la sobrecarga se listan a continuación:\n", 21 | "\n", 22 | "" 23 | ] 24 | }, 25 | { 26 | "cell_type": "markdown", 27 | "metadata": {}, 28 | "source": [ 29 | "Tomemos la clase Perro vista en la sección de Clases, y agreguemos la sobrecarga del operador de suma (+), de manera que cuando sumemos 2 perritos, \"nazca\" otro:" 30 | ] 31 | }, 32 | { 33 | "cell_type": "code", 34 | "execution_count": null, 35 | "metadata": { 36 | "collapsed": true 37 | }, 38 | "outputs": [], 39 | "source": [ 40 | "class Perro:\n", 41 | " \n", 42 | " def __init__(self, nombre, dia, mes, año, ladrido):\n", 43 | " self.nombre = nombre\n", 44 | " self.dia = dia\n", 45 | " self.mes = mes\n", 46 | " self.año = año\n", 47 | " self.ladrido = ladrido\n", 48 | "\n", 49 | " # El metodo bark es un método accesor que retorna el valor de la variable ladrido\n", 50 | " def bark(self):\n", 51 | " return self.ladrido\n", 52 | "\n", 53 | " # El metodo getName es un método accesor que retorna el nombre del perro\n", 54 | " def getName(self):\n", 55 | " return self.nombre\n", 56 | " \n", 57 | " # El método getBirthDate es un método accesor que retorna la fecha de nacimiento del perro\n", 58 | " def getBirthdate(self):\n", 59 | " return str(self.dia) + \"/\" + str(self.mes) + \"/\" + str(self.año)\n", 60 | "\n", 61 | " # Este es un método mutador que cambia el ladrido del objeto Perro.\n", 62 | " def changeBark(self, ladrido):\n", 63 | " self.ladrido = ladrido\n", 64 | " \n", 65 | " # Aquí está el método interesante. Con este método podremos \"sumar\" dos perros.\n", 66 | " # La mayor gracia está en que lo que se sobrecarga es el operador \"+\", de sintaxis\n", 67 | " # amistosa.\n", 68 | " def __add__(self,otherDog):\n", 69 | " return Perro(\"Cachorro de \" + self.nombre + \" y \" + otherDog.nombre, \\\n", 70 | " self.dia, self.mes, self.año + 1, \\\n", 71 | " self.ladrido + otherDog.ladrido)" 72 | ] 73 | }, 74 | { 75 | "cell_type": "markdown", 76 | "metadata": {}, 77 | "source": [ 78 | "Hagamos ahora un ejemplo de sobrecarga del operador de suma" 79 | ] 80 | }, 81 | { 82 | "cell_type": "code", 83 | "execution_count": null, 84 | "metadata": { 85 | "collapsed": true 86 | }, 87 | "outputs": [], 88 | "source": [ 89 | "help(Perro)" 90 | ] 91 | }, 92 | { 93 | "cell_type": "code", 94 | "execution_count": null, 95 | "metadata": { 96 | "collapsed": true 97 | }, 98 | "outputs": [], 99 | "source": [ 100 | "Padre = Perro(\"Bobby\", 9, 7, 1978, \"Wrafff\")\n", 101 | "Madre = Perro(\"Lucy\", 12, 4, 1975, \"Arf\")\n", 102 | "\n", 103 | "# El milagro de la vida...\n", 104 | "Hijo = Padre + Madre\n", 105 | "\n", 106 | "print(Hijo.getName())\n", 107 | "print(Hijo.bark())\n", 108 | "print(Hijo.getBirthdate())" 109 | ] 110 | }, 111 | { 112 | "cell_type": "markdown", 113 | "metadata": {}, 114 | "source": [ 115 | "---\n", 116 | "# Ejercicios\n", 117 | "\n", 118 | "Realice los siguientes ejercicios. En caso de tener dudas, puede apoyarse con sus compañeros, preguntarle al profesor y hacer búsquedas en internet." 119 | ] 120 | }, 121 | { 122 | "cell_type": "markdown", 123 | "metadata": {}, 124 | "source": [ 125 | "1. Cree una clase llamada `complejo` que permita representar un número complejo (parte real y parte imaginaria). Sobrecargue los siguientes operadores:\n", 126 | "\n", 127 | " * +\n", 128 | " * *\n", 129 | " * str()\n", 130 | " * ==" 131 | ] 132 | }, 133 | { 134 | "cell_type": "code", 135 | "execution_count": null, 136 | "metadata": { 137 | "collapsed": true 138 | }, 139 | "outputs": [], 140 | "source": [] 141 | }, 142 | { 143 | "cell_type": "markdown", 144 | "metadata": {}, 145 | "source": [] 146 | } 147 | ], 148 | "metadata": { 149 | "kernelspec": { 150 | "display_name": "Python 3", 151 | "language": "python", 152 | "name": "python3" 153 | }, 154 | "language_info": { 155 | "codemirror_mode": { 156 | "name": "ipython", 157 | "version": 3 158 | }, 159 | "file_extension": ".py", 160 | "mimetype": "text/x-python", 161 | "name": "python", 162 | "nbconvert_exporter": "python", 163 | "pygments_lexer": "ipython3", 164 | "version": "3.6.4" 165 | } 166 | }, 167 | "nbformat": 4, 168 | "nbformat_minor": 2 169 | } 170 | -------------------------------------------------------------------------------- /tutoriales/10_Creacion_de_modulos.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# Módulos\n", 8 | "\n", 9 | "**Autor:** Roberto Muñoz
\n", 10 | "**E-mail:**
\n", 11 | "**Github:**
\n", 12 | "\n", 13 | "\n", 14 | "En el caso de escribir programa más o menos largo en Python, es conveniente usar un editor de texto como sublime o un IDE como Spyder para grabar los códigos en un archivo con sufijo `.py`. Por ejemplo, si queremos usar una definición de una función en múltiples proyectos sería conveniente guardarlo en un archivo de python e importatla posteriormente.\n", 15 | "\n", 16 | "Para soportar esto, Python tiene una manera de poner definiciones en un archivo y usarlos en un script o en una instancia interactiva del intérprete. Tal archivo es llamado módulo; las definiciones de un módulo pueden ser importadas a otros módulos o al módulo principal (la colección de variables a las que tenés acceso en un script ejecutado en el nivel superior y en el modo calculadora).\n", 17 | "\n", 18 | "Un módulo es un archivo que conteniene definiciones y declaraciones de Python. El nombre del archivo es el nombre del módulo con el sufijo `.py` agregado. Dentro de un módulo, el nombre del mismo (como una cadena de caractéres) está disponible en el valor de la variable global __name__." 19 | ] 20 | }, 21 | { 22 | "cell_type": "markdown", 23 | "metadata": {}, 24 | "source": [ 25 | "## 1. Creación de módulos\n", 26 | "\n", 27 | "Usemos Spyder para crear un modulo de python que contendrá la definición de la función que permite crear la serie de Fibonacci." 28 | ] 29 | }, 30 | { 31 | "cell_type": "code", 32 | "execution_count": null, 33 | "metadata": { 34 | "collapsed": true 35 | }, 36 | "outputs": [], 37 | "source": [ 38 | "# módulo de números Fibonacci\n", 39 | "\n", 40 | "def fib1(n): # escribe la serie Fibonacci hasta n\n", 41 | " a, b = 0, 1\n", 42 | " while b < n:\n", 43 | " print(b, end=' ')\n", 44 | " a, b = b, a+b\n", 45 | " print()\n", 46 | "\n", 47 | "def fib2(n): # devuelve la serie Fibonacci hasta n\n", 48 | " resultado = []\n", 49 | " a, b = 0, 1\n", 50 | " while b < n:\n", 51 | " resultado.append(b)\n", 52 | " a, b = b, a+b\n", 53 | " return resultado" 54 | ] 55 | }, 56 | { 57 | "cell_type": "code", 58 | "execution_count": null, 59 | "metadata": { 60 | "collapsed": true 61 | }, 62 | "outputs": [], 63 | "source": [ 64 | "import fibo" 65 | ] 66 | }, 67 | { 68 | "cell_type": "code", 69 | "execution_count": null, 70 | "metadata": { 71 | "collapsed": true 72 | }, 73 | "outputs": [], 74 | "source": [ 75 | "help(fibo)" 76 | ] 77 | }, 78 | { 79 | "cell_type": "markdown", 80 | "metadata": {}, 81 | "source": [ 82 | "La función nativa `dir()` se usa para encontrar qué nombres define un módulo. Devuelve una lista ordenada de cadenas:" 83 | ] 84 | }, 85 | { 86 | "cell_type": "code", 87 | "execution_count": null, 88 | "metadata": { 89 | "collapsed": true 90 | }, 91 | "outputs": [], 92 | "source": [ 93 | "dir(fibo)" 94 | ] 95 | }, 96 | { 97 | "cell_type": "code", 98 | "execution_count": null, 99 | "metadata": { 100 | "collapsed": true 101 | }, 102 | "outputs": [], 103 | "source": [ 104 | "fibo.fib1(100)" 105 | ] 106 | }, 107 | { 108 | "cell_type": "code", 109 | "execution_count": null, 110 | "metadata": { 111 | "collapsed": true 112 | }, 113 | "outputs": [], 114 | "source": [ 115 | "x=fibo.fib2(1000)\n", 116 | "print(x)" 117 | ] 118 | }, 119 | { 120 | "cell_type": "markdown", 121 | "metadata": {}, 122 | "source": [ 123 | "## 2. Ejecución de módulos como scripts\n", 124 | "\n", 125 | "En algunos casos es conveniente poder ejecutar los módulos de Python como si fuesen scripts. En este caso, no gustaría ejecutar el siguiente commando en el Anaconda prompt\n", 126 | "\n", 127 | " python fibonacci.py \n", 128 | " \n", 129 | "El código en el módulo será ejecutado tal como si lo hubieses importado, pero con __name__ con el valor de \"__main__\".\n", 130 | "\n", 131 | "Para lograr esta funcionalidad, debemos agregar un par de líneas al final del archivo .py\n", 132 | "\n", 133 | "```python\n", 134 | "\n", 135 | "if __name__ == \"__main__\":\n", 136 | " import sys\n", 137 | " fib1(int(sys.argv[1]))\n", 138 | "```" 139 | ] 140 | }, 141 | { 142 | "cell_type": "code", 143 | "execution_count": null, 144 | "metadata": { 145 | "collapsed": true 146 | }, 147 | "outputs": [], 148 | "source": [ 149 | "import fibonacci\n", 150 | "help(fibonacci)" 151 | ] 152 | }, 153 | { 154 | "cell_type": "markdown", 155 | "metadata": {}, 156 | "source": [ 157 | "Abran la consola de `Anaconda prompt` o un terminal, y ejecuten la siguiente instrucción\n", 158 | "\n", 159 | " python fibonacci.py 100" 160 | ] 161 | }, 162 | { 163 | "cell_type": "markdown", 164 | "metadata": {}, 165 | "source": [ 166 | "---\n", 167 | "\n", 168 | "# Ejercicios\n", 169 | "\n", 170 | "Realice los siguientes ejercicios. En caso de tener dudas, puede apoyarse con sus compañeros, preguntarle al profesor y hacer búsquedas en internet.\n", 171 | "\n", 172 | "1. Cree un módulo que se llame perro.py y que contenga la definición de la clase Perro que vimos en el tutotial **01_Sobrecarga_de_operadores**. Luego ejecute la expresión `import perro` desde una celda del Jupyter notebook y cree dos objetos de la clase Perro que tengan diferentes valores de sus atributos.

\n", 173 | "\n", 174 | "2. Cree un script de Python llamado crear_fibonacci.py que reciba múltiples argumentos y que imprima en pantalla la serie de Fibonacci para cada uno de estos argumentos. Use como base lo visto al comienzo de este notebook. Una vez creado este script, lámelo desde `Anaconda prompt` con lo siguientes 3 argumentos\n", 175 | "\n", 176 | "```python\n", 177 | "python crear_fibonacci.py 50 100 100\n", 178 | "```\n" 179 | ] 180 | }, 181 | { 182 | "cell_type": "code", 183 | "execution_count": null, 184 | "metadata": { 185 | "collapsed": true 186 | }, 187 | "outputs": [], 188 | "source": [] 189 | } 190 | ], 191 | "metadata": { 192 | "kernelspec": { 193 | "display_name": "Python 3", 194 | "language": "python", 195 | "name": "python3" 196 | }, 197 | "language_info": { 198 | "codemirror_mode": { 199 | "name": "ipython", 200 | "version": 3 201 | }, 202 | "file_extension": ".py", 203 | "mimetype": "text/x-python", 204 | "name": "python", 205 | "nbconvert_exporter": "python", 206 | "pygments_lexer": "ipython3", 207 | "version": "3.6.4" 208 | } 209 | }, 210 | "nbformat": 4, 211 | "nbformat_minor": 2 212 | } 213 | -------------------------------------------------------------------------------- /tutoriales/11_Introduccion_a_Numpy.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# Introducción a Numpy\n", 8 | "\n", 9 | "**Autor:** Roberto Muñoz
\n", 10 | "**E-mail:**
\n", 11 | "**Github:**
\n", 12 | "\n", 13 | "Uno de los módulos más importantes de Python es **[Numpy](http://www.numpy.org/)**. El origen de Numpy se debe principalmente al diseñador de software Jim Hugunin quien diseñó el módulo Numeric para dotar a Python de capacidades de cálculo similares a las de otros softwares como MATLAB. Posteriormente, mejoró Numeric incorporando nuevas funcionalidades naciendo lo que hoy conocemos como Numpy.\n", 14 | "\n", 15 | "Numpy es el encargado de añadir toda la capacidad matemática y vectorial a Python haciendo posible operar con cualquier dato numérico o array (posteriormente veremos qué es un array). Incorpora operaciones tan básicas como la suma o la multiplicación u otras mucho más complejas como la transformada de Fourier o el álgebra lineal. Además incorpora herramientas que nos permiten incorporar código fuente de otros lenguajes de programación como C/C++ o Fortran lo que incrementa notablemente su compatibilidad e implementación.\n" 16 | ] 17 | }, 18 | { 19 | "cell_type": "markdown", 20 | "metadata": {}, 21 | "source": [ 22 | "## ¿Porqué usar Numpy?\n", 23 | "\n", 24 | "En múltiples ocasiones necesitamos hacer operaciones numéricas sobre datos provenientes de archivos Excel o Bases de datos que contienen múltiples campos (columnas) y múltiples registros (filas).\n", 25 | "\n", 26 | "Vimos que en Python existen las listas, tuplas y diccionarios, las cuales son de gran ayuda para almacenar y adminsitrar datos. Veamos qué sucede cuando queremos sumar los elementos almacenados en dos listas." 27 | ] 28 | }, 29 | { 30 | "cell_type": "code", 31 | "execution_count": null, 32 | "metadata": {}, 33 | "outputs": [], 34 | "source": [ 35 | "x=[1,2,3,4]\n", 36 | "y=[5,6,7,8]\n", 37 | "print(x+y)" 38 | ] 39 | }, 40 | { 41 | "cell_type": "markdown", 42 | "metadata": {}, 43 | "source": [ 44 | "Como podemos notar, el operador + simplemente concatena las dos listas.\n", 45 | "¿Alguien sugiere como podriamos sumar los elmentos de las dos listas, elemento por elemento?" 46 | ] 47 | }, 48 | { 49 | "cell_type": "code", 50 | "execution_count": null, 51 | "metadata": {}, 52 | "outputs": [], 53 | "source": [ 54 | "res=[]\n", 55 | "for i in range(4):\n", 56 | " res.append(x[i]+y[i])\n", 57 | " \n", 58 | "print(res)" 59 | ] 60 | }, 61 | { 62 | "cell_type": "markdown", 63 | "metadata": {}, 64 | "source": [ 65 | "## Cómo importar el paquete Numpy\n", 66 | "\n", 67 | "Partimos importando el paquete numpy usando la función import. En este caso usaremos el alias np para referirnos de manera más abreviada a las clases y métodos implementados en numpy." 68 | ] 69 | }, 70 | { 71 | "cell_type": "code", 72 | "execution_count": null, 73 | "metadata": { 74 | "collapsed": true 75 | }, 76 | "outputs": [], 77 | "source": [ 78 | "import numpy" 79 | ] 80 | }, 81 | { 82 | "cell_type": "code", 83 | "execution_count": null, 84 | "metadata": {}, 85 | "outputs": [], 86 | "source": [ 87 | "import numpy as np\n", 88 | "print(np.__version__)" 89 | ] 90 | }, 91 | { 92 | "cell_type": "code", 93 | "execution_count": null, 94 | "metadata": {}, 95 | "outputs": [], 96 | "source": [ 97 | "help(np)" 98 | ] 99 | }, 100 | { 101 | "cell_type": "markdown", 102 | "metadata": {}, 103 | "source": [ 104 | "## Definición de arreglos en Numpy" 105 | ] 106 | }, 107 | { 108 | "cell_type": "code", 109 | "execution_count": null, 110 | "metadata": {}, 111 | "outputs": [], 112 | "source": [ 113 | "x= np.array([1,2,3])\n", 114 | "x" 115 | ] 116 | }, 117 | { 118 | "cell_type": "code", 119 | "execution_count": null, 120 | "metadata": {}, 121 | "outputs": [], 122 | "source": [ 123 | "# Definir un arreglo 2D\n", 124 | "\n", 125 | "x = np.array([[1,2,3,4],[5,6,7,8]])\n", 126 | "\n", 127 | "print(x)\n", 128 | "print('type(x): ', type(x))\n", 129 | "print('x.dtype: ', x.dtype)\n", 130 | "print('x.size: ', x.size)\n", 131 | "print('x.shape: ', x.shape)" 132 | ] 133 | }, 134 | { 135 | "cell_type": "code", 136 | "execution_count": null, 137 | "metadata": {}, 138 | "outputs": [], 139 | "source": [ 140 | "# Definir un arreglo 1D como tipo de dato de punto flotante\n", 141 | "\n", 142 | "x = np.array([1,2,3,4], dtype=np.float32)\n", 143 | "print(x)\n", 144 | "print('type(x): ', type(x))\n", 145 | "print('x.dtype: ', x.dtype)\n", 146 | "print('x.size: ', x.size)\n", 147 | "print('x.shape: ', x.shape)" 148 | ] 149 | }, 150 | { 151 | "cell_type": "code", 152 | "execution_count": null, 153 | "metadata": {}, 154 | "outputs": [], 155 | "source": [ 156 | "# Sumar los arreglos x e y\n", 157 | "x = np.array([1,2,3,4], dtype=np.float32)\n", 158 | "y = np.array([5,6,7,8])\n", 159 | "\n", 160 | "print('x: ', x)\n", 161 | "print('y: ', y)\n", 162 | "print('Suma: ', x+y)" 163 | ] 164 | }, 165 | { 166 | "cell_type": "code", 167 | "execution_count": null, 168 | "metadata": {}, 169 | "outputs": [], 170 | "source": [ 171 | "x+10" 172 | ] 173 | }, 174 | { 175 | "cell_type": "code", 176 | "execution_count": null, 177 | "metadata": {}, 178 | "outputs": [], 179 | "source": [ 180 | "x = np.array([[1,2,3,4],[5,6,7,8]])\n", 181 | "y = np.array([5,6,7,8])\n", 182 | "x*y" 183 | ] 184 | }, 185 | { 186 | "cell_type": "code", 187 | "execution_count": null, 188 | "metadata": {}, 189 | "outputs": [], 190 | "source": [ 191 | "# Definir un arreglo 2D\n", 192 | "\n", 193 | "x= np.array([[[1,2,3,4],[5,6,7,8]]])\n", 194 | "print(x)\n", 195 | "print(type(x))\n", 196 | "print(x.size)\n", 197 | "print(x.shape)" 198 | ] 199 | }, 200 | { 201 | "cell_type": "code", 202 | "execution_count": null, 203 | "metadata": { 204 | "collapsed": true 205 | }, 206 | "outputs": [], 207 | "source": [ 208 | "x[0:2,0:3]" 209 | ] 210 | }, 211 | { 212 | "cell_type": "markdown", 213 | "metadata": {}, 214 | "source": [ 215 | "**See Figure 1 for an illustration of indexing on a 2D array.**
\n", 216 | "" 217 | ] 218 | }, 219 | { 220 | "cell_type": "code", 221 | "execution_count": null, 222 | "metadata": {}, 223 | "outputs": [], 224 | "source": [ 225 | "# Inicializar un arreglo 1D y otro 2D con ceros. Notar que usamos Y por X\n", 226 | "\n", 227 | "x=np.zeros(10)\n", 228 | "print('x: ', x)\n", 229 | "\n", 230 | "y=np.zeros([2,4])\n", 231 | "print('y:', y)" 232 | ] 233 | }, 234 | { 235 | "cell_type": "code", 236 | "execution_count": null, 237 | "metadata": {}, 238 | "outputs": [], 239 | "source": [ 240 | "# Crear un arreglo usando valores aleatorios entre 0 y 1\n", 241 | "\n", 242 | "x=np.random.random(100)\n", 243 | "print(x)" 244 | ] 245 | }, 246 | { 247 | "cell_type": "code", 248 | "execution_count": null, 249 | "metadata": {}, 250 | "outputs": [], 251 | "source": [ 252 | "# Extraer valores de un arreglo Numpy usando indices\n", 253 | "\n", 254 | "x= np.array([[1,2,3,4],\n", 255 | " [5,6,7,8],\n", 256 | " [9,10,11,12]])\n", 257 | "print(x)\n", 258 | "\n", 259 | "print('\\nx[0,3]: ', x[0,3])\n", 260 | "\n", 261 | "print('\\nx[:,0]: ', x[:,0])\n", 262 | "print('\\nx[0,:]: ', x[0,:])" 263 | ] 264 | }, 265 | { 266 | "cell_type": "code", 267 | "execution_count": null, 268 | "metadata": {}, 269 | "outputs": [], 270 | "source": [ 271 | "# Numpy permite crear máscaras fácilmente usando condiciones booleanas\n", 272 | "\n", 273 | "a=x>6\n", 274 | "print(a)" 275 | ] 276 | }, 277 | { 278 | "cell_type": "code", 279 | "execution_count": null, 280 | "metadata": {}, 281 | "outputs": [], 282 | "source": [ 283 | "# Extraer los valores de x que satisfacen la condición booleana. Para ello usamos la máscara\n", 284 | "\n", 285 | "print(x[a])" 286 | ] 287 | }, 288 | { 289 | "cell_type": "code", 290 | "execution_count": null, 291 | "metadata": {}, 292 | "outputs": [], 293 | "source": [ 294 | "y = filter(lambda n: n>6, x)\n", 295 | "list(y)" 296 | ] 297 | }, 298 | { 299 | "cell_type": "code", 300 | "execution_count": null, 301 | "metadata": {}, 302 | "outputs": [], 303 | "source": [ 304 | "x[x>6]" 305 | ] 306 | }, 307 | { 308 | "cell_type": "code", 309 | "execution_count": null, 310 | "metadata": { 311 | "collapsed": true 312 | }, 313 | "outputs": [], 314 | "source": [] 315 | }, 316 | { 317 | "cell_type": "markdown", 318 | "metadata": {}, 319 | "source": [ 320 | "**See Figure 2 for an illustration of boolean indexing on a 2D array.**
\n", 321 | "" 322 | ] 323 | }, 324 | { 325 | "cell_type": "code", 326 | "execution_count": null, 327 | "metadata": {}, 328 | "outputs": [], 329 | "source": [ 330 | "x.shape" 331 | ] 332 | }, 333 | { 334 | "cell_type": "code", 335 | "execution_count": null, 336 | "metadata": {}, 337 | "outputs": [], 338 | "source": [ 339 | "x" 340 | ] 341 | }, 342 | { 343 | "cell_type": "code", 344 | "execution_count": null, 345 | "metadata": {}, 346 | "outputs": [], 347 | "source": [ 348 | "# Sumar los valores de un arreglo 2D a lo largo del eje Y (columnas)\n", 349 | "\n", 350 | "np.sum(x, axis=0)" 351 | ] 352 | }, 353 | { 354 | "cell_type": "code", 355 | "execution_count": null, 356 | "metadata": {}, 357 | "outputs": [], 358 | "source": [ 359 | "# Sumar los valores de un arrego 2D a lo largo del eje X (filas)\n", 360 | "\n", 361 | "np.sum(x, axis=1)" 362 | ] 363 | }, 364 | { 365 | "cell_type": "code", 366 | "execution_count": null, 367 | "metadata": {}, 368 | "outputs": [], 369 | "source": [ 370 | "# Crear la transpuesta de la matriz x\n", 371 | "\n", 372 | "y= x.T\n", 373 | "print(y, y.shape)\n" 374 | ] 375 | }, 376 | { 377 | "cell_type": "markdown", 378 | "metadata": {}, 379 | "source": [ 380 | "## Funciones matemáticas" 381 | ] 382 | }, 383 | { 384 | "cell_type": "code", 385 | "execution_count": null, 386 | "metadata": {}, 387 | "outputs": [], 388 | "source": [ 389 | "x=np.random.random(10)\n", 390 | "#print(x)\n", 391 | "print('Mean: ', np.mean(x))\n", 392 | "print('StdDev: ', np.std(x))" 393 | ] 394 | }, 395 | { 396 | "cell_type": "code", 397 | "execution_count": null, 398 | "metadata": {}, 399 | "outputs": [], 400 | "source": [ 401 | "x=np.random.random(1000)\n", 402 | "#print(x)\n", 403 | "print('Mean: ', np.mean(x))\n", 404 | "print('StdDev: ', np.std(x))" 405 | ] 406 | }, 407 | { 408 | "cell_type": "code", 409 | "execution_count": null, 410 | "metadata": {}, 411 | "outputs": [], 412 | "source": [ 413 | "x=np.random.randn(10000)\n", 414 | "print('Mean: ', np.mean(x))\n", 415 | "print('StdDev: ', np.std(x))" 416 | ] 417 | }, 418 | { 419 | "cell_type": "code", 420 | "execution_count": null, 421 | "metadata": { 422 | "collapsed": true 423 | }, 424 | "outputs": [], 425 | "source": [ 426 | "# También es posible importar algunas funciones directamente desde las librerías\n", 427 | "# Para ello usamos la sintaxis from import \n", 428 | "\n", 429 | "from numpy.random import random" 430 | ] 431 | }, 432 | { 433 | "cell_type": "code", 434 | "execution_count": null, 435 | "metadata": {}, 436 | "outputs": [], 437 | "source": [ 438 | "random(100)" 439 | ] 440 | }, 441 | { 442 | "cell_type": "code", 443 | "execution_count": null, 444 | "metadata": {}, 445 | "outputs": [], 446 | "source": [ 447 | "x=range(0,10)\n", 448 | "list(x)" 449 | ] 450 | }, 451 | { 452 | "cell_type": "code", 453 | "execution_count": null, 454 | "metadata": {}, 455 | "outputs": [], 456 | "source": [ 457 | "# Crear un arreglo de enteros que comience en 0 y termine en 10 (no incluído)\n", 458 | "\n", 459 | "x=np.arange(0,10)\n", 460 | "print(x)" 461 | ] 462 | }, 463 | { 464 | "cell_type": "code", 465 | "execution_count": null, 466 | "metadata": {}, 467 | "outputs": [], 468 | "source": [ 469 | "# Crear un arreglo de punto flotante que comience en 0 y termine en 10, con paso de 0.5\n", 470 | "\n", 471 | "x=np.arange(0,10,0.5, dtype=np.float64)\n", 472 | "print(x)\n", 473 | "print(x.dtype)" 474 | ] 475 | }, 476 | { 477 | "cell_type": "code", 478 | "execution_count": null, 479 | "metadata": { 480 | "scrolled": false 481 | }, 482 | "outputs": [], 483 | "source": [ 484 | "# Usar funciones trigonométricas\n", 485 | "# Numpy contiene una serie de constantes matemáticas. Usaremos Pi\n", 486 | "\n", 487 | "y=np.sin(x*np.pi)\n", 488 | "print(y)" 489 | ] 490 | }, 491 | { 492 | "cell_type": "code", 493 | "execution_count": null, 494 | "metadata": {}, 495 | "outputs": [], 496 | "source": [ 497 | "# Usar funciones como potencia\n", 498 | "\n", 499 | "y=np.power(x,2) # elevar cada elemento del arreglo x, a la segunda potencia\n", 500 | "print(y)" 501 | ] 502 | }, 503 | { 504 | "cell_type": "code", 505 | "execution_count": null, 506 | "metadata": {}, 507 | "outputs": [], 508 | "source": [ 509 | "# Usar funciones como raíz cuadrada\n", 510 | "\n", 511 | "y=np.sqrt(x) # raíz de a, del inglés \"square root\"\n", 512 | "print(y)" 513 | ] 514 | }, 515 | { 516 | "cell_type": "code", 517 | "execution_count": null, 518 | "metadata": { 519 | "collapsed": true 520 | }, 521 | "outputs": [], 522 | "source": [ 523 | "from numpy import *" 524 | ] 525 | }, 526 | { 527 | "cell_type": "code", 528 | "execution_count": null, 529 | "metadata": {}, 530 | "outputs": [], 531 | "source": [ 532 | "sqrt(x)" 533 | ] 534 | }, 535 | { 536 | "cell_type": "markdown", 537 | "metadata": {}, 538 | "source": [ 539 | "Escribir *np.sqrt(x)* es mucho más breve que la alternativa de usar funciones nativas de Python: Calcular una a una las raíces cuadradas de cada elemento de *x*." 540 | ] 541 | }, 542 | { 543 | "cell_type": "code", 544 | "execution_count": null, 545 | "metadata": {}, 546 | "outputs": [], 547 | "source": [ 548 | "result = []\n", 549 | "for el in x:\n", 550 | " result.append(el**0.5)\n", 551 | "\n", 552 | "print(\"\\nUsando Python built-in: \", result)\n", 553 | "print(\"\\nUsando Numpy: \", y)" 554 | ] 555 | }, 556 | { 557 | "cell_type": "markdown", 558 | "metadata": { 559 | "collapsed": true 560 | }, 561 | "source": [ 562 | "---\n", 563 | "\n", 564 | "# Ejercicios\n", 565 | "\n", 566 | "Realice los siguientes ejercicios. En caso de tener dudas, puede apoyarse con sus compañeros, preguntarle al profesor y hacer búsquedas en internet.\n", 567 | "\n", 568 | "1. Cree una matriz de 7 columnas por 9 filas. Las primeras 3 columnas de la matriz tienen que tener el valor 0. La cuarta columna debe tener el valor 0.5, excepto por el último valor de esa columna, que tiene que ser 0.7. Las otras tres columnas deben tener el valor 1.\n", 569 | "\n", 570 | " Imprima la matriz y calcule las suma de los elementos de la última fila" 571 | ] 572 | }, 573 | { 574 | "cell_type": "code", 575 | "execution_count": null, 576 | "metadata": { 577 | "collapsed": true 578 | }, 579 | "outputs": [], 580 | "source": [] 581 | }, 582 | { 583 | "cell_type": "markdown", 584 | "metadata": {}, 585 | "source": [ 586 | "2. La siguienteinstrucción crea una matriz aleatoria de 5 por 5 con valores entre 0 y 1\n", 587 | " `matriz_aleatoria=np.random.rand(5,5)` \n", 588 | "\n", 589 | " Imprima las posiciones (Fila y columna) de los elementos de la matriz que son mayores que 0.5" 590 | ] 591 | }, 592 | { 593 | "cell_type": "code", 594 | "execution_count": null, 595 | "metadata": { 596 | "collapsed": true 597 | }, 598 | "outputs": [], 599 | "source": [ 600 | "matriz_aleatoria=np.random.rand(5,5)\n", 601 | "print(matriz_aleatoria)" 602 | ] 603 | }, 604 | { 605 | "cell_type": "code", 606 | "execution_count": null, 607 | "metadata": { 608 | "collapsed": true 609 | }, 610 | "outputs": [], 611 | "source": [] 612 | } 613 | ], 614 | "metadata": { 615 | "kernelspec": { 616 | "display_name": "Python 3", 617 | "language": "python", 618 | "name": "python3" 619 | }, 620 | "language_info": { 621 | "codemirror_mode": { 622 | "name": "ipython", 623 | "version": 3 624 | }, 625 | "file_extension": ".py", 626 | "mimetype": "text/x-python", 627 | "name": "python", 628 | "nbconvert_exporter": "python", 629 | "pygments_lexer": "ipython3", 630 | "version": "3.6.4" 631 | } 632 | }, 633 | "nbformat": 4, 634 | "nbformat_minor": 2 635 | } 636 | -------------------------------------------------------------------------------- /tutoriales/12_Introduccion_a_Matplotlib.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# Introducción a Matplotlib\n", 8 | "\n", 9 | "**Autor:** Roberto Muñoz
\n", 10 | "**E-mail:**
\n", 11 | "**Github:**
\n", 12 | "\n", 13 | "[Matplotlib](http://matplotlib.org/) es el módulo de dibujo de gráficas 2D y 3D que vamos a utilizar aunque no es el único existente. Matplotlib tiene multitud de librerías de las cuales nosotros, por semejanza a Matlab, utilizaremos pyplot.\n", 14 | "\n", 15 | "En el sitio web http://matplotlib.org/ se pueden encontrar multitud de programas y ejemplos de como hacer dibujos con Matplotlib." 16 | ] 17 | }, 18 | { 19 | "cell_type": "markdown", 20 | "metadata": {}, 21 | "source": [ 22 | "## Cómo importar el paquete Matplotlib\n", 23 | "\n", 24 | "Partimos importando el paquete matplotlib usando la función import. En este curso usaremos matplotlib.pyplot, la cual es una colección de funciones tipo comandos que permiten que matplotlib funcione de manera similar a como se hacen gráficos en MATLAB." 25 | ] 26 | }, 27 | { 28 | "cell_type": "code", 29 | "execution_count": null, 30 | "metadata": { 31 | "collapsed": true 32 | }, 33 | "outputs": [], 34 | "source": [ 35 | "# La manera estándar es importar matplotlib directamente\n", 36 | "\n", 37 | "import matplotlib" 38 | ] 39 | }, 40 | { 41 | "cell_type": "code", 42 | "execution_count": null, 43 | "metadata": { 44 | "collapsed": true 45 | }, 46 | "outputs": [], 47 | "source": [ 48 | "# En este caso usaremos el alias plt para referirnos de manera más abreviada a matplot.pyplot\n", 49 | "\n", 50 | "import numpy as np\n", 51 | "import matplotlib.pyplot as plt\n", 52 | "\n", 53 | "%matplotlib inline" 54 | ] 55 | }, 56 | { 57 | "cell_type": "markdown", 58 | "metadata": {}, 59 | "source": [ 60 | "Partamos haciendo un gráfico sencillo. Generemos una variable x que contenga 100 número de punto flotante entre los valores 0 y 2." 61 | ] 62 | }, 63 | { 64 | "cell_type": "markdown", 65 | "metadata": {}, 66 | "source": [ 67 | "## Crear gráficos de líneas" 68 | ] 69 | }, 70 | { 71 | "cell_type": "code", 72 | "execution_count": null, 73 | "metadata": {}, 74 | "outputs": [], 75 | "source": [ 76 | "x = np.linspace(0, 2, 100)\n", 77 | "print(x)" 78 | ] 79 | }, 80 | { 81 | "cell_type": "code", 82 | "execution_count": null, 83 | "metadata": {}, 84 | "outputs": [], 85 | "source": [ 86 | "plt.plot(x)" 87 | ] 88 | }, 89 | { 90 | "cell_type": "code", 91 | "execution_count": null, 92 | "metadata": {}, 93 | "outputs": [], 94 | "source": [ 95 | "x = np.linspace(0, 2, 100)\n", 96 | "y = np.sin(x*np.pi)\n", 97 | "\n", 98 | "plt.plot(x,y)" 99 | ] 100 | }, 101 | { 102 | "cell_type": "code", 103 | "execution_count": null, 104 | "metadata": {}, 105 | "outputs": [], 106 | "source": [ 107 | "plt.plot(y)" 108 | ] 109 | }, 110 | { 111 | "cell_type": "markdown", 112 | "metadata": {}, 113 | "source": [ 114 | "Uso de subplots() para multiplés gráficos por figura" 115 | ] 116 | }, 117 | { 118 | "cell_type": "code", 119 | "execution_count": null, 120 | "metadata": {}, 121 | "outputs": [], 122 | "source": [ 123 | "figure, ax = plt.subplots(2, 2)\n", 124 | "print(ax)\n", 125 | "print(figure)" 126 | ] 127 | }, 128 | { 129 | "cell_type": "code", 130 | "execution_count": null, 131 | "metadata": {}, 132 | "outputs": [], 133 | "source": [ 134 | "ax[1]" 135 | ] 136 | }, 137 | { 138 | "cell_type": "code", 139 | "execution_count": null, 140 | "metadata": {}, 141 | "outputs": [], 142 | "source": [ 143 | "# Go ahead and explicitly create a figure and an axes\n", 144 | "fig, ax = plt.subplots(1, 1, figsize=(5,3))\n", 145 | "\n", 146 | "# Plot our x variable on the x-axis and x^2 on the y-axis\n", 147 | "ax.plot(x, x**2, c='red')\n", 148 | "ax.plot(x, x**3, c='blue')\n", 149 | "plt.xlabel(\"Distancia\")\n", 150 | "plt.ylabel(\"Velocidad\")\n", 151 | "\n", 152 | "ax.set_xlim(0,10)" 153 | ] 154 | }, 155 | { 156 | "cell_type": "code", 157 | "execution_count": null, 158 | "metadata": {}, 159 | "outputs": [], 160 | "source": [ 161 | "plt.plot(x,x**2)\n", 162 | "plt.xlim(0,10)" 163 | ] 164 | }, 165 | { 166 | "cell_type": "markdown", 167 | "metadata": {}, 168 | "source": [ 169 | "Como pueden notar, el gráfico fue creado y almacenado como un objeto del tipo Line2D. Para poder visualizar el gráfico debemos ejecutar el siguiente comando." 170 | ] 171 | }, 172 | { 173 | "cell_type": "code", 174 | "execution_count": null, 175 | "metadata": { 176 | "collapsed": true 177 | }, 178 | "outputs": [], 179 | "source": [ 180 | "plt.show()" 181 | ] 182 | }, 183 | { 184 | "cell_type": "markdown", 185 | "metadata": {}, 186 | "source": [ 187 | "Para graficar directamente en el notebook y evitar tener que llarma plot.show() cada vez, ejecutamos la siguiente línea." 188 | ] 189 | }, 190 | { 191 | "cell_type": "code", 192 | "execution_count": null, 193 | "metadata": { 194 | "collapsed": true 195 | }, 196 | "outputs": [], 197 | "source": [ 198 | "%matplotlib inline" 199 | ] 200 | }, 201 | { 202 | "cell_type": "code", 203 | "execution_count": null, 204 | "metadata": {}, 205 | "outputs": [], 206 | "source": [ 207 | "# Add some labels to the plot\n", 208 | "\n", 209 | "plt.plot(x,x**2)\n", 210 | "plt.xlabel('x')\n", 211 | "plt.ylabel('x^2')\n", 212 | "\n", 213 | "fig, ax = plt.subplots(1, 1, figsize=(5,3))\n", 214 | "ax.plot(x, x**2, c='red')\n", 215 | "ax.set_xlabel('x')\n", 216 | "ax.set_ylabel('x^2')\n", 217 | "\n", 218 | "# Needed to reuse and see the updated plot while using inline\n", 219 | "#display(fig)" 220 | ] 221 | }, 222 | { 223 | "cell_type": "code", 224 | "execution_count": null, 225 | "metadata": {}, 226 | "outputs": [], 227 | "source": [ 228 | "display(fig)" 229 | ] 230 | }, 231 | { 232 | "cell_type": "code", 233 | "execution_count": null, 234 | "metadata": { 235 | "slideshow": { 236 | "slide_type": "subslide" 237 | } 238 | }, 239 | "outputs": [], 240 | "source": [ 241 | "# Let's add a title with a bit of latex syntax\n", 242 | "ax.set_title('$y = x^2$', fontdict={'size':22})\n", 243 | "\n", 244 | "display(fig)" 245 | ] 246 | }, 247 | { 248 | "cell_type": "markdown", 249 | "metadata": {}, 250 | "source": [ 251 | "## Hacer varios gráficos en la misma figura" 252 | ] 253 | }, 254 | { 255 | "cell_type": "code", 256 | "execution_count": null, 257 | "metadata": { 258 | "scrolled": false, 259 | "slideshow": { 260 | "slide_type": "subslide" 261 | } 262 | }, 263 | "outputs": [], 264 | "source": [ 265 | "fig, ax = plt.subplots(1, 1)\n", 266 | "\n", 267 | "# Plot a set of different polynomials.\n", 268 | "# The label argument is used when generating a legend.\n", 269 | "ax.plot(x, x, label='$x$')\n", 270 | "ax.plot(x, x * x, label='$x^2$')\n", 271 | "ax.plot(x, x**3, label='$x^3$')\n", 272 | "\n", 273 | "# Add labels and title\n", 274 | "ax.set_xlabel('x')\n", 275 | "ax.set_ylabel('f(x)')\n", 276 | "ax.set_title('Polynomials')\n", 277 | "\n", 278 | "# Add gridlines\n", 279 | "ax.grid(True)\n", 280 | "\n", 281 | "# Add a legend to the upper left corner of the plot\n", 282 | "ax.legend(loc='lower left')" 283 | ] 284 | }, 285 | { 286 | "cell_type": "markdown", 287 | "metadata": {}, 288 | "source": [ 289 | "## También es posible cambiar el tipo de línea" 290 | ] 291 | }, 292 | { 293 | "cell_type": "code", 294 | "execution_count": null, 295 | "metadata": { 296 | "collapsed": true 297 | }, 298 | "outputs": [], 299 | "source": [ 300 | "help(plt.subplots)" 301 | ] 302 | }, 303 | { 304 | "cell_type": "code", 305 | "execution_count": null, 306 | "metadata": {}, 307 | "outputs": [], 308 | "source": [ 309 | "fig, ax = plt.subplots(1, 3, figsize=(15,8))\n", 310 | "\n", 311 | "# Plot a set of different polynomials.\n", 312 | "# The label argument is used when generating a legend.\n", 313 | "ax[0].plot(x, x, '-', label='$x$', c='blue')\n", 314 | "ax[1].plot(x, x * x, '--', label='$x^2$')\n", 315 | "ax[2].plot(x, x**3, '.', label='$x^3$')\n", 316 | "\n", 317 | "# Add labels and title\n", 318 | "for i in range(3):\n", 319 | " ax[i].set_xlabel('x')\n", 320 | " ax[i].set_ylabel('f(x)')\n", 321 | " ax[i].set_title('Polynomials')\n", 322 | "\n", 323 | " # Add gridlines\n", 324 | " ax[i].grid(True)\n", 325 | "\n", 326 | " # Add a legend to the upper left corner of the plot\n", 327 | " ax[i].legend(loc='upper left')" 328 | ] 329 | }, 330 | { 331 | "cell_type": "code", 332 | "execution_count": null, 333 | "metadata": { 334 | "collapsed": true 335 | }, 336 | "outputs": [], 337 | "source": [ 338 | "# El método savefig() nos permite guardar el gráfico como un archivo en el computador\n", 339 | "\n", 340 | "fig.savefig('figures/grafico1.pdf')" 341 | ] 342 | }, 343 | { 344 | "cell_type": "code", 345 | "execution_count": null, 346 | "metadata": { 347 | "collapsed": true 348 | }, 349 | "outputs": [], 350 | "source": [ 351 | "# La extensión del nombre archivo determina el formato en que será guardado el gráfico\n", 352 | "\n", 353 | "fig.savefig('figures/grafico1.png')" 354 | ] 355 | }, 356 | { 357 | "cell_type": "markdown", 358 | "metadata": {}, 359 | "source": [ 360 | "# Ejercicio 1\n", 361 | "\n", 362 | "Realice los siguientes ejercicios. En caso de tener dudas, puede apoyarse con sus compañeros, preguntarle al profesor y hacer búsquedas en internet.\n" 363 | ] 364 | }, 365 | { 366 | "cell_type": "markdown", 367 | "metadata": { 368 | "collapsed": true 369 | }, 370 | "source": [ 371 | "1. Defina una arreglo 1D llamado x que vaya entre los valores 0 y 2*np.pi. Use al menos 100 puntos intermedios entre este rango de valores.\n", 372 | "2. Use la variable x antes definida para generar una figura con los siguientes 3 gráficos. Para el primer gráfico use la función np.sin(x), para el segundo la función np.exp() y para el tercero la función np.sqrt(). Use un color distinto para cada gráfico.\n", 373 | "3. Agregue etiquetas a los ejes X e Y, y también un título al gráfico" 374 | ] 375 | }, 376 | { 377 | "cell_type": "code", 378 | "execution_count": null, 379 | "metadata": { 380 | "collapsed": true 381 | }, 382 | "outputs": [], 383 | "source": [] 384 | }, 385 | { 386 | "cell_type": "markdown", 387 | "metadata": {}, 388 | "source": [ 389 | "## Ejercicio 2\n", 390 | "\n", 391 | "A continuación, están definidos dos arreglos que contienen información de los ocho planetas del Sistema Solar, desde Mercurio, hasta Neptuno, además de incluir información de Plutón (ahora considerado planetoide en vez de planeta).\n", 392 | "\n", 393 | "La variable *p* contiene el periodo de cada planeta en años, mientras que la variable *a* contiene el tamaño de la órbita en unidades astronómicas. Con estos datos, usted construirá un gráfico en dos dimensiones, como los de los ejemplos superiores, con los que comprobará experimentalmente la 3era ley de Kepler, cuya forma matemática dice $p = a^k$, con $k$ una constante (no necesariamente entera) que usted debe determinar tras ensayo y error.\n", 394 | "\n", 395 | "Para ello, grafique los arreglos entregados, junto con una curva de la forma $y=x^k$ para distinto valores de $k$, y vea cuál es la que más se acerca. ¿Cuál es el valor de $k$ que usted obtiene?" 396 | ] 397 | }, 398 | { 399 | "cell_type": "code", 400 | "execution_count": null, 401 | "metadata": { 402 | "collapsed": true 403 | }, 404 | "outputs": [], 405 | "source": [ 406 | "# Mediciones del periodo y semieje mayor de los planetas del Sistema Solar\n", 407 | "\n", 408 | "p = np.array([0.214,0.615,1,1.88,11.9,29.4,83.7,163.7,247.9])\n", 409 | "a = np.array([0.387,0.723,1,1.52,5.2,9.58,19.2,30.05,39.48])" 410 | ] 411 | }, 412 | { 413 | "cell_type": "code", 414 | "execution_count": null, 415 | "metadata": { 416 | "collapsed": true 417 | }, 418 | "outputs": [], 419 | "source": [] 420 | }, 421 | { 422 | "cell_type": "code", 423 | "execution_count": null, 424 | "metadata": { 425 | "collapsed": true 426 | }, 427 | "outputs": [], 428 | "source": [] 429 | }, 430 | { 431 | "cell_type": "code", 432 | "execution_count": null, 433 | "metadata": { 434 | "collapsed": true 435 | }, 436 | "outputs": [], 437 | "source": [] 438 | } 439 | ], 440 | "metadata": { 441 | "kernelspec": { 442 | "display_name": "Python 3", 443 | "language": "python", 444 | "name": "python3" 445 | }, 446 | "language_info": { 447 | "codemirror_mode": { 448 | "name": "ipython", 449 | "version": 3 450 | }, 451 | "file_extension": ".py", 452 | "mimetype": "text/x-python", 453 | "name": "python", 454 | "nbconvert_exporter": "python", 455 | "pygments_lexer": "ipython3", 456 | "version": "3.6.4" 457 | } 458 | }, 459 | "nbformat": 4, 460 | "nbformat_minor": 2 461 | } 462 | -------------------------------------------------------------------------------- /tutoriales/13_Introduccion_a_Pandas.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# Introducción a Pandas\n", 8 | "\n", 9 | "**Autor:** Roberto Muñoz
\n", 10 | "**E-mail:**
\n", 11 | "**Github:**
\n", 12 | "\n", 13 | "[Pandas](http://pandas.pydata.org/) es un paquete de Python que proporciona estructuras de datos similares a los dataframes de R. Pandas depende de Numpy, la librería que añade un potente tipo matricial a Python. Los principales tipos de datos que pueden representarse con pandas son:\n", 14 | "\n", 15 | "- Datos tabulares con columnas de tipo heterogéneo con etiquetas en columnas y filas.\n", 16 | "- Series temporales.\n", 17 | "\n", 18 | "Pandas proporciona herramientas que permiten:\n", 19 | "\n", 20 | "- leer y escribir datos en diferentes formatos: CSV, Microsoft Excel, bases SQL y formato HDF5\n", 21 | "- seleccionar y filtrar de manera sencilla tablas de datos en función de posición, valor o etiquetas\n", 22 | "- fusionar y unir datos\n", 23 | "- transformar datos aplicando funciones tanto en global como por ventanas\n", 24 | "- manipulación de series temporales\n", 25 | "- hacer gráficas\n", 26 | "\n", 27 | "En pandas existen tres tipos básicos de objetos todos ellos basados a su vez en Numpy:\n", 28 | "\n", 29 | "- Series (listas, 1D),\n", 30 | "- DataFrame (tablas, 2D) y\n", 31 | "- Panels (tablas 3D)." 32 | ] 33 | }, 34 | { 35 | "cell_type": "code", 36 | "execution_count": null, 37 | "metadata": {}, 38 | "outputs": [], 39 | "source": [ 40 | "import numpy as np\n", 41 | "import pandas as pd\n", 42 | "pd.__version__" 43 | ] 44 | }, 45 | { 46 | "cell_type": "markdown", 47 | "metadata": {}, 48 | "source": [ 49 | "## 1. Series\n", 50 | "\n", 51 | "Una serie (o *Series*) Pandas es un arreglo unidimensional de datos indexados. Puede ser creado desde una lista o arreglo como sigue:" 52 | ] 53 | }, 54 | { 55 | "cell_type": "code", 56 | "execution_count": null, 57 | "metadata": {}, 58 | "outputs": [], 59 | "source": [ 60 | "data = pd.Series([0.25, 0.5, 0.75, 1.0])\n", 61 | "data" 62 | ] 63 | }, 64 | { 65 | "cell_type": "markdown", 66 | "metadata": {}, 67 | "source": [ 68 | "Como vemos en la salida, la Serie contiene una secuencia de valores y una secuencia de índices, las cuales podemos acceder con los atributos `values` y `index`. Los valores son simplemente un familiar arreglo NumPy:" 69 | ] 70 | }, 71 | { 72 | "cell_type": "code", 73 | "execution_count": null, 74 | "metadata": {}, 75 | "outputs": [], 76 | "source": [ 77 | "data.values" 78 | ] 79 | }, 80 | { 81 | "cell_type": "markdown", 82 | "metadata": {}, 83 | "source": [ 84 | "El índice es un objeto tipo arreglo, con su nombre de tipo igual a `pd.Index`, el que discutiremos en más detalle." 85 | ] 86 | }, 87 | { 88 | "cell_type": "code", 89 | "execution_count": null, 90 | "metadata": {}, 91 | "outputs": [], 92 | "source": [ 93 | "data.index" 94 | ] 95 | }, 96 | { 97 | "cell_type": "markdown", 98 | "metadata": {}, 99 | "source": [ 100 | "Al igual que con un arreglo NumPy, los datos pueden ser accedidos por el índice asociado, a través de la notación de brackets o paréntesis cuadrados:" 101 | ] 102 | }, 103 | { 104 | "cell_type": "code", 105 | "execution_count": null, 106 | "metadata": {}, 107 | "outputs": [], 108 | "source": [ 109 | "data[3]" 110 | ] 111 | }, 112 | { 113 | "cell_type": "markdown", 114 | "metadata": {}, 115 | "source": [ 116 | "### Series como un arreglo NumPy generalizado" 117 | ] 118 | }, 119 | { 120 | "cell_type": "markdown", 121 | "metadata": {}, 122 | "source": [ 123 | "De lo que hemos visto hasta ahora, puede parecer que el objeto `Series` es básicamente intercambiable con un arreglo unidimensional NumPy. **La diferencia esencial es la presencia del índice**: mientras que el arreglo NumPy tiene un índice entero implícitamente definido, usado para acceder a los valores, la serie Pandas tiene un índice explícitamente definido con los valores." 124 | ] 125 | }, 126 | { 127 | "cell_type": "code", 128 | "execution_count": null, 129 | "metadata": {}, 130 | "outputs": [], 131 | "source": [ 132 | "data = pd.Series([0.25, 0.5, 0.75, 1.0],\n", 133 | " index=['2018-02-01', '2018-02-02', 'c', 'd'])\n", 134 | "data" 135 | ] 136 | }, 137 | { 138 | "cell_type": "markdown", 139 | "metadata": {}, 140 | "source": [ 141 | "Y el acceso a los ítemes funciona como es esperado:" 142 | ] 143 | }, 144 | { 145 | "cell_type": "code", 146 | "execution_count": null, 147 | "metadata": {}, 148 | "outputs": [], 149 | "source": [ 150 | "data['b']" 151 | ] 152 | }, 153 | { 154 | "cell_type": "markdown", 155 | "metadata": {}, 156 | "source": [ 157 | "### Series como diccionario especializado\n", 158 | "\n", 159 | "In this way, you can think of a Pandas Series a bit like a specialization of a Python dictionary. A dictionary is a structure that maps arbitrary keys to a set of arbitrary values, and a Series is a structure which maps typed keys to a set of typed values. This typing is important: just as the type-specific compiled code behind a NumPy array makes it more efficient than a Python list for certain operations, the type information of a Pandas Series makes it much more efficient than Python dictionaries for certain operations.\n", 160 | "\n", 161 | "De esta manera, se puede pensar en una `Series`Pandas un poco como una especialización de un diccionario Python. Un diccionario es una estructira que mapea llaves arbitrarias a un conjunto de valores arbitrarios, y una serie es una estructura que mapea llaves tipadas a un conjunto de valores tipados. Este tipado (la exigencia de un tipo definido de dato) es importante: así como el código específico de tipos compilado detrás de un arreglo Numpy lo hace más eficiente que una lista Python para ciertas operaciones, la información de tipo de datos de una serie Pandas la hace mucho más eficiente que los diccionarios Python para ciertas operaciones." 162 | ] 163 | }, 164 | { 165 | "cell_type": "code", 166 | "execution_count": null, 167 | "metadata": {}, 168 | "outputs": [], 169 | "source": [ 170 | "population_dict = {'Arica y Parinacota': 243149,\n", 171 | " 'Antofagasta': 631875,\n", 172 | " 'Metropolitana de Santiago': 7399042,\n", 173 | " 'Valparaiso': 1842880,\n", 174 | " 'Bíobío': 2127902,\n", 175 | " 'Magallanes y Antártica Chilena': 165547}\n", 176 | "population = pd.Series(population_dict)\n", 177 | "population" 178 | ] 179 | }, 180 | { 181 | "cell_type": "markdown", 182 | "metadata": {}, 183 | "source": [ 184 | "You can notice the indexes were sorted lexicographically. That's the default behaviour in Pandas" 185 | ] 186 | }, 187 | { 188 | "cell_type": "code", 189 | "execution_count": null, 190 | "metadata": {}, 191 | "outputs": [], 192 | "source": [ 193 | "population['Arica y Parinacota']" 194 | ] 195 | }, 196 | { 197 | "cell_type": "markdown", 198 | "metadata": {}, 199 | "source": [ 200 | "Unlike a dictionary, though, the Series also supports array-style operations such as slicing:" 201 | ] 202 | }, 203 | { 204 | "cell_type": "code", 205 | "execution_count": null, 206 | "metadata": {}, 207 | "outputs": [], 208 | "source": [ 209 | "population['Metropolitana':'Valparaíso']" 210 | ] 211 | }, 212 | { 213 | "cell_type": "markdown", 214 | "metadata": {}, 215 | "source": [ 216 | "## 2. DataFrame\n", 217 | "\n", 218 | "La siguiente estructura fundamental en Pandas es el **`DataFrame`**. Como el objeto `Series` discutido en la sección anterior, el `DataFrame` puede pensarse ya sea como una generalización del arreglo NumPy, o como una especialización de un diccionario Python. Lo miraremos desde ambas perspectivas." 219 | ] 220 | }, 221 | { 222 | "cell_type": "markdown", 223 | "metadata": {}, 224 | "source": [ 225 | "### DataFrame como un arreglo NumPy generalizado\n", 226 | "\n", 227 | "Si una `Series` es el análogo de un arreglo unidimensional con índices flexibles, un `DataFrame` es el análogo de un arreglo bidimensional con índices de fila flexible y nombres de columna flexibles." 228 | ] 229 | }, 230 | { 231 | "cell_type": "code", 232 | "execution_count": null, 233 | "metadata": {}, 234 | "outputs": [], 235 | "source": [ 236 | "# Area in km^2\n", 237 | "area_dict = {'Arica y Parinacota': 16873.3,\n", 238 | " 'Antofagasta': 126049.1,\n", 239 | " 'Metropolitana de Santiago': 15403.2,\n", 240 | " 'Valparaiso': 16396.1,\n", 241 | " 'Bíobío': 37068.7,\n", 242 | " 'Magallanes y Antártica Chilena': 1382291.1}\n", 243 | "area = pd.Series(area_dict)\n", 244 | "area" 245 | ] 246 | }, 247 | { 248 | "cell_type": "markdown", 249 | "metadata": {}, 250 | "source": [ 251 | "Ahora que tenemos esto junto con la serie de población de antes, podemos utilizar un diccionario para construir un único objeto bidimensional que contenga esta información:" 252 | ] 253 | }, 254 | { 255 | "cell_type": "code", 256 | "execution_count": null, 257 | "metadata": {}, 258 | "outputs": [], 259 | "source": [ 260 | "regions = pd.DataFrame({'population': population,\n", 261 | " 'area': area})\n", 262 | "regions" 263 | ] 264 | }, 265 | { 266 | "cell_type": "code", 267 | "execution_count": null, 268 | "metadata": { 269 | "collapsed": true 270 | }, 271 | "outputs": [], 272 | "source": [ 273 | "regions['densidad'] = regions['population']/regions['area']" 274 | ] 275 | }, 276 | { 277 | "cell_type": "code", 278 | "execution_count": null, 279 | "metadata": {}, 280 | "outputs": [], 281 | "source": [ 282 | "regions['densidad']['Antofagasta']" 283 | ] 284 | }, 285 | { 286 | "cell_type": "code", 287 | "execution_count": null, 288 | "metadata": {}, 289 | "outputs": [], 290 | "source": [ 291 | "regions.index" 292 | ] 293 | }, 294 | { 295 | "cell_type": "code", 296 | "execution_count": null, 297 | "metadata": {}, 298 | "outputs": [], 299 | "source": [ 300 | "regions.columns" 301 | ] 302 | }, 303 | { 304 | "cell_type": "markdown", 305 | "metadata": {}, 306 | "source": [ 307 | "### DataFrame como diccionario especializado\n", 308 | "\n", 309 | "Similarmente, podemos pensar el `DataFrame` como la especialización de un diccionario. Donde un diccionario mapea una llave a un valor, un `DataFrame` mapea un nombre de columna a una serie de datos de columna. Por ejemplo, preguntar por el atributo 'área' retorna el objeto Serie conteniendo las áreas que vimos antes:" 310 | ] 311 | }, 312 | { 313 | "cell_type": "code", 314 | "execution_count": null, 315 | "metadata": {}, 316 | "outputs": [], 317 | "source": [ 318 | "regions['area']" 319 | ] 320 | }, 321 | { 322 | "cell_type": "code", 323 | "execution_count": null, 324 | "metadata": {}, 325 | "outputs": [], 326 | "source": [ 327 | "regions['population']" 328 | ] 329 | }, 330 | { 331 | "cell_type": "markdown", 332 | "metadata": {}, 333 | "source": [ 334 | "### Construyendo objetos DataFrame\n", 335 | "Un `DataFrame` Pandas puede ser construido de una variedad de formas. Veremos algunos ejemplos." 336 | ] 337 | }, 338 | { 339 | "cell_type": "markdown", 340 | "metadata": {}, 341 | "source": [ 342 | "### Desde un único objeto `Series`\n", 343 | "Un `DataFrame` es una colección de objetos `Series`, y un `DataFrame` de una sóla columna puede ser construido de una serie individual:" 344 | ] 345 | }, 346 | { 347 | "cell_type": "code", 348 | "execution_count": null, 349 | "metadata": {}, 350 | "outputs": [], 351 | "source": [ 352 | "pd.DataFrame(population, columns=['poblacion'])\n", 353 | "pd.DataFrame(area, columns=['superficie'])" 354 | ] 355 | }, 356 | { 357 | "cell_type": "markdown", 358 | "metadata": {}, 359 | "source": [ 360 | "### Desde un diccionario de objetos `Series`\n", 361 | "Como vimos antes, un `DataFrame` puede ser construido a partir de un diccionario de objetos `Series` también:" 362 | ] 363 | }, 364 | { 365 | "cell_type": "code", 366 | "execution_count": null, 367 | "metadata": {}, 368 | "outputs": [], 369 | "source": [ 370 | "pd.DataFrame({'poblacion': population,\n", 371 | " 'area': area}, columns=['poblacion', 'area'])" 372 | ] 373 | }, 374 | { 375 | "cell_type": "markdown", 376 | "metadata": { 377 | "collapsed": true 378 | }, 379 | "source": [ 380 | "## 3. Leyendo un archivo CSV y haciendo operaciones comunes Pandas" 381 | ] 382 | }, 383 | { 384 | "cell_type": "code", 385 | "execution_count": null, 386 | "metadata": { 387 | "collapsed": true 388 | }, 389 | "outputs": [], 390 | "source": [ 391 | "regiones_file='data/chile_regiones.csv'\n", 392 | "provincias_file='data/chile_provincias.csv'\n", 393 | "comunas_file='data/chile_comunas.csv'\n", 394 | "\n", 395 | "regiones=pd.read_csv(regiones_file, header=0, sep=',')\n", 396 | "provincias=pd.read_csv(provincias_file, header=0, sep=',')\n", 397 | "comunas=pd.read_csv(comunas_file, header=0, sep=',')" 398 | ] 399 | }, 400 | { 401 | "cell_type": "code", 402 | "execution_count": null, 403 | "metadata": {}, 404 | "outputs": [], 405 | "source": [ 406 | "print('regiones table: ', regiones.columns.values.tolist())\n", 407 | "print('provincias table: ', provincias.columns.values.tolist())\n", 408 | "print('comunas table: ', comunas.columns.values.tolist())" 409 | ] 410 | }, 411 | { 412 | "cell_type": "code", 413 | "execution_count": null, 414 | "metadata": {}, 415 | "outputs": [], 416 | "source": [ 417 | "regiones.head()" 418 | ] 419 | }, 420 | { 421 | "cell_type": "code", 422 | "execution_count": null, 423 | "metadata": {}, 424 | "outputs": [], 425 | "source": [ 426 | "provincias.head()" 427 | ] 428 | }, 429 | { 430 | "cell_type": "code", 431 | "execution_count": null, 432 | "metadata": {}, 433 | "outputs": [], 434 | "source": [ 435 | "comunas.head()" 436 | ] 437 | }, 438 | { 439 | "cell_type": "code", 440 | "execution_count": null, 441 | "metadata": {}, 442 | "outputs": [], 443 | "source": [ 444 | "comunas.sort_values('ComunaNombre').head()" 445 | ] 446 | }, 447 | { 448 | "cell_type": "code", 449 | "execution_count": null, 450 | "metadata": {}, 451 | "outputs": [], 452 | "source": [ 453 | "comunas.describe()" 454 | ] 455 | }, 456 | { 457 | "cell_type": "code", 458 | "execution_count": null, 459 | "metadata": {}, 460 | "outputs": [], 461 | "source": [ 462 | "regiones_provincias=pd.merge(regiones, provincias, how='outer')\n", 463 | "regiones_provincias.head()" 464 | ] 465 | }, 466 | { 467 | "cell_type": "code", 468 | "execution_count": null, 469 | "metadata": {}, 470 | "outputs": [], 471 | "source": [ 472 | "provincias_comunas=pd.merge(provincias, comunas, how='outer')\n", 473 | "provincias_comunas.head()" 474 | ] 475 | }, 476 | { 477 | "cell_type": "code", 478 | "execution_count": null, 479 | "metadata": {}, 480 | "outputs": [], 481 | "source": [ 482 | "regiones_provincias_comunas=pd.merge(regiones_provincias, comunas, how='outer')\n", 483 | "regiones_provincias_comunas.index.name='ID'\n", 484 | "regiones_provincias_comunas.head()" 485 | ] 486 | }, 487 | { 488 | "cell_type": "code", 489 | "execution_count": null, 490 | "metadata": {}, 491 | "outputs": [], 492 | "source": [ 493 | "regiones_provincias_comunas.loc[4]" 494 | ] 495 | }, 496 | { 497 | "cell_type": "code", 498 | "execution_count": null, 499 | "metadata": { 500 | "collapsed": true 501 | }, 502 | "outputs": [], 503 | "source": [ 504 | "regiones_provincias_comunas.to_csv('data/chile_demographic_merge.csv', index=False)" 505 | ] 506 | }, 507 | { 508 | "cell_type": "code", 509 | "execution_count": null, 510 | "metadata": {}, 511 | "outputs": [], 512 | "source": [ 513 | "regiones_provincias_comunas.loc[1,\"ComunaNombre\"]" 514 | ] 515 | }, 516 | { 517 | "cell_type": "markdown", 518 | "metadata": {}, 519 | "source": [ 520 | "## 4. Loading ful dataset" 521 | ] 522 | }, 523 | { 524 | "cell_type": "code", 525 | "execution_count": null, 526 | "metadata": {}, 527 | "outputs": [], 528 | "source": [ 529 | "data_file='data/chile_demographic.csv'\n", 530 | "data=pd.read_csv(data_file, header=0, sep=',')\n", 531 | "data.head()" 532 | ] 533 | }, 534 | { 535 | "cell_type": "code", 536 | "execution_count": null, 537 | "metadata": { 538 | "scrolled": true 539 | }, 540 | "outputs": [], 541 | "source": [ 542 | "# Podemos ordenar el dataframe usando el campo Poblacion\n", 543 | "\n", 544 | "data_sort=data.sort_values('Poblacion')\n", 545 | "data_sort.head()" 546 | ] 547 | }, 548 | { 549 | "cell_type": "code", 550 | "execution_count": null, 551 | "metadata": { 552 | "scrolled": true 553 | }, 554 | "outputs": [], 555 | "source": [ 556 | "# Podemos ordenarlo de mayor a menor\n", 557 | "\n", 558 | "data_sort=data.sort_values('Poblacion', ascending=False)\n", 559 | "data_sort.head()" 560 | ] 561 | }, 562 | { 563 | "cell_type": "code", 564 | "execution_count": null, 565 | "metadata": {}, 566 | "outputs": [], 567 | "source": [ 568 | "(data.groupby(data['Region'])['Poblacion','Superficie'].sum())" 569 | ] 570 | }, 571 | { 572 | "cell_type": "code", 573 | "execution_count": null, 574 | "metadata": { 575 | "scrolled": false 576 | }, 577 | "outputs": [], 578 | "source": [ 579 | "x=data.groupby(data['Region'])\n", 580 | "x['Poblacion','Superficie'].sum()" 581 | ] 582 | }, 583 | { 584 | "cell_type": "code", 585 | "execution_count": null, 586 | "metadata": {}, 587 | "outputs": [], 588 | "source": [ 589 | "(data.groupby(data['Region'])['Poblacion','Superficie'].sum()) \\\n", 590 | " .sort_values(['Poblacion'])" 591 | ] 592 | }, 593 | { 594 | "cell_type": "code", 595 | "execution_count": null, 596 | "metadata": { 597 | "collapsed": true 598 | }, 599 | "outputs": [], 600 | "source": [] 601 | }, 602 | { 603 | "cell_type": "code", 604 | "execution_count": null, 605 | "metadata": { 606 | "collapsed": true 607 | }, 608 | "outputs": [], 609 | "source": [] 610 | } 611 | ], 612 | "metadata": { 613 | "kernelspec": { 614 | "display_name": "Python 3", 615 | "language": "python", 616 | "name": "python3" 617 | }, 618 | "language_info": { 619 | "codemirror_mode": { 620 | "name": "ipython", 621 | "version": 3 622 | }, 623 | "file_extension": ".py", 624 | "mimetype": "text/x-python", 625 | "name": "python", 626 | "nbconvert_exporter": "python", 627 | "pygments_lexer": "ipython3", 628 | "version": "3.6.4" 629 | } 630 | }, 631 | "nbformat": 4, 632 | "nbformat_minor": 1 633 | } 634 | -------------------------------------------------------------------------------- /tutoriales/14_Visualizacion_con_Pandas.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# Visualización con Pandas\n", 8 | "\n", 9 | "**Autor:** Roberto Muñoz
\n", 10 | "**E-mail:**
\n", 11 | "**Github:**
\n", 12 | "\n", 13 | "[Pandas](http://pandas.pydata.org/) puede ser usado en conjunto a los paquetes de matplotlib y seaborn para generar visualizaciones de gran calidad y con poco esfuerzo." 14 | ] 15 | }, 16 | { 17 | "cell_type": "code", 18 | "execution_count": null, 19 | "metadata": { 20 | "collapsed": true 21 | }, 22 | "outputs": [], 23 | "source": [ 24 | "import numpy as np\n", 25 | "import pandas as pd\n", 26 | "import matplotlib.pyplot as plt\n", 27 | "import seaborn as sns\n", 28 | "\n", 29 | "%matplotlib inline\n", 30 | "params = {'legend.fontsize': 'x-large',\n", 31 | " 'figure.figsize': (15, 10),\n", 32 | " 'axes.labelsize': 'x-large',\n", 33 | " 'axes.titlesize':'x-large',\n", 34 | " 'xtick.labelsize':'x-large',\n", 35 | " 'ytick.labelsize':'x-large',\n", 36 | " 'axes.titlepad': 20,\n", 37 | " 'axes.titlesize': 24,\n", 38 | " 'axes.labelpad': 20,\n", 39 | " 'axes.labelsize': 20,\n", 40 | " 'lines.linewidth': 3,\n", 41 | " 'lines.markersize': 10,\n", 42 | " 'xtick.labelsize': 16,\n", 43 | " 'ytick.labelsize': 16}\n", 44 | "plt.rcParams.update(params)\n", 45 | "sns.color_palette(\"bright\")\n", 46 | "\n", 47 | "# También es posible limitar el número de registros que imprimirá en pantalla Pandas\n", 48 | "pd.set_option('display.max_rows', 100)" 49 | ] 50 | }, 51 | { 52 | "cell_type": "markdown", 53 | "metadata": {}, 54 | "source": [ 55 | "## Fondecyt Postdoctorado" 56 | ] 57 | }, 58 | { 59 | "cell_type": "code", 60 | "execution_count": null, 61 | "metadata": { 62 | "scrolled": true 63 | }, 64 | "outputs": [], 65 | "source": [ 66 | "fondecyt = pd.read_csv('data/fondecyt postdoc 2007-2017.csv')\n", 67 | "fondecyt.head()" 68 | ] 69 | }, 70 | { 71 | "cell_type": "code", 72 | "execution_count": null, 73 | "metadata": {}, 74 | "outputs": [], 75 | "source": [ 76 | "fondecyt=fondecyt.rename(columns = {'año':'Año', 'n_concursados':'Concursados', 'n_aprobados':'Aprobados', \n", 77 | " 'monto_solicitado':'Recursos solicitados', 'monto_aprobado':'Recursos aprobados'})\n", 78 | "fondecyt['Tasa de aprobación']=np.round(fondecyt['Aprobados']/fondecyt['Concursados']*100,decimals=1)\n", 79 | "fondecyt_postdoc=fondecyt.copy()\n", 80 | "fondecyt.head()" 81 | ] 82 | }, 83 | { 84 | "cell_type": "code", 85 | "execution_count": null, 86 | "metadata": {}, 87 | "outputs": [], 88 | "source": [ 89 | "fig, ax = plt.subplots(figsize=(15, 10))\n", 90 | "ax2 = ax.twinx()\n", 91 | "\n", 92 | "fondecyt.plot(kind='line', x='Año', y='Concursados', marker='o', markersize=10, ax=ax, label='Postdoc Concursados')\n", 93 | "fondecyt.plot(kind='line', x='Año', y='Aprobados', marker='o', markersize=10, ax=ax, label='Postdoc Aprobados')\n", 94 | "ax.set_xlim([2006.5,2017.5])\n", 95 | "ax.set_ylim([0,1300])\n", 96 | "ax.yaxis.set_ticks(np.arange(0, 1400, 100))\n", 97 | "ax.legend(loc=2)\n", 98 | "\n", 99 | "fondecyt.plot(kind='line', x='Año', y='Tasa de aprobación', color='red', grid=True, ax=ax2)\n", 100 | "ax2.set_ylim([0,100])\n", 101 | "ax2.yaxis.set_ticks(np.arange(0,110,10))\n", 102 | "ax2.set_xlim([2006.5,2017.5])\n", 103 | "ax2.xaxis.set_ticks(np.arange(2007, 2018, 1))\n", 104 | "ax2.grid(linestyle='--')\n", 105 | "ax2.legend(loc=1)\n", 106 | "\n", 107 | "ax.set_title('Estadística Proyectos Fondecyt de Postdoctorado')\n", 108 | "ax.set_ylabel('Número de proyectos / año')\n", 109 | "ax2.set_ylabel('Tasa (%)')\n", 110 | "\n", 111 | "fig.savefig('figures/estadistica_proyectos_fondecyt_postdoc.pdf')\n", 112 | "fig.savefig('figures/estadistica_proyectos_fondecyt_postdoc.png')" 113 | ] 114 | }, 115 | { 116 | "cell_type": "markdown", 117 | "metadata": {}, 118 | "source": [ 119 | "## Fondecyt Iniciación" 120 | ] 121 | }, 122 | { 123 | "cell_type": "code", 124 | "execution_count": null, 125 | "metadata": {}, 126 | "outputs": [], 127 | "source": [ 128 | "fondecyt = pd.read_csv('data/fondecyt iniciacion 2007-2017.csv')\n", 129 | "fondecyt.head()" 130 | ] 131 | }, 132 | { 133 | "cell_type": "code", 134 | "execution_count": null, 135 | "metadata": {}, 136 | "outputs": [], 137 | "source": [ 138 | "fondecyt=fondecyt.rename(columns = {'año':'Año', 'n_concursados':'Concursados', 'n_aprobados':'Aprobados', \n", 139 | " 'monto_solicitado':'Recursos solicitados', 'monto_aprobado':'Recursos aprobados'})\n", 140 | "fondecyt['Tasa de aprobación']=np.round(fondecyt['Aprobados']/fondecyt['Concursados']*100,decimals=1)\n", 141 | "fondecyt_iniciacion=fondecyt.copy()\n", 142 | "fondecyt.head()" 143 | ] 144 | }, 145 | { 146 | "cell_type": "code", 147 | "execution_count": null, 148 | "metadata": {}, 149 | "outputs": [], 150 | "source": [ 151 | "fig, ax = plt.subplots(figsize=(15, 10))\n", 152 | "ax2 = ax.twinx()\n", 153 | "\n", 154 | "fondecyt.plot(kind='line', x='Año', y='Concursados', marker='o', markersize=10, ax=ax, label='Proyectos Concursados')\n", 155 | "fondecyt.plot(kind='line', x='Año', y='Aprobados', marker='o', markersize=10, ax=ax, label='Proyectos Aprobados')\n", 156 | "ax.set_xlim([2006.5,2017.5])\n", 157 | "ax.set_ylim([0,1300])\n", 158 | "ax.yaxis.set_ticks(np.arange(0, 1400, 100))\n", 159 | "ax.legend(loc=2)\n", 160 | "\n", 161 | "fondecyt.plot(kind='line', x='Año', y='Tasa de aprobación', color='red', grid=False, ax=ax2)\n", 162 | "ax2.set_ylim([0,100])\n", 163 | "ax2.yaxis.set_ticks(np.arange(0,110,10))\n", 164 | "ax2.set_xlim([2006.5,2017.5])\n", 165 | "ax2.xaxis.set_ticks(np.arange(2007, 2018, 1))\n", 166 | "ax2.grid(linestyle='--')\n", 167 | "ax2.legend(loc=1)\n", 168 | "\n", 169 | "ax.set_title('Estadística Proyectos Fondecyt de Iniciación')\n", 170 | "ax.set_ylabel('Número de proyectos / año')\n", 171 | "ax2.set_ylabel('Tasa (%)')\n", 172 | "\n", 173 | "fig.savefig('figures/estadistica_proyectos_fondecyt_iniciacion.pdf')\n", 174 | "fig.savefig('figures/estadistica_proyectos_fondecyt_iniciacion.png')" 175 | ] 176 | }, 177 | { 178 | "cell_type": "code", 179 | "execution_count": null, 180 | "metadata": { 181 | "collapsed": true 182 | }, 183 | "outputs": [], 184 | "source": [] 185 | }, 186 | { 187 | "cell_type": "code", 188 | "execution_count": null, 189 | "metadata": { 190 | "collapsed": true 191 | }, 192 | "outputs": [], 193 | "source": [] 194 | } 195 | ], 196 | "metadata": { 197 | "kernelspec": { 198 | "display_name": "Python 3", 199 | "language": "python", 200 | "name": "python3" 201 | }, 202 | "language_info": { 203 | "codemirror_mode": { 204 | "name": "ipython", 205 | "version": 3 206 | }, 207 | "file_extension": ".py", 208 | "mimetype": "text/x-python", 209 | "name": "python", 210 | "nbconvert_exporter": "python", 211 | "pygments_lexer": "ipython3", 212 | "version": "3.6.4" 213 | } 214 | }, 215 | "nbformat": 4, 216 | "nbformat_minor": 2 217 | } 218 | -------------------------------------------------------------------------------- /tutoriales/15_Visualizacion_con_Seaborn_y_Pandas.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# Análisis exploratorio usando Pandas y Matplotlib\n", 8 | "\n", 9 | "**Autor:** Roberto Muñoz
\n", 10 | "**E-mail:**
\n", 11 | "**Github:**
\n" 12 | ] 13 | }, 14 | { 15 | "cell_type": "markdown", 16 | "metadata": {}, 17 | "source": [ 18 | "Para visualizar datos en Python debemos cargar algunas librerías. Las librerías más empleadas para analizar y visualizar datos son las siguientes,\n", 19 | "\n", 20 | "- **numpy**: Numpy es una librería de Python usada para cálculo numérico y científico. Abreviatura de Numerical Python.\n", 21 | "\n", 22 | "\n", 23 | "- **pandas**: Pandas es una librería de Python usada para el análisis de datos. Ofrece estructuras de datos flexibles y permite trabajar con ellos de forma muy eficiente.\n", 24 | "\n", 25 | "\n", 26 | "- **matplotlib**: Matplotlib es la librería más popular de Python para hacer visualizaciones y gráficos. Matplotlib posee gran flexibilidad para generar diferentes tipos de gráficos.\n", 27 | "\n", 28 | "\n", 29 | "- **seaborn**: Seaborn es una librería de visualización basada en matplotlib. La idea de Seaborn es que los científicos de datos dispongan de una interfaz para hacer gráficos estadísticos atractivos y explicativos." 30 | ] 31 | }, 32 | { 33 | "cell_type": "code", 34 | "execution_count": null, 35 | "metadata": { 36 | "collapsed": true 37 | }, 38 | "outputs": [], 39 | "source": [ 40 | "import numpy as np\n", 41 | "import pandas as pd\n", 42 | "import matplotlib.pyplot as plt\n", 43 | "import seaborn as sns\n", 44 | "\n", 45 | "%matplotlib inline\n", 46 | "params = {'legend.fontsize': 'x-large',\n", 47 | " 'figure.figsize': (10, 7.5),\n", 48 | " 'axes.labelsize': 'x-large',\n", 49 | " 'axes.titlesize':'x-large',\n", 50 | " 'xtick.labelsize':'x-large',\n", 51 | " 'ytick.labelsize':'x-large'}\n", 52 | "plt.rcParams.update(params)\n", 53 | "\n", 54 | "# También es posible limitar el número de registros que imprimirá en pantalla Pandas\n", 55 | "pd.set_option('display.max_rows', 30)" 56 | ] 57 | }, 58 | { 59 | "cell_type": "markdown", 60 | "metadata": {}, 61 | "source": [ 62 | "## Lectura de datos\n", 63 | "\n", 64 | "Para este tutorial usaremos una base de datos de vuelos áreos publicada por el sitio web [Openflights](https://openflights.org/data.html). La base de datos contiene una tabla de los aeropuertos en el mundo (**`aeropuertos.csv`**), una tabla de las aerolíneas en el mundo (**`aerolineas.csv`**) y una tabla de las rutas de vuelos comerciales (**`rutas.csv`**).\n", 65 | "\n", 66 | "Más información en https://github.com/jpatokal/openflights" 67 | ] 68 | }, 69 | { 70 | "cell_type": "code", 71 | "execution_count": null, 72 | "metadata": {}, 73 | "outputs": [], 74 | "source": [ 75 | "aeropuertos_file='data/aeropuertos.csv'\n", 76 | "aerolineas_file='data/aerolineas.csv'\n", 77 | "rutas_file='data/rutas.csv'\n", 78 | "\n", 79 | "aeropuertos=pd.read_csv(aeropuertos_file)\n", 80 | "aerolineas=pd.read_csv(aerolineas_file)\n", 81 | "rutas=pd.read_csv(rutas_file)" 82 | ] 83 | }, 84 | { 85 | "cell_type": "code", 86 | "execution_count": null, 87 | "metadata": {}, 88 | "outputs": [], 89 | "source": [ 90 | "aeropuertos.head()" 91 | ] 92 | }, 93 | { 94 | "cell_type": "code", 95 | "execution_count": null, 96 | "metadata": {}, 97 | "outputs": [], 98 | "source": [ 99 | "aerolineas.head()" 100 | ] 101 | }, 102 | { 103 | "cell_type": "code", 104 | "execution_count": null, 105 | "metadata": {}, 106 | "outputs": [], 107 | "source": [ 108 | "rutas.head()" 109 | ] 110 | }, 111 | { 112 | "cell_type": "code", 113 | "execution_count": null, 114 | "metadata": {}, 115 | "outputs": [], 116 | "source": [ 117 | "rutas[rutas['Pais_origen'] == 'Chile']" 118 | ] 119 | }, 120 | { 121 | "cell_type": "markdown", 122 | "metadata": {}, 123 | "source": [ 124 | "## Visualización de datos\n", 125 | "\n", 126 | "### 1. Histograma de frecuencia absoluta\n", 127 | "\n", 128 | "Uno de los gráficos más usados para la visualización de datos es el **histograma**. Un histograma es una representación gráfica de una variable en forma de barras, donde la superficie de cada barra es proporcional a la frecuencia de los valores representados. Sirven para obtener una primera vista general de la distribución de la muestra de datos respecto a una característica.\n", 129 | "\n", 130 | "Supongamos que nos interesa contar el número de vuelos de acuerdo a la distancia recorrida en kilómetros. Para ello construimos un histograma de la Distancia de los vuelos." 131 | ] 132 | }, 133 | { 134 | "cell_type": "code", 135 | "execution_count": null, 136 | "metadata": {}, 137 | "outputs": [], 138 | "source": [ 139 | "n, bins, patches = plt.hist(rutas['Distancia_km'], bins=20)\n", 140 | "plt.xlabel('Distancia recorrida (km)')\n", 141 | "plt.ylabel('Número de vuelos')\n", 142 | "plt.title('Histograma - Frecuencia absoluta')" 143 | ] 144 | }, 145 | { 146 | "cell_type": "markdown", 147 | "metadata": {}, 148 | "source": [ 149 | "Es importante notar que los histogramas se contruyen usando variables cuantitativas, como es el caso de la variable **Distancia recorrida (km)**." 150 | ] 151 | }, 152 | { 153 | "cell_type": "markdown", 154 | "metadata": {}, 155 | "source": [ 156 | "### 2. Histograma de frecuencia relativa" 157 | ] 158 | }, 159 | { 160 | "cell_type": "code", 161 | "execution_count": null, 162 | "metadata": {}, 163 | "outputs": [], 164 | "source": [ 165 | "sns.distplot(rutas['Distancia_km'], bins=20)\n", 166 | "plt.xlabel('Distancia recorrida (km)')\n", 167 | "plt.ylabel('Número de vuelos')\n", 168 | "plt.title('Histograma - Frecuencia relativa')" 169 | ] 170 | }, 171 | { 172 | "cell_type": "markdown", 173 | "metadata": {}, 174 | "source": [ 175 | "### 3. Gráfico de barras\n", 176 | "\n", 177 | "Otro gráfico ampliamente usado es el **diagrama de barras** o **gráfico de barras**. Es una representación gráfica de un conjunto de datos o valores, y está conformado por barras rectangulares de longitudes proporcionales a los valores representados.\n", 178 | "\n", 179 | "A diferencia de un histograma, el gráfico de barras se construye usando variables categóricas o cualitativas.\n", 180 | "\n", 181 | "Digamos que nos interesa separar los vuelos en cortos, intermedios y largos de acuerdo a la distancia recorrida. Para ello, creamos tres categorías y hacemos un gráfico de barras." 182 | ] 183 | }, 184 | { 185 | "cell_type": "code", 186 | "execution_count": null, 187 | "metadata": { 188 | "collapsed": true 189 | }, 190 | "outputs": [], 191 | "source": [ 192 | "bins = [0, 2000, 10000, 1000000]\n", 193 | "group_names = ['Vuelo corto', 'Vuelo intermedio', 'Vuelo largo']\n", 194 | "rutas['Tipo_vuelo'] = pd.cut(rutas['Distancia_km'], bins, labels=group_names)" 195 | ] 196 | }, 197 | { 198 | "cell_type": "code", 199 | "execution_count": null, 200 | "metadata": {}, 201 | "outputs": [], 202 | "source": [ 203 | "rutas.tail()" 204 | ] 205 | }, 206 | { 207 | "cell_type": "code", 208 | "execution_count": null, 209 | "metadata": {}, 210 | "outputs": [], 211 | "source": [ 212 | "sns.countplot(x=\"Tipo_vuelo\", order=group_names, data=rutas)\n", 213 | "plt.xlabel('Tipo de vuelo')\n", 214 | "plt.ylabel('Número de vuelos')\n", 215 | "plt.title('Gráfico de barras')\n", 216 | "plt.xticks(size = 15, rotation=60)" 217 | ] 218 | }, 219 | { 220 | "cell_type": "markdown", 221 | "metadata": {}, 222 | "source": [ 223 | "Digamos que nos interesa conocer el número de vuelos que parten desde algún país en Sudamérica. La mejor manera de visualizar el número de vuelos por país es usando un gráfico de barras." 224 | ] 225 | }, 226 | { 227 | "cell_type": "code", 228 | "execution_count": null, 229 | "metadata": { 230 | "collapsed": true 231 | }, 232 | "outputs": [], 233 | "source": [ 234 | "paises_sudamerica=['Brazil','Colombia','Argentina','Peru','Venezuela','Chile','Ecuador','Bolivia','Paraguay','Uruguay','Guyana','Suriname','French Guiana']\n", 235 | "rutas_sudamerica=rutas[rutas['Pais_origen'].isin(paises_sudamerica)]\n", 236 | "rutas_sudamerica_pais=rutas_sudamerica.groupby('Pais_origen')['Linea_aerea'].agg('count').sort_values(ascending=False)" 237 | ] 238 | }, 239 | { 240 | "cell_type": "code", 241 | "execution_count": null, 242 | "metadata": {}, 243 | "outputs": [], 244 | "source": [ 245 | "rutas_sudamerica_pais.head()" 246 | ] 247 | }, 248 | { 249 | "cell_type": "code", 250 | "execution_count": null, 251 | "metadata": {}, 252 | "outputs": [], 253 | "source": [ 254 | "sns.countplot(x=\"Pais_origen\", order=rutas_sudamerica_pais.index.tolist(), data=rutas_sudamerica)\n", 255 | "plt.xlabel('País de origen')\n", 256 | "plt.ylabel('Número de vuelos')\n", 257 | "plt.title('Gráfico de barras')\n", 258 | "plt.xticks(size = 15, rotation=60)" 259 | ] 260 | }, 261 | { 262 | "cell_type": "markdown", 263 | "metadata": {}, 264 | "source": [ 265 | "### 4. Gráfico de cajas\n", 266 | "\n", 267 | "Otro gráfico usado es el **diagrama de caja** o **gráfico de caja**. Es un gráfico que está basado en cuartiles y mediante el cual se visualiza la distribución de un conjunto de datos. Está compuesto por un rectángulo (caja) y dos brazos (bigotes).\n", 268 | "\n", 269 | "Digamos que nos interesa conocer cómo se distribuyen los vuelos en cada país de Sudamérica. Para ello usamos la variable *País de origen* como variable categórica y la variable *Distancia recorrida* para estudiar su distribución." 270 | ] 271 | }, 272 | { 273 | "cell_type": "code", 274 | "execution_count": null, 275 | "metadata": {}, 276 | "outputs": [], 277 | "source": [ 278 | "sns.boxplot(x='Pais_origen', y='Distancia_km', order=rutas_sudamerica_pais.index.tolist(), data=rutas_sudamerica)\n", 279 | "plt.xlabel('País de origen')\n", 280 | "plt.ylabel('Distancia recorrida (km)')\n", 281 | "plt.title('Gráfico de cajas')\n", 282 | "plt.xticks(size = 15, rotation=60)" 283 | ] 284 | }, 285 | { 286 | "cell_type": "markdown", 287 | "metadata": {}, 288 | "source": [ 289 | "### 4. Gráfico de puntos\n", 290 | "\n", 291 | "Otro gráfico usado es el **diagrama de dispersión** o **gráfico de puntos**. Es un gráfico que utiliza las coordenadas cartesianas para mostrar los valores de dos variables de un conjunto de datos.\n", 292 | "\n", 293 | "Cabe notar que un gráfico de puntos se construye usando variables cuantitativas.\n", 294 | "\n", 295 | "Supongamos que nos interesa saber si los vuelos que parten desde el hemisferio Norte son más largos que los vuelos que parten desde el hemisferio Sur. Para ello usamos la variable *Latitud País de origen* como variable dependiente y la variable *Distancia recorrida* como variable independiente." 296 | ] 297 | }, 298 | { 299 | "cell_type": "code", 300 | "execution_count": null, 301 | "metadata": { 302 | "collapsed": true 303 | }, 304 | "outputs": [], 305 | "source": [ 306 | "rutas_coordenadas=rutas.merge(aeropuertos[['Id','Latitud','Longitud']], how='inner', left_on='Aeropuerto_origen_Id', right_on='Id')\n", 307 | "rutas_coordenadas=rutas_coordenadas.sample(10000)" 308 | ] 309 | }, 310 | { 311 | "cell_type": "code", 312 | "execution_count": null, 313 | "metadata": {}, 314 | "outputs": [], 315 | "source": [ 316 | "rutas_coordenadas.head()" 317 | ] 318 | }, 319 | { 320 | "cell_type": "code", 321 | "execution_count": null, 322 | "metadata": {}, 323 | "outputs": [], 324 | "source": [ 325 | "rutas_coordenadas.plot.scatter(x='Latitud', y='Distancia_km', s=3);\n", 326 | "plt.xlim(-90,90)\n", 327 | "plt.xlabel('Latitud País de origen')\n", 328 | "plt.ylabel('Distancia recorrida (km)')\n", 329 | "plt.title('Gráfico de puntos - Vuelos')\n", 330 | "plt.xticks(size = 15, rotation=0);" 331 | ] 332 | }, 333 | { 334 | "cell_type": "markdown", 335 | "metadata": {}, 336 | "source": [ 337 | "Digamos que nos interesa saber como están distribuidos los aeropuertos en el mundo. Para ello usamos las variables `Longitud` y `Latitud` de la tabla aeropuertos." 338 | ] 339 | }, 340 | { 341 | "cell_type": "code", 342 | "execution_count": null, 343 | "metadata": { 344 | "scrolled": false 345 | }, 346 | "outputs": [], 347 | "source": [ 348 | "aeropuertos.plot.scatter(x='Longitud', y='Latitud', s=3);\n", 349 | "plt.xlim(-180,180)\n", 350 | "plt.ylim(-90,90)\n", 351 | "plt.xlabel('Longitud')\n", 352 | "plt.ylabel('Latitud')\n", 353 | "plt.title('Gráfico de puntos - Aeropuertos')\n", 354 | "plt.xticks(size = 15, rotation=0);" 355 | ] 356 | }, 357 | { 358 | "cell_type": "code", 359 | "execution_count": null, 360 | "metadata": { 361 | "collapsed": true 362 | }, 363 | "outputs": [], 364 | "source": [] 365 | } 366 | ], 367 | "metadata": { 368 | "kernelspec": { 369 | "display_name": "Python 3", 370 | "language": "python", 371 | "name": "python3" 372 | }, 373 | "language_info": { 374 | "codemirror_mode": { 375 | "name": "ipython", 376 | "version": 3 377 | }, 378 | "file_extension": ".py", 379 | "mimetype": "text/x-python", 380 | "name": "python", 381 | "nbconvert_exporter": "python", 382 | "pygments_lexer": "ipython3", 383 | "version": "3.6.4" 384 | } 385 | }, 386 | "nbformat": 4, 387 | "nbformat_minor": 2 388 | } 389 | -------------------------------------------------------------------------------- /tutoriales/data/chile_comunas.csv: -------------------------------------------------------------------------------- 1 | ComunaID,ComunaNombre,ProvinciaID 2 | 1,'Arica',1 3 | 2,'Camarones',1 4 | 3,'General Lagos',2 5 | 4,'Putre',2 6 | 5,'Alto Hospicio',3 7 | 6,'Iquique',3 8 | 7,'Camiña',4 9 | 8,'Colchane',4 10 | 9,'Huara',4 11 | 10,'Pica',4 12 | 11,'Pozo Almonte',4 13 | 12,'Antofagasta',5 14 | 13,'Mejillones',5 15 | 14,'Sierra Gorda',5 16 | 15,'Taltal',5 17 | 16,'Calama',6 18 | 17,'Ollague',6 19 | 18,'San Pedro de Atacama',6 20 | 19,'María Elena',7 21 | 20,'Tocopilla',7 22 | 21,'Chañaral',8 23 | 22,'Diego de Almagro',8 24 | 23,'Caldera',9 25 | 24,'Copiapó',9 26 | 25,'Tierra Amarilla',9 27 | 26,'Alto del Carmen',10 28 | 27,'Freirina',10 29 | 28,'Huasco',10 30 | 29,'Vallenar',10 31 | 30,'Canela',11 32 | 31,'Illapel',11 33 | 32,'Los Vilos',11 34 | 33,'Salamanca',11 35 | 34,'Andacollo',12 36 | 35,'Coquimbo',12 37 | 36,'La Higuera',12 38 | 37,'La Serena',12 39 | 38,'Paihuaco',12 40 | 39,'Vicuña',12 41 | 40,'Combarbalá',13 42 | 41,'Monte Patria',13 43 | 42,'Ovalle',13 44 | 43,'Punitaqui',13 45 | 44,'Río Hurtado',13 46 | 45,'Isla de Pascua',14 47 | 46,'Calle Larga',15 48 | 47,'Los Andes',15 49 | 48,'Rinconada',15 50 | 49,'San Esteban',15 51 | 50,'La Ligua',16 52 | 51,'Papudo',16 53 | 52,'Petorca',16 54 | 53,'Zapallar',16 55 | 54,'Hijuelas',17 56 | 55,'La Calera',17 57 | 56,'La Cruz',17 58 | 57,'Limache',17 59 | 58,'Nogales',17 60 | 59,'Olmué',17 61 | 60,'Quillota',17 62 | 61,'Algarrobo',18 63 | 62,'Cartagena',18 64 | 63,'El Quisco',18 65 | 64,'El Tabo',18 66 | 65,'San Antonio',18 67 | 66,'Santo Domingo',18 68 | 67,'Catemu',19 69 | 68,'Llaillay',19 70 | 69,'Panquehue',19 71 | 70,'Putaendo',19 72 | 71,'San Felipe',19 73 | 72,'Santa María',19 74 | 73,'Casablanca',20 75 | 74,'Concón',20 76 | 75,'Juan Fernández',20 77 | 76,'Puchuncaví',20 78 | 77,'Quilpué',20 79 | 78,'Quintero',20 80 | 79,'Valparaíso',20 81 | 80,'Villa Alemana',20 82 | 81,'Viña del Mar',20 83 | 82,'Colina',21 84 | 83,'Lampa',21 85 | 84,'Tiltil',21 86 | 85,'Pirque',22 87 | 86,'Puente Alto',22 88 | 87,'San José de Maipo',22 89 | 88,'Buin',23 90 | 89,'Calera de Tango',23 91 | 90,'Paine',23 92 | 91,'San Bernardo',23 93 | 92,'Alhué',24 94 | 93,'Curacaví',24 95 | 94,'María Pinto',24 96 | 95,'Melipilla',24 97 | 96,'San Pedro',24 98 | 97,'Cerrillos',25 99 | 98,'Cerro Navia',25 100 | 99,'Conchalí',25 101 | 100,'El Bosque',25 102 | 101,'Estación Central',25 103 | 102,'Huechuraba',25 104 | 103,'Independencia',25 105 | 104,'La Cisterna',25 106 | 105,'La Granja',25 107 | 106,'La Florida',25 108 | 107,'La Pintana',25 109 | 108,'La Reina',25 110 | 109,'Las Condes',25 111 | 110,'Lo Barnechea',25 112 | 111,'Lo Espejo',25 113 | 112,'Lo Prado',25 114 | 113,'Macul',25 115 | 114,'Maipú',25 116 | 115,'Ñuñoa',25 117 | 116,'Pedro Aguirre Cerda',25 118 | 117,'Peñalolén',25 119 | 118,'Providencia',25 120 | 119,'Pudahuel',25 121 | 120,'Quilicura',25 122 | 121,'Quinta Normal',25 123 | 122,'Recoleta',25 124 | 123,'Renca',25 125 | 124,'San Miguel',25 126 | 125,'San Joaquín',25 127 | 126,'San Ramón',25 128 | 127,'Santiago',25 129 | 128,'Vitacura',25 130 | 129,'El Monte',26 131 | 130,'Isla de Maipo',26 132 | 131,'Padre Hurtado',26 133 | 132,'Peñaflor',26 134 | 133,'Talagante',26 135 | 134,'Codegua',27 136 | 135,'Coínco',27 137 | 136,'Coltauco',27 138 | 137,'Doñihue',27 139 | 138,'Graneros',27 140 | 139,'Las Cabras',27 141 | 140,'Machalí',27 142 | 141,'Malloa',27 143 | 142,'Mostazal',27 144 | 143,'Olivar',27 145 | 144,'Peumo',27 146 | 145,'Pichidegua',27 147 | 146,'Quinta de Tilcoco',27 148 | 147,'Rancagua',27 149 | 148,'Rengo',27 150 | 149,'Requínoa',27 151 | 150,'San Vicente de Tagua Tagua',27 152 | 151,'La Estrella',28 153 | 152,'Litueche',28 154 | 153,'Marchihue',28 155 | 154,'Navidad',28 156 | 155,'Peredones',28 157 | 156,'Pichilemu',28 158 | 157,'Chépica',29 159 | 158,'Chimbarongo',29 160 | 159,'Lolol',29 161 | 160,'Nancagua',29 162 | 161,'Palmilla',29 163 | 162,'Peralillo',29 164 | 163,'Placilla',29 165 | 164,'Pumanque',29 166 | 165,'San Fernando',29 167 | 166,'Santa Cruz',29 168 | 167,'Cauquenes',30 169 | 168,'Chanco',30 170 | 169,'Pelluhue',30 171 | 170,'Curicó',31 172 | 171,'Hualañé',31 173 | 172,'Licantén',31 174 | 173,'Molina',31 175 | 174,'Rauco',31 176 | 175,'Romeral',31 177 | 176,'Sagrada Familia',31 178 | 177,'Teno',31 179 | 178,'Vichuquén',31 180 | 179,'Colbún',32 181 | 180,'Linares',32 182 | 181,'Longaví',32 183 | 182,'Parral',32 184 | 183,'Retiro',32 185 | 184,'San Javier',32 186 | 185,'Villa Alegre',32 187 | 186,'Yerbas Buenas',32 188 | 187,'Constitución',33 189 | 188,'Curepto',33 190 | 189,'Empedrado',33 191 | 190,'Maule',33 192 | 191,'Pelarco',33 193 | 192,'Pencahue',33 194 | 193,'Río Claro',33 195 | 194,'San Clemente',33 196 | 195,'San Rafael',33 197 | 196,'Talca',33 198 | 197,'Arauco',34 199 | 198,'Cañete',34 200 | 199,'Contulmo',34 201 | 200,'Curanilahue',34 202 | 201,'Lebu',34 203 | 202,'Los Álamos',34 204 | 203,'Tirúa',34 205 | 204,'Alto Biobío',35 206 | 205,'Antuco',35 207 | 206,'Cabrero',35 208 | 207,'Laja',35 209 | 208,'Los Ángeles',35 210 | 209,'Mulchén',35 211 | 210,'Nacimiento',35 212 | 211,'Negrete',35 213 | 212,'Quilaco',35 214 | 213,'Quilleco',35 215 | 214,'San Rosendo',35 216 | 215,'Santa Bárbara',35 217 | 216,'Tucapel',35 218 | 217,'Yumbel',35 219 | 218,'Chiguayante',36 220 | 219,'Concepción',36 221 | 220,'Coronel',36 222 | 221,'Florida',36 223 | 222,'Hualpén',36 224 | 223,'Hualqui',36 225 | 224,'Lota',36 226 | 225,'Penco',36 227 | 226,'San Pedro de La Paz',36 228 | 227,'Santa Juana',36 229 | 228,'Talcahuano',36 230 | 229,'Tomé',36 231 | 230,'Bulnes',37 232 | 231,'Chillán',37 233 | 232,'Chillán Viejo',37 234 | 233,'Cobquecura',37 235 | 234,'Coelemu',37 236 | 235,'Coihueco',37 237 | 236,'El Carmen',37 238 | 237,'Ninhue',37 239 | 238,'Ñiquen',37 240 | 239,'Pemuco',37 241 | 240,'Pinto',37 242 | 241,'Portezuelo',37 243 | 242,'Quillón',37 244 | 243,'Quirihue',37 245 | 244,'Ránquil',37 246 | 245,'San Carlos',37 247 | 246,'San Fabián',37 248 | 247,'San Ignacio',37 249 | 248,'San Nicolás',37 250 | 249,'Treguaco',37 251 | 250,'Yungay',37 252 | 251,'Carahue',38 253 | 252,'Cholchol',38 254 | 253,'Cunco',38 255 | 254,'Curarrehue',38 256 | 255,'Freire',38 257 | 256,'Galvarino',38 258 | 257,'Gorbea',38 259 | 258,'Lautaro',38 260 | 259,'Loncoche',38 261 | 260,'Melipeuco',38 262 | 261,'Nueva Imperial',38 263 | 262,'Padre Las Casas',38 264 | 263,'Perquenco',38 265 | 264,'Pitrufquén',38 266 | 265,'Pucón',38 267 | 266,'Saavedra',38 268 | 267,'Temuco',38 269 | 268,'Teodoro Schmidt',38 270 | 269,'Toltén',38 271 | 270,'Vilcún',38 272 | 271,'Villarrica',38 273 | 272,'Angol',39 274 | 273,'Collipulli',39 275 | 274,'Curacautín',39 276 | 275,'Ercilla',39 277 | 276,'Lonquimay',39 278 | 277,'Los Sauces',39 279 | 278,'Lumaco',39 280 | 279,'Purén',39 281 | 280,'Renaico',39 282 | 281,'Traiguén',39 283 | 282,'Victoria',39 284 | 283,'Corral',40 285 | 284,'Lanco',40 286 | 285,'Los Lagos',40 287 | 286,'Máfil',40 288 | 287,'Mariquina',40 289 | 288,'Paillaco',40 290 | 289,'Panguipulli',40 291 | 290,'Valdivia',40 292 | 291,'Futrono',41 293 | 292,'La Unión',41 294 | 293,'Lago Ranco',41 295 | 294,'Río Bueno',41 296 | 295,'Ancud',42 297 | 296,'Castro',42 298 | 297,'Chonchi',42 299 | 298,'Curaco de Vélez',42 300 | 299,'Dalcahue',42 301 | 300,'Puqueldón',42 302 | 301,'Queilén',42 303 | 302,'Quemchi',42 304 | 303,'Quellón',42 305 | 304,'Quinchao',42 306 | 305,'Calbuco',43 307 | 306,'Cochamó',43 308 | 307,'Fresia',43 309 | 308,'Frutillar',43 310 | 309,'Llanquihue',43 311 | 310,'Los Muermos',43 312 | 311,'Maullín',43 313 | 312,'Puerto Montt',43 314 | 313,'Puerto Varas',43 315 | 314,'Osorno',44 316 | 315,'Puero Octay',44 317 | 316,'Purranque',44 318 | 317,'Puyehue',44 319 | 318,'Río Negro',44 320 | 319,'San Juan de la Costa',44 321 | 320,'San Pablo',44 322 | 321,'Chaitén',45 323 | 322,'Futaleufú',45 324 | 323,'Hualaihué',45 325 | 324,'Palena',45 326 | 325,'Aisén',46 327 | 326,'Cisnes',46 328 | 327,'Guaitecas',46 329 | 328,'Cochrane',47 330 | 329,'O\'higgins',47 331 | 330,'Tortel',47 332 | 331,'Coihaique',48 333 | 332,'Lago Verde',48 334 | 333,'Chile Chico',49 335 | 334,'Río Ibáñez',49 336 | 335,'Antártica',50 337 | 336,'Cabo de Hornos',50 338 | 337,'Laguna Blanca',51 339 | 338,'Punta Arenas',51 340 | 339,'Río Verde',51 341 | 340,'San Gregorio',51 342 | 341,'Porvenir',52 343 | 342,'Primavera',52 344 | 343,'Timaukel',52 345 | 344,'Natales',53 346 | 345,'Torres del Paine',53 -------------------------------------------------------------------------------- /tutoriales/data/chile_demographic.xlsx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rpmunoz/intensivo_python_v3/509fbd8ef6a091b16b5f8c0f7b7b014545c96b4c/tutoriales/data/chile_demographic.xlsx -------------------------------------------------------------------------------- /tutoriales/data/chile_demographic_database.sql: -------------------------------------------------------------------------------- 1 | /* Estructura y Datos de las Regiones, Provincias */ 2 | /* y Comunas de Chile. */ 3 | /* */ 4 | /* Fecha: Julio 2010 */ 5 | /* Autor: Juan Pablo Aqueveque - juque.cl */ 6 | 7 | -- 8 | -- Comunas 9 | -- 10 | USE intensivopython; 11 | 12 | DROP TABLE IF EXISTS `comunas`; 13 | CREATE TABLE `comunas` ( 14 | `comuna_id` int(11) NOT NULL AUTO_INCREMENT, 15 | `comuna_nombre` varchar(64) NOT NULL, 16 | `provincia_id` int(11) NOT NULL, 17 | PRIMARY KEY (`comuna_id`) 18 | ) ENGINE=InnoDB AUTO_INCREMENT=346 DEFAULT CHARSET=utf8; 19 | 20 | INSERT INTO `comunas` (`comuna_id`,`comuna_nombre`,`provincia_id`) 21 | VALUES 22 | (1,'Arica',1), 23 | (2,'Camarones',1), 24 | (3,'General Lagos',2), 25 | (4,'Putre',2), 26 | (5,'Alto Hospicio',3), 27 | (6,'Iquique',3), 28 | (7,'Camiña',4), 29 | (8,'Colchane',4), 30 | (9,'Huara',4), 31 | (10,'Pica',4), 32 | (11,'Pozo Almonte',4), 33 | (12,'Antofagasta',5), 34 | (13,'Mejillones',5), 35 | (14,'Sierra Gorda',5), 36 | (15,'Taltal',5), 37 | (16,'Calama',6), 38 | (17,'Ollague',6), 39 | (18,'San Pedro de Atacama',6), 40 | (19,'María Elena',7), 41 | (20,'Tocopilla',7), 42 | (21,'Chañaral',8), 43 | (22,'Diego de Almagro',8), 44 | (23,'Caldera',9), 45 | (24,'Copiapó',9), 46 | (25,'Tierra Amarilla',9), 47 | (26,'Alto del Carmen',10), 48 | (27,'Freirina',10), 49 | (28,'Huasco',10), 50 | (29,'Vallenar',10), 51 | (30,'Canela',11), 52 | (31,'Illapel',11), 53 | (32,'Los Vilos',11), 54 | (33,'Salamanca',11), 55 | (34,'Andacollo',12), 56 | (35,'Coquimbo',12), 57 | (36,'La Higuera',12), 58 | (37,'La Serena',12), 59 | (38,'Paihuaco',12), 60 | (39,'Vicuña',12), 61 | (40,'Combarbalá',13), 62 | (41,'Monte Patria',13), 63 | (42,'Ovalle',13), 64 | (43,'Punitaqui',13), 65 | (44,'Río Hurtado',13), 66 | (45,'Isla de Pascua',14), 67 | (46,'Calle Larga',15), 68 | (47,'Los Andes',15), 69 | (48,'Rinconada',15), 70 | (49,'San Esteban',15), 71 | (50,'La Ligua',16), 72 | (51,'Papudo',16), 73 | (52,'Petorca',16), 74 | (53,'Zapallar',16), 75 | (54,'Hijuelas',17), 76 | (55,'La Calera',17), 77 | (56,'La Cruz',17), 78 | (57,'Limache',17), 79 | (58,'Nogales',17), 80 | (59,'Olmué',17), 81 | (60,'Quillota',17), 82 | (61,'Algarrobo',18), 83 | (62,'Cartagena',18), 84 | (63,'El Quisco',18), 85 | (64,'El Tabo',18), 86 | (65,'San Antonio',18), 87 | (66,'Santo Domingo',18), 88 | (67,'Catemu',19), 89 | (68,'Llaillay',19), 90 | (69,'Panquehue',19), 91 | (70,'Putaendo',19), 92 | (71,'San Felipe',19), 93 | (72,'Santa María',19), 94 | (73,'Casablanca',20), 95 | (74,'Concón',20), 96 | (75,'Juan Fernández',20), 97 | (76,'Puchuncaví',20), 98 | (77,'Quilpué',20), 99 | (78,'Quintero',20), 100 | (79,'Valparaíso',20), 101 | (80,'Villa Alemana',20), 102 | (81,'Viña del Mar',20), 103 | (82,'Colina',21), 104 | (83,'Lampa',21), 105 | (84,'Tiltil',21), 106 | (85,'Pirque',22), 107 | (86,'Puente Alto',22), 108 | (87,'San José de Maipo',22), 109 | (88,'Buin',23), 110 | (89,'Calera de Tango',23), 111 | (90,'Paine',23), 112 | (91,'San Bernardo',23), 113 | (92,'Alhué',24), 114 | (93,'Curacaví',24), 115 | (94,'María Pinto',24), 116 | (95,'Melipilla',24), 117 | (96,'San Pedro',24), 118 | (97,'Cerrillos',25), 119 | (98,'Cerro Navia',25), 120 | (99,'Conchalí',25), 121 | (100,'El Bosque',25), 122 | (101,'Estación Central',25), 123 | (102,'Huechuraba',25), 124 | (103,'Independencia',25), 125 | (104,'La Cisterna',25), 126 | (105,'La Granja',25), 127 | (106,'La Florida',25), 128 | (107,'La Pintana',25), 129 | (108,'La Reina',25), 130 | (109,'Las Condes',25), 131 | (110,'Lo Barnechea',25), 132 | (111,'Lo Espejo',25), 133 | (112,'Lo Prado',25), 134 | (113,'Macul',25), 135 | (114,'Maipú',25), 136 | (115,'Ñuñoa',25), 137 | (116,'Pedro Aguirre Cerda',25), 138 | (117,'Peñalolén',25), 139 | (118,'Providencia',25), 140 | (119,'Pudahuel',25), 141 | (120,'Quilicura',25), 142 | (121,'Quinta Normal',25), 143 | (122,'Recoleta',25), 144 | (123,'Renca',25), 145 | (124,'San Miguel',25), 146 | (125,'San Joaquín',25), 147 | (126,'San Ramón',25), 148 | (127,'Santiago',25), 149 | (128,'Vitacura',25), 150 | (129,'El Monte',26), 151 | (130,'Isla de Maipo',26), 152 | (131,'Padre Hurtado',26), 153 | (132,'Peñaflor',26), 154 | (133,'Talagante',26), 155 | (134,'Codegua',27), 156 | (135,'Coínco',27), 157 | (136,'Coltauco',27), 158 | (137,'Doñihue',27), 159 | (138,'Graneros',27), 160 | (139,'Las Cabras',27), 161 | (140,'Machalí',27), 162 | (141,'Malloa',27), 163 | (142,'Mostazal',27), 164 | (143,'Olivar',27), 165 | (144,'Peumo',27), 166 | (145,'Pichidegua',27), 167 | (146,'Quinta de Tilcoco',27), 168 | (147,'Rancagua',27), 169 | (148,'Rengo',27), 170 | (149,'Requínoa',27), 171 | (150,'San Vicente de Tagua Tagua',27), 172 | (151,'La Estrella',28), 173 | (152,'Litueche',28), 174 | (153,'Marchihue',28), 175 | (154,'Navidad',28), 176 | (155,'Peredones',28), 177 | (156,'Pichilemu',28), 178 | (157,'Chépica',29), 179 | (158,'Chimbarongo',29), 180 | (159,'Lolol',29), 181 | (160,'Nancagua',29), 182 | (161,'Palmilla',29), 183 | (162,'Peralillo',29), 184 | (163,'Placilla',29), 185 | (164,'Pumanque',29), 186 | (165,'San Fernando',29), 187 | (166,'Santa Cruz',29), 188 | (167,'Cauquenes',30), 189 | (168,'Chanco',30), 190 | (169,'Pelluhue',30), 191 | (170,'Curicó',31), 192 | (171,'Hualañé',31), 193 | (172,'Licantén',31), 194 | (173,'Molina',31), 195 | (174,'Rauco',31), 196 | (175,'Romeral',31), 197 | (176,'Sagrada Familia',31), 198 | (177,'Teno',31), 199 | (178,'Vichuquén',31), 200 | (179,'Colbún',32), 201 | (180,'Linares',32), 202 | (181,'Longaví',32), 203 | (182,'Parral',32), 204 | (183,'Retiro',32), 205 | (184,'San Javier',32), 206 | (185,'Villa Alegre',32), 207 | (186,'Yerbas Buenas',32), 208 | (187,'Constitución',33), 209 | (188,'Curepto',33), 210 | (189,'Empedrado',33), 211 | (190,'Maule',33), 212 | (191,'Pelarco',33), 213 | (192,'Pencahue',33), 214 | (193,'Río Claro',33), 215 | (194,'San Clemente',33), 216 | (195,'San Rafael',33), 217 | (196,'Talca',33), 218 | (197,'Arauco',34), 219 | (198,'Cañete',34), 220 | (199,'Contulmo',34), 221 | (200,'Curanilahue',34), 222 | (201,'Lebu',34), 223 | (202,'Los Álamos',34), 224 | (203,'Tirúa',34), 225 | (204,'Alto Biobío',35), 226 | (205,'Antuco',35), 227 | (206,'Cabrero',35), 228 | (207,'Laja',35), 229 | (208,'Los Ángeles',35), 230 | (209,'Mulchén',35), 231 | (210,'Nacimiento',35), 232 | (211,'Negrete',35), 233 | (212,'Quilaco',35), 234 | (213,'Quilleco',35), 235 | (214,'San Rosendo',35), 236 | (215,'Santa Bárbara',35), 237 | (216,'Tucapel',35), 238 | (217,'Yumbel',35), 239 | (218,'Chiguayante',36), 240 | (219,'Concepción',36), 241 | (220,'Coronel',36), 242 | (221,'Florida',36), 243 | (222,'Hualpén',36), 244 | (223,'Hualqui',36), 245 | (224,'Lota',36), 246 | (225,'Penco',36), 247 | (226,'San Pedro de La Paz',36), 248 | (227,'Santa Juana',36), 249 | (228,'Talcahuano',36), 250 | (229,'Tomé',36), 251 | (230,'Bulnes',37), 252 | (231,'Chillán',37), 253 | (232,'Chillán Viejo',37), 254 | (233,'Cobquecura',37), 255 | (234,'Coelemu',37), 256 | (235,'Coihueco',37), 257 | (236,'El Carmen',37), 258 | (237,'Ninhue',37), 259 | (238,'Ñiquen',37), 260 | (239,'Pemuco',37), 261 | (240,'Pinto',37), 262 | (241,'Portezuelo',37), 263 | (242,'Quillón',37), 264 | (243,'Quirihue',37), 265 | (244,'Ránquil',37), 266 | (245,'San Carlos',37), 267 | (246,'San Fabián',37), 268 | (247,'San Ignacio',37), 269 | (248,'San Nicolás',37), 270 | (249,'Treguaco',37), 271 | (250,'Yungay',37), 272 | (251,'Carahue',38), 273 | (252,'Cholchol',38), 274 | (253,'Cunco',38), 275 | (254,'Curarrehue',38), 276 | (255,'Freire',38), 277 | (256,'Galvarino',38), 278 | (257,'Gorbea',38), 279 | (258,'Lautaro',38), 280 | (259,'Loncoche',38), 281 | (260,'Melipeuco',38), 282 | (261,'Nueva Imperial',38), 283 | (262,'Padre Las Casas',38), 284 | (263,'Perquenco',38), 285 | (264,'Pitrufquén',38), 286 | (265,'Pucón',38), 287 | (266,'Saavedra',38), 288 | (267,'Temuco',38), 289 | (268,'Teodoro Schmidt',38), 290 | (269,'Toltén',38), 291 | (270,'Vilcún',38), 292 | (271,'Villarrica',38), 293 | (272,'Angol',39), 294 | (273,'Collipulli',39), 295 | (274,'Curacautín',39), 296 | (275,'Ercilla',39), 297 | (276,'Lonquimay',39), 298 | (277,'Los Sauces',39), 299 | (278,'Lumaco',39), 300 | (279,'Purén',39), 301 | (280,'Renaico',39), 302 | (281,'Traiguén',39), 303 | (282,'Victoria',39), 304 | (283,'Corral',40), 305 | (284,'Lanco',40), 306 | (285,'Los Lagos',40), 307 | (286,'Máfil',40), 308 | (287,'Mariquina',40), 309 | (288,'Paillaco',40), 310 | (289,'Panguipulli',40), 311 | (290,'Valdivia',40), 312 | (291,'Futrono',41), 313 | (292,'La Unión',41), 314 | (293,'Lago Ranco',41), 315 | (294,'Río Bueno',41), 316 | (295,'Ancud',42), 317 | (296,'Castro',42), 318 | (297,'Chonchi',42), 319 | (298,'Curaco de Vélez',42), 320 | (299,'Dalcahue',42), 321 | (300,'Puqueldón',42), 322 | (301,'Queilén',42), 323 | (302,'Quemchi',42), 324 | (303,'Quellón',42), 325 | (304,'Quinchao',42), 326 | (305,'Calbuco',43), 327 | (306,'Cochamó',43), 328 | (307,'Fresia',43), 329 | (308,'Frutillar',43), 330 | (309,'Llanquihue',43), 331 | (310,'Los Muermos',43), 332 | (311,'Maullín',43), 333 | (312,'Puerto Montt',43), 334 | (313,'Puerto Varas',43), 335 | (314,'Osorno',44), 336 | (315,'Puero Octay',44), 337 | (316,'Purranque',44), 338 | (317,'Puyehue',44), 339 | (318,'Río Negro',44), 340 | (319,'San Juan de la Costa',44), 341 | (320,'San Pablo',44), 342 | (321,'Chaitén',45), 343 | (322,'Futaleufú',45), 344 | (323,'Hualaihué',45), 345 | (324,'Palena',45), 346 | (325,'Aysén',46), 347 | (326,'Cisnes',46), 348 | (327,'Guaitecas',46), 349 | (328,'Cochrane',47), 350 | (329,'O\'higgins',47), 351 | (330,'Tortel',47), 352 | (331,'Coyhaique',48), 353 | (332,'Lago Verde',48), 354 | (333,'Chile Chico',49), 355 | (334,'Río Ibáñez',49), 356 | (335,'Antártica',50), 357 | (336,'Cabo de Hornos',50), 358 | (337,'Laguna Blanca',51), 359 | (338,'Punta Arenas',51), 360 | (339,'Río Verde',51), 361 | (340,'San Gregorio',51), 362 | (341,'Porvenir',52), 363 | (342,'Primavera',52), 364 | (343,'Timaukel',52), 365 | (344,'Natales',53), 366 | (345,'Torres del Paine',53); 367 | 368 | -- 369 | -- Provincias 370 | -- 371 | 372 | DROP TABLE IF EXISTS `provincias`; 373 | CREATE TABLE `provincias` ( 374 | `provincia_id` int(11) NOT NULL AUTO_INCREMENT, 375 | `provincia_nombre` varchar(64) NOT NULL, 376 | `region_id` int(11) NOT NULL, 377 | PRIMARY KEY (`provincia_id`) 378 | ) ENGINE=InnoDB AUTO_INCREMENT=54 DEFAULT CHARSET=utf8; 379 | 380 | INSERT INTO `provincias` (`provincia_id`,`provincia_nombre`,`region_id`) 381 | VALUES 382 | (1,'Arica',1), 383 | (2,'Parinacota',1), 384 | (3,'Iquique',2), 385 | (4,'El Tamarugal',2), 386 | (5,'Antofagasta',3), 387 | (6,'El Loa',3), 388 | (7,'Tocopilla',3), 389 | (8,'Chañaral',4), 390 | (9,'Copiapó',4), 391 | (10,'Huasco',4), 392 | (11,'Choapa',5), 393 | (12,'Elqui',5), 394 | (13,'Limarí',5), 395 | (14,'Isla de Pascua',6), 396 | (15,'Los Andes',6), 397 | (16,'Petorca',6), 398 | (17,'Quillota',6), 399 | (18,'San Antonio',6), 400 | (19,'San Felipe de Aconcagua',6), 401 | (20,'Valparaiso',6), 402 | (21,'Chacabuco',7), 403 | (22,'Cordillera',7), 404 | (23,'Maipo',7), 405 | (24,'Melipilla',7), 406 | (25,'Santiago',7), 407 | (26,'Talagante',7), 408 | (27,'Cachapoal',8), 409 | (28,'Cardenal Caro',8), 410 | (29,'Colchagua',8), 411 | (30,'Cauquenes',9), 412 | (31,'Curicó',9), 413 | (32,'Linares',9), 414 | (33,'Talca',9), 415 | (34,'Arauco',10), 416 | (35,'Bio Bío',10), 417 | (36,'Concepción',10), 418 | (37,'Ñuble',10), 419 | (38,'Cautín',11), 420 | (39,'Malleco',11), 421 | (40,'Valdivia',12), 422 | (41,'Ranco',12), 423 | (42,'Chiloé',13), 424 | (43,'Llanquihue',13), 425 | (44,'Osorno',13), 426 | (45,'Palena',13), 427 | (46,'Aysén',14), 428 | (47,'Capitán Prat',14), 429 | (48,'Coyhaique',14), 430 | (49,'General Carrera',14), 431 | (50,'Antártica Chilena',15), 432 | (51,'Magallanes',15), 433 | (52,'Tierra del Fuego',15), 434 | (53,'Última Esperanza',15); 435 | 436 | -- 437 | -- Regiones 438 | -- 439 | 440 | DROP TABLE IF EXISTS `regiones`; 441 | CREATE TABLE `regiones` ( 442 | `region_id` int(11) NOT NULL AUTO_INCREMENT, 443 | `region_nombre` varchar(64) NOT NULL, 444 | `region_ordinal` varchar(4) NOT NULL, 445 | PRIMARY KEY (`region_id`) 446 | ) ENGINE=InnoDB AUTO_INCREMENT=16 DEFAULT CHARSET=utf8; 447 | 448 | INSERT INTO `regiones` (`region_id`,`region_nombre`,`region_ordinal`) 449 | VALUES 450 | (1,'Arica y Parinacota','XV'), 451 | (2,'Tarapacá','I'), 452 | (3,'Antofagasta','II'), 453 | (4,'Atacama','III'), 454 | (5,'Coquimbo','IV'), 455 | (6,'Valparaíso','V'), 456 | (7,'Metropolitana de Santiago','RM'), 457 | (8,'Libertador General Bernardo O\'Higgins','VI'), 458 | (9,'Maule','VII'), 459 | (10,'Biobío','VIII'), 460 | (11,'La Araucanía','IX'), 461 | (12,'Los Ríos','XIV'), 462 | (13,'Los Lagos','X'), 463 | (14,'Aysén del General Carlos Ibáñez del Campo','XI'), 464 | (15,'Magallanes y de la Antártica Chilena','XII'); 465 | 466 | 467 | 468 | /* 469 | 470 | Consulta de prueba 471 | ------------------ 472 | 473 | SELECT 474 | comuna_nombre AS comuna, 475 | provincia_nombre AS provincia, 476 | region_nombre AS region 477 | FROM comunas 478 | INNER JOIN provincias ON 479 | comunas.provincia_id = provincias.provincia_id 480 | INNER JOIN regiones ON 481 | provincias.region_id = regiones.region_id 482 | WHERE region_ordinal LIKE "IX"; 483 | 484 | */ -------------------------------------------------------------------------------- /tutoriales/data/chile_poblacion.csv: -------------------------------------------------------------------------------- 1 | Codigo,Nombre,Provincia,Superficie,Poblacion_2012,Densidad,IDH_2005 2 | 15101,Arica,Arica,4799.4,210936,38.4,0.736 3 | 15102,Camarones,Arica,3927.0,679,0.3,0.751 4 | 15201,Putre,Parinacota,5902.5,1462,0.2,0.707 5 | 15202,General Lagos,Parinacota,2244.4,739,0.5,0.670 6 | 01101,Iquique,Iquique,2242.1,184953,82.4,0.766 7 | 01107,Alto Hospicio,Iquique,572.9,94455,87.6, 8 | 01401,Pozo Almonte,Tamarugal,13765.8,11519,0.7,0.722 9 | 01402,Camiña,Tamarugal,2200.2,1156,0.5,0.619 10 | 01403,Colchane,Tamarugal,4015.6,1384,0.4,0.603 11 | 01404,Huara,Tamarugal,10474.6,2360,0.2,0.676 12 | 01405,Pica,Tamarugal,8934.3,4194,0.6,0.793 13 | 02101,Antofagasta,Antofagasta,30718.1,348669,9.7,0.734 14 | 02102,Mejillones,Antofagasta,3803.9,9752,2.2,0.730 15 | 02103,Sierra Gorda,Antofagasta,12886.0,1206,0.1,0.789 16 | 02104,Taltal,Antofagasta,20405.1,13493,0.5,0.716 17 | 02201,Calama,El Loa,15596.9,147886,9.1,0.757 18 | 02202,Ollagüe,El Loa,2964.0,332,0.1,0.679 19 | 02203,San Pedro de Atacama,El Loa,23439.0,5605,0.2,0.711 20 | 02301,Tocopilla,Tocopilla,4038.8,20091,5.9,0.690 21 | 02302,María Elena,Tocopilla,12197.0,4593,0.6,0.779 22 | 03101,Copiapó,Copiapó,16681.3,158261,11.9,0.725 23 | 03102,Caldera,Copiapó,4666.6,16150,2.9,0.741 24 | 03103,Tierra Amarilla,Copiapó,11191.0,13912,1.1,0.686 25 | 03201,Chañaral,Chañaral,5772.0,14146,2.2,0.714 26 | 03202,Diego de Almagro,Chañaral,18664.0,16452,1.0,0.789 27 | 03301,Vallenar,Huasco,7084.0,52099,6.7,0.731 28 | 03302,Alto del Carmen,Huasco,5939.0,5488,0.8,0.664 29 | 03303,Freirina,Huasco,3207.0,6531,1.7,0.693 30 | 03304,Huasco,Huasco,1601.4,9015,5.6,0.695 31 | 04101,La Serena,Elqui,1892.8,211275,132.5,0.781 32 | 04102,Coquimbo,Elqui,1429.0,202441,141.6,0.731 33 | 04103,Andacollo,Elqui,310.0,11116,33.1,0.675 34 | 04104,La Higuera,Elqui,4158.2,4331,0.8,0.670 35 | 04105,Paihuano,Elqui,1495.0,4252,2.8,0.734 36 | 04106,Vicuña,Elqui,7610.0,26029,3.2,0.716 37 | 04201,Illapel,Choapa,2629.0,30598,11.6,0.667 38 | 04202,Canela,Choapa,2196.6,9182,4.2,0.644 39 | 04203,Los Vilos,Choapa,1823.8,18483,9.6,0.675 40 | 04204,Salamanca,Choapa,3445.0,25671,7.1,0.676 41 | 04301,Ovalle,Limarí,3835.0,112956,28.1,0.725 42 | 04302,Combarbalá,Limarí,2257.5,13818,7.7,0.661 43 | 04303,Monte Patria,Limarí,4366.9,30137,6.9,0.653 44 | 04304,Punitaqui,Limarí,1339.0,10418,7.1,0.653 45 | 04305,Río Hurtado,Limarí,2180.0,4149,1.9,0.653 46 | 05101,Valparaíso,Valparaíso,401.6,308137,687.2,0.701 47 | 05102,Casablanca,Valparaíso,953.0,25165,22.9,0.712 48 | 05103,Concón,Valparaíso,76.0,63210,424.6,0.781 49 | 05104,Juan Fernández,Valparaíso,149.4,792,4.0,0.744 50 | 05105,Puchuncaví,Valparaíso,300.0,16371,43.1,0.734 51 | 05107,Quintero,Valparaíso,148.0,28066,143.5,0.733 52 | 05109,Viña del Mar,Valparaíso,121.6,311399,2560.8,0.766 53 | 05201,Isla de Pascua,Isla de Pascua,163.6,5761,23.1,0.715 54 | 05301,Los Andes,Los Andes,1248.0,110866,48.2,0.756 55 | 05302,Calle Larga,Los Andes,321.7,11110,34.3,0.706 56 | 05303,Rinconada,Los Andes,122.5,8097,63.8,0.691 57 | 05304,San Esteban,Los Andes,681.0,17371,12.5,0.732 58 | 05401,La Ligua,Petorca,1163.0,38524,27.5,0.708 59 | 05402,Cabildo,Petorca,1455.0,21094,13.0,0.671 60 | 05403,Papudo,Petorca,64.2,5643,71.7,0.734 61 | 05404,Petorca,Petorca,11.6,10074,390.5,0.696 62 | 05405,Zapallar,Petorca,288.0,6726,22.1,0.743 63 | 05501,Quillota,Quillota,302.0,88803,288.5,0.726 64 | 05502,La Calera,Quillota,60.5,55207,830.0,0.700 65 | 05503,Hijuelas,Quillota,267.0,19132,71.6,0.672 66 | 05504,La Cruz,Quillota,78.0,17346,164.3,0.763 67 | 05506,Nogales,Quillota,405.0,26385,53.3,0.689 68 | 05601,San Antonio,San Antonio,405.0,87697,215.3,0.697 69 | 05602,Algarrobo,San Antonio,176.0,13472,48.9,0.722 70 | 05603,Cartagena,San Antonio,246.0,17029,68.6,0.708 71 | 05604,El Quisco,San Antonio,51.0,15829,185.6,0.745 72 | 05605,El Tabo,San Antonio,99.0,11861,71.0,0.747 73 | 05606,Santo Domingo,San Antonio,536.0,9205,34.5,0.751 74 | 05701,San Felipe,San Felipe de Aconcagua,186.0,72121,344.9,0.730 75 | 05702,Catemu,San Felipe de Aconcagua,361.6,13902,33.5,0.669 76 | 05703,Llaillay,San Felipe de Aconcagua,349.1,23680,62.0,0.676 77 | 05704,Panquehue,San Felipe de Aconcagua,121.9,7569,53.8,0.696 78 | 05705,Putaendo,San Felipe de Aconcagua,7.68,17369,1938.8,0.674 79 | 05706,Santa María,San Felipe de Aconcagua,166.3,14504,9.2,0.699 80 | 05801,Quilpué,Marga Marga,537.0,162320,280.7,0.752 81 | 05802,Limache,Marga Marga,294.0,45864,133.4,0.722 82 | 05803,Olmué,Marga Marga,232.0,16243,70.5,0.701 83 | 05804,Villa Alemana,Marga Marga,97.0,135368,1225.6,0.755 84 | 06101,Rancagua,Cachapoal,260.3,250638,823.4,0.732 85 | 06102,Codegua,Cachapoal,287.0,12725,37.6,0.706 86 | 06103,Coinco,Cachapoal,98.0,7248,65.1,0.678 87 | 06104,Coltauco,Cachapoal,225.0,17620,72.1,0.644 88 | 06105,Doñihue,Cachapoal,78.0,21023,86.7,0.685 89 | 06106,Graneros,Cachapoal,113.0,30372,252.2,0.691 90 | 06107,Las Cabras,Cachapoal,749.0,23857,27.0,0.661 91 | 06108,Machalí,Cachapoal,2597.0,44566,11.1,0.730 92 | 06109,Malloa,Cachapoal,113.0,14972,113.9,0.649 93 | 06110,Mostazal,Cachapoal,524.0,23430,44.7,0.691 94 | 06111,Olivar,Cachapoal,45.0,13483,256.5,0.661 95 | 06112,Peumo,Cachapoal,153.1,14158,92.1,0.674 96 | 06113,Pichidegua,Cachapoal,320.0,18637,55.5,0.652 97 | 06114,Quinta de Tilcoco,Cachapoal,93.0,12144,122.4,0.678 98 | 06115,Rengo,Cachapoal,755.0,56188,66.8,0.680 99 | 06116,Requínoa,Cachapoal,673.0,26235,33.0,0.668 100 | 06117,San Vicente,Cachapoal,497.8,47716,66.6,0.694 101 | 06201,Pichilemu,Cardenal Caro,749.1,13916,16.5,0.677 102 | 06202,La Estrella,Cardenal Caro,435.0,4821,9.7,0.696 103 | 06203,Litueche,Cardenal Caro,619.0,5591,8.9,0.645 104 | 06204,Marchihue,Cardenal Caro,660.0,7557,10.4,0.670 105 | 06205,Navidad,Cardenal Caro,300.0,5650,18.0,0.651 106 | 06206,Paredones,Cardenal Caro,562.0,6802,11.9,0.628 107 | 06301,San Fernando,Colchagua,2441.0,75221,30.8,0.725 108 | 06302,Chépica,Colchagua,503.0,15820,27.5,0.637 109 | 06303,Chimbarongo,Colchagua,498.0,35664,64.9,0.674 110 | 06304,Lolol,Colchagua,597.0,6630,10.4,0.628 111 | 06305,Nancagua,Colchagua,111.0,18921,140.9,0.665 112 | 06306,Palmilla,Colchagua,237.0,12373,47.3,0.676 113 | 06307,Peralillo,Colchagua,282.6,10933,38.6,0.653 114 | 06308,Placilla,Colchagua,146.9,9624,65.5,0.621 115 | 06309,Pumanque,Colchagua,441.0,3458,7.8,0.635 116 | 06310,Santa Cruz,Colchagua,419.5,35255,77.2,0.719 117 | 07101,Talca,Talca,232.0,264842,928.5,0.731 118 | 07102,Constitución,Talca,1344.0,41416,34.3,0.715 119 | 07103,Curepto,Talca,1073.8,9714,9.7,0.644 120 | 07104,Empedrado,Talca,565.0,4250,7.4,0.637 121 | 07105,Maule,Talca,190.0,21957,88.6,0.681 122 | 07106,Pelarco,Talca,332.0,7959,21.8,0.653 123 | 07107,Pencahue,Talca,956.8,9187,8.6,0.649 124 | 07108,Río Claro,Talca,431.0,13020,30.2,0.671 125 | 07109,San Clemente,Talca,4504.0,39554,9.5,0.659 126 | 07110,San Rafael,Talca,263.5,8512,29.1,0.629 127 | 07201,Cauquenes,Cauquenes,2216.0,40245,19.4,0.656 128 | 07202,Chanco,Cauquenes,530.0,9571,17.8,0.612 129 | 07203,Pelluhue,Cauquenes,371.0,6636,17.2,0.694 130 | 07301,Curicó,Curicó,1328.0,177766,133.8,0.710 131 | 07302,Hualañé,Curicó,629.0,9977,15.4,0.631 132 | 07303,Licantén,Curicó,273.0,6689,25.2,0.705 133 | 07304,Molina,Curicó,1552.0,40329,25.8,0.663 134 | 07305,Rauco,Curicó,309.0,9878,27.7,0.659 135 | 07306,Romeral,Curicó,1597.0,14460,7.9,0.668 136 | 07307,Sagrada Familia,Curicó,548.8,17839,31.9,0.672 137 | 07308,Teno,Curicó,618.4,28228,45.6,0.648 138 | 07309,Vichuquén,Curicó,426.0,4335,11.5,0.678 139 | 07401,Linares,Linares,1466.0,107311,73.1,0.710 140 | 07402,Colbún,Linares,2900.0,19361,6.0,0.638 141 | 07403,Longaví,Linares,1454.0,28968,19.3,0.626 142 | 07404,Parral,Linares,1638.0,39404,23.2,0.656 143 | 07405,Retiro,Linares,827.0,18760,22.0,0.649 144 | 07406,San Javier,Linares,1313.0,40881,31.0,0.654 145 | 07407,Villa Alegre,Linares,190.0,15428,77.5,0.648 146 | 07408,Yerbas Buenas,Linares,262.0,17158,61.5,0.640 147 | 08101,Concepción,Concepción,221.6,227768,1027.8,0.757 148 | 08102,Coronel,Concepción,279.4,107508,384.8,0.682 149 | 08103,Chiguayante,Concepción,71.5,115366,1613.5,0.764 150 | 08104,Florida,Concepción,608.6,9867,16.2,0.604 151 | 08105,Hualqui,Concepción,530.5,21934,41.3,0.666 152 | 08106,Lota,Concepción,135.8,48045,353.8,0.643 153 | 08107,Penco,Concepción,107.6,52389,486.9,0.689 154 | 08108,San Pedro de La Paz,Concepción,112.5,94827,842.9,0.787 155 | 08109,Santa Juana,Concepción,731.2,13331,18.2,0.626 156 | 08110,Talcahuano,Concepción,92.3,171673,1859.9,0.731 157 | 08111,Tomé,Concepción,494.5,55764,112.8,0.668 158 | 08112,Hualpén,Concepción,53.5,86176,1610.8, 159 | 08201,Lebu,Arauco,561.4,25790,45.9,0.633 160 | 08202,Arauco,Arauco,956.1,41153,43.0,0.704 161 | 08203,Cañete,Arauco,1089.2,33535,30.8,0.641 162 | 08204,Contulmo,Arauco,638.8,5188,8.1,0.603 163 | 08205,Curanilahue,Arauco,994.3,33855,31.0,0.643 164 | 08206,Los Álamos,Arauco,599.1,20723,34.6,0.645 165 | 08207,Tirúa,Arauco,624.4,10859,17.4,0.584 166 | 08301,Los Ángeles,Biobío,1748.2,195813,112.0,0.696 167 | 08302,Antuco,Biobío,1884.1,3774,2.0,0.662 168 | 08303,Cabrero,Biobío,639.8,29532,46.2,0.635 169 | 08304,Laja,Biobío,339.8,20964,61.7,0.665 170 | 08305,Mulchén,Biobío,1925.3,28517,14.8,0.639 171 | 08306,Nacimiento,Biobío,934.9,26145,28.0,0.656 172 | 08307,Negrete,Biobío,156.5,8933,57.1,0.629 173 | 08308,Quilaco,Biobío,1123.7,3722,3.3,0.635 174 | 08309,Quilleco,Biobío,1121.8,10396,9.3,0.641 175 | 08310,San Rosendo,Biobío,92.4,3627,39.3,0.647 176 | 08311,Santa Bárbara,Biobío,1254.9,14612,11.6,0.637 177 | 08312,Tucapel,Biobío,914.9,13442,14.7,0.655 178 | 08313,Yumbel,Biobío,727.0,20572,28.3,0.597 179 | 08314,Alto Biobío,Biobío,2124.6,10039,4.7, 180 | 08401,Chillán,Ñuble,511.2,175585,343.5,0.714 181 | 08402,Bulnes,Ñuble,425.4,21542,50.6,0.626 182 | 08403,Cobquecura,Ñuble,570.3,5173,9.1,0.633 183 | 08404,Coelemu,Ñuble,342.3,15461,45.2,0.611 184 | 08405,Coihueco,Ñuble,1776.6,24714,13.9,0.639 185 | 08406,Chillán Viejo,Ñuble,291.8,29199,100.1,0.732 186 | 08407,El Carmen,Ñuble,664.3,11830,17.8,0.611 187 | 08408,Ninhue,Ñuble,401.2,5278,13.2,0.569 188 | 08409,Ñiquén,Ñuble,493.1,10063,20.4,0.629 189 | 08410,Pemuco,Ñuble,562.7,9120,16.2,0.631 190 | 08411,Pinto,Ñuble,1164.0,10883,9.3,0.618 191 | 08412,Portezuelo,Ñuble,282.3,5061,17.9,0.599 192 | 08413,Quillón,Ñuble,423.0,15525,36.7,0.590 193 | 08414,Quirihue,Ñuble,589.0,11851,20.1,0.594 194 | 08415,Ránquil,Ñuble,248.3,4983,20.1,0.586 195 | 08416,San Carlos,Ñuble,874.0,51335,58.7,0.653 196 | 08417,San Fabián,Ñuble,1568.3,3503,2.2,0.618 197 | 08418,San Ignacio,Ñuble,363.6,15770,43.4,0.618 198 | 08419,San Nicolás,Ñuble,490.5,10051,20.5,0.625 199 | 08420,Treguaco,Ñuble,313.1,4995,16.0,0.562 200 | 08421,Yungay,Ñuble,823.5,18234,22.1,0.669 201 | 09101,Temuco,Cautín,464.0,269992,8039.0,0.763 202 | 09102,Carahue,Cautín,1340.6,25718,19.2,0.604 203 | 09103,Cunco,Cautín,1906.5,19024,10.0,0.659 204 | 09104,Curarrehue,Cautín,1170.7,7540,6.4,0.603 205 | 09105,Freire,Cautín,935.2,27616,29.5,0.614 206 | 09106,Galvarino,Cautín,568.2,11324,19.9,0.611 207 | 09107,Gorbea,Cautín,694.5,15481,22.3,0.644 208 | 09108,Lautaro,Cautín,901.1,35451,39.3,0.669 209 | 09109,Loncoche,Cautín,976.8,22191,22.7,0.652 210 | 09110,Melipeuco,Cautín,1107.3,5451,4.9,0.629 211 | 09111,Nueva Imperial,Cautín,732.5,32109,43.8,0.629 212 | 09112,Padre Las Casas,Cautín,400.7,72135,180.0,0.662 213 | 09113,Perquenco,Cautín,330.7,6911,20.9,0.630 214 | 09114,Pitrufquén,Cautín,580.7,23776,40.9,0.663 215 | 09115,Pucón,Cautín,1248.5,29987,24.0,0.767 216 | 09116,Saavedra,Cautín,400.8,13481,33.6,0.574 217 | 09117,Teodoro Schmidt,Cautín,649.9,15793,24.3,0.607 218 | 09118,Toltén,Cautín,860.4,10403,12.1,0.617 219 | 09119,Vilcún,Cautín,1420.9,23823,16.8,0.643 220 | 09120,Villarrica,Cautín,1291.1,56178,43.5,0.698 221 | 09121,Cholchol,Cautín,427.9,10825,25.3, 222 | 09201,Angol,Malleco,1194.4,51136,42.8,0.707 223 | 09202,Collipulli,Malleco,1295.9,21705,16.7,0.633 224 | 09203,Curacautín,Malleco,1664.0,15728,9.5,0.657 225 | 09204,Ercilla,Malleco,499.7,9148,18.3,0.609 226 | 09205,Lonquimay,Malleco,3914.2,11341,2.9,0.629 227 | 09206,Los Sauces,Malleco,849.8,6490,7.6,0.602 228 | 09207,Lumaco,Malleco,1119.0,10479,9.4,0.603 229 | 09208,Purén,Malleco,464.9,11789,25.4,0.594 230 | 09209,Renaico,Malleco,267.4,9028,33.8,0.615 231 | 09210,Traiguén,Malleco,908.0,18357,20.2,0.657 232 | 09211,Victoria,Malleco,1256.0,33127,26.4,0.686 233 | 14101,Valdivia,Valdivia,1016.0,163148,138.4,0.754 234 | 14102,Corral,Valdivia,767.0,5084,7.1,0.658 235 | 14103,Lanco,Valdivia,532.4,16663,28.4,0.648 236 | 14104,Los Lagos,Valdivia,1791.2,18733,11.3,0.658 237 | 14105,Máfil,Valdivia,583.0,7006,12.3,0.655 238 | 14106,Mariquina,Valdivia,1320.5,19823,15.1,0.653 239 | 14107,Paillaco,Valdivia,896.0,19898,22.0,0.647 240 | 14108,Panguipulli,Valdivia,3292.0,35185,10.1,0.627 241 | 14201,La Unión,Ranco,2137.0,38544,18.4,0.687 242 | 14202,Futrono,Ranco,2267.5,15811,6.6,0.637 243 | 14203,Lago Ranco,Ranco,1763.3,9380,5.7,0.606 244 | 14204,Río Bueno,Ranco,2211.7,31343,15.5,0.624 245 | 10101,Puerto Montt,Llanquihue,1673.0,248945,142.5,0.718 246 | 10102,Calbuco,Llanquihue,590.8,34902,59.1,0.642 247 | 10103,Cochamó,Llanquihue,3910.8,4326,1.1,0.690 248 | 10104,Fresia,Llanquihue,1278.1,12454,9.7,0.657 249 | 10105,Frutillar,Llanquihue,831.4,17756,21.4,0.669 250 | 10106,Los Muermos,Llanquihue,1245.8,16522,13.3,0.648 251 | 10107,Llanquihue,Llanquihue,420.8,18151,43.1,0.695 252 | 10108,Maullín,Llanquihue,860.8,13914,16.2,0.691 253 | 10109,Puerto Varas,Llanquihue,4064.9,39414,9.7,0.748 254 | 10201,Castro,Chiloé,472.5,50764,107.4,0.720 255 | 10202,Ancud,Chiloé,1752.4,41960,23.9,0.705 256 | 10203,Chonchi,Chiloé,1362.1,14639,10.7,0.641 257 | 10204,Curaco de Vélez,Chiloé,80.0,3884,48.6,0.702 258 | 10205,Dalcahue,Chiloé,1239.4,14548,11.7,0.690 259 | 10206,Puqueldón,Chiloé,97.3,4097,42.1,0.628 260 | 10207,Queilén,Chiloé,332.9,5319,16.0,0.646 261 | 10208,Quellón,Chiloé,3244.0,30964,9.5,0.670 262 | 10209,Quemchi,Chiloé,440.3,9191,20.9,0.656 263 | 10210,Quinchao,Chiloé,160.7,9043,56.3,0.648 264 | 10301,Osorno,Osorno,951.0,153797,152.9,0.700 265 | 10302,Puerto Octay,Osorno,1795.7,9480,5.3,0.679 266 | 10303,Purranque,Osorno,1458.8,20768,14.2,0.627 267 | 10304,Puyehue,Osorno,1597.9,11370,7.1,0.675 268 | 10305,Río Negro,Osorno,1265.7,13425,10.6,0.633 269 | 10306,San Juan de la Costa,Osorno,1517.0,7997,5.3,0.510 270 | 10307,San Pablo,Osorno,637.3,9150,14.4,0.625 271 | 10401,Chaitén,Palena,8470.5,7122,0.8,0.704 272 | 10402,Futaleufú,Palena,1280.0,1836,1.4,0.665 273 | 10403,Hualaihué,Palena,2787.7,8426,3.0,0.659 274 | 10404,Palena,Palena,2763.7,1665,0.6,0.667 275 | 11101,Coyhaique,Coyhaique,7290.2,59221,6.8,0.751 276 | 11102,Lago Verde,Coyhaique,5422.3,925,0.2,0.637 277 | 11201,Aysén,Aysén,29796.4,27187,0.9,0.674 278 | 11202,Cisnes,Aysén,16093.0,6166,0.3,0.725 279 | 11203,Guaitecas,Aysén,620.6,1862,2.4,0.654 280 | 11301,Cochrane,Capitán Prat,8599.5,2759,0.3,0.668 281 | 11302,O'Higgins,Capitán Prat,8182.5,700,0.1,0.572 282 | 11303,Tortel,Capitán Prat,19710.6,531,0.0,0.655 283 | 11401,Chile Chico,General Carrera,5737.1,5334,0.8,0.707 284 | 11402,Río Ibáñez,General Carrera,5997.2,2208,0.4,0.654 285 | 12101,Punta Arenas,Magallanes,17846.3,125483,6.8,0.748 286 | 12102,Laguna Blanca,Magallanes,3695.6,631,0.0,0.785 287 | 12103,Río Verde,Magallanes,17248.0,363,0.0,0.784 288 | 12104,San Gregorio,Magallanes,6883.7,731,0.1,0.823 289 | 12201,Cabo de Hornos,Antártica Chilena,15578.7,1677,0.1,0.806 290 | 12202,Antártica,Antártica Chilena,1250257.6,127,0.0, 291 | 12301,Porvenir,Tierra del Fuego,9707.4,5650,0.8,0.731 292 | 12302,Primavera,Tierra del Fuego,4253.4,803,0.2,0.774 293 | 12303,Timaukel,Tierra del Fuego,10758.9,873,0.1,0.717 294 | 12401,Natales,Última Esperanza,49924.1,21327,0.4,0.699 295 | 12402,Torres del Paine,Última Esperanza,6630.0,1163,0.1,0.730 296 | 13101,Santiago,Santiago,22.0,237369,8654.8,0.807 297 | 13102,Cerrillos,Santiago,21.0,79195,3422.1,0.743 298 | 13103,Cerro Navia,Santiago,11.0,128090,13361.4,0.683 299 | 13104,Conchalí,Santiago,10.7,121118,11229.0,0.707 300 | 13105,El Bosque,Santiago,14.2,162671,12365.0,0.711 301 | 13106,Estación Central,Santiago,15.0,119292,8601.5,0.735 302 | 13107,Huechuraba,Santiago,44.8,87667,1886.6,0.737 303 | 13108,Independencia,Santiago,7.0,73874,9354.1,0.709 304 | 13109,La Cisterna,Santiago,10.0,80910,8511.8,0.775 305 | 13110,La Florida,Santiago,70.2,397497,5209.0,0.804 306 | 13111,La Granja,Santiago,10.0,121214,13252.0,0.689 307 | 13112,La Pintana,Santiago,30.6,202146,8511.8,0.679 308 | 13113,La Reina,Santiago,23.0,91927,9618.3,0.883 309 | 13114,Las Condes,Santiago,99.0,289949,2524.2,0.933 310 | 13115,Lo Barnechea,Santiago,1024.0,97230,73.0,0.912 311 | 13116,Lo Espejo,Santiago,7.0,99527,15667.0,0.657 312 | 13117,Lo Prado,Santiago,7.0,94766,13100.4,0.715 313 | 13118,Macul,Santiago,12.9,111436,8656.5,0.806 314 | 13119,Maipú,Santiago,135.5,805000,3876.2,0.902 315 | 13120,Ñuñoa,Santiago,16.9,195410,8937.5,0.860 316 | 13121,Pedro Aguirre Cerda,Santiago,10.0,104018,11456.0,0.708 317 | 13122,Peñalolén,Santiago,54.0,249621,4001.1,0.743 318 | 13123,Providencia,Santiago,14.3,126487,8429.1,0.911 319 | 13124,Pudahuel,Santiago,197.0,225509,993.7,0.735 320 | 13125,Quilicura,Santiago,58.0,203946,3486.6,0.782 321 | 13126,Quinta Normal,Santiago,13.0,101737,8388.0,0.723 322 | 13127,Recoleta,Santiago,16.0,152985,9273.8,0.697 323 | 13128,Renca,Santiago,24.0,142136,8388.1,0.709 324 | 13129,San Joaquín,Santiago,9.7,94255,10064.4,0.719 325 | 13130,San Miguel,Santiago,10.0,90846,7787.2,0.765 326 | 13131,San Ramón,Santiago,7.0,85195,14600.9,0.679 327 | 13132,Vitacura,Santiago,28.3,84195,2910.7,0.949 328 | 13201,Puente Alto,Cordillera,88.0,757721,6664.8,0.773 329 | 13202,Pirque,Cordillera,445.3,20732,37.2,0.807 330 | 13203,San José de Maipo,Cordillera,4994.8,14455,0.3,0.759 331 | 13301,Colina,Chacabuco,971.2,113340,80.1,0.726 332 | 13302,Lampa,Chacabuco,452.0,79421,89.0,0.697 333 | 13303,Til Til,Chacabuco,653.0,16405,22.6,0.706 334 | 13401,San Bernardo,Maipo,155.0,277802,1974.0,0.712 335 | 13402,Buin,Maipo,214.0,74232,296.2,0.731 336 | 13403,Calera de Tango,Maipo,73.3,27781,782.6,0.792 337 | 13404,Paine,Maipo,820.0,66512,73.7,0.718 338 | 13501,Melipilla,Melipilla,1345.0,107698,70.3,0.735 339 | 13502,Alhué,Melipilla,845.0,4646,5.2,0.700 340 | 13503,Curacaví,Melipilla,693.0,28439,35.1,0.710 341 | 13504,María Pinto,Melipilla,393.5,12501,115.6,0.698 342 | 13505,San Pedro,Melipilla,788.0,8062,9.6,0.701 343 | 13601,Talagante,Talagante,126.0,78887,474.6,0.749 344 | 13602,El Monte,Talagante,118.0,32468,224.2,0.688 345 | 13603,Isla de Maipo,Talagante,189.0,33723,136.5,0.724 346 | 13604,Padre Hurtado,Talagante,80.8,50696,626.2,0.728 347 | 13605,Peñaflor,Talagante,69.0,87741,965.5,0.753 348 | -------------------------------------------------------------------------------- /tutoriales/data/chile_provincias.csv: -------------------------------------------------------------------------------- 1 | ProvinciaID,ProvinciaNombre,RegionID 2 | 1,'Arica',1 3 | 2,'Parinacota',1 4 | 3,'Iquique',2 5 | 4,'El Tamarugal',2 6 | 5,'Antofagasta',3 7 | 6,'El Loa',3 8 | 7,'Tocopilla',3 9 | 8,'Chañaral',4 10 | 9,'Copiapó',4 11 | 10,'Huasco',4 12 | 11,'Choapa',5 13 | 12,'Elqui',5 14 | 13,'Limarí',5 15 | 14,'Isla de Pascua',6 16 | 15,'Los Andes',6 17 | 16,'Petorca',6 18 | 17,'Quillota',6 19 | 18,'San Antonio',6 20 | 19,'San Felipe de Aconcagua',6 21 | 20,'Valparaiso',6 22 | 21,'Chacabuco',7 23 | 22,'Cordillera',7 24 | 23,'Maipo',7 25 | 24,'Melipilla',7 26 | 25,'Santiago',7 27 | 26,'Talagante',7 28 | 27,'Cachapoal',8 29 | 28,'Cardenal Caro',8 30 | 29,'Colchagua',8 31 | 30,'Cauquenes',9 32 | 31,'Curicó',9 33 | 32,'Linares',9 34 | 33,'Talca',9 35 | 34,'Arauco',10 36 | 35,'Bio Bío',10 37 | 36,'Concepción',10 38 | 37,'Ñuble',10 39 | 38,'Cautín',11 40 | 39,'Malleco',11 41 | 40,'Valdivia',12 42 | 41,'Ranco',12 43 | 42,'Chiloé',13 44 | 43,'Llanquihue',13 45 | 44,'Osorno',13 46 | 45,'Palena',13 47 | 46,'Aisén',14 48 | 47,'Capitán Prat',14 49 | 48,'Coihaique',14 50 | 49,'General Carrera',14 51 | 50,'Antártica Chilena',15 52 | 51,'Magallanes',15 53 | 52,'Tierra del Fuego',15 54 | 53,'Última Esperanza',15 -------------------------------------------------------------------------------- /tutoriales/data/chile_regiones.csv: -------------------------------------------------------------------------------- 1 | RegionID,RegionNombre,RegionOrdinal 2 | 1,'Arica y Parinacota','XV' 3 | 2,'Tarapacá','I' 4 | 3,'Antofagasta','II' 5 | 4,'Atacama','III' 6 | 5,'Coquimbo','IV' 7 | 6,'Valparaiso','V' 8 | 7,'Metropolitana de Santiago','RM' 9 | 8,'Libertador General Bernardo O\'Higgins','VI' 10 | 9,'Maule','VII' 11 | 10,'Biobío','VIII' 12 | 11,'La Araucanía','IX' 13 | 12,'Los Ríos','XIV' 14 | 13,'Los Lagos','X' 15 | 14,'Aisén del General Carlos Ibáñez del Campo','XI' 16 | 15,'Magallanes y de la Antártica Chilena','XII' -------------------------------------------------------------------------------- /tutoriales/data/conicyt doctorado nacional 2003-2017.csv: -------------------------------------------------------------------------------- 1 | año,n_concursados,n_aprobados 2 | 2003,333,140 3 | 2004,477,200 4 | 2005,528,220 5 | 2006,674,332 6 | 2007,930,420 7 | 2008,876,551 8 | 2009,1032,605 9 | 2010,987,604 10 | 2011,838,607 11 | 2012,931,609 12 | 2013,1019,613 13 | 2014,1294,708 14 | 2015,1479,740 15 | 2016,1559,735 16 | 2017,1795,735 -------------------------------------------------------------------------------- /tutoriales/data/fondecyt iniciacion 2007-2017.csv: -------------------------------------------------------------------------------- 1 | año,n_concursados,n_aprobados,monto_solicitado,monto_aprobado 2 | 2007,357,128,, 3 | 2008,350,181,, 4 | 2009,439,134,, 5 | 2010,489,168,25623402,8487191 6 | 2011,525,262,28836874,14019657 7 | 2012,530,293,30780656,16196452 8 | 2013,703,308,51630542,23613509 9 | 2014,894,307,63059607,21494919 10 | 2015,989,275,74183960,21234820 11 | 2016,1058,288,83694810,21847834 12 | 2017,1151,331,91168939,24620632 -------------------------------------------------------------------------------- /tutoriales/data/fondecyt postdoc 2007-2017.csv: -------------------------------------------------------------------------------- 1 | año,n_concursados,n_aprobados,monto_solicitado,monto_aprobado 2 | 2007,58,37,,922052 3 | 2008,110,74,1684744,1132227 4 | 2009,76,66,1245880,1084471 5 | 2010,140,80,6856883,3959662 6 | 2011,172,90,8686381,4662685 7 | 2012,226,150,12282093,8274817 8 | 2013,432,238,26740972,14980070 9 | 2014,629,303,40757915,19868554 10 | 2015,700,301,46696085,20580012 11 | 2016,791,291,55318090,20870304 12 | 2017,955,310,68985186,23231581 -------------------------------------------------------------------------------- /tutoriales/data/galaxies_hcn_hco.dat: -------------------------------------------------------------------------------- 1 | CGCG011-076 3.12e+08 4.15e+07 0 3.38e+08 4.71e+07 0 0.32 0.02 0 2 | NGC1797 6.40e+07 1.53e+07 0 4.88e+07 1.06e+07 0 0.62 0.01 0 3 | IRASF05189-2524 5.62e+08 9.74e+07 0 4.14e+08 9.53e+07 0 0.03 0.00 0 4 | IRASF05187-1017 2.40e+08 3.42e+07 0 2.43e+08 4.33e+07 0 0.53 0.03 0 5 | CGCG141-034 1.85e+08 3.72e+07 0 3.12e+07 2.98e+07 1 0.48 0.01 0 6 | MCG-03-04-014 4.33e+08 5.56e+07 0 4.24e+08 4.24e+07 0 0.67 0.01 0 7 | NGC0034 1.11e+08 1.81e+07 0 1.77e+08 2.28e+07 0 0.45 0.02 0 8 | IRASF22491-1808 5.09e+08 6.45e+08 1 5.03e+08 5.68e+08 1 0.48 0.02 0 9 | UGC11041 1.87e+08 3.19e+07 0 1.82e+08 2.43e+07 0 0.58 0.01 0 10 | UGC11415 3.51e+07 2.52e+07 1 1.45e+08 3.19e+07 0 0.29 0.01 0 11 | IRAS01364-1042 1.55e+08 2.21e+08 1 1.53e+08 1.37e+08 1 0.39 0.01 0 12 | NGC6907 1.20e+08 1.64e+07 0 6.56e+07 1.39e+07 0 0.57 0.01 0 13 | NGC2623 4.00e+08 7.39e+07 0 3.62e+08 8.09e+07 0 0.27 0.01 0 14 | UGC08739 1.90e+08 2.45e+07 0 1.36e+08 2.77e+07 0 0.51 0.01 0 15 | NGC5104 2.12e+08 3.80e+07 0 1.26e+08 3.33e+07 0 0.51 0.01 0 16 | ESO602-G025 2.08e+08 5.12e+07 0 1.83e+08 2.91e+07 0 0.45 0.01 0 17 | ESO593-8 2.61e+08 3.31e+08 1 2.55e+08 4.03e+08 1 0.56 0.01 0 18 | IC214 1.27e+08 3.42e+07 0 1.95e+08 4.11e+07 0 0.64 0.01 0 19 | ESO550-IG02 1.72e+08 4.32e+07 0 1.35e+08 4.24e+07 0 nan nan 1 20 | IRASF14348-1447 5.94e+08 5.20e+08 1 5.87e+08 3.62e+08 1 0.25 0.01 0 21 | IRAS18090+0130 2.56e+08 3.81e+07 0 2.95e+08 4.17e+07 0 0.61 0.01 0 22 | NGC5936 1.13e+08 1.49e+07 0 7.53e+07 1.03e+07 0 0.62 0.01 0 23 | IRASF06076-2139 6.06e+08 1.14e+08 0 1.09e+08 1.12e+08 1 0.33 0.02 0 24 | IRASF16164-0746 1.34e+08 2.65e+07 0 2.30e+08 3.00e+07 0 0.61 0.01 0 25 | NGC6701 2.28e+08 1.83e+07 0 1.83e+08 1.80e+07 0 0.55 0.01 0 26 | IC4280 1.37e+08 2.98e+07 0 1.67e+08 3.28e+07 0 0.59 0.01 0 27 | NGC0958 3.62e+07 3.36e+07 1 3.57e+07 2.70e+07 1 0.29 0.01 0 28 | IC1623 2.46e+08 2.51e+07 0 6.43e+08 2.47e+07 0 0.30 0.00 0 29 | IRASF23365+3604 1.37e+09 4.53e+08 0 2.13e+09 4.43e+08 0 0.41 0.02 0 30 | NGC6786 1.35e+08 2.23e+07 0 1.49e+08 2.83e+07 0 0.64 0.01 0 31 | CGCG247-020 2.92e+08 4.62e+07 0 1.69e+08 3.69e+07 0 0.56 0.01 0 32 | IRAS07251-0248 1.13e+09 3.56e+08 0 2.28e+08 3.48e+08 1 0.09 0.01 0 33 | Arp220 1.96e+09 1.21e+08 0 9.62e+08 1.19e+08 0 0.17 0.00 0 34 | CGCG052-037 1.92e+08 3.37e+07 0 2.10e+08 2.70e+07 0 0.62 0.01 0 35 | IRASF16399-0937 2.58e+08 3.36e+07 0 2.28e+08 3.30e+07 0 0.43 0.01 0 36 | UGC03094 2.52e+07 3.40e+07 1 1.76e+08 3.32e+07 0 0.43 0.01 0 37 | UGC12150 2.57e+08 3.11e+07 0 2.95e+08 2.64e+07 0 0.53 0.01 0 38 | NGC7591 1.46e+08 1.95e+07 0 7.35e+07 1.35e+07 0 0.48 0.01 0 39 | NGC5331 3.35e+08 5.16e+07 0 2.20e+08 5.06e+07 0 0.61 0.01 0 40 | IRASF12224-0624 7.49e+07 5.73e+07 1 7.40e+07 6.89e+07 1 0.07 0.02 0 41 | ESO507-G070 2.89e+08 4.51e+07 0 4.37e+08 4.78e+07 0 0.56 0.01 0 42 | IRASF17138-1017 1.24e+08 1.41e+07 0 1.51e+08 1.70e+07 0 0.68 0.01 0 43 | UGC05101 1.43e+09 1.32e+08 0 8.11e+08 1.12e+08 0 0.13 0.01 0 44 | VIIZw031 4.91e+08 3.96e+08 1 1.50e+09 4.75e+08 0 0.64 0.01 0 45 | CGCG049-057 2.72e+08 2.75e+07 0 1.24e+08 1.71e+07 0 0.51 0.04 0 46 | NGC6286 2.57e+08 3.40e+07 0 2.60e+08 3.34e+07 0 0.59 0.01 0 47 | NGC6285 1.41e+07 1.89e+07 1 1.39e+07 1.31e+07 1 0.66 0.02 0 48 | CGCG453-062 2.38e+08 3.90e+07 0 1.16e+08 3.83e+07 0 0.58 0.02 0 49 | -------------------------------------------------------------------------------- /tutoriales/data/poema_15_Pablo_Neruda.txt: -------------------------------------------------------------------------------- 1 | Me gustas cuando callas porque estás como ausente, 2 | y me oyes desde lejos, y mi voz no te toca. 3 | Parece que los ojos se te hubieran volado 4 | y parece que un beso te cerrara la boca. 5 | 6 | Como todas las cosas están llenas de mi alma 7 | emerges de las cosas, llena del alma mía. 8 | Mariposa de sueño, te pareces a mi alma, 9 | y te pareces a la palabra melancolía. 10 | 11 | Me gustas cuando callas y estás como distante. 12 | Y estás como quejándote, mariposa en arrullo. 13 | Y me oyes desde lejos, y mi voz no te alcanza: 14 | déjame que me calle con el silencio tuyo. 15 | 16 | Déjame que te hable también con tu silencio 17 | claro como una lámpara, simple como un anillo. 18 | Eres como la noche, callada y constelada. 19 | Tu silencio es de estrella, tan lejano y sencillo. 20 | 21 | Me gustas cuando callas porque estás como ausente. 22 | Distante y dolorosa como si hubieras muerto. 23 | Una palabra entonces, una sonrisa bastan. 24 | Y estoy alegre, alegre de que no sea cierto. -------------------------------------------------------------------------------- /tutoriales/extras/10_Entrada_y_salida.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# Entrada y salida\n", 8 | "\n", 9 | "**Autor:** Roberto Muñoz
\n", 10 | "**E-mail:**
\n", 11 | "**Github:**
\n", 12 | "\n", 13 | "\n", 14 | "Hay diferentes métodos de presentar la salida de un programa; los datos pueden ser impresos de una forma legible por humanos, o escritos a un archivo para uso futuro. Este capítulo discutirá algunas de las posibilidades." 15 | ] 16 | }, 17 | { 18 | "cell_type": "markdown", 19 | "metadata": {}, 20 | "source": [ 21 | "## 1. Formateo elegante de la salida\n", 22 | "\n", 23 | "Hasta ahora encontramos dos maneras de escribir valores: declaraciones de expresión y la función print(). (Una tercer manera es usando el método write() de los objetos tipo archivo; el archivo de salida estándar puede referenciarse como sys.stdout\n", 24 | "\n", 25 | "Frecuentemente queremos más control sobre el formateo de tu salida que simplemente imprimir valores separados por espacios. Hay dos maneras de formatear tu salida;\n", 26 | "\n", 27 | "La primera es hacer todo el manejo de las cadenas nosotros mismo: usando rebanado de cadenas y operaciones de concatenado podés crear cualquier forma que puedas imaginar. El tipo string contiene algunos métodos útiles para emparejar cadenas a un determinado ancho; estas las discutiremos en breve.\n", 28 | "\n", 29 | "La otra forma es usar formatted string literals o el método str.format().\n", 30 | "\n", 31 | "La función str() devuelve representaciones de los valores que son bastante legibles por humanos, mientras que repr() genera representaciones que pueden ser leídas por el el intérprete (o forzarían un SyntaxError si no hay sintáxis equivalente)." 32 | ] 33 | }, 34 | { 35 | "cell_type": "code", 36 | "execution_count": 1, 37 | "metadata": {}, 38 | "outputs": [], 39 | "source": [ 40 | "s = 'Hola mundo.'" 41 | ] 42 | }, 43 | { 44 | "cell_type": "code", 45 | "execution_count": 2, 46 | "metadata": {}, 47 | "outputs": [ 48 | { 49 | "data": { 50 | "text/plain": [ 51 | "'Hola mundo.'" 52 | ] 53 | }, 54 | "execution_count": 2, 55 | "metadata": {}, 56 | "output_type": "execute_result" 57 | } 58 | ], 59 | "source": [ 60 | "str(s)" 61 | ] 62 | }, 63 | { 64 | "cell_type": "code", 65 | "execution_count": 3, 66 | "metadata": {}, 67 | "outputs": [ 68 | { 69 | "data": { 70 | "text/plain": [ 71 | "\"'Hola mundo.'\"" 72 | ] 73 | }, 74 | "execution_count": 3, 75 | "metadata": {}, 76 | "output_type": "execute_result" 77 | } 78 | ], 79 | "source": [ 80 | "repr(s)" 81 | ] 82 | }, 83 | { 84 | "cell_type": "code", 85 | "execution_count": 4, 86 | "metadata": {}, 87 | "outputs": [ 88 | { 89 | "data": { 90 | "text/plain": [ 91 | "'0.14285714285714285'" 92 | ] 93 | }, 94 | "execution_count": 4, 95 | "metadata": {}, 96 | "output_type": "execute_result" 97 | } 98 | ], 99 | "source": [ 100 | "str(1 / 7)" 101 | ] 102 | }, 103 | { 104 | "cell_type": "code", 105 | "execution_count": 5, 106 | "metadata": {}, 107 | "outputs": [ 108 | { 109 | "name": "stdout", 110 | "output_type": "stream", 111 | "text": [ 112 | "El valor de x es 32.5, y es 40000...\n" 113 | ] 114 | } 115 | ], 116 | "source": [ 117 | "x = 10 * 3.25\n", 118 | "y = 200 * 200\n", 119 | "s = 'El valor de x es ' + repr(x) + ', y es ' + repr(y) + '...'\n", 120 | "print(s)" 121 | ] 122 | }, 123 | { 124 | "cell_type": "code", 125 | "execution_count": 6, 126 | "metadata": {}, 127 | "outputs": [ 128 | { 129 | "name": "stdout", 130 | "output_type": "stream", 131 | "text": [ 132 | "hola mundo\n", 133 | "\n", 134 | "'hola mundo\\n'\n" 135 | ] 136 | } 137 | ], 138 | "source": [ 139 | "# El repr() de una cadena agrega apóstrofos y barras invertidas\n", 140 | "hola = 'hola mundo\\n'\n", 141 | "holas = repr(hola)\n", 142 | "\n", 143 | "print(hola)\n", 144 | "print(holas)" 145 | ] 146 | }, 147 | { 148 | "cell_type": "markdown", 149 | "metadata": {}, 150 | "source": [ 151 | "Supongamos queremos imprimir una tabla de números que contenga el cuadrado y el cubo de estos valores en diferentes columnas. Tenemos dos maneras" 152 | ] 153 | }, 154 | { 155 | "cell_type": "code", 156 | "execution_count": 7, 157 | "metadata": {}, 158 | "outputs": [ 159 | { 160 | "name": "stdout", 161 | "output_type": "stream", 162 | "text": [ 163 | " 1 1 1\n", 164 | " 2 4 8\n", 165 | " 3 9 27\n", 166 | " 4 16 64\n", 167 | " 5 25 125\n", 168 | " 6 36 216\n", 169 | " 7 49 343\n", 170 | " 8 64 512\n", 171 | " 9 81 729\n", 172 | "10 100 1000\n" 173 | ] 174 | } 175 | ], 176 | "source": [ 177 | "for x in range(1, 11):\n", 178 | " print(repr(x).rjust(2), repr(x * x).rjust(3), end=' ')\n", 179 | " # notar el uso de 'end' en la linea anterior\n", 180 | " print(repr(x * x * x).rjust(4))" 181 | ] 182 | }, 183 | { 184 | "cell_type": "markdown", 185 | "metadata": {}, 186 | "source": [ 187 | "Este ejemplo muestra el método str.rjust() de los objetos cadena, el cual ordena una cadena a la derecha en un campo del ancho dado llenándolo con espacios a la izquierda. Hay métodos similares str.ljust() y str.center(). Estos métodos no escriben nada, sólo devuelven una nueva cadena.\n", 188 | "\n", 189 | "En el siguiente ejemplo usamos el método format()" 190 | ] 191 | }, 192 | { 193 | "cell_type": "code", 194 | "execution_count": 8, 195 | "metadata": {}, 196 | "outputs": [ 197 | { 198 | "name": "stdout", 199 | "output_type": "stream", 200 | "text": [ 201 | " 1 1 1\n", 202 | " 2 4 8\n", 203 | " 3 9 27\n", 204 | " 4 16 64\n", 205 | " 5 25 125\n", 206 | " 6 36 216\n", 207 | " 7 49 343\n", 208 | " 8 64 512\n", 209 | " 9 81 729\n", 210 | "10 100 1000\n" 211 | ] 212 | } 213 | ], 214 | "source": [ 215 | "for x in range(1,11):\n", 216 | " print('{0:2d} {1:3d} {2:4d}'.format(x, x * x, x * x * x))" 217 | ] 218 | }, 219 | { 220 | "cell_type": "markdown", 221 | "metadata": {}, 222 | "source": [ 223 | "El uso básico del método str.format() es como esto" 224 | ] 225 | }, 226 | { 227 | "cell_type": "code", 228 | "execution_count": 9, 229 | "metadata": {}, 230 | "outputs": [ 231 | { 232 | "name": "stdout", 233 | "output_type": "stream", 234 | "text": [ 235 | "Somos los caballeros quienes decimos \"Nop!\"\n" 236 | ] 237 | } 238 | ], 239 | "source": [ 240 | "print('Somos los {} quienes decimos \"{}!\"'.format('caballeros', 'Nop'))" 241 | ] 242 | }, 243 | { 244 | "cell_type": "markdown", 245 | "metadata": {}, 246 | "source": [ 247 | "Las llaves y caracteres dentro de las mismas (llamados campos de formato) son reemplazadas con los objetos pasados en el método str.format(). Un número en las llaves se refiere a la posición del objeto pasado en el método." 248 | ] 249 | }, 250 | { 251 | "cell_type": "code", 252 | "execution_count": 10, 253 | "metadata": {}, 254 | "outputs": [ 255 | { 256 | "name": "stdout", 257 | "output_type": "stream", 258 | "text": [ 259 | "carne y huevos\n" 260 | ] 261 | } 262 | ], 263 | "source": [ 264 | "print('{0} y {1}'.format('carne', 'huevos'))" 265 | ] 266 | }, 267 | { 268 | "cell_type": "code", 269 | "execution_count": 11, 270 | "metadata": {}, 271 | "outputs": [ 272 | { 273 | "name": "stdout", 274 | "output_type": "stream", 275 | "text": [ 276 | "huevos y carne\n" 277 | ] 278 | } 279 | ], 280 | "source": [ 281 | "print('{1} y {0}'.format('carne', 'huevos'))" 282 | ] 283 | }, 284 | { 285 | "cell_type": "markdown", 286 | "metadata": {}, 287 | "source": [ 288 | "Si se usan argumentos nombrados en el método str.format(), sus valores serán referidos usando el nombre del argumento." 289 | ] 290 | }, 291 | { 292 | "cell_type": "code", 293 | "execution_count": 12, 294 | "metadata": {}, 295 | "outputs": [ 296 | { 297 | "name": "stdout", 298 | "output_type": "stream", 299 | "text": [ 300 | "Esta carne es espantosa.\n" 301 | ] 302 | } 303 | ], 304 | "source": [ 305 | "print('Esta {comida} es {adjetivo}.'.format(\n", 306 | " comida='carne', adjetivo='espantosa'))" 307 | ] 308 | }, 309 | { 310 | "cell_type": "markdown", 311 | "metadata": {}, 312 | "source": [ 313 | "Un ': y especificador de formato opcionales pueden ir luego del nombre del campo. Esto aumenta el control sobre cómo el valor es formateado. El siguiente ejemplo redondea Pi a tres lugares luego del punto decimal." 314 | ] 315 | }, 316 | { 317 | "cell_type": "code", 318 | "execution_count": 13, 319 | "metadata": {}, 320 | "outputs": [ 321 | { 322 | "name": "stdout", 323 | "output_type": "stream", 324 | "text": [ 325 | "El valor de PI es aproximadamente 3.142.\n" 326 | ] 327 | } 328 | ], 329 | "source": [ 330 | "import math\n", 331 | "print('El valor de PI es aproximadamente {0:.3f}.'.format(math.pi))" 332 | ] 333 | }, 334 | { 335 | "cell_type": "markdown", 336 | "metadata": {}, 337 | "source": [ 338 | "Pasando un entero luego del ':' causará que que el campo sea de un mínimo número de caracteres de ancho. Esto es útil para hacer tablas lindas.\n", 339 | "\n" 340 | ] 341 | }, 342 | { 343 | "cell_type": "code", 344 | "execution_count": 14, 345 | "metadata": {}, 346 | "outputs": [ 347 | { 348 | "name": "stdout", 349 | "output_type": "stream", 350 | "text": [ 351 | "Sjoerd ==> 4127\n", 352 | "Jack ==> 4098\n", 353 | "Dcab ==> 7678\n" 354 | ] 355 | } 356 | ], 357 | "source": [ 358 | "tabla = {'Sjoerd': 4127, 'Jack': 4098, 'Dcab': 7678}\n", 359 | "for nombre, telefono in tabla.items():\n", 360 | " print('{0:10} ==> {1:10d}'.format(nombre, telefono))" 361 | ] 362 | }, 363 | { 364 | "cell_type": "markdown", 365 | "metadata": {}, 366 | "source": [ 367 | "El operador % también puede usarse para formateo de cadenas. Interpreta el argumento de la izquierda con el estilo de formateo de sprintf() para ser aplicado al argumento de la derecha, y devuelve la cadena resultante de esta operación de formateo. Por ejemplo:" 368 | ] 369 | }, 370 | { 371 | "cell_type": "code", 372 | "execution_count": 15, 373 | "metadata": {}, 374 | "outputs": [ 375 | { 376 | "name": "stdout", 377 | "output_type": "stream", 378 | "text": [ 379 | "El valor de PI es aproximadamente 3.142.\n" 380 | ] 381 | } 382 | ], 383 | "source": [ 384 | "import math\n", 385 | "print('El valor de PI es aproximadamente %5.3f.' % math.pi)" 386 | ] 387 | }, 388 | { 389 | "cell_type": "markdown", 390 | "metadata": {}, 391 | "source": [ 392 | "## 2. Leyendo y escribiendo archivos" 393 | ] 394 | }, 395 | { 396 | "cell_type": "code", 397 | "execution_count": null, 398 | "metadata": {}, 399 | "outputs": [], 400 | "source": [] 401 | } 402 | ], 403 | "metadata": { 404 | "kernelspec": { 405 | "display_name": "Python 3", 406 | "language": "python", 407 | "name": "python3" 408 | }, 409 | "language_info": { 410 | "codemirror_mode": { 411 | "name": "ipython", 412 | "version": 3 413 | }, 414 | "file_extension": ".py", 415 | "mimetype": "text/x-python", 416 | "name": "python", 417 | "nbconvert_exporter": "python", 418 | "pygments_lexer": "ipython3", 419 | "version": "3.6.3" 420 | } 421 | }, 422 | "nbformat": 4, 423 | "nbformat_minor": 2 424 | } 425 | -------------------------------------------------------------------------------- /tutoriales/fibo.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python3 2 | # -*- coding: utf-8 -*- 3 | """ 4 | Módulo que contiene funciones para crear la serie de Fibonacci 5 | 6 | @author: Roberto Muñoz 7 | """ 8 | 9 | 10 | def fib1(n): 11 | """ Imprime en pantalla la serie Fibonacci hasta n """ 12 | a, b = 0, 1 13 | while b < n: 14 | print(b, end=' ') 15 | a, b = b, a+b 16 | print() 17 | 18 | def fib2(n): 19 | """ Retorna una lista que contiene la serie Fibonacci hasta n """ 20 | resultado = [] 21 | a, b = 0, 1 22 | while b < n: 23 | resultado.append(b) 24 | a, b = b, a+b 25 | return resultado -------------------------------------------------------------------------------- /tutoriales/fibonacci.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python3 2 | # -*- coding: utf-8 -*- 3 | """ 4 | Módulo que contiene funciones para crear la serie de Fibonacci 5 | Permite ejecutar el módulo como script 6 | 7 | @author: Roberto Muñoz 8 | """ 9 | 10 | 11 | def fib1(n): 12 | """ Imprime en pantalla la serie Fibonacci hasta n """ 13 | a, b = 0, 1 14 | while b < n: 15 | print(b, end=' ') 16 | a, b = b, a+b 17 | print() 18 | 19 | def fib2(n): 20 | """ Retorna una lista que contiene la serie Fibonacci hasta n """ 21 | resultado = [] 22 | a, b = 0, 1 23 | while b < n: 24 | resultado.append(b) 25 | a, b = b, a+b 26 | return resultado 27 | 28 | if __name__ == "__main__": 29 | import sys 30 | fib1(int(sys.argv[1])) -------------------------------------------------------------------------------- /tutoriales/figures/banner metricarts.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rpmunoz/intensivo_python_v3/509fbd8ef6a091b16b5f8c0f7b7b014545c96b4c/tutoriales/figures/banner metricarts.png -------------------------------------------------------------------------------- /tutoriales/figures/estadistica_proyectos_fondecyt_iniciacion.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rpmunoz/intensivo_python_v3/509fbd8ef6a091b16b5f8c0f7b7b014545c96b4c/tutoriales/figures/estadistica_proyectos_fondecyt_iniciacion.pdf -------------------------------------------------------------------------------- /tutoriales/figures/estadistica_proyectos_fondecyt_iniciacion.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rpmunoz/intensivo_python_v3/509fbd8ef6a091b16b5f8c0f7b7b014545c96b4c/tutoriales/figures/estadistica_proyectos_fondecyt_iniciacion.png -------------------------------------------------------------------------------- /tutoriales/figures/estadistica_proyectos_fondecyt_postdoc.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rpmunoz/intensivo_python_v3/509fbd8ef6a091b16b5f8c0f7b7b014545c96b4c/tutoriales/figures/estadistica_proyectos_fondecyt_postdoc.pdf -------------------------------------------------------------------------------- /tutoriales/figures/estadistica_proyectos_fondecyt_postdoc.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rpmunoz/intensivo_python_v3/509fbd8ef6a091b16b5f8c0f7b7b014545c96b4c/tutoriales/figures/estadistica_proyectos_fondecyt_postdoc.png -------------------------------------------------------------------------------- /tutoriales/figures/grafico1.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rpmunoz/intensivo_python_v3/509fbd8ef6a091b16b5f8c0f7b7b014545c96b4c/tutoriales/figures/grafico1.pdf -------------------------------------------------------------------------------- /tutoriales/figures/grafico1.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rpmunoz/intensivo_python_v3/509fbd8ef6a091b16b5f8c0f7b7b014545c96b4c/tutoriales/figures/grafico1.png -------------------------------------------------------------------------------- /tutoriales/figures/perfil Roberto Munoz.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rpmunoz/intensivo_python_v3/509fbd8ef6a091b16b5f8c0f7b7b014545c96b4c/tutoriales/figures/perfil Roberto Munoz.jpg -------------------------------------------------------------------------------- /tutoriales/images/IDE_jupyter_notebook.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rpmunoz/intensivo_python_v3/509fbd8ef6a091b16b5f8c0f7b7b014545c96b4c/tutoriales/images/IDE_jupyter_notebook.png -------------------------------------------------------------------------------- /tutoriales/images/IDE_pycharm.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rpmunoz/intensivo_python_v3/509fbd8ef6a091b16b5f8c0f7b7b014545c96b4c/tutoriales/images/IDE_pycharm.png -------------------------------------------------------------------------------- /tutoriales/images/IDE_spyder.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rpmunoz/intensivo_python_v3/509fbd8ef6a091b16b5f8c0f7b7b014545c96b4c/tutoriales/images/IDE_spyder.png -------------------------------------------------------------------------------- /tutoriales/images/Python_club_question_1.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rpmunoz/intensivo_python_v3/509fbd8ef6a091b16b5f8c0f7b7b014545c96b4c/tutoriales/images/Python_club_question_1.png -------------------------------------------------------------------------------- /tutoriales/images/Python_club_question_2.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rpmunoz/intensivo_python_v3/509fbd8ef6a091b16b5f8c0f7b7b014545c96b4c/tutoriales/images/Python_club_question_2.png -------------------------------------------------------------------------------- /tutoriales/images/Python_club_question_3.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rpmunoz/intensivo_python_v3/509fbd8ef6a091b16b5f8c0f7b7b014545c96b4c/tutoriales/images/Python_club_question_3.png -------------------------------------------------------------------------------- /tutoriales/images/boolean_indexing.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rpmunoz/intensivo_python_v3/509fbd8ef6a091b16b5f8c0f7b7b014545c96b4c/tutoriales/images/boolean_indexing.png -------------------------------------------------------------------------------- /tutoriales/images/ipython-notebook-screenshot.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rpmunoz/intensivo_python_v3/509fbd8ef6a091b16b5f8c0f7b7b014545c96b4c/tutoriales/images/ipython-notebook-screenshot.jpg -------------------------------------------------------------------------------- /tutoriales/images/ipython-screenshot.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rpmunoz/intensivo_python_v3/509fbd8ef6a091b16b5f8c0f7b7b014545c96b4c/tutoriales/images/ipython-screenshot.jpg -------------------------------------------------------------------------------- /tutoriales/images/jupyter_notebook.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rpmunoz/intensivo_python_v3/509fbd8ef6a091b16b5f8c0f7b7b014545c96b4c/tutoriales/images/jupyter_notebook.png -------------------------------------------------------------------------------- /tutoriales/images/listaSobrecargas.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rpmunoz/intensivo_python_v3/509fbd8ef6a091b16b5f8c0f7b7b014545c96b4c/tutoriales/images/listaSobrecargas.png -------------------------------------------------------------------------------- /tutoriales/images/ml_classification.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rpmunoz/intensivo_python_v3/509fbd8ef6a091b16b5f8c0f7b7b014545c96b4c/tutoriales/images/ml_classification.png -------------------------------------------------------------------------------- /tutoriales/images/ml_regression.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rpmunoz/intensivo_python_v3/509fbd8ef6a091b16b5f8c0f7b7b014545c96b4c/tutoriales/images/ml_regression.png -------------------------------------------------------------------------------- /tutoriales/images/ml_statistics.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rpmunoz/intensivo_python_v3/509fbd8ef6a091b16b5f8c0f7b7b014545c96b4c/tutoriales/images/ml_statistics.png -------------------------------------------------------------------------------- /tutoriales/images/ml_supervised_blackbox.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rpmunoz/intensivo_python_v3/509fbd8ef6a091b16b5f8c0f7b7b014545c96b4c/tutoriales/images/ml_supervised_blackbox.png -------------------------------------------------------------------------------- /tutoriales/images/ml_supervised_learning.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rpmunoz/intensivo_python_v3/509fbd8ef6a091b16b5f8c0f7b7b014545c96b4c/tutoriales/images/ml_supervised_learning.png -------------------------------------------------------------------------------- /tutoriales/images/ml_types.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rpmunoz/intensivo_python_v3/509fbd8ef6a091b16b5f8c0f7b7b014545c96b4c/tutoriales/images/ml_types.png -------------------------------------------------------------------------------- /tutoriales/images/numpy_indexing.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rpmunoz/intensivo_python_v3/509fbd8ef6a091b16b5f8c0f7b7b014545c96b4c/tutoriales/images/numpy_indexing.png -------------------------------------------------------------------------------- /tutoriales/images/python-screenshot.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rpmunoz/intensivo_python_v3/509fbd8ef6a091b16b5f8c0f7b7b014545c96b4c/tutoriales/images/python-screenshot.jpg -------------------------------------------------------------------------------- /tutoriales/images/python_builtin_functions.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rpmunoz/intensivo_python_v3/509fbd8ef6a091b16b5f8c0f7b7b014545c96b4c/tutoriales/images/python_builtin_functions.png -------------------------------------------------------------------------------- /tutoriales/images/pythonclub_create_pullrequest.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rpmunoz/intensivo_python_v3/509fbd8ef6a091b16b5f8c0f7b7b014545c96b4c/tutoriales/images/pythonclub_create_pullrequest.png -------------------------------------------------------------------------------- /tutoriales/images/pythonclub_how_to_fork.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rpmunoz/intensivo_python_v3/509fbd8ef6a091b16b5f8c0f7b7b014545c96b4c/tutoriales/images/pythonclub_how_to_fork.png -------------------------------------------------------------------------------- /tutoriales/images/pythonclub_pullrequest.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rpmunoz/intensivo_python_v3/509fbd8ef6a091b16b5f8c0f7b7b014545c96b4c/tutoriales/images/pythonclub_pullrequest.png -------------------------------------------------------------------------------- /tutoriales/tools/plot_2d_separator.py: -------------------------------------------------------------------------------- 1 | import numpy as np 2 | import matplotlib.pyplot as plt 3 | 4 | 5 | def plot_2d_separator(classifier, X, fill=False, ax=None, eps=None): 6 | if eps is None: 7 | eps = X.std() / 2. 8 | x_min, x_max = X[:, 0].min() - eps, X[:, 0].max() + eps 9 | y_min, y_max = X[:, 1].min() - eps, X[:, 1].max() + eps 10 | xx = np.linspace(x_min, x_max, 100) 11 | yy = np.linspace(y_min, y_max, 100) 12 | 13 | X1, X2 = np.meshgrid(xx, yy) 14 | X_grid = np.c_[X1.ravel(), X2.ravel()] 15 | try: 16 | decision_values = classifier.decision_function(X_grid) 17 | levels = [0] 18 | fill_levels = [decision_values.min(), 0, decision_values.max()] 19 | except AttributeError: 20 | # no decision_function 21 | decision_values = classifier.predict_proba(X_grid)[:, 1] 22 | levels = [.5] 23 | fill_levels = [0, .5, 1] 24 | 25 | if ax is None: 26 | ax = plt.gca() 27 | if fill: 28 | ax.contourf(X1, X2, decision_values.reshape(X1.shape), 29 | levels=fill_levels, colors=['blue', 'red']) 30 | else: 31 | ax.contour(X1, X2, decision_values.reshape(X1.shape), levels=levels, 32 | colors="black") 33 | ax.set_xlim(x_min, x_max) 34 | ax.set_ylim(y_min, y_max) 35 | ax.set_xticks(()) 36 | ax.set_yticks(()) 37 | 38 | 39 | if __name__ == '__main__': 40 | from sklearn.datasets import make_blobs 41 | from sklearn.linear_model import LogisticRegression 42 | X, y = make_blobs(centers=2, random_state=42) 43 | clf = LogisticRegression().fit(X, y) 44 | plot_2d_separator(clf, X, fill=True) 45 | plt.scatter(X[:, 0], X[:, 1], c=y) 46 | plt.show() 47 | -------------------------------------------------------------------------------- /tutoriales/tools/plot_forest.py: -------------------------------------------------------------------------------- 1 | import numpy as np 2 | import matplotlib.pyplot as plt 3 | 4 | from sklearn.datasets import make_blobs 5 | from sklearn.ensemble import RandomForestClassifier 6 | 7 | 8 | X, y = make_blobs(centers=[[0, 0], [1, 1]], random_state=61526, n_samples=50) 9 | 10 | 11 | def plot_forest(max_depth=1): 12 | plt.figure() 13 | ax = plt.gca() 14 | h = 0.02 15 | 16 | x_min, x_max = X[:, 0].min() - .5, X[:, 0].max() + .5 17 | y_min, y_max = X[:, 1].min() - .5, X[:, 1].max() + .5 18 | xx, yy = np.meshgrid(np.arange(x_min, x_max, h), np.arange(y_min, y_max, h)) 19 | 20 | if max_depth != 0: 21 | forest = RandomForestClassifier(n_estimators=20, max_depth=max_depth, 22 | random_state=1).fit(X, y) 23 | Z = forest.predict_proba(np.c_[xx.ravel(), yy.ravel()])[:, 1] 24 | Z = Z.reshape(xx.shape) 25 | ax.contourf(xx, yy, Z, alpha=.4, cmap='RdBu_r') 26 | ax.set_title("max_depth = %d" % max_depth) 27 | else: 28 | ax.set_title("data set") 29 | ax.scatter(X[:, 0], X[:, 1], c=np.array(['b', 'r'])[y], s=60) 30 | ax.set_xlim(x_min, x_max) 31 | ax.set_ylim(y_min, y_max) 32 | ax.set_xticks(()) 33 | ax.set_yticks(()) 34 | 35 | 36 | def plot_forest_interactive(): 37 | from ipywidgets import interactive, IntSlider 38 | slider = IntSlider(min=0, max=8, step=1, value=0) 39 | return interactive(plot_forest, max_depth=slider) 40 | -------------------------------------------------------------------------------- /tutoriales/tools/plot_tree.py: -------------------------------------------------------------------------------- 1 | import numpy as np 2 | import matplotlib.pyplot as plt 3 | 4 | from sklearn.datasets import make_blobs 5 | from sklearn.tree import DecisionTreeClassifier 6 | 7 | from scipy import ndimage 8 | 9 | from .tree_plotting import plot_tree as plot_tree_mpl 10 | 11 | X, y = make_blobs(centers=[[0, 0], [1, 1]], random_state=61526, n_samples=50) 12 | 13 | 14 | def plot_tree(max_depth=1): 15 | fig, ax = plt.subplots(1, 2, figsize=(10, 5)) 16 | h = 0.02 17 | 18 | x_min, x_max = X[:, 0].min() - .5, X[:, 0].max() + .5 19 | y_min, y_max = X[:, 1].min() - .5, X[:, 1].max() + .5 20 | xx, yy = np.meshgrid(np.arange(x_min, x_max, h), 21 | np.arange(y_min, y_max, h)) 22 | 23 | if max_depth != 0: 24 | tree = DecisionTreeClassifier(max_depth=max_depth, random_state=1) 25 | tree.fit(X, y) 26 | Z = tree.predict_proba(np.c_[xx.ravel(), yy.ravel()])[:, 1] 27 | Z = Z.reshape(xx.shape) 28 | faces = tree.tree_.apply( 29 | np.c_[xx.ravel(), yy.ravel()].astype(np.float32)) 30 | faces = faces.reshape(xx.shape) 31 | border = ndimage.laplace(faces) != 0 32 | ax[0].contourf(xx, yy, Z, alpha=.4, cmap='RdBu_r') 33 | ax[0].scatter(xx[border], yy[border], marker='.', s=1) 34 | ax[0].set_title("max_depth = %d" % max_depth) 35 | plot_tree_mpl(tree, ax=ax[1], impurity=False, filled=True) 36 | # ax[1].axis("off") 37 | else: 38 | ax[0].set_title("data set") 39 | ax[1].set_visible(False) 40 | ax[0].scatter(X[:, 0], X[:, 1], c=np.array(['b', 'r'])[y], s=60) 41 | ax[0].set_xlim(x_min, x_max) 42 | ax[0].set_ylim(y_min, y_max) 43 | ax[0].set_xticks(()) 44 | ax[0].set_yticks(()) 45 | 46 | 47 | def plot_tree_interactive(): 48 | from ipywidgets import interactive, IntSlider 49 | slider = IntSlider(min=0, max=8, step=1, value=0) 50 | return interactive(plot_tree, max_depth=slider) 51 | -------------------------------------------------------------------------------- /tutoriales/tutorial_flask/hello.py: -------------------------------------------------------------------------------- 1 | from flask import Flask 2 | 3 | app = Flask(__name__) 4 | 5 | @app.route("/") 6 | def home(): 7 | return "Hello World!" 8 | 9 | app.run(debug=True) --------------------------------------------------------------------------------