From ceb2d76617b42c7e575358f2473d52eb3c71ed7e Mon Sep 17 00:00:00 2001 From: Sebastian Flores Date: Fri, 13 Apr 2018 23:58:42 -0300 Subject: [PATCH 01/17] Prueba con primer notebook traducido --- notebooks_es/1_Interactuando_con_Python.ipynb | 1451 +++++++++++++++++ 1 file changed, 1451 insertions(+) create mode 100644 notebooks_es/1_Interactuando_con_Python.ipynb diff --git a/notebooks_es/1_Interactuando_con_Python.ipynb b/notebooks_es/1_Interactuando_con_Python.ipynb new file mode 100644 index 0000000..8cb0e7a --- /dev/null +++ b/notebooks_es/1_Interactuando_con_Python.ipynb @@ -0,0 +1,1451 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "###### Contenido bajo licencia Creative Commons Attribution CC-BY 4.0, código bajo licencia BSD 3-Clause © 2017 L.A. Barba, N.C. Clementi" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Interactuando con Python\n", + "\n", + "Esta es la primera lección de nuestro curso _\"Computación de Ingeniería\"_, un curso de un semestre para estudiantes universitarios de segundo año. El curso usa Python y no asume experiencia previa en programación.\n", + "Nuestro primer paso será interactuar con Python.\n", + "Pero también aprenderemos algunos antecedentes." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## ¿Qué es Python?\n", + "\n", + "Python tiene 26 años de existencia. Su creador, [Guido van Rossum](https://en.wikipedia.org/wiki/Guido_van_Rossum), lo nombró así por la comedia británica \"Flying Circus de Monty Python\". Sus objetivos para el lenguaje eran que era un \"lenguaje fácil e intuitivo, tan poderoso como los principales competidores\", produciendo un código de computadora \"que es tan comprensible como el inglés simple\".\n", + "\n", + "Es un lenguaje de propósito general, lo que significa que puede ser usardo para cualquier cosa: organización de datos, web scraping, creación de sitios web, análisis de sonidos, creación de juegos y, por supuesto, \"cálculos de ingeniería\".\n", + "\n", + "Python es un lenguaje interpretado. Esto significa que puede escribir comandos de Python y la computadora puede ejecutar esas instrucciones directamente. Otros lenguajes de programación, como C, C ++ y Fortran, requieren un paso previo de _compilación_: traducir los comandos al lenguaje de la máquina.\n", + "Una buena habilidad de Python es que puede ser utilizada _interactivamente_. [Fernando Perez](https://en.wikipedia.org/wiki/Fernando_Pérez_ (software_developer)) creó famoso ** IPython ** como un proyecto paralelo durante su doctorado. Vamos a usar IPython (el I significa \"interactivo\") en esta lección." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## ¿Por qué Python?\n", + "\n", + "\n", + "_¡Porque es divertido!_ Con Python, cuanto más aprendes, más quieres aprender.\n", + "Puede encontrar muchos recursos en línea y, dado que Python es un proyecto de código abierto, también encontrará una comunidad amigable de personas que comparten sus conocimientos.\n", + "\n", + "Python es conocido como un lenguaje de \"alta productividad\". Como programador, necesitará menos tiempo para desarrollar una solución con Python que con la mayoría de los idiomas.\n", + "Es importante que aparezca siempre que alguien se queje de que \"Python es lento\".\n", + "¡Tu tiempo es más valioso que el de una máquina!\n", + "(Consulta la sección Lecturas recomendadas al final).\n", + "Y si realmente necesitamos acelerar nuestro programa, podemos volver a escribir las partes lentas en un lenguaje compilado después.\n", + "Porque Python interactua bien con otros idiomas :-)\n", + "\n", + "Las principales compañías tecnológicas usan Python: Google, Facebook, Dropbox, Wikipedia, Yahoo !, YouTube ... Y este año, Python ocupó el lugar número 1 en la lista interactiva de [The 2017 Top Programming Languages](http://spectrum.ieee.org/computing/software/the-2017-top-programming-languages), por _EEEE Spectrum_ ([IEEE](http://www.ieee.org/about/index.html) es la sociedad técnica profesional más grande del mundo )" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### _Python es un lenguaje versátil, puede analizar datos, crear sitios web (por ejemplo, Instagram, Mozilla, Pinterest), hacer arte o música, etc. Debido a que es un lenguaje versátil, los empleadores adoran Python: si conoces Python, querrán contratarte._ —Jessica McKellar, ex Directora de la Python Software Foundation, en un [tutorial de 2014](https://youtu.be/rkx5_MRAV3A)." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Empecemos\n", + "\n", + "En esta primera lección, usaremos IPython: una herramienta para trabajar con Python de forma interactiva. Si ya lo tienes instalado en la computadora que estás utilizando para esta lección, ingresa al programa escribiendo\n", + "\n", + "`ipython`\n", + "\n", + "en la interfaz de la línea de comandos (la aplicación **Terminal** en Mac OSX, y en Windows posiblemente la **PowerShell** o **git bash**). Obtendrás algunas líneas de texto sobre tu versión de IPython y cómo obtener ayuda, y un cursor parpadeante al lado del contador de línea de entrada:\n", + "\n", + "`En [1]:`\n", + "\n", + "Esa línea de entrada está lista para recibir cualquier código de Python para ser ejecutado de manera interactiva. La salida del código se mostrará junto a `Out [1]`, y así sucesivamente para líneas sucesivas de entrada/salida.\n", + "\n", + "##### Nota:\n", + "\n", + "Nuestro plan para este curso es trabajar en un laboratorio de computación, donde todos tendrán una computadora con todo instalado con anticipación. Por esta razón, no discutiremos la instalación en este momento. Más adelante, cuando esté ansioso por trabajar en su computadora personal, lo ayudaremos a instalar todo lo que necesita. _¡Esto es gratis!_" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Tu primer programa\n", + "\n", + "En cada clase de programación, tu primer programa consiste en imprimir un mensaje de _\"Hola mundo\"_. En Python, utiliza la función `print()`, con su mensaje entre comillas." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "¡Hola mundo!\n" + ] + } + ], + "source": [ + "print(\"¡Hola mundo!\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "¡¡Pan comido!! acabas de escribir tu primer programa y aprendiste a usar la función `print()`. Sí, `print()` es una función: pasamos el _argumento_ sobre el que queremos que actúe la función, dentro de los paréntesis. En el caso anterior, pasamos un _string_, que es una serie de caracteres entre comillas. No te preocupes, volveremos a los strings más adelante en esta lección." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "##### Concepto clave: función\n", + "\n", + "Una función es una colección compacta de código que ejecuta alguna acción en sus _argumentos_. Cada función de Python tiene un _nombre_, usado para llamarlo, y toma sus argumentos dentro de corchetes. Algunos argumentos pueden ser opcionales (lo que significa que tienen un valor predeterminado definido dentro de la función), otros son obligatorios. Por ejemplo, la función `print()` tiene un argumento requerido: la cadena de caracteres que debe imprimir para usted.\n", + "\n", + "Python viene con muchas funciones _predefinidas_, pero también puedes construir las tuyas propias. Cortar bloques de código en funciones es una de las mejores estrategias para lidiar con programas complejos. Te hace más eficiente, porque puedes reutilizar el código que escribiste en una función. La modularidad y la reutilización son las herramientas diarias de un programador." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Python como calculadora\n", + "\n", + "Prueba cualquier operación aritmética en IPython. Los símbolos son lo que esperaría, excepto el operador de potencia, que obtiene con dos asteriscos: `**`. Prueba todos estos:\n", + "\n", + "```python\n", + "+ - */**% //\n", + "```\n", + "\n", + "El símbolo `%` es el operador _módulo_ (divide y devuelve el resto), y la barra doble es _división entera_." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "4" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "2 + 2" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "4.9" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "1.25 + 3.65" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "2" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "5 - 3" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "8" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "2 * 4" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "3.5" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "7 / 2" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "8" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "2**3" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Veamos un caso interesante:" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "4.5" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "9**1/2" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "##### Discute con tu vecino:\n", + "_¿Qué pasó?_¿No es $ 9 ^ {1/2} = 3 $? (Aumentar al poder $ 1/2 $ es lo mismo que tomar la raíz cuadrada.) ¿Python se equivocó?\n", + "\n", + "Compara con esto:" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "3.0" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "9**(1/2)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "¡Sí! ¡El orden de las operaciones es importante!\n", + "\n", + "Si no recuerdas de lo que estamos hablando, revise la [Aritmética/Orden de operaciones](https://en.wikibooks.org/wiki/Arithmetic/Order_of_Operations). Una situación frecuente que expone esto es la siguiente:" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "4.5" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "3 + 3 / 2" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "3.0" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "(3 + 3) / 2" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "En el primer caso, estamos agregando $ 3 $ más el número resultante de la operación $ 3/2 $. Si queremos que la división se aplique al resultado de $ 3 + 3 $, necesitamos los paréntesis." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "##### Ejercicios:\n", + "Usa IPython (como una calculadora) para resolver los siguientes dos problemas:\n", + "\n", + "1. El volumen de una esfera con radio $ r $ es $ \\frac {4} {3} \\pi r ^ 3 $. ¿Cuál es el volumen de una esfera con un diámetro de 6.65 cm?\n", + "\n", + "    Por el valor de $ \\pi $ usa 3.14159 (por ahora). Compare su respuesta con la solución hasta 4 números decimales.\n", + "\n", + "    Sugerencia: 523.5983 es incorrecto y 615.9184 también es incorrecto.\n", + "    \n", + "2. Supongamos que el precio de un libro es $ \\$ 24.95 $, pero las librerías obtienen un descuento de $ 40 \\% $. El envío cuesta $ \\$ 3 $ por la primera copia y $ 75 $ centavos por cada copia adicional. ¿Cuál es el costo total al por mayor de $ 60 $ copias? Compare su respuesta con la solución hasta 2 números decimales." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Para revelar las respuestas, resalta la siguiente línea de texto con el ratón:" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Respuesta ejercicio 1: 153.9796 Respuesta ejercicio 2: 945.45 " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Variables y su tipo\n", + "\n", + "Las variables constan de dos partes: un nombre y un valor. Cuando queremos dar a una variable su nombre y valor, usamos el signo igual: `nombre = valor`. Esto se llama una 'asignación'. El nombre de la variable va a la izquierda y el valor a la derecha.\n", + "\n", + "¡Lo primero a lo que hay que acostumbrarse es a que el signo igual en una tarea tiene un significado diferente del que tiene en Algebra! Imagina que es una flecha que apunta de `nombre` a` valor`.\n", + "\n", + "\n", + "\n", + "Tenemos muchas posibilidades para nombres de variables: pueden estar formados por letras mayúsculas y minúsculas, guiones bajos y dígitos ... aunque los dígitos no pueden ir al principio del nombre. Por ejemplo, los nombres de variable válidos son:\n", + "\n", + "```python\n", + "    X\n", + "    x1\n", + "    X_2\n", + "    nombre_3\n", + "    NombreApellido\n", + "```\n", + "Ten en cuenta que hay palabras reservadas que no puede usar; son las [palabras reservadas de Python](https://docs.python.org/3/reference/lexical_analysis.html#keywords).\n", + "  \n", + "OK. Asignemos algunos valores a las variables y realicemos algunas operaciones con ellos:" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "x = 3 " + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "y = 4.5" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "##### Ejercicio:\n", + "Imprime los valores de las variables `x` y` y`." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Hagamos algunas operaciones aritméticas con nuestras nuevas variables:" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "7.5" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "x + y" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "8" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "2**x" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "1.5" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "y - 3" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Y ahora, revisemos los valores de `x` y` y`. ¿Siguen siendo los mismos que cuando los asignaste?" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "3\n" + ] + } + ], + "source": [ + "print(x)" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "4.5\n" + ] + } + ], + "source": [ + "print(y)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Variables de cadena\n", + "\n", + "Además del nombre y el valor, las variables de Python tienen un _typo_ (_type_): el tipo del valor al que se refiere. Por ejemplo, un valor entero tiene el tipo `int`, y un número real tiene el tipo` float`. Una cadena es una variable que consiste en una secuencia de caracteres marcados por dos comillas, y tiene el tipo `str`." + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "z = 'this is a string'" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "w = '1'" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "¿Qué pasa si intentas \"agregar\" dos cadenas?" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'this is a string1'" + ] + }, + "execution_count": 21, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "z + w" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "La operación anterior se llama _concatenación_: encadenando dos cadenas juntas en una. Interesante, ¿eh? Pero mira esto:" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [ + { + "ename": "TypeError", + "evalue": "unsupported operand type(s) for +: 'int' and 'str'", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mx\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0mw\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", + "\u001b[0;31mTypeError\u001b[0m: unsupported operand type(s) for +: 'int' and 'str'" + ] + } + ], + "source": [ + "x + w" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "_¡Error!_ ¿Por qué? Examinemos lo que Python tiene que decir y exploremos lo que está sucediendo.\n", + "\n", + "Python es un lenguaje dinámico, lo que significa que no necesitas especificar un tipo para llamar un objeto existente. El apodo humorístico para esto es \"duck typing\" (comportamiento de pato):\n", + "\n", + "#### \"Cuando veo un ave que camina como un pato, nada como un pato y suena como un pato, a esa ave yo la llamo un pato.\".\n", + "\n", + "En otras palabras, una variable tiene un tipo, pero no necesitamos especificarlo. Simplemente se comportará como se supone que debe hacerlo cuando operemos con él (graznará y caminará como fue la intención de la naturaleza).\n", + "\n", + "Pero a veces debe asegurarse de conocer el tipo de variable. Afortunadamente, Python ofrece una función para encontrar el tipo de variable: `type()`." + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "int" + ] + }, + "execution_count": 23, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "type(x)" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "str" + ] + }, + "execution_count": 24, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "type(w)" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "float" + ] + }, + "execution_count": 25, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "type(y)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Más asignaciones\n", + "\n", + "¿Qué sucede si se desea asignar a una nueva variable el resultado de una operación que involucra otras variables? ¡Ningún problema!" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "sum_xy = x + y\n", + "diff_xy = x - y" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "ename": "NameError", + "evalue": "name 'sum_xy' is not defined", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'The sum of x and y is:'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0msum_xy\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 2\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'The difference between x and y is:'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdiff_xy\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mNameError\u001b[0m: name 'sum_xy' is not defined" + ] + } + ], + "source": [ + "print('The sum of x and y is:', sum_xy)\n", + "print('The difference between x and y is:', diff_xy)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Observa lo que hicimos arriba: utilizamos la función `print()` con una cadena de texto (string), seguido de una variable, y Python imprimió una combinación útil del mensaje y el valor de la variable. Un consejo profesional: Quieres imprimir mensajes para humanos. Veamos ahora el tipo de las nuevas variables que acabamos de crear:" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "float" + ] + }, + "execution_count": 28, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "type(sum_xy)" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "float" + ] + }, + "execution_count": 29, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "type(diff_xy)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "##### Discute con tu vecino:\n", + "¿Puedes resumir lo que hicimos arriba?" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Variables especiales\n", + "\n", + "Python tiene variables especiales que están integradas en el lenguaje. Estos son:\n", + "`True`,` False`, `None` y` NotImplemented`.\n", + "Por ahora, veremos solo los primeros tres de estos.\n", + "\n", + "** Las variables booleanas ** se utilizan para representar valores de verdad, y pueden tomar uno de dos valores posibles: `True` y` False`.\n", + "_Expresiones lógicas_ devuelven booleanos. Aquí está la expresión lógica más simple, usando la palabra reservada `not`:\n", + "\n", + "```Python\n", + "  not True\n", + "```\n", + "\n", + "Retorna ... lo has adivinado ... `False` (Falso).\n", + "\n", + "La función de Python `bool()` devuelve un valor de verdad asignado a cualquier argumento. Cualquier número que no sea cero tiene un valor de verdad de `True`, así como cualquier cadena o lista no vacía. El número cero y cualquier cadena o lista vacía tendrán un valor de verdad de `False`. Explore la función `bool ()` con varios argumentos." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "False" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "bool(0)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "True" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "bool('Do we need oxygen?')" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "True" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "bool('We do not need oxygen')" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "collapsed": true + }, + "source": [ + "**None no es cero **: `None` (ninguno, nada) es una variable especial que indica que no se asignó ningún valor o que un comportamiento no está definido. Es diferente del valor cero, una cadena vacía o algún otro valor nulo.\n", + "\n", + "Puedes verificar que no sea cero tratando de agregarlo a un número. Veamos qué pasa cuando intentamos eso:" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "a = None\n", + "\n", + "b = 3" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "metadata": {}, + "outputs": [ + { + "ename": "TypeError", + "evalue": "unsupported operand type(s) for +: 'NoneType' and 'int'", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0ma\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0mb\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", + "\u001b[0;31mTypeError\u001b[0m: unsupported operand type(s) for +: 'NoneType' and 'int'" + ] + } + ], + "source": [ + "a + b" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Operadores lógicos y de comparación\n", + "\n", + "Los operadores de comparación de Python son: `<`, `<=`, `>`, `> =`, `==`, `!=`. Comparan dos objetos y devuelven `True` o` False`: menor, menor o igual, mayor, mayor o igual, igual, distinto. ¡Intentalo!" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "x = 3\n", + "y = 5" + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "False" + ] + }, + "execution_count": 36, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "x > y" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Podemos asignar el valor de verdad de una operación de comparación a un nuevo nombre de variable:" + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "z = x > y" + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "False" + ] + }, + "execution_count": 38, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "z" + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "bool" + ] + }, + "execution_count": 39, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "type(z)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Los operadores lógicos son los siguientes: `and`,` or`, y `not`. Funcionan igual que en el inglés. Una expresión lógica con `and` es verdadera (`True`) sólo si ambos operandos son verdaderos. Una expresión con `or` es verdadera (`True`) cuando cualquiera de los operandos es verdadero. Y la palabra clave `not` siempre niega la expresión que le sigue.\n", + "\n", + "Hagamos algunos ejemplos:" + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "a = 5\n", + "b = 3\n", + "c = 10" + ] + }, + { + "cell_type": "code", + "execution_count": 41, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "False" + ] + }, + "execution_count": 41, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "a > b and b > c" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Recuerde que el operador lógico `and` es `True` solo cuando ambos operandos son `True`. En el caso anterior, el primer operando es `True` pero el segundo es` False`.\n", + "\n", + "Si probamos la operación `or` usando los mismos operandos, deberíamos obtener un `True`." + ] + }, + { + "cell_type": "code", + "execution_count": 42, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "True" + ] + }, + "execution_count": 42, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "a > b or b > c" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Y la negación del segundo operando resulta en ..." + ] + }, + { + "cell_type": "code", + "execution_count": 43, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "True" + ] + }, + "execution_count": 43, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "not b > c" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "¿Qué pasa si negamos el segundo operando en la operación `and` de arriba?\n", + "\n", + "##### Nota:\n", + "\n", + "Tenga cuidado con el orden de las operaciones lógicas. El orden de precedencia en la lógica es:\n", + "\n", + "1. Negación (`not`)\n", + "2. Y (`and`)\n", + "3. O (`or`)\n", + "\n", + "Si no recuerda esto, asegúrese de usar paréntesis para indicar el orden que desea." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "##### Ejercicio:\n", + "\n", + "¿Qué está pasando en el caso a continuación? Juega con operadores lógicos y prueba algunos ejemplos." + ] + }, + { + "cell_type": "code", + "execution_count": 44, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "True" + ] + }, + "execution_count": 44, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "a > b and not b > c" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Lo que hemos aprendido\n", + "\n", + "* Como se usa la función `print()`. El concepto de _función_.\n", + "* Usar Python como una calculadora.\n", + "* Conceptos de variable, tipo, asignación.\n", + "* Variables especiales: `True`,` False`, `None`.\n", + "* Operaciones compatibles, operaciones lógicas.\n", + "* Lectura de mensajes de error." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Referencias\n", + "\n", + "A lo largo de este módulo de curso, vamos a usar las siguientes referencias:\n", + "\n", + "1. _Effective Computation in Physics: Field Guide to Research with Python_ (Computación Eficaz en Física: Guía de campo para la investigación con Python, 2015). Anthony Scopatz & Kathryn D. Huff. O'Reilly Media, Inc.\n", + "2. _Python for Everybody: Exploring Data Using Python 3_ (Python para todos: explorando datos con Python 3, 2016). Charles R. Severance. [PDF available](http://do1.dr-chuck.com/pythonlearn/EN_us/pythonlearn.pdf)\n", + "3. _Think Python: How to Think Like a Computer Scientist_ (Piensa en Python: Aprenda a pensar como un cientista computacional, 2012). Allen Downey. Green Tea Press. [PDF available](http://greenteapress.com/thinkpython/thinkpython.pdf)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Lecturas recomendadas\n", + "\n", + "- [\"Yes, Python is Slow, and I Don’t Care\"](https://hackernoon.com/yes-python-is-slow-and-i-dont-care-13763980b5a1) (\"Sí, Python es lento, y no me importa\") por Nick Humrich, en Hackernoon. Conviene omitir la parte de microservicios, que es un poco especializada, y continuar después de la foto de las luces del automóvil en movimiento.\n", + "- [\"Why I Push for Python\"](http://lorenabarba.com/blog/why-i-push-for-python/) (Por qué apoyo a Python), por la profesora Lorena A. Barba (2014). Esta publicación de blog obtuvo un poco de interés en [Hacker News](https://news.ycombinator.com/item?id=7760870)." + ] + }, + { + "cell_type": "code", + "execution_count": 45, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + "\n", + "\n", + "\n", + "\n" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 45, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Execute this cell to load the notebook's style sheet, then ignore it\n", + "from IPython.core.display import HTML\n", + "css_file = '../style/custom.css'\n", + "HTML(open(css_file, \"r\").read())" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.6.4" + }, + "widgets": { + "state": {}, + "version": "1.1.2" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} From 4cec86eb5ba59db5c468063c5f449c5b8d0d9ead Mon Sep 17 00:00:00 2001 From: Sebastian Flores Date: Sat, 14 Apr 2018 22:27:33 -0300 Subject: [PATCH 02/17] Improving notebook 1, adding other translated notebooks --- notebooks_es/1_Interactuando_con_Python.ipynb | 28 +- .../2_Strings_y_listas_en_Jupyter.ipynb | 2405 +++++++++++++++++ notebooks_es/3_Ejemplo_con_MAEbulletin.ipynb | 726 +++++ notebooks_es/4_NumPy_Arrays_y_Graficos.ipynb | 1639 +++++++++++ .../5_Regresion_Lineal_con_datos_reales.ipynb | 1227 +++++++++ 5 files changed, 6010 insertions(+), 15 deletions(-) create mode 100644 notebooks_es/2_Strings_y_listas_en_Jupyter.ipynb create mode 100644 notebooks_es/3_Ejemplo_con_MAEbulletin.ipynb create mode 100644 notebooks_es/4_NumPy_Arrays_y_Graficos.ipynb create mode 100644 notebooks_es/5_Regresion_Lineal_con_datos_reales.ipynb diff --git a/notebooks_es/1_Interactuando_con_Python.ipynb b/notebooks_es/1_Interactuando_con_Python.ipynb index 8cb0e7a..412c031 100644 --- a/notebooks_es/1_Interactuando_con_Python.ipynb +++ b/notebooks_es/1_Interactuando_con_Python.ipynb @@ -14,8 +14,7 @@ "# Interactuando con Python\n", "\n", "Esta es la primera lección de nuestro curso _\"Computación de Ingeniería\"_, un curso de un semestre para estudiantes universitarios de segundo año. El curso usa Python y no asume experiencia previa en programación.\n", - "Nuestro primer paso será interactuar con Python.\n", - "Pero también aprenderemos algunos antecedentes." + "Nuestro primer paso será interactuar con Python. Pero primero veamos algunos datos interesantes." ] }, { @@ -24,11 +23,11 @@ "source": [ "## ¿Qué es Python?\n", "\n", - "Python tiene 26 años de existencia. Su creador, [Guido van Rossum](https://en.wikipedia.org/wiki/Guido_van_Rossum), lo nombró así por la comedia británica \"Flying Circus de Monty Python\". Sus objetivos para el lenguaje eran que era un \"lenguaje fácil e intuitivo, tan poderoso como los principales competidores\", produciendo un código de computadora \"que es tan comprensible como el inglés simple\".\n", + "Python tiene 26 años de existencia. Su creador, [Guido van Rossum](https://en.wikipedia.org/wiki/Guido_van_Rossum), lo nombró así por la comedia británica \"Flying Circus de Monty Python\". Sus objetivos para el lenguaje eran que era un \"lenguaje fácil e intuitivo, tan poderoso como los principales competidores\", produciendo un código de computadora \"que sea tan comprensible como el inglés\".\n", "\n", "Es un lenguaje de propósito general, lo que significa que puede ser usardo para cualquier cosa: organización de datos, web scraping, creación de sitios web, análisis de sonidos, creación de juegos y, por supuesto, \"cálculos de ingeniería\".\n", "\n", - "Python es un lenguaje interpretado. Esto significa que puede escribir comandos de Python y la computadora puede ejecutar esas instrucciones directamente. Otros lenguajes de programación, como C, C ++ y Fortran, requieren un paso previo de _compilación_: traducir los comandos al lenguaje de la máquina.\n", + "Python es un lenguaje interpretado. Esto significa que puedes escribir comandos de Python y la computadora ejecuta esas instrucciones directamente. Otros lenguajes de programación, como C, C ++ y Fortran, requieren un paso previo de _compilación_: traducir los comandos al lenguaje de la máquina.\n", "Una buena habilidad de Python es que puede ser utilizada _interactivamente_. [Fernando Perez](https://en.wikipedia.org/wiki/Fernando_Pérez_ (software_developer)) creó famoso ** IPython ** como un proyecto paralelo durante su doctorado. Vamos a usar IPython (el I significa \"interactivo\") en esta lección." ] }, @@ -39,15 +38,14 @@ "## ¿Por qué Python?\n", "\n", "\n", - "_¡Porque es divertido!_ Con Python, cuanto más aprendes, más quieres aprender.\n", - "Puede encontrar muchos recursos en línea y, dado que Python es un proyecto de código abierto, también encontrará una comunidad amigable de personas que comparten sus conocimientos.\n", + "_¡Porque es divertido!_ Con Python, cuanto más aprendes, más querrás aprender.\n", + "Existen muchos recursos en línea y, dado que Python es un proyecto de código abierto, también encontrarás una comunidad amigable de personas que comparten sus conocimientos.\n", "\n", - "Python es conocido como un lenguaje de \"alta productividad\". Como programador, necesitará menos tiempo para desarrollar una solución con Python que con la mayoría de los idiomas.\n", - "Es importante que aparezca siempre que alguien se queje de que \"Python es lento\".\n", + "Python es conocido como un lenguaje de \"alta productividad\". Como programador, necesitarás menos tiempo para desarrollar una solución con Python que con la mayoría de los idiomas.\n", + "Esto es importante cuando alguien te diga que \"Python es lento\".\n", "¡Tu tiempo es más valioso que el de una máquina!\n", - "(Consulta la sección Lecturas recomendadas al final).\n", - "Y si realmente necesitamos acelerar nuestro programa, podemos volver a escribir las partes lentas en un lenguaje compilado después.\n", - "Porque Python interactua bien con otros idiomas :-)\n", + "(Al respecto, consulta la sección Lecturas recomendadas al final).\n", + "Y si realmente necesitamos acelerar nuestro programa, podemos volver a escribir las partes lentas en un lenguaje compilado después. Porque Python interactua bien con otros idiomas :-)\n", "\n", "Las principales compañías tecnológicas usan Python: Google, Facebook, Dropbox, Wikipedia, Yahoo !, YouTube ... Y este año, Python ocupó el lugar número 1 en la lista interactiva de [The 2017 Top Programming Languages](http://spectrum.ieee.org/computing/software/the-2017-top-programming-languages), por _EEEE Spectrum_ ([IEEE](http://www.ieee.org/about/index.html) es la sociedad técnica profesional más grande del mundo )" ] @@ -77,7 +75,7 @@ "\n", "##### Nota:\n", "\n", - "Nuestro plan para este curso es trabajar en un laboratorio de computación, donde todos tendrán una computadora con todo instalado con anticipación. Por esta razón, no discutiremos la instalación en este momento. Más adelante, cuando esté ansioso por trabajar en su computadora personal, lo ayudaremos a instalar todo lo que necesita. _¡Esto es gratis!_" + "Nuestro plan para este curso es trabajar en un laboratorio de computación, donde todos tendrán una computadora con todo instalado con anticipación. Por esta razón, no discutiremos la instalación en este momento. Más adelante, cuando esté ansioso por trabajar en su computadora personal, te ayudaremos a instalar todo lo que necesita. _¡Esto es gratis!_" ] }, { @@ -86,7 +84,7 @@ "source": [ "### Tu primer programa\n", "\n", - "En cada clase de programación, tu primer programa consiste en imprimir un mensaje de _\"Hola mundo\"_. En Python, utiliza la función `print()`, con su mensaje entre comillas." + "En todo curso de programación, tu primer programa consiste en imprimir un mensaje que diga _\"Hola mundo\"_. En Python, esto se logra con la función `print()`, con su mensaje entre comillas." ] }, { @@ -119,9 +117,9 @@ "source": [ "##### Concepto clave: función\n", "\n", - "Una función es una colección compacta de código que ejecuta alguna acción en sus _argumentos_. Cada función de Python tiene un _nombre_, usado para llamarlo, y toma sus argumentos dentro de corchetes. Algunos argumentos pueden ser opcionales (lo que significa que tienen un valor predeterminado definido dentro de la función), otros son obligatorios. Por ejemplo, la función `print()` tiene un argumento requerido: la cadena de caracteres que debe imprimir para usted.\n", + "Una función es una colección compacta de código que ejecuta alguna acción en sus _argumentos_. Cada función de Python tiene un _nombre_, usado para llamarlo, y toma sus argumentos dentro de corchetes. Algunos argumentos pueden ser opcionales (lo que significa que tienen un valor predeterminado definido dentro de la función), otros son obligatorios. Por ejemplo, la función `print()` tiene un argumento requerido: la cadena de caracteres que se desea imprimir.\n", "\n", - "Python viene con muchas funciones _predefinidas_, pero también puedes construir las tuyas propias. Cortar bloques de código en funciones es una de las mejores estrategias para lidiar con programas complejos. Te hace más eficiente, porque puedes reutilizar el código que escribiste en una función. La modularidad y la reutilización son las herramientas diarias de un programador." + "Python viene con muchas funciones _predefinidas_, pero también puedes construir funciones propias. Dividir los distintos bloques de código en funciones es una de las mejores estrategias para lidiar con programas complejos. Te hace más eficiente, porque puedes reutilizar el código que escribiste en una función. La modularidad y la reutilización son las herramientas diarias de un programador." ] }, { diff --git a/notebooks_es/2_Strings_y_listas_en_Jupyter.ipynb b/notebooks_es/2_Strings_y_listas_en_Jupyter.ipynb new file mode 100644 index 0000000..215c543 --- /dev/null +++ b/notebooks_es/2_Strings_y_listas_en_Jupyter.ipynb @@ -0,0 +1,2405 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "###### Contenido bajo licencia Creative Commons Attribution CC-BY 4.0, código bajo licencia BSD 3-Clause © 2017 L.A. Barba, N.C. Clementi" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Juega con datos en Jupyter\n", + "\n", + "Esta es la segunda lección de nuestro curso en _\"Cálculos de ingeniería\". _ En la primera lección, [_Interactuando con Python_](http://nbviewer.jupyter.org/github/engineersCode/EngComp1_offtheground/blob/master/notebooks_en/1_Interacting_with_Python .ipynb), usamos ** IPython **, el shell interactivo de Python. Es realmente genial escribir expresiones de Python de una sola línea y obtener los resultados de forma interactiva. Sin embargo, lo creas o no, ¡hay cosas más grandes!\n", + "\n", + "En esta lección, continuarás jugando con datos usando Python, pero lo harás en un ** cuaderno Jupyter **. Esta misma lección está escrita en un cuaderno de Jupyter. Listo? Lo amarás." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## ¿Qué es Jupyter?\n", + "\n", + "Jupyter es un conjunto de herramientas de código abierto para la informática interactiva y exploratoria. Trabajas directamente en tu navegador, que se convierte en la interfaz de usuario a través de la cual Jupyter te proporciona un explorador de archivos (el _dashboard_) y un formato de documento: el ** cuaderno **.\n", + "\n", + "Un cuaderno Jupyter puede contener: entrada y salida de código, texto formateado, imágenes, videos, bonitas ecuaciones matemáticas y mucho más. El código de la computadora es _executable_, lo que significa que puede ejecutar los bits de código, directamente en el documento, y obtener la salida de ese código que se muestra para usted. Esta forma interactiva de computación, mezclada con la narrativa multimedia, le permite contar una historia (¡incluso a usted mismo) con poderes adicionales!" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Trabajar en Jupyter\n", + "\n", + "Varias cosas le parecerán contraintuitivas al principio. Por ejemplo, la mayoría de las personas están acostumbradas a iniciar aplicaciones en sus computadoras haciendo clic en algún ícono: esto es lo primero que se debe \"desaprender\". Jupyter se lanza desde la línea de comando_ (como cuando lanzaste IPython). A continuación, tenemos dos tipos de contenido: código y reducción, que se manejan de forma un poco diferente. El hecho de que su navegador sea una interfaz para un motor de cómputo (llamado \"kernel\") lleva a un mantenimiento interno adicional (como cerrar el kernel). ¡Pero te acostumbrarás bastante rápido!" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Start Jupyter\n", + "\n", + "La forma estándar de iniciar Jupyter es escribir lo siguiente en la interfaz de línea de comandos:\n", + "\n", + "`cuaderno jupyter`\n", + "\n", + "Presiona enter y tadah !!\n", + "Después de un poco de tiempo de configuración, su navegador predeterminado se abrirá con la aplicación Jupyter. Debería verse como en la captura de pantalla siguiente, pero es posible que vea una lista de archivos y carpetas, según la ubicación de su computadora donde la lanzó.\n", + "\n", + "##### Nota:\n", + "\n", + "No cierre la ventana de la terminal donde lanzó Jupyter (mientras todavía está trabajando en Jupyter). Si necesita hacer otras tareas en la línea de comando, abra una nueva ventana de terminal.\n", + "\n", + "\n", + "#### Captura de pantalla del tablero de Jupyter, abierto en el navegador.\n", + "\n", + "\n", + "Para iniciar un nuevo cuaderno Jupyter, haga clic en la esquina superior derecha, donde dice ** Nuevo **, y seleccione `Python 3`. Mira la captura de pantalla a continuación.\n", + "\n", + "\n", + "#### Captura de pantalla que muestra cómo crear un nuevo cuaderno.\n", + "\n", + "Aparecerá una nueva pestaña en su navegador y verá un cuaderno vacío, con una sola línea de entrada, esperando que ingrese algún código. Ver la siguiente captura de pantalla.\n", + "\n", + "\n", + "#### Captura de pantalla que muestra un nuevo cuaderno vacío.\n", + "\n", + "El notebook se abre de manera predeterminada con una sola celda de código vacía. Intenta escribir allí un código Python y ejecútalo presionando `[shift] + [enter]`." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Celdas de notebook\n", + "\n", + "El cuaderno Jupyter usa _cells_: bloques que dividen fragmentos de texto y código. Cualquier contenido de texto se ingresa en una celda * Markdown *: contiene texto que puede formatear con marcadores simples para obtener encabezados, negrita, cursiva, viñetas, hipervínculos y más.\n", + "\n", + "Markdown es fácil de aprender, consulte la sintaxis en la página web [\"Daring Fireball\"](https://daringfireball.net/projects/markdown/syntax) (por John Gruber). Algunos consejos:\n", + "\n", + "* para crear un título, use un hash para comenzar la línea: `# Title`\n", + "* para crear el siguiente encabezado, use dos hashes (y así sucesivamente): `## Heading`\n", + "* para poner en cursiva una palabra o frase, enciérrelo en asteriscos (o en las líneas inferiores): `* italic *` o `_italic_`\n", + "* para que sea negrita, enciérrelo con dos asteriscos: `** en negrita **`\n", + "* para hacer un hipervínculo, use corchetes cuadrados y redondos: `[texto hipervinculado](url)`\n", + "\n", + "El contenido computable se ingresa en celdas de código. Usaremos el kernel de IPython (\"kernel\" es el nombre utilizado para el motor de computación), pero debe saber que Jupyter se puede usar con muchos lenguajes de computación diferentes. Es asombroso.\n", + "\n", + "Una celda de código le mostrará una marca de entrada, como esta:\n", + "\n", + "`En []:`\n", + "\n", + "Una vez que agregue un código y lo ejecute, Jupyter agregará una ID de número a la celda de entrada, y producirá una salida marcada así:\n", + "\n", + "`Fuera [1]:`\n", + "\n", + "##### Un poco de historia:\n", + "\n", + "Markdown fue co-creado por el legendario pero trágico [Aaron Swartz](https://en.wikipedia.org/wiki/Aaron_Swartz). El documental biográfico sobre él se llama [\"The Own Boy de Internet\"](https://en.wikipedia.org/wiki/The_Internet%27s_Own_Boy) y puedes verlo en YouTube o Netflix. ¡Recomendado!" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Computación interactiva en el cuaderno\n", + "\n", + "Mire los iconos en el menú de Jupyter (vea las capturas de pantalla arriba). El primer ícono a la izquierda (un disquete viejo) es para guardar su computadora portátil. Puede agregar una nueva celda con el gran botón ** + **. Luego tiene los botones cortar, copiar y pegar. Las flechas son para mover su celda actual hacia arriba o hacia abajo. Luego tiene un botón para \"ejecutar\" una celda de código (ejecutar el código), el icono cuadrado significa \"detener\" y la flecha swirly para \"reiniciar\" el núcleo de su computadora portátil (si el cálculo está atascado, por ejemplo). Junto a eso, tiene el selector de tipo de celda: Código o Marcado (u otros que puede ignorar por ahora).\n", + "\n", + "Puede probar una celda de código escribiendo algunas operaciones aritméticas. Como vimos en nuestra primera lección, los operadores de Python son:\n", + "```python\n", + "    + - */**% //\n", + "```\n", + "\n", + "Hay suma, resta, multiplicación y división. Los últimos tres operadores son _exponent_ (raise to the power of), _modulo_ (divide y devuelve el resto) y _floor division_.\n", + "\n", + "Tecleando `[shift] + [enter]` ejecutará la celda y le dará la salida en una nueva línea, etiquetada como `Out [1]` (la numeración aumenta cada vez que ejecuta una celda).\n", + "\n", + "##### ¡Intentalo!\n", + "\n", + "Agregue una celda con el botón más, ingrese algunas operaciones, y `[shift] + [enter]` para ejecutar." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Todo lo que hicimos usando IPython lo podemos hacer en celdas de código dentro de un portátil Jupyter. Pruebe algunas de las cosas que aprendimos en la lección 1:" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Hello World!\n" + ] + } + ], + "source": [ + "print(\"Hello World!\")" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "False" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "x = 2**8\n", + "x < 64" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Modo de edición y modo de comando\n", + "\n", + "Una vez que haga clic en una celda de la notebook para seleccionarla, puede interactuar con ella de dos maneras, que se llaman _modes_. Más adelante, cuando revise este material nuevamente, lea más sobre esto en la Referencia 1.\n", + "\n", + "**Modo de edición:**\n", + "\n", + "* Ingresamos ** al modo de edición ** presionando 'Enter' o haciendo doble clic en la celda.\n", + "\n", + "* Sabemos que estamos en este modo cuando vemos un borde de celda verde y un mensaje en el área de la celda.\n", + "\n", + "* Cuando estamos en modo de edición, podemos escribir en la celda, como un editor de texto normal.\n", + "\n", + "\n", + "** Modo de comando: **\n", + "\n", + "* Ingresamos en ** modo de comando ** presionando `Esc` o haciendo clic fuera del área de la celda.\n", + "\n", + "* Sabemos que estamos en este modo cuando vemos un borde de celda gris con un margen azul izquierdo.\n", + "\n", + "* En este modo, ciertas teclas se asignan a accesos directos para ayudar con\n", + "  acciones comunes.\n", + "\n", + "\n", + "Puede encontrar una lista de los accesos directos seleccionando `Ayuda-> Métodos abreviados de teclado`\n", + "desde la barra de menú del notebook. Es posible que desee dejar esto para más adelante y volver a él, pero se vuelve más útil cuanto más use Jupyter." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Cómo cerrar el kernel y salir\n", + "\n", + "Cerrar la pestaña del navegador donde ha estado trabajando en una computadora portátil no \"cierra\" inmediatamente el kernel de cómputo. Entonces a veces necesitas hacer un poco de limpieza.\n", + "\n", + "Una vez que cierre una computadora portátil, verá en la aplicación Jupyter principal que su\n", + "el archivo del cuaderno tiene un símbolo del libro verde al lado. Debería hacer clic en el cuadro a la izquierda de ese símbolo, y luego hacer clic donde dice ** Apagar **. No necesita hacer esto todo el tiempo, pero si tiene un lote de computadoras portátiles en ejecución, usarán recursos en su máquina.\n", + "\n", + "Del mismo modo, Jupyter aún se está ejecutando incluso después de cerrar la pestaña que tiene abierto el tablero de Jupyter. Para salir de la aplicación Jupyter, debe ir a la terminal que utilizó para abrir Jupyter, y escriba `[Ctrl] + [c]` para salir." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Nbviewer\n", + "\n", + "[Nbviewer](http://nbviewer.jupyter.org/) es un servicio web gratuito que le permite compartir versiones estáticas de archivos portátiles alojados, como si se tratara de una página web. Si un archivo de computadora portátil está disponible públicamente en la web, puede verlo ingresando su URL en la página web de nbviewer y presionando el botón ** Ir! **. El cuaderno se representará como una página estática: los visitantes pueden leer todo, pero no pueden interactuar con el código." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Juega con cadenas de Python\n", + "\n", + "Sigamos jugando con cadenas, pero ahora codificamos en un cuaderno Jupyter (en lugar de IPython). Le recomendamos que abra un nuevo cuaderno limpio para seguir los ejemplos de esta lección y escriba los comandos que ve. (Si copia y pega, ahorrará tiempo, pero aprenderá poco. ¡Tipee todo!)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "str_1 = 'hello'\n", + "str_2 = 'world'" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Recuerde que podemos concatenar cadenas (\"agregar\"), por ejemplo:" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "helloworld\n" + ] + } + ], + "source": [ + "new_string = str_1 + str_2\n", + "print(new_string)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "¿Qué ocurre si queremos agregar un espacio que separa `hello` from` world`? Añadimos directamente la cadena `''` en el medio de las dos variables. Un espacio es un personaje!" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "hello world\n" + ] + } + ], + "source": [ + "my_string = str_1 + ' ' + str_2\n", + "print(my_string)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "##### Ejercicio:\n", + "\n", + "Cree una nueva variable de cadena que agregue tres signos de admiración al final de `my_string`." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "collapsed": true + }, + "source": [ + "### Indexación\n", + "\n", + "Podemos acceder a cada carácter por separado en una cadena (o un segmento continuo de ella) usando _indices_: enteros que denotan la posición del carácter en la cadena. Los índices van entre corchetes, tocando el nombre de la variable de cadena a la derecha. Por ejemplo, para acceder al primer elemento de `new_string`, debemos ingresar` new_string [0] `. ¡Sí! en Python comenzamos a contar desde 0." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'h'" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "my_string[0]" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'l'" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "#If we want the 3rd element we do:\n", + "my_string[2]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Es posible que haya notado que en la celda de arriba tenemos una línea antes del código que comienza con el signo `#`. Esa línea parece ser ignorada por Python: ¿sabes por qué?\n", + "\n", + "Es un comentario: cuando quiera comentar su código de Python, coloca un `#` delante del comentario. Por ejemplo:" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'e'" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "my_string[1] #this is how we access the second element of a string" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "¿Cómo sabemos el índice del último elemento en la cadena?\n", + "\n", + "Python tiene una función incorporada llamada `len ()` que proporciona la información sobre la longitud de un objeto. Vamos a intentarlo:" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "11" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "len(my_string)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "¡Estupendo! Ahora sabemos que `my_string` tiene once caracteres. ¿Qué sucede si ingresamos este número como índice?" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "ename": "IndexError", + "evalue": "string index out of range", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mIndexError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mmy_string\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m11\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", + "\u001b[0;31mIndexError\u001b[0m: string index out of range" + ] + } + ], + "source": [ + "my_string[11]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Oops. Tenemos un error: ¿por qué? Sabemos que la longitud de `my_string` es once. Pero el número entero 11 no funciona como un índice. Si esperaba obtener el último elemento, es porque olvidó que Python comienza a contar a cero. No te preocupes: lleva un tiempo acostumbrarse.\n", + "\n", + "El mensaje de error dice que el índice está fuera de rango: esto es porque el índice del _último elemento_ siempre será: `len (cadena) - 1`. En nuestro caso, ese número es 10. Probémoslo." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'d'" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "my_string[10]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Python también ofrece una forma inteligente de captar el último elemento, por lo que no es necesario calcular la longitud y restar uno: está utilizando un 1 negativo para el índice. Me gusta esto:" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'d'" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "my_string[-1]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "¿Qué pasa si usamos un `-2` como índice?" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'l'" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "my_string[-2]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Esa es la última `l` en la cadena` hello world`. ¡Python es tan inteligente que puede contar hacia atrás!" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Cortar cadenas\n", + "\n", + "A veces, queremos captar más de un elemento: es posible que deseemos una sección de la cadena. Lo hacemos utilizando la notación _slicing_ entre corchetes. Por ejemplo, podemos usar `[start: end]`, donde `start` es el índice para comenzar el corte, y` end` es el índice (no incluido) para terminar el corte. Por ejemplo, para tomar la palabra `hello` de nuestra cadena, hacemos:" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'hello'" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "my_string[0:5]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Puede omitir el índice `start`, si desea cortar desde el principio de la cadena, y puede omitir el` end` de una porción, lo que indica que desea llegar hasta el final de la cadena. Por ejemplo, si queremos tomar la palabra `'world'` de` my_string`, podríamos hacer lo siguiente:" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'world'" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "my_string[6:]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Una forma útil de visualizar segmentos es imaginar que los índices apuntan a los espacios _entre_caracteres en la cadena. De esta forma, cuando escriba `my_string [i]`, se estaría refiriendo al \"carácter a la derecha de` i` \"(Referencia 2).\n", + "\n", + "Mira el diagrama a continuación. Comenzamos a contar a cero; la letra '' g'` está a la derecha del índice 2. Entonces, si queremos agarrar la subcadena `'gin'` de` 'engineer'`, necesitamos `[start: end] = [2: 5 ] `.\n", + "\n", + "" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "collapsed": true + }, + "source": [ + "¡Inténtalo tú mismo!" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'gin'" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Define your string\n", + "eng_string = 'engineer'\n", + "\n", + "# Grab 'gin'slice\n", + "eng_string[2:5]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "##### Ejercicios:\n", + "\n", + "1. Defina una cadena llamada `'banana'` e imprima la primera y última' 'a'`.\n", + "2. Usando la misma cuerda, agarre las 2 rebanadas posibles que corresponden a la palabra \"ana\" e imprímalas.\n", + "3. Cree su propio ejercicio de rebanar y pídales a sus compañeros que lo prueben (trabaje en grupos de 3)." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Las siguientes líneas contienen las soluciones; para revelar la respuesta, seleccione las líneas con el mouse:\n", + " \n", + "Ejercicio de solución 1:\n", + "\n", + " b = 'banana' \n", + " print (b [1]) \n", + " print (b [-1]) \n", + "\n", + "\n", + "Ejercicio de solución 2:\n", + "\n", + " print (b [1: 4]) \n", + " print (b [3:]) " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### ¿Qué más podemos hacer con las cadenas?\n", + "\n", + "Python tiene muchas funciones integradas útiles para cadenas. Aprenderá algunos de ellos en esta sección. Un detalle técnico: en Python, algunas funciones están asociadas a una clase particular de objetos (por ejemplo, cadenas de caracteres). La palabra ** method ** se usa en este caso, y tenemos una nueva forma de llamarlos: el operador de punto. Es un poco contra-intuitivo que el nombre del método viene después del punto, mientras que el nombre del objeto en particular en el que actúa es lo primero. Me gusta esto: `mystring.method ()`.\n", + "\n", + "Si tiene curiosidad acerca de los muchos métodos disponibles para cadenas, vaya a la sección \"Métodos de cadena incorporados\" en este [tutorial](https://www.tutorialspoint.com/python3/python_strings.htm).\n", + "\n", + "Usemos una cita de Albert Einstein como una cadena y apliquemos algunos métodos de cadena útiles." + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "AE_quote = \"Everybody is a genius. But if you judge a fish by its ability to climb a tree, it will live its whole life believing that it is stupid.\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "El método ** `count ()` ** da el número de ocurrencias de una subcadena en un rango. Los argumentos para el rango son opcionales.\n", + "\n", + "*Sintaxis:*\n", + "\n", + "`str.count (subcadena, inicio, fin)`\n", + "\n", + "Aquí, `start` y` end` son enteros que indican los índices donde comenzar y finalizar el conteo. Por ejemplo, si queremos saber cuántas letras '' e '' tenemos en toda la cadena, podemos hacer:" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "10" + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "AE_quote.count('e')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Si queremos saber cuántos de esos `` e'` caracteres están en el rango `[0:20]`, hacemos:" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "2" + ] + }, + "execution_count": 19, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "AE_quote.count('e', 0, 20)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Podemos buscar cadenas más complejas, por ejemplo:" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "1" + ] + }, + "execution_count": 20, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "AE_quote.count('Everybody')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "El método ** find () ** nos dice si una cadena `'substr'` ocurre en la cadena en la que estamos aplicando el método. Los argumentos para el rango son opcionales.\n", + "\n", + "*Sintaxis:*\n", + "\n", + "`str.find (substr, start, end)`\n", + "\n", + "Donde `start` y` end` son índices que indican dónde comenzar y terminar el corte para aplicar el método `find ()`.\n", + "\n", + "Si la cadena `'substr'` está en la cadena original, el método` find () `devolverá el índice donde comienza la subcadena, de lo contrario devolverá` -1`.\n", + "\n", + "Por ejemplo, busquemos la palabra \"pez\" en la cita de Albert Einstein." + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "42" + ] + }, + "execution_count": 21, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "AE_quote.find('fish')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Si conocemos la longitud de nuestra subcadena, ahora podemos aplicar la notación de corte para tomar la palabra \"pez\"." + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "4" + ] + }, + "execution_count": 22, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "len('fish')" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'fish'" + ] + }, + "execution_count": 23, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "AE_quote[42: 42 + len('fish')]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Veamos qué sucede cuando tratamos de buscar una cadena que no está en la cita." + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "-1" + ] + }, + "execution_count": 24, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "AE_quote.find('albert')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Devuelve `-1` ... pero cuidado, ¡eso no significa que la posición esté al final de la cadena original! Si leemos la [documentación](https://docs.python.org/3/library/stdtypes.html#string-methods), confirmamos que un valor devuelto de `-1` indica que la subcadena que estamos buscar es _no en la cadena_ en la que estamos buscando\n", + "\n", + "Un método similar es ** `index ()` **: funciona como el método `find ()`, pero genera un error si no se encuentra la cadena que estamos buscando.\n", + "\n", + "*Sintaxis:*\n", + "\n", + "`str.index (substr, start, end)`" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "42" + ] + }, + "execution_count": 25, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "AE_quote.index('fish')" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [ + { + "ename": "ValueError", + "evalue": "substring not found", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mValueError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mAE_quote\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mindex\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'albert'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", + "\u001b[0;31mValueError\u001b[0m: substring not found" + ] + } + ], + "source": [ + "AE_quote.index('albert')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "En el ejemplo anterior, usamos la función `len ()` para calcular la longitud de la cadena `'fish'`, y usamos el resultado para calcular el índice final. Sin embargo, si la cadena es demasiado larga, tener una línea que calcule la longitud puede ser inconveniente o puede hacer que su código parezca desordenado. Para evitar esto, podemos usar los métodos `find ()` o `index ()` para calcular la posición final. En el ejemplo de \"pez\", podríamos buscar el índice de la palabra \"by\" (la palabra que sigue a \"pez\") y restar 1 de ese índice para obtener el índice que corresponde al espacio correcto. después de `'fish'`. ¡Hay muchas formas de cortar cuerdas, solo limitadas por tu imaginación!\n", + "\n", + "##### Nota:\n", + "Recuerde que el índice final no es inclusivo, por lo que queremos el índice del espacio que sigue a la cadena `'peces'`." + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "idx_start = AE_quote.index('fish')\n", + "idx_end = AE_quote.index('by') - 1 # -1 to get the index off the space after 'fish'" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'fish'" + ] + }, + "execution_count": 28, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "AE_quote[idx_start:idx_end]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "##### Ejercicios:\n", + "\n", + "1. Usa el método `count ()` para contar cuántas letras '' a'` están en 'AE_quote`?\n", + "2. Usando el mismo método, ¿cuántas letras aisladas `'a'` están en` AE_quote`?\n", + "3. Usa el método `index ()` para encontrar la posición de las palabras `'genius'`,`' judge'` y `'tree'` en` AE_quote`.\n", + "4. Con la sintaxis de corte, extraiga las palabras del ejercicio 3 de `AE_quote`." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Otros dos métodos de cadena resultan útiles cuando trabaja con textos y necesita limpiar, separar o categorizar partes del texto.\n", + "\n", + "Vamos a trabajar con una cadena diferente, una cita de Eleanor Roosevelt:" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "ER_quote = \" Great minds discuss ideas; average minds discuss events; small minds discuss people. \"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Tenga en cuenta que la cadena que definimos anteriormente contiene espacios en blanco adicionales al principio y al final. En este caso, lo hicimos a propósito, pero a menudo hay espacios extra molestos cuando leemos texto de un archivo (quizás debido a la sangría de un párrafo).\n", + "\n", + "Las cadenas tienen un método que nos permite deshacernos de esos espacios en blanco adicionales.\n", + "\n", + "El método ** `strip ()` ** devuelve una copia de la cadena en la que se eliminan todos los caracteres dados como argumento desde el principio y el final de la cadena.\n", + "\n", + "*Sintaxis:*\n", + "\n", + "`str.strip ([chars])`\n", + "\n", + "El argumento predeterminado es el carácter de espacio. Por ejemplo, si queremos eliminar los espacios en blanco en `ER_quote` y guardar el resultado en` ER_quote`, podemos hacer:" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "ER_quote = ER_quote.strip()" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'Great minds discuss ideas; average minds discuss events; small minds discuss people.'" + ] + }, + "execution_count": 31, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "ER_quote" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Supongamos que quieres quitar el período al final; podrías hacer lo siguiente:\n", + "\n", + "`ER_quote = ER_quote.strip ('.')`\n", + "\n", + "Pero si no queremos mantener los cambios en nuestra variable de cadena, no sobrescribimos la variable como hicimos anteriormente. Veamos cómo se ve:" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'Great minds discuss ideas; average minds discuss events; small minds discuss people'" + ] + }, + "execution_count": 32, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "ER_quote.strip('.')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Verifique la variable de cadena para confirmar que no cambió (todavía tiene el punto al final):" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'Great minds discuss ideas; average minds discuss events; small minds discuss people.'" + ] + }, + "execution_count": 33, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "ER_quote" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Otro método útil es ** `startswith ()` **, para averiguar si una cadena comienza con un cierto carácter.\n", + "Más adelante en esta lección veremos un ejemplo más interesante; pero por ahora, solo \"verifiquemos\" si nuestra cadena comienza con la palabra \"genial\"." + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "False" + ] + }, + "execution_count": 34, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "ER_quote.startswith('great')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "La salida es `False` porque la palabra no está en mayúscula. Las letras mayúsculas y minúsculas son caracteres distintos." + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "True" + ] + }, + "execution_count": 35, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "ER_quote.startswith('Great')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Es importante mencionar que no es necesario que coincidamos con el personaje hasta que lleguemos al espacio en blanco." + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "True" + ] + }, + "execution_count": 36, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "ER_quote.startswith('Gre')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "El último método de cadena que mencionaremos es ** `split ()` **: devuelve una ** lista ** de todas las palabras en una cadena. También podemos definir un separador y dividir nuestra cadena de acuerdo con ese separador, y opcionalmente podemos limitar el número de divisiones a `num`.\n", + "\n", + "*Sintaxis:*\n", + "\n", + "`str.split (separator, num)`" + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "['Everybody', 'is', 'a', 'genius.', 'But', 'if', 'you', 'judge', 'a', 'fish', 'by', 'its', 'ability', 'to', 'climb', 'a', 'tree,', 'it', 'will', 'live', 'its', 'whole', 'life', 'believing', 'that', 'it', 'is', 'stupid.']\n" + ] + } + ], + "source": [ + "print(AE_quote.split())" + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "['Great', 'minds', 'discuss', 'ideas;', 'average', 'minds', 'discuss', 'events;', 'small', 'minds', 'discuss', 'people.']\n" + ] + } + ], + "source": [ + "print(ER_quote.split())" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Vamos a dividir el `ER_quote` por un personaje diferente, un punto y coma:" + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "['Great minds discuss ideas', ' average minds discuss events', ' small minds discuss people.']\n" + ] + } + ], + "source": [ + " print(ER_quote.split(';'))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "##### Pensar...\n", + "\n", + "¿Notan algo nuevo en la salida de las llamadas `print()`?\n", + "¿Cuáles son esos `[]`?" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Juega con listas de Python\n", + "\n", + "Los corchetes de arriba indican una ** lista ** de Python. Una lista es un tipo de datos integrado que consiste en una secuencia de valores, por ejemplo, números o cadenas. Las listas funcionan de muchas maneras de manera similar a las cadenas: sus elementos están numerados a partir de cero, la función `len ()` da el número de elementos, se pueden manipular con notación de división, y así sucesivamente.\n", + "\n", + "La forma más fácil de crear una lista es incluir una secuencia de valores separados por comas entre corchetes:" + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[1, 4, 7, 9]" + ] + }, + "execution_count": 40, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# A list of integers \n", + "[1, 4, 7, 9]" + ] + }, + { + "cell_type": "code", + "execution_count": 41, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "['apple', 'banana', 'orange']" + ] + }, + "execution_count": 41, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# A list of strings\n", + "['apple', 'banana', 'orange']" + ] + }, + { + "cell_type": "code", + "execution_count": 42, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[2, 'apple', 4.5, [5, 10]]" + ] + }, + "execution_count": 42, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# A list with different element types\n", + "[2, 'apple', 4.5, [5, 10]]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "En el último ejemplo de lista, el último elemento de la lista es en realidad _otra lista_. ¡Sí! podemos hacer eso por completo\n", + "\n", + "También podemos asignar listas a nombres de variables, por ejemplo:" + ] + }, + { + "cell_type": "code", + "execution_count": 43, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "integers = [1, 2, 3, 4, 5]\n", + "fruits = ['apple', 'banana', 'orange']" + ] + }, + { + "cell_type": "code", + "execution_count": 44, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[1, 2, 3, 4, 5]\n" + ] + } + ], + "source": [ + "print(integers)" + ] + }, + { + "cell_type": "code", + "execution_count": 45, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "['apple', 'banana', 'orange']\n" + ] + } + ], + "source": [ + "print(fruits)" + ] + }, + { + "cell_type": "code", + "execution_count": 46, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "new_list = [integers, fruits]" + ] + }, + { + "cell_type": "code", + "execution_count": 47, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[1, 2, 3, 4, 5], ['apple', 'banana', 'orange']]\n" + ] + } + ], + "source": [ + "print(new_list)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Tenga en cuenta que esta `new_list` tiene solo 2 elementos. Podemos verificarlo con la función `len ()`:" + ] + }, + { + "cell_type": "code", + "execution_count": 48, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "2" + ] + }, + "execution_count": 48, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "len(new_list)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Cada elemento de `new_list` es, por supuesto, otra lista.\n", + "Al igual que con las cadenas, accedemos a los elementos de la lista con índices y notación de división. El primer elemento de `new_list` es la lista de enteros del 1 al 5, mientras que el segundo elemento es la lista de tres nombres de frutas." + ] + }, + { + "cell_type": "code", + "execution_count": 49, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[1, 2, 3, 4, 5]" + ] + }, + "execution_count": 49, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "new_list[0]" + ] + }, + { + "cell_type": "code", + "execution_count": 50, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "['apple', 'banana', 'orange']" + ] + }, + "execution_count": 50, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "new_list[1]" + ] + }, + { + "cell_type": "code", + "execution_count": 51, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "['apple', 'banana']" + ] + }, + "execution_count": 51, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Accessing the first two elements of the list fruits\n", + "fruits[0:2]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "##### Ejercicios:\n", + "\n", + "1. De la lista `enteros`, tome la porción` [2, 3, 4] `y luego` [4, 5] `.\n", + "2. Crea tu propia lista y diseña un ejercicio para agarrar rebanadas, trabajando con tus compañeros de clase." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Agregar elementos a una lista\n", + "\n", + "Podemos agregar elementos a una lista usando el método ** append () **: agrega el objeto que pasamos a la lista existente. Por ejemplo, para agregar el elemento 6 a nuestra lista `enteros`, podemos hacer:" + ] + }, + { + "cell_type": "code", + "execution_count": 52, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "integers.append(6)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Comprobemos que la lista `entera 'ahora tiene un 6 al final:" + ] + }, + { + "cell_type": "code", + "execution_count": 53, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[1, 2, 3, 4, 5, 6]\n" + ] + } + ], + "source": [ + "print(integers)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Lista de miembros\n", + "\n", + "¡Comprobar la membresía de la lista en Python parece bastante similar al inglés sencillo!\n", + "\n", + "*Sintaxis*\n", + "\n", + "Para verificar si un elemento está ** en ** una lista:\n", + "\n", + "`elemento en la lista`\n", + "\n", + "Para verificar si un elemento ** no está en ** una lista:\n", + "\n", + "`elemento no en la lista`" + ] + }, + { + "cell_type": "code", + "execution_count": 54, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "False" + ] + }, + "execution_count": 54, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "'strawberry' in fruits" + ] + }, + { + "cell_type": "code", + "execution_count": 55, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "True" + ] + }, + "execution_count": 55, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "'strawberry' not in fruits" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "##### Ejercicios\n", + "\n", + "1. Agregue dos frutas diferentes a la lista `fruits`.\n", + "2. Comprueba si `'mango'` está en tu nueva lista` fruits`.\n", + "3. Dada la lista `alist = [1, 2, 3, '4', [5, 'six'], [7]]` ejecuta lo siguiente en celdas separadas y analiza la salida con tus compañeros de clase:\n", + "\n", + "```Python\n", + "   4 en alista\n", + "   5 en alista\n", + "   7 en alista\n", + "   [7] en alista\n", + "```" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Modificar elementos de una lista\n", + "\n", + "No solo podemos agregar elementos a una lista, también podemos modificar un elemento específico.\n", + "Reutilicemos la lista del ejercicio anterior y reemplacemos algunos elementos." + ] + }, + { + "cell_type": "code", + "execution_count": 56, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "alist = [1, 2, 3, '4', [5, 'six'], [7]]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Podemos encontrar la posición de un cierto elemento con el método `index ()`, al igual que con las cadenas. Por ejemplo, si queremos saber dónde está el elemento `'4'`, podemos hacer:" + ] + }, + { + "cell_type": "code", + "execution_count": 57, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "3" + ] + }, + "execution_count": 57, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "alist.index('4')" + ] + }, + { + "cell_type": "code", + "execution_count": 58, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'4'" + ] + }, + "execution_count": 58, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "alist[3]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Vamos a reemplazarlo con el valor entero `4`:" + ] + }, + { + "cell_type": "code", + "execution_count": 59, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "alist[3] = 4" + ] + }, + { + "cell_type": "code", + "execution_count": 60, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[1, 2, 3, 4, [5, 'six'], [7]]" + ] + }, + "execution_count": 60, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "alist" + ] + }, + { + "cell_type": "code", + "execution_count": 61, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "True" + ] + }, + "execution_count": 61, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "4 in alist" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "##### Ejercicio\n", + "Reemplace el último elemento de `a list` con algo diferente." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Poder modificar elementos en una lista es una \"propiedad\" de las listas de Python; otros objetos Python que veremos más adelante en el curso también se comportan así, pero no todos los objetos Python. Por ejemplo, no puede modificar elementos en una cadena. Si lo intentamos, Python se quejará.\n", + "\n", + "¡Multa! Vamos a intentarlo:" + ] + }, + { + "cell_type": "code", + "execution_count": 62, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "string = 'This is a string.'" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Supongamos que queremos reemplazar el período ('.') Por un signo de exclamación ('!'). ¿Podemos simplemente modificar este elemento de cadena?" + ] + }, + { + "cell_type": "code", + "execution_count": 63, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'.'" + ] + }, + "execution_count": 63, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "string[-1]" + ] + }, + { + "cell_type": "code", + "execution_count": 64, + "metadata": {}, + "outputs": [ + { + "ename": "TypeError", + "evalue": "'str' object does not support item assignment", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mstring\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m'!'\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", + "\u001b[0;31mTypeError\u001b[0m: 'str' object does not support item assignment" + ] + } + ], + "source": [ + "string[-1] = '!'" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "¡Te lo dije! Python confirma que no podemos cambiar los elementos de una cadena por asignación de elemento." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Siguiente: cadenas y listas en acción\n", + "\n", + "Ha aprendido muchas cosas sobre cadenas y listas en esta lección, y probablemente esté ansioso por ver cómo aplicarlo a una situación realista. Creamos un [ejemplo completo](http://nbviewer.jupyter.org/github/engineersCode/EngComp1_offtheground/blob/master/notebooks_en/3_Example_play_with_MAEbulletin.ipynb) en un cuaderno separado para mostrarle el poder de Python con los datos de texto.\n", + "\n", + "Pero antes de saltar, deberíamos presentarle las potentes ideas de ** iteration ** y ** conditionals ** en Python." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Iteración con declaraciones `for`\n", + "\n", + "La idea de _iteration_ (en inglés simple) es repetir un proceso varias veces. Si tiene alguna experiencia en programación con otro lenguaje (como C o Java, por ejemplo), puede tener una idea de cómo crear iteraciones con sentencias `for`. Pero estos son un poco diferentes en Python, como puede leer en la [documentación](https://docs.python.org/3/tutorial/controlflow.html#for-statements).\n", + "\n", + "Una instrucción Python `for` itera sobre los elementos de una secuencia, naturalmente. Digamos que tiene una lista llamada `frutas` que contiene una secuencia de cadenas con nombres de fruta; puedes escribir una declaración como\n", + "\n", + "```Python\n", + "para fruta en frutas:\n", + "```\n", + "hacer algo con cada elemento de la lista.\n", + "\n", + "Aquí, por primera vez, encontraremos una característica distintiva del lenguaje Python: agrupando por ** sangría **. Para delimitar _what_ Python debe hacer con cada `fruta` en la lista de` fruits`, colocamos las siguientes declaraciones _indented_ desde la izquierda.\n", + "\n", + "¿Cuánto sangrar? Esta es una pregunta de estilo, y todos tienen una preferencia: dos espacios, cuatro espacios, una sola pestaña ... todos son válidos: ¡pero elija uno y sea consecuente!\n", + "\n", + "Usemos cuatro espacios:" + ] + }, + { + "cell_type": "code", + "execution_count": 65, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Eat your apple\n", + "Eat your banana\n", + "Eat your orange\n", + "Eat your cherry\n", + "Eat your mandarin\n" + ] + } + ], + "source": [ + "fruits = ['apple', 'banana', 'orange', 'cherry', 'mandarin']\n", + "\n", + "for fruit in fruits:\n", + " print(\"Eat your\", fruit)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "##### Presta atención:\n", + "\n", + "* la instrucción `for` termina con dos puntos,`: `\n", + "* la variable `fruit` está implícitamente definida en la declaración` for`\n", + "* `fruit` toma el valor (cadena) de cada elemento de la lista` fruits`, en orden\n", + "* la sentencia sangrienta `print()` se ejecuta para cada valor de `fruit`\n", + "* una vez que Python se queda sin 'fruits', se detiene\n", + "* ¡no necesitamos saber con anticipación cuántos elementos hay en la lista!" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "##### Pregunta desafiante:\n", + "\n", + "- ¿Cuál es el valor de la variable `fruit` después de ejecutar la instrucción` for` anterior? Discute con tu vecino. (Confirma tu conjetura en una celda de código)." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Una función muy útil para usar con declaraciones `for` es **` enumerate () `**: agrega un contador que puede usar como índice mientras se ejecuta su iteración. Para usarlo, define implícitamente _two_ variables en la instrucción `for`: el contador y el valor de la secuencia que se itera.\n", + "\n", + "Estudia el siguiente bloque de código:" + ] + }, + { + "cell_type": "code", + "execution_count": 66, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "['Sam', 'Zoe', 'Naty', 'Gil', 'Tom']\n" + ] + } + ], + "source": [ + "names = ['sam', 'zoe', 'naty', 'gil', 'tom']\n", + "\n", + "for i, name in enumerate(names):\n", + " names[i] = name.capitalize()\n", + "print(names)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "##### Pregunta desafiante:\n", + "\n", + "- ¿Cuál es el valor de la variable `name` después de ejecutar la instrucción` for` anterior? Discute con tu vecino. (Confirma tu conjetura en una celda de código)." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "##### Ejercicio:\n", + "\n", + "Supongamos que tenemos una lista de listas (a.k.a., a _nested_ list), como se muestra a continuación:\n", + "```Python\n", + "nombres completos = [['sam', 'jones'], ['zoe', 'smith'], ['joe', 'cheek'], ['tom', 'perez']]\n", + "```\n", + "Escriba un código que cree dos listas simples: una con los primeros nombres, otra con los apellidos de la lista anidada arriba, pero en mayúscula.\n", + "\n", + "Para comenzar, necesita crear dos listas _empty_ utilizando los corchetes con nada dentro. Hemos hecho eso por ti a continuación. _Hint_: ¡Usa el método de lista `append ()`!" + ] + }, + { + "cell_type": "code", + "execution_count": 67, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "fullnames = [ ['sam','jones'], ['zoe','smith'],['joe','cheek'],['tom','perez'] ]\n", + "firstnames = []\n", + "lastnames = []\n", + "\n", + "# Write your code here" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Condicionales con declaraciones `if`\n", + "\n", + "Algunas veces necesitamos la habilidad de verificar condiciones y cambiar el comportamiento de nuestro programa dependiendo de la condición. Lo logramos con una instrucción `if`, que puede tomar una de tres formas." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "(1) ** Si ** declaración por sí mismo:" + ] + }, + { + "cell_type": "code", + "execution_count": 68, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "a is bigger than b\n" + ] + } + ], + "source": [ + "a = 8 \n", + "b = 3\n", + "\n", + "if a > b:\n", + " print('a is bigger than b')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "(2) declaración ** If-else **:" + ] + }, + { + "cell_type": "code", + "execution_count": 69, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "# We pick a number, but you can change it\n", + "x = 1547" + ] + }, + { + "cell_type": "code", + "execution_count": 70, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Your number is a multiple of 17.\n" + ] + } + ], + "source": [ + "if x % 17 == 0: \n", + " print('Your number is a multiple of 17.')\n", + "else:\n", + " print('Your number is not a multiple of 17.')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "* Nota: * El `%` representa una operación de módulo: da el resto de la división del primer argumento por el segundo" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "* Sugerencia: * Puede descomentar esta siguiente celda y aprender un buen truco para pedirle al usuario que inserte un número. Puede usar esto en lugar de asignar un valor específico a `x` arriba." + ] + }, + { + "cell_type": "code", + "execution_count": 71, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "#x = float(input('Insert your number: '))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "(3) ** declaración If-elif-else **:" + ] + }, + { + "cell_type": "code", + "execution_count": 72, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "a is smaller than b\n" + ] + } + ], + "source": [ + "a = 3\n", + "b = 5\n", + "\n", + "if a > b:\n", + " print('a is bigger than b')\n", + "elif a < b:\n", + " print('a is smaller than b')\n", + "else:\n", + " print('a is equal to b')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "* Nota: * Podemos tener tantas líneas `elif` como queramos." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "##### Ejercicio\n", + "\n", + "Usando declaraciones `if`,` elif` y `else` escribe un código donde eliges un número de 4 dígitos, si es divisible entre 2 y 3, imprimes: 'Tu número no solo es divisible por 2 y 3 sino también por 6 '. Si es divisible por 2, imprime: 'Tu número es divisible por 2'. Si es divisible por 3, imprime: 'Tu número es divisible por 3'. Cualquier otra opción, imprime: 'Tu número no es divisible por 2, 3 o 6'" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Lo que hemos aprendido\n", + "\n", + "* Cómo usar el entorno de Jupyter.\n", + "* Jugar con cadenas: acceder a valores, cortar y métodos de cadena.\n", + "* Jugar con listas: acceder a valores, cortar y enumerar métodos.\n", + "* Iteración con declaraciones `for`.\n", + "* Condicionales con declaraciones `if`." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Referencias\n", + "\n", + "1. [Conceptos básicos del cuaderno: editor modal](http://jupyter-notebook.readthedocs.io/en/latest/examples/Notebook/Notebook%20Basics.html)\n", + "2. [\"Indices señalan los elementos,\"](https://blog.nelhage.com/2015/08/indices-point-between-elements/) publicación de blog de Nelson Elhage (2015).\n", + "3. _Python para todos: explorando datos usando Python 3_ (2016). Charles R. Severance. [PDF disponible](http://do1.dr-chuck.com/pythonlearn/EN_us/pythonlearn.pdf)\n", + "4. _Piense en Python: cómo pensar como un científico de la computación_ (2012). Allen Downey. Green Tea Press. [PDF disponible](http://greenteapress.com/thinkpython/thinkpython.pdf)" + ] + }, + { + "cell_type": "code", + "execution_count": 73, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + "\n", + "\n", + "\n", + "\n" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 73, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Execute this cell to load the notebook's style sheet, then ignore it\n", + "from IPython.core.display import HTML\n", + "css_file = '../style/custom.css'\n", + "HTML(open(css_file, \"r\").read())" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.6.4" + }, + "widgets": { + "state": {}, + "version": "1.1.2" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/notebooks_es/3_Ejemplo_con_MAEbulletin.ipynb b/notebooks_es/3_Ejemplo_con_MAEbulletin.ipynb new file mode 100644 index 0000000..5875a1b --- /dev/null +++ b/notebooks_es/3_Ejemplo_con_MAEbulletin.ipynb @@ -0,0 +1,726 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "###### Contenido bajo licencia Creative Commons Attribution CC-BY 4.0, código bajo licencia BSD 3-Clause © 2017 L.A. Barba, N.C. Clementi" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Cadenas y listas en acción\n", + "\n", + "Después de completar [Lección 1](http://nbviewer.jupyter.org/github/engineersCode/EngComp1_offtheground/blob/master/notebooks_en/1_Interacting_with_Python.ipynb) y [Lesson 2](http://nbviewer.jupyter.org/github) /engineersCode/EngComp1_offtheground/blob/master/notebooks_en/2_Jupyter_strings_and_lists.ipynb) de este curso en _\"Engineering Computations_,\"\n", + "aquí tenemos un ejemplo completo usando todo lo que has aprendido.\n", + "\n", + "Quizás te estés preguntando por qué estamos dedicando las primeras lecciones del curso a jugar con cadenas y listas. _\"¡Los cálculos de ingeniería implican números, fórmulas y ecuaciones!\"_, Puede estar pensando. La razón es que este curso no asume ninguna experiencia de programación, por lo que queremos que todos estén acostumbrados a Python primero, sin agregar la complejidad adicional de la generación de números. La idea es familiarizarse primero con los constructos de programación, aplicándolos a situaciones que no implican matemáticas ... ¡por ahora!" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Juega con el boletín MAE\n", + "\n", + "Vamos a jugar con el texto de un archivo que contiene una copia del [MAE Bulletin](http://bulletin.gwu.edu/engineering-applied-science/mechanical-aerospace-engineering/#coursestext) para 2017-2018. Crearemos diferentes listas para permitirnos ubicar el título, los créditos y la descripción de un curso en función del código del curso.\n", + "\n", + "El archivo de datos para este ejemplo debe ubicarse en una carpeta llamada `datos`, dos niveles por encima de la ubicación de esta lección, si copió los materiales del curso tal como fueron almacenados. Si tiene los datos en otro lugar, debe editar la ruta completa a continuación.\n", + "\n", + "Comenzaremos leyendo el archivo de datos en el cuaderno Jupyter, luego limpiaremos un poco los datos y finalmente resolveremos las formas de jugar con él." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Leer datos de un archivo\n", + "\n", + "Sabemos que tenemos un archivo de datos y nos gustaría leer su contenido en el cuaderno de Jupyter. Por lo general, es una buena idea echar un vistazo primero al archivo, para ver cómo se ve su contenido. Esto también nos da la oportunidad de enseñarle un truco muy bueno.\n", + "\n", + "Recuerde que las celdas de código en una computadora portátil Jupyter pueden manejar cualquier declaración válida ** IPython **. Bueno, IPython es capaz de hacer algo más que solo Python: también puede ejecutar cualquier [comando del sistema](https://ipython.org/ipython-doc/3/interactive/reference.html#system-shell-access) . Si conoce un poco de Unix, esto puede ser muy útil; por ejemplo, podría enumerar todos los archivos en el directorio de trabajo (su ubicación en el sistema de archivos de la computadora).\n", + "\n", + "Para ejecutar un comando de sistema (a.k.a., shell), antepone `!` -a \"bang\". El comando que necesitamos es `head`: imprime las primeras líneas de un archivo.\n", + "\n", + "Nuestra carpeta de datos se encuentra dos directorios arriba de las lecciones (este cuaderno Jupyter): en Unix, ir _a_ un directorio está indicado por dos puntos; así que necesitamos tener `../../ data /` antes del nombre del archivo, `mae_bulletin.txt`, como parte de la ruta.\n", + "\n", + "Llamemos `head` con un golpe:" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "MAE 1004. Engineering Drawing and Computer Graphics. 0-3 Credits.\r\n", + "\r\n", + "Introduction to technical drawing, including use of instruments, lettering, geometric construction, sketching, orthographic projection, section view, dimensioning, tolerancing, and pictorial drawing. Introduction to computer graphics, including topics covered in manual drawing and computer-aided drafting. (Fall and spring).\r\n", + "\r\n", + "MAE 2117. Engineering Computations. 3 Credits.\r\n", + "\r\n", + "Numerical methods for engineering applications. Round-off errors and discretization errors. Methods for solving systems of linear equations, root finding, curve fitting, numerical Fourier transform, and data approximation. Numerical differentiation and integration and numerical solution of differential equations. Computer applications. Prerequisite: MATH 1232. (Fall, Every Year).\r\n", + "\r\n", + "MAE 2124. Linear Systems Analysis for Robotics. 3 Credits.\r\n", + "\r\n" + ] + } + ], + "source": [ + "!head ../data/mae_bulletin.txt" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "¡Eso se ve bien! El siguiente paso es abrir el archivo y guardar sus contenidos en una variable de Python que podamos usar.\n", + "\n", + "La función ** `open ()` ** con el nombre del archivo como un argumento _string_ (tenga en cuenta las comillas) devuelve un objeto de archivo Python. Tenemos varias opciones a continuación, y definitivamente debe leer la [documentación](https://docs.python.org/2/tutorial/inputoutput.html#reading-and-writing-files) sobre cómo leer y escribir archivos.\n", + "\n", + "Si usa el método de archivo ** `read ()` **, obtiene una cadena (grande) con todos los contenidos del archivo. Si utiliza el método ** `readlines ()` **, obtendrá una lista de cadenas, donde cada cadena contiene una línea en el archivo. Otra opción es usar la función ** `list ()` ** para crear una lista de líneas a partir del contenido del archivo." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "mae_bulletin_file = open('../data/mae_bulletin.txt')" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "mae_bulletin_text = mae_bulletin_file.readlines()" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "list" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "type(mae_bulletin_text)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "431" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "len(mae_bulletin_text)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Limpieza y organización de datos de texto\n", + "\n", + "Al manipular datos de texto, una de las acciones típicas es deshacerse de líneas y espacios en blanco adicionales. Aquí, eliminaremos los espacios al principio y al final de cada línea.\n", + "\n", + "Tenga en cuenta que también hay algunas líneas en blanco: las omitiremos. El objetivo es obtener dos listas nuevas: una con la línea de identificación del curso y otra con las descripciones de los cursos.\n", + "\n", + "Estudia el siguiente bloque de código:" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "courses = []\n", + "descriptions = []\n", + "\n", + "for line in mae_bulletin_text:\n", + " line = line.strip() #Remove white spaces\n", + " if line == '': #Skip the empty lines \n", + " continue\n", + " elif line.startswith('MAE'): \n", + " courses.append(line) #Save lines that start with MAE in list\n", + " else:\n", + " descriptions.append(line) #Save descriptions in other list" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Asegúrese de visitar también la [documentación](https://docs.python.org/3/library/stdtypes.html#string-methods) para conocer los métodos de cadena, ¡para tener una idea de todas las cosas que puede hacer con Python! Aquí, usamos el método ** `strip ()` ** para deshacernos de los espacios iniciales y finales, y también usamos ** `startswith ()` ** para identificar las líneas de identificación del curso.\n", + "\n", + "Comprobemos con qué terminamos imprimiendo algunos artículos en cada lista:" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "['MAE 1004. Engineering Drawing and Computer Graphics. 0-3 Credits.', 'MAE 2117. Engineering Computations. 3 Credits.', 'MAE 2124. Linear Systems Analysis for Robotics. 3 Credits.', 'MAE 2131. Thermodynamics. 3 Credits.', 'MAE 2170. History and Impact of the US Patent System. 3 Credits.']\n" + ] + } + ], + "source": [ + "#print first 5 elements of courses\n", + "print(courses[0:5])" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "['Introduction to technical drawing, including use of instruments, lettering, geometric construction, sketching, orthographic projection, section view, dimensioning, tolerancing, and pictorial drawing. Introduction to computer graphics, including topics covered in manual drawing and computer-aided drafting. (Fall and spring).', 'Numerical methods for engineering applications. Round-off errors and discretization errors. Methods for solving systems of linear equations, root finding, curve fitting, numerical Fourier transform, and data approximation. Numerical differentiation and integration and numerical solution of differential equations. Computer applications. Prerequisite: MATH 1232. (Fall, Every Year).', 'Properties of linear systems. Mathematical modeling of dynamic systems. State space, state variables, and their selection. Linearization of non-linear behavior. Matrix functions. Solution of state equations in the time domain and using transformations. System stability and frequency response.']\n" + ] + } + ], + "source": [ + "#print first 3 elements of descriptions\n", + "print(descriptions[0:3])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "¡También deberíamos verificar que ambas listas tengan la misma longitud!" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "108\n", + "108\n" + ] + } + ], + "source": [ + "print(len(courses))\n", + "print(len(descriptions))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Separa la lista de \"cursos\" en la identificación del curso, título y créditos\n", + "\n", + "Es posible que deseemos tener la información de la identificación, título y créditos del curso en listas separadas. Así es como podríamos hacer eso:" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "course_id = []\n", + "course_title = []\n", + "course_credits = []\n", + "\n", + "for course in courses:\n", + " course_info = course.split('. ') \n", + " course_id.append(course_info[0])\n", + " course_title.append(course_info[1])\n", + " course_credits.append(course_info[2])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Tenga en cuenta que dividimos usando la cadena `'. '' (período + espacio) para evitar tener un espacio en blanco adicional al comienzo de cada cadena en las listas de títulos y créditos del curso.\n", + "\n", + "Vamos a imprimir los primeros elementos de las nuevas listas." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "['MAE 1004', 'MAE 2117', 'MAE 2124', 'MAE 2131', 'MAE 2170']\n" + ] + } + ], + "source": [ + "print(course_id[0:5])" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "['Engineering Drawing and Computer Graphics', 'Engineering Computations', 'Linear Systems Analysis for Robotics', 'Thermodynamics', 'History and Impact of the US Patent System']\n" + ] + } + ], + "source": [ + "print(course_title[0:5])" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "['0-3 Credits.', '3 Credits.', '3 Credits.', '3 Credits.', '3 Credits.']\n" + ] + } + ], + "source": [ + "print(course_credits[0:5])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Información del curso de seguimiento\n", + "\n", + "Las listas que hemos creado están alineadas: es decir, cada elemento en la misma ubicación de índice corresponde al mismo curso. Entonces, al encontrar la ubicación de una identificación de curso, podemos acceder a toda la otra información.\n", + "\n", + "Usamos el método `index ()` para encontrar el índice de la identificación del curso y rastrear el resto de la información. ¡Pruébalo!" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "17" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "course_id.index('MAE 3190')" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "MAE 3190\n", + "Analysis and Synthesis of Mechanisms\n", + "3 Credits.\n", + "Kinematics and dynamics of mechanisms. Displacements, velocities, and accelerations in linkage, cam, and gear systems by analytical, graphical, and computer methods. Synthesis of linkages to meet prescribed performance requirements. Prerequisite: APSC 2058. (Fall).\n" + ] + } + ], + "source": [ + "print(course_id[17])\n", + "print(course_title[17])\n", + "print(course_credits[17])\n", + "print(descriptions[17])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### ¿Cuántos cursos tienen prerrequisitos?\n", + "\n", + "Aquí hay una idea: podemos buscar todos los cursos que tengan requisitos previos usando una declaración `for`. En este caso, iteraremos sobre el _index_ de los elementos en la lista `descriptions`.\n", + "\n", + "Nos da la oportunidad de presentarle un objeto Python muy útil: ** `range` **: crea una secuencia de números en la progresión aritmética para iterar. Con un único argumento, `range (N)` creará una secuencia de longitud `N` comenzando en cero:` 0, 1, 2, ..., N-1`." + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0\n", + "1\n", + "2\n", + "3\n" + ] + } + ], + "source": [ + "for i in range(4):\n", + " print(i)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Lo gracioso con `range` es que se crea sobre la marcha, al iterar sobre él. Entonces, no es realmente una lista, aunque para la mayoría de los propósitos prácticos, se comporta como tal.\n", + "\n", + "Una forma típica de usarlo es con un argumento que sale de la función `len ()`. Estudia este bloque de código:" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "course_with_pre = []\n", + "\n", + "for i in range(len(descriptions)):\n", + " if 'Prerequisite' in descriptions[i]:\n", + " course_with_pre.append(course_id[i])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Ahora tenemos una lista llamada `course_with_pre` que contiene el id de todos los cursos que tienen requisitos previos." + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "['MAE 2117', 'MAE 2131', 'MAE 3120', 'MAE 3126', 'MAE 3128', 'MAE 3134', 'MAE 3145', 'MAE 3155', 'MAE 3162', 'MAE 3166W', 'MAE 3167W', 'MAE 3187', 'MAE 3190', 'MAE 3191', 'MAE 3192', 'MAE 3193', 'MAE 3195', 'MAE 3197', 'MAE 4129', 'MAE 4149', 'MAE 4157', 'MAE 4163', 'MAE 4168', 'MAE 4172', 'MAE 4182', 'MAE 4193', 'MAE 4194', 'MAE 4198', 'MAE 4199', 'MAE 6201', 'MAE 6207', 'MAE 6220', 'MAE 6221', 'MAE 6222', 'MAE 6223', 'MAE 6224', 'MAE 6225', 'MAE 6226', 'MAE 6227', 'MAE 6228', 'MAE 6229', 'MAE 6230', 'MAE 6231', 'MAE 6232', 'MAE 6233', 'MAE 6234', 'MAE 6237', 'MAE 6238', 'MAE 6239', 'MAE 6240', 'MAE 6241', 'MAE 6243', 'MAE 6244', 'MAE 6245', 'MAE 6246', 'MAE 6247', 'MAE 6249', 'MAE 6251', 'MAE 6252', 'MAE 6253', 'MAE 6254', 'MAE 6255', 'MAE 6257', 'MAE 6258', 'MAE 6260', 'MAE 6261', 'MAE 6262', 'MAE 6270', 'MAE 6271', 'MAE 6274', 'MAE 6276', 'MAE 6280', 'MAE 6281', 'MAE 6282', 'MAE 6283', 'MAE 6284', 'MAE 6286', 'MAE 6287', 'MAE 6288', 'MAE 6290', 'MAE 6291', 'MAE 6292', 'MAE 8350', 'MAE 8351', 'MAE 8352']\n" + ] + } + ], + "source": [ + "print(course_with_pre)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "##### Ejercicio:\n", + "\n", + "1. Guarde en una nueva lista llamada `course_with_cor` todos los cursos que tengan un correquisito e imprima la lista.\n", + "2. Utilizando una declaración `for` y declaraciones` if-elif-else`, separe los cursos que se ofrecen en el semestre de otoño, los ofrecidos en el semestre de primavera, los que se ofrecen en ambos semestres y los que no especifican un semestre. Crea 4 listas: `fall_and_spring`,` fall`, `spring` y` not_spec`." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Para comprobar sus respuestas, elimine el comentario de las siguientes líneas eliminando el símbolo # y ejecutando la celda. Si no hay salida, ¡lo hiciste bien!" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "#course_with_cor_ans = ['MAE 3184', 'MAE 4183', 'MAE 4195', 'MAE 6194', 'MAE 6195']\n", + "#fall_and_spring_ans = []\n", + "#fall_ans = ['MAE 1004', 'MAE 2117', 'MAE 3126', 'MAE 3145', 'MAE 3162', 'MAE 3166W', 'MAE 3190', 'MAE 3191', 'MAE 4157', 'MAE 4163', 'MAE 4193', 'MAE 4199', 'MAE 6210', 'MAE 6275']\n", + "#spring_ans = ['MAE 3128', 'MAE 3167W', 'MAE 3193', 'MAE 6194', 'MAE 6195', 'MAE 6229', 'MAE 6235', 'MAE 6242', 'MAE 6247', 'MAE 6249', 'MAE 6258']\n", + "#not_spec_ans = ['MAE 2124', 'MAE 2131', 'MAE 2170', 'MAE 3120', 'MAE 3134', 'MAE 3155', 'MAE 3171', 'MAE 3184', 'MAE 3187', 'MAE 3192', 'MAE 3195', 'MAE 3196', 'MAE 3197', 'MAE 4129', 'MAE 4149', 'MAE 4168', 'MAE 4172', 'MAE 4182', 'MAE 4183', 'MAE 4194', 'MAE 4195', 'MAE 4198', 'MAE 6201', 'MAE 6203', 'MAE 6204', 'MAE 6207', 'MAE 6220', 'MAE 6221', 'MAE 6222', 'MAE 6223', 'MAE 6224', 'MAE 6225', 'MAE 6226', 'MAE 6227', 'MAE 6228', 'MAE 6230', 'MAE 6231', 'MAE 6232', 'MAE 6233', 'MAE 6234', 'MAE 6237', 'MAE 6238', 'MAE 6239', 'MAE 6240', 'MAE 6241', 'MAE 6243', 'MAE 6244', 'MAE 6245', 'MAE 6246', 'MAE 6251', 'MAE 6252', 'MAE 6253', 'MAE 6254', 'MAE 6255', 'MAE 6257', 'MAE 6260', 'MAE 6261', 'MAE 6262', 'MAE 6263', 'MAE 6270', 'MAE 6271', 'MAE 6274', 'MAE 6276', 'MAE 6277', 'MAE 6280', 'MAE 6281', 'MAE 6282', 'MAE 6283', 'MAE 6284', 'MAE 6286', 'MAE 6287', 'MAE 6288', 'MAE 6290', 'MAE 6291', 'MAE 6292', 'MAE 6298', 'MAE 6998', 'MAE 6999', 'MAE 8350', 'MAE 8351', 'MAE 8352', 'MAE 8998', 'MAE 8999']\n", + "\n", + "#assert course_with_cor == course_with_cor_ans\n", + "#assert fall_and_spring == fall_and_spring_ans \n", + "#assert fall == fall_ans\n", + "#assert spring == spring_ans\n", + "#assert not_spec == not_spec_ans" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Lo que hemos aprendido\n", + "\n", + "* Los comandos del sistema en una celda de código comienzan con un bang (`!`).\n", + "* Abrir un archivo de texto y guardar su contenido en una cadena o lista de variables.\n", + "* Limpiando datos de texto usando métodos de cadena.\n", + "* Manipulando texto en listas." + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + "\n", + "\n", + "\n", + "\n" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 20, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Execute this cell to load the notebook's style sheet, then ignore it\n", + "from IPython.core.display import HTML\n", + "css_file = '../style/custom.css'\n", + "HTML(open(css_file, \"r\").read())" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.6.4" + }, + "widgets": { + "state": {}, + "version": "1.1.2" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/notebooks_es/4_NumPy_Arrays_y_Graficos.ipynb b/notebooks_es/4_NumPy_Arrays_y_Graficos.ipynb new file mode 100644 index 0000000..55091f2 --- /dev/null +++ b/notebooks_es/4_NumPy_Arrays_y_Graficos.ipynb @@ -0,0 +1,1639 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "###### Contenido bajo licencia Creative Commons Attribution CC-BY 4.0, código bajo licencia BSD 3-Clause © 2017 L.A. Barba, N.C. Clementi" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Juega con matrices NumPy\n", + "\n", + "Bienvenido a ** Lección 4 ** del primer módulo de curso en _\"Computaciones de ingeniería_\". ¡Usted ha recorrido un largo camino!\n", + "\n", + "Recuerde, este curso no asume ninguna experiencia de codificación, por lo que las tres primeras lecciones se centraron en crear una base con construcciones de programación de Python utilizando esencialmente _no mathematics_. Las lecciones anteriores son:\n", + "\n", + "* [Lección 1](http://nbviewer.jupyter.org/github/engineersCode/EngComp1_offtheground/blob/master/notebooks_en/1_Interacting_with_Python.ipynb): interactuando con Python\n", + "* [Lección 2](http://nbviewer.jupyter.org/github/engineersCode/EngComp1_offtheground/blob/master/notebooks_en/2_Jupyter_strings_and_lists.ipynb): juega con los datos en Jupyter\n", + "* [Lección 3](http://nbviewer.jupyter.org/github/engineersCode/EngComp1_offtheground/blob/master/notebooks_en/3_Example_play_with_MAEbulletin.ipynb): Cadenas y listas en acción\n", + "\n", + "En aplicaciones de ingeniería, la mayoría de las situaciones informáticas se benefician del uso de * arrays *: son secuencias de datos del mismo tipo_. Se comportan como listas, a excepción de la restricción en el tipo de sus elementos. Hay una gran ventaja de eficiencia cuando sabes que todos los elementos de una secuencia son del mismo tipo, por lo que los métodos equivalentes para las matrices se ejecutan mucho más rápido que los de las listas.\n", + "\n", + "El lenguaje Python se amplía para aplicaciones especiales, como la informática científica, con ** libraries **. La biblioteca más importante en ciencia e ingeniería es ** NumPy **, que proporciona la estructura de datos _n-dimensional array_ (a.k.a, `ndarray`) y una gran cantidad de funciones, operaciones y algoritmos para cálculos de álgebra lineal eficientes.\n", + "\n", + "En esta lección, comenzarás a jugar con matrices NumPy y descubrirás su poder. También se encontrará con otra biblioteca muy apreciada: ** Matplotlib **, para crear gráficos bidimensionales de datos." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Importación de librerías\n", + "\n", + "Primero, una palabra sobre la importación de bibliotecas para expandir la sesión en ejecución de Python. Debido a que las bibliotecas son grandes colecciones de código y son para fines especiales, no se cargan automáticamente al iniciar Python (o IPython, o Jupyter). Tienes que importar una biblioteca usando el comando `import`. Por ejemplo, para importar ** NumPy **, con todas sus bondades de álgebra lineal, ingresamos:\n", + "\n", + "```python\n", + "importar numpy\n", + "```\n", + "\n", + "Una vez que ejecutas ese comando en una celda de código, puedes llamar a cualquier función de NumPy usando la notación de puntos, anteponiendo el nombre de la biblioteca. Por ejemplo, algunas funciones comúnmente usadas son:\n", + "\n", + "* [`numpy.linspace ()`](https://docs.scipy.org/doc/numpy/reference/generated/numpy.linspace.html)\n", + "* [`numpy.ones ()`](https://docs.scipy.org/doc/numpy/reference/generated/numpy.ones.html#numpy.ones)\n", + "* [`numpy.zeros ()`](https://docs.scipy.org/doc/numpy/reference/generated/numpy.zeros.html#numpy.zeros)\n", + "* [`numpy.empty ()`](https://docs.scipy.org/doc/numpy/reference/generated/numpy.empty.html#numpy.empty)\n", + "* [`numpy.copy ()`](https://docs.scipy.org/doc/numpy/reference/generated/numpy.copy.html#numpy.copy)\n", + "\n", + "¡Siga los enlaces para explorar la documentación de estas útiles funciones de NumPy!" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "##### Advertencia:\n", + "\n", + "Encontrará _un lote_ de código de muestra en línea que usa una sintaxis diferente para importar. Ellos harán:\n", + "```python\n", + "importar numpy como np\n", + "```\n", + "Todo lo que hace es crear un alias para `numpy` con la cadena más corta` np`, por lo que llamaría a una función ** NumPy ** como esta: `np.linspace ()`. Esta es solo una forma alternativa de hacerlo, para personas perezosas que les resulta demasiado largo para escribir `numpy` y quieren guardar 3 caracteres cada vez. Para el no perezoso, escribir `numpy` es más legible y hermoso.\n", + "\n", + "Nos gusta más así:" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "import numpy" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Creando matrices\n", + "\n", + "Para crear una matriz NumPy a partir de una lista existente de números (homogéneos), llamamos ** `numpy.array ()` **, así:" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([ 3, 5, 8, 17])" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "numpy.array([3, 5, 8, 17])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "NumPy ofrece muchas [formas de crear matrices](https://docs.scipy.org/doc/numpy/reference/routines.array-creation.html#routines-array-creation) además de esto. Ya hemos mencionado algunos de ellos más arriba.\n", + "\n", + "Juega con `numpy.ones ()` y `numpy.zeros ()`: crean arrays llenos de unos y ceros, respectivamente. Pasamos como argumento la cantidad de elementos de matriz que queremos." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([ 1., 1., 1., 1., 1.])" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "numpy.ones(5)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([ 0., 0., 0.])" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "numpy.zeros(3)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Otro útil: `numpy.arange ()` da una matriz de valores espaciados uniformemente en un intervalo definido.\n", + "\n", + "*Sintaxis:*\n", + "\n", + "`numpy.arange (inicio, parada, paso)`\n", + "\n", + "donde `start` por defecto es cero,` stop` no es inclusivo, y el predeterminado\n", + "para `paso` es uno. ¡Juega con ello!" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([0, 1, 2, 3])" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "numpy.arange(4)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([2, 3, 4, 5])" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "numpy.arange(2, 6)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([2, 4])" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "numpy.arange(2, 6, 2)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([ 2. , 2.5, 3. , 3.5, 4. , 4.5, 5. , 5.5])" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "numpy.arange(2, 6, 0.5)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "`numpy.linspace ()` es similar a `numpy.arange ()`, pero usa número de muestras en lugar de un tamaño de paso. Devuelve una matriz con números espaciados uniformemente durante el intervalo especificado.\n", + "\n", + "*Sintaxis:*\n", + "\n", + "`numpy.linspace (start, stop, num)`\n", + "\n", + "`stop` está incluido por defecto (se puede eliminar, lea los documentos), y` num` de forma predeterminada es 50." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([ 2. , 2.02040816, 2.04081633, 2.06122449, 2.08163265,\n", + " 2.10204082, 2.12244898, 2.14285714, 2.16326531, 2.18367347,\n", + " 2.20408163, 2.2244898 , 2.24489796, 2.26530612, 2.28571429,\n", + " 2.30612245, 2.32653061, 2.34693878, 2.36734694, 2.3877551 ,\n", + " 2.40816327, 2.42857143, 2.44897959, 2.46938776, 2.48979592,\n", + " 2.51020408, 2.53061224, 2.55102041, 2.57142857, 2.59183673,\n", + " 2.6122449 , 2.63265306, 2.65306122, 2.67346939, 2.69387755,\n", + " 2.71428571, 2.73469388, 2.75510204, 2.7755102 , 2.79591837,\n", + " 2.81632653, 2.83673469, 2.85714286, 2.87755102, 2.89795918,\n", + " 2.91836735, 2.93877551, 2.95918367, 2.97959184, 3. ])" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "numpy.linspace(2.0, 3.0)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "50" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "len(numpy.linspace(2.0, 3.0))" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([ 2. , 2.2, 2.4, 2.6, 2.8, 3. ])" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "numpy.linspace(2.0, 3.0, 6)" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([-1. , -0.75, -0.5 , -0.25, 0. , 0.25, 0.5 , 0.75, 1. ])" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "numpy.linspace(-1, 1, 9)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Operaciones de matriz\n", + "\n", + "Asignemos algunas matrices a nombres de variables y realicemos algunas operaciones con ellos." + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "x_array = numpy.linspace(-1, 1, 9)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "collapsed": true + }, + "source": [ + "Ahora que lo hemos guardado con un nombre de variable, podemos hacer algunos cálculos con la matriz. Por ejemplo, toma el cuadrado de cada elemento de la matriz de una sola vez:" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[ 1. 0.5625 0.25 0.0625 0. 0.0625 0.25 0.5625 1. ]\n" + ] + } + ], + "source": [ + "y_array = x_array**2\n", + "print(y_array)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "También podemos tomar la raíz cuadrada de una matriz positiva, usando la función `numpy.sqrt ()`:" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[ 1. 0.75 0.5 0.25 0. 0.25 0.5 0.75 1. ]\n" + ] + } + ], + "source": [ + "z_array = numpy.sqrt(y_array)\n", + "print(z_array)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Ahora que tenemos diferentes matrices `x_array`,` y_array` y `z_array`, podemos hacer más cálculos, como agregarlos o multiplicarlos. Por ejemplo:" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[ 0. -0.1875 -0.25 -0.1875 0. 0.3125 0.75 1.3125 2. ]\n" + ] + } + ], + "source": [ + "add_array = x_array + y_array \n", + "print(add_array)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "La adición de matriz se define como elemento, como cuando se agregan dos vectores (o matrices). La multiplicación de matrices también se basa en los elementos:" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[-1. -0.5625 -0.25 -0.0625 0. 0.0625 0.25 0.5625 1. ]\n" + ] + } + ], + "source": [ + "mult_array = x_array * z_array\n", + "print(mult_array)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "También podemos dividir matrices, pero debe tener cuidado de no dividir por cero. Esta operación dará como resultado ** `nan` ** que significa * Not a Number *. Python todavía realizará la división, pero nos contará sobre el problema.\n", + "\n", + "Veamos cómo podría verse esto:" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "//anaconda/envs/future/lib/python3.5/site-packages/ipykernel/__main__.py:1: RuntimeWarning: invalid value encountered in true_divide\n", + " if __name__ == '__main__':\n" + ] + }, + { + "data": { + "text/plain": [ + "array([-1. , -1.33333333, -2. , -4. , nan,\n", + " 4. , 2. , 1.33333333, 1. ])" + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "x_array / y_array" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Arrays multidimensionales\n", + "\n", + "### matrices 2D\n", + "\n", + "NumPy puede crear matrices de N dimensiones. Por ejemplo, una matriz 2D es como una matriz, y se crea a partir de una lista anidada de la siguiente manera:" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[1 2]\n", + " [3 4]]\n" + ] + } + ], + "source": [ + "array_2d = numpy.array([[1, 2], [3, 4]])\n", + "print(array_2d)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Las matrices 2D se pueden agregar, restar y multiplicar:" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "X = numpy.array([[1, 2], [3, 4]])\n", + "Y = numpy.array([[1, -1], [0, 1]])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "La adición de estas dos matrices funciona exactamente como era de esperar:" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[2, 1],\n", + " [3, 5]])" + ] + }, + "execution_count": 21, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "X + Y" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "¿Qué pasa si tratamos de multiplicar matrices utilizando el operador `'*'`?" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[ 1, -2],\n", + " [ 0, 4]])" + ] + }, + "execution_count": 22, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "X * Y" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "La multiplicación usando el operador `'*'` es por elementos. Si queremos hacer una multiplicación matricial usamos el operador `'@'`:" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[1, 1],\n", + " [3, 1]])" + ] + }, + "execution_count": 23, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "X @ Y" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "O de manera equivalente, podemos usar `numpy.dot ()`:" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[1, 1],\n", + " [3, 1]])" + ] + }, + "execution_count": 24, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "numpy.dot(X, Y)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### matrices 3D\n", + "\n", + "Vamos a crear una matriz 3D remodelando una matriz 1D. Podemos usar [`numpy.reshape ()`](https://docs.scipy.org/doc/numpy/reference/generated/numpy.reshape.html), donde pasamos la matriz que queremos remodelar y la forma queremos darlo, es decir, la cantidad de elementos en cada dimensión.\n", + "\n", + "*Sintaxis*\n", + " \n", + "`numpy.reshape (array, newshape)`\n", + "\n", + "Por ejemplo:" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "a = numpy.arange(24)" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[[ 0 1 2 3]\n", + " [ 4 5 6 7]\n", + " [ 8 9 10 11]]\n", + "\n", + " [[12 13 14 15]\n", + " [16 17 18 19]\n", + " [20 21 22 23]]]\n" + ] + } + ], + "source": [ + "a_3D = numpy.reshape(a, (2, 3, 4))\n", + "print(a_3D)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Podemos verificar la forma de una matriz NumPy usando la función `numpy.shape ()`:" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(2, 3, 4)" + ] + }, + "execution_count": 27, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "numpy.shape(a_3D)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Visualizar las dimensiones de la matriz `a_3D` puede ser complicado, así que aquí hay un diagrama que lo ayudará a comprender cómo se asignan las dimensiones: cada dimensión se muestra como un eje de coordenadas. Para una matriz 3D, en el \"eje x\", tenemos las sub-matrices que son bidimensionales (matrices). Tenemos dos de estas sub-matrices 2D, en este caso; cada uno tiene 3 filas y 4 columnas. Estudie este boceto cuidadosamente, mientras compara con la forma en que se imprime la matriz `a_3D`.\n", + "\n", + "" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "collapsed": true + }, + "source": [ + "Cuando tenemos matrices multidimensionales, podemos acceder a porciones de sus elementos cortando en cada dimensión. Esta es una de las ventajas del uso de matrices: no podemos hacer esto con listas.\n", + "\n", + "Accedamos a algunos elementos de nuestra matriz 2D llamada `X`." + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[1, 2],\n", + " [3, 4]])" + ] + }, + "execution_count": 28, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "X" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "1" + ] + }, + "execution_count": 29, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Grab the element in the 1st row and 1st column \n", + "X[0, 0]" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "2" + ] + }, + "execution_count": 30, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Grab the element in the 1st row and 2nd column \n", + "X[0, 1]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "##### Ejercicios:\n", + "\n", + "De la matriz X:\n", + "\n", + "1. Coge el segundo elemento en la primera columna.\n", + "2. Coge el segundo elemento en la segunda columna." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Juega con cortar en esta matriz:" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([1, 3])" + ] + }, + "execution_count": 31, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Grab the 1st column\n", + "X[:, 0]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Cuando no especificamos el punto inicial y/o final en el corte, el símbolo `':'` significa \"todo\". En el ejemplo anterior, le estamos diciendo a NumPy que queremos todos los elementos del índice 0 en la segunda dimensión (la primera columna)." + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([1, 2])" + ] + }, + "execution_count": 32, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Grab the 1st row\n", + "X[0, :]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "##### Ejercicios:\n", + "\n", + "De la matriz X:\n", + "\n", + "1. Coge la segunda columna.\n", + "2. Coge la segunda fila." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Practiquemos con una matriz 3D." + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[[ 0, 1, 2, 3],\n", + " [ 4, 5, 6, 7],\n", + " [ 8, 9, 10, 11]],\n", + "\n", + " [[12, 13, 14, 15],\n", + " [16, 17, 18, 19],\n", + " [20, 21, 22, 23]]])" + ] + }, + "execution_count": 33, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "a_3D" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Si queremos tomar la primera columna de ambas matrices en nuestra matriz `a_3D`, hacemos:" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[ 0, 4, 8],\n", + " [12, 16, 20]])" + ] + }, + "execution_count": 34, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "a_3D[:, :, 0]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "La línea de arriba le está diciendo a NumPy que queremos:\n", + "\n", + "* first `':'`: desde la primera dimensión, toma todos los elementos (2 matrices).\n", + "* second `':'`: desde la segunda dimensión, toma todos los elementos (todas las filas).\n", + "* `'0'`: desde la tercera dimensión, toma el primer elemento (primera columna).\n", + "\n", + "Si queremos los primeros 2 elementos de la primera columna de ambas matrices:" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[ 0, 4],\n", + " [12, 16]])" + ] + }, + "execution_count": 35, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "a_3D[:, 0:2, 0]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "A continuación, desde la primera matriz de nuestra matriz `a_3D`, tomaremos los dos elementos intermedios (5,6):" + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([5, 6])" + ] + }, + "execution_count": 36, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "a_3D[0, 1, 1:3]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "##### Ejercicios:\n", + "\n", + "De la matriz llamada `a_3D`:\n", + "\n", + "1. Toma los dos elementos del medio (17, 18) de la segunda matriz.\n", + "2. Coge la última fila de ambas matrices.\n", + "3. Tome los elementos de la primera matriz que excluyen la primera fila y la primera columna.\n", + "4. Tome los elementos de la 2da matriz que excluyen la última fila y la última columna." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## NumPy == ¡Rápido y limpio!\n", + "\n", + "Cuando trabajamos con números, los arreglos son una mejor opción porque la biblioteca NumPy tiene funciones integradas que están optimizadas y, por lo tanto, son más rápidas que las de Python. Especialmente si tenemos grandes arreglos. Además, usar matrices NumPy y explotar sus propiedades hace que nuestro código sea más legible.\n", + "\n", + "Por ejemplo, si quisiéramos agregar elemento-sabio los elementos de 2 listas, necesitamos hacerlo con una declaración `for`. Si queremos agregar dos matrices NumPy, simplemente usamos el símbolo de suma `'+'`!\n", + "\n", + "A continuación, agregaremos dos listas y dos matrices (con elementos aleatorios) y compararemos el tiempo que lleva computar cada adición." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Suma de elementos de una lista de Python\n", + "\n", + "Usando la biblioteca de Python [`random`](https://docs.python.org/3/library/random.html), generaremos dos listas con 100 elementos pseudoaleatorios en el rango [0,100), sin números repetido." + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "#import random library\n", + "import random" + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "lst_1 = random.sample(range(100), 100)\n", + "lst_2 = random.sample(range(100), 100)" + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[69, 21, 55, 9, 12, 57, 75, 81, 15, 17]\n", + "[57, 29, 94, 67, 51, 71, 78, 55, 41, 72]\n" + ] + } + ], + "source": [ + "#print first 10 elements\n", + "print(lst_1[0:10])\n", + "print(lst_2[0:10])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Necesitamos escribir una declaración `for`, añadiendo el resultado de la suma de elementos a una nueva lista que llamamos` result_lst`.\n", + "\n", + "Para el tiempo, podemos usar el IPython \"mágico\" `%% time`. Escribiendo al comienzo de la celda de código, el comando `%% time` nos dará el tiempo que lleva ejecutar todo el código en esa celda." + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "CPU times: user 36 µs, sys: 1 µs, total: 37 µs\n", + "Wall time: 38.9 µs\n" + ] + } + ], + "source": [ + "%%time\n", + "res_lst = []\n", + "for i in range(100):\n", + " res_lst.append(lst_1[i] + lst_2[i])" + ] + }, + { + "cell_type": "code", + "execution_count": 41, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[126, 50, 149, 76, 63, 128, 153, 136, 56, 89]\n" + ] + } + ], + "source": [ + "print(res_lst[0:10])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Suma de elementos de las matrices NumPy\n", + "\n", + "En este caso, generamos matrices con enteros aleatorios usando la función NumPy [`numpy.random.randint ()`](https://docs.scipy.org/doc/numpy-1.13.0/reference/generated/numpy. random.randint.html). Las matrices que generamos con esta función no serán como las listas: en este caso, tendremos 100 elementos en el rango [0, 100) pero pueden repetirse. Nuestro objetivo es comparar el tiempo que lleva computar la adición de una lista o un grupo de números, de modo que todo lo que importa es que las matrices y las listas son de la misma longitud y tipo (enteros)." + ] + }, + { + "cell_type": "code", + "execution_count": 42, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "arr_1 = numpy.random.randint(0, 100, size=100)\n", + "arr_2 = numpy.random.randint(0, 100, size=100)" + ] + }, + { + "cell_type": "code", + "execution_count": 43, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[31 13 72 30 13 29 34 64 26 56]\n", + "[ 3 57 63 51 35 75 56 59 86 50]\n" + ] + } + ], + "source": [ + "#print first 10 elements\n", + "print(arr_1[0:10])\n", + "print(arr_2[0:10])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Ahora podemos usar la magia de la celda `%% time`, nuevamente, para ver cuánto tarda NumPy en calcular la suma de elementos." + ] + }, + { + "cell_type": "code", + "execution_count": 44, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "CPU times: user 20 µs, sys: 1 µs, total: 21 µs\n", + "Wall time: 26 µs\n" + ] + } + ], + "source": [ + "%%time\n", + "arr_res = arr_1 + arr_2" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Tenga en cuenta que en el caso de las matrices, el código no solo es más legible (solo una línea de código), sino que también es más rápido que con las listas. Esta vez, la ventaja será mayor con matrices/listas más grandes.\n", + "\n", + "(Sus resultados de tiempo pueden variar a los que mostramos en este cuaderno, porque estará computando en una máquina diferente)." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "##### Ejercicio\n", + "\n", + "1. Pruebe la comparación entre listas y matrices, usando matrices más grandes; por ejemplo, de tamaño 10,000.\n", + "2. Repita el análisis, pero ahora calcula la operación que eleva cada elemento de una matriz/lista a la potencia dos. Usa arreglos de 10,000 elementos." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Tiempo para trazar\n", + "\n", + "¡Te encantará la biblioteca de Python ** Matplotlib **! Aprenderá aquí sobre su módulo `pyplot`, que hace gráficos de líneas.\n", + "\n", + "Necesitamos algunos datos para trazar. Definamos una matriz NumPy, calcule los datos derivados usando su cuadrado, cubo y raíz cuadrada (elemento-sabio), y trace estos valores con la matriz original en el eje x." + ] + }, + { + "cell_type": "code", + "execution_count": 45, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[ 0. 0.05 0.1 0.15 0.2 0.25 0.3 0.35 0.4 0.45 0.5 0.55\n", + " 0.6 0.65 0.7 0.75 0.8 0.85 0.9 0.95 1. 1.05 1.1 1.15\n", + " 1.2 1.25 1.3 1.35 1.4 1.45 1.5 1.55 1.6 1.65 1.7 1.75\n", + " 1.8 1.85 1.9 1.95 2. ]\n" + ] + } + ], + "source": [ + "xarray = numpy.linspace(0, 2, 41)\n", + "print(xarray)" + ] + }, + { + "cell_type": "code", + "execution_count": 46, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "pow2 = xarray**2\n", + "pow3 = xarray**3\n", + "pow_half = numpy.sqrt(xarray)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Para trazar las matrices resultantes como una función de la original (`xarray`) en el eje x, necesitamos importar el módulo` pyplot` de ** Matplotlib **." + ] + }, + { + "cell_type": "code", + "execution_count": 47, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "from matplotlib import pyplot\n", + "%matplotlib inline" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "El comando `% matplotlib inline` está ahí para obtener nuestros trazados dentro del portátil (en lugar de una ventana emergente, que es el comportamiento predeterminado de` pyplot`).\n", + "\n", + "Utilizaremos la función `pyplot.plot ()`, especificando el color de línea (`'k'` para negro) y el estilo de línea (`' -'`, `'-'` y `':'` para línea continua, punteada y punteada), y dando a cada línea una etiqueta. Tenga en cuenta que los valores para `color`,` linestyle` y `label` se dan entre comillas." + ] + }, + { + "cell_type": "code", + "execution_count": 48, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 48, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAW8AAAEACAYAAAB8nvebAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n5C2EEDZIkrcQQtggSd5CCGGD/j+RWiKuPrsMFQAAAABJRU5ErkJggg==\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "#Plot x^2\n", + "pyplot.plot(xarray, pow2, color='k', linestyle='-', label='square')\n", + "#Plot x^3\n", + "pyplot.plot(xarray, pow3, color='k', linestyle='--', label='cube')\n", + "#Plot sqrt(x)\n", + "pyplot.plot(xarray, pow_half, color='k', linestyle=':', label='square root')\n", + "#Plot the legends in the best location\n", + "pyplot.legend(loc='best')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Para ilustrar otras características, trazaremos los mismos datos, pero variando los colores en lugar del estilo de línea. También usaremos la sintaxis LaTeX para escribir fórmulas en las etiquetas. Si desea obtener más información sobre la sintaxis de LaTeX, hay una [guía rápida de LaTeX](https://users.dickinson.edu/~richesod/latex/latexcheatsheet.pdf) disponible en línea.\n", + "\n", + "Agregar un punto y coma (`';'`) a la última línea del bloque de código de trazado evita esa salida fea, como ``. Intentalo." + ] + }, + { + "cell_type": "code", + "execution_count": 49, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAW8AAAEACAYAAAB8nvebAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "#Plot x^2\n", + "pyplot.plot(xarray, pow2, color='red', linestyle='-', label='$x^2$')\n", + "#Plot x^3\n", + "pyplot.plot(xarray, pow3, color='green', linestyle='-', label='$x^3$')\n", + "#Plot sqrt(x)\n", + "pyplot.plot(xarray, pow_half, color='blue', linestyle='-', label='$\\sqrt{x}$')\n", + "#Plot the legends in the best location\n", + "pyplot.legend(loc='best'); " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Eso es muy bueno! Por ahora, probablemente estés imaginando todo lo bueno que puedes hacer con los cuadernos Jupyter, Python y sus bibliotecas científicas ** NumPy ** y ** Matplotlib **. Acabamos de ver una introducción al trazado pero seguiremos aprendiendo sobre el poder de ** Matplotlib ** en la próxima lección.\n", + "\n", + "Si tiene curiosidad, puede explorar todas las parcelas hermosas que puede hacer navegando por la [galería Matplotlib](http://matplotlib.org/gallery.html)." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "##### Ejercicio:\n", + "\n", + "Elija dos operaciones diferentes para aplicar a `xarray` y grábelas con los datos resultantes en la misma gráfica." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Lo que hemos aprendido\n", + "\n", + "* Cómo importar bibliotecas\n", + "* Arrays multidimensionales usando NumPy\n", + "* Acceder a valores y cortar en matrices NumPy\n", + "* Magia `%% time` para cronometrar la ejecución de la celda.\n", + "* Comparación de rendimiento: listas vs matrices NumPy\n", + "* Trazado básico con `pyplot`." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Referencias\n", + "\n", + "1. _Eficaz de Computación en Física: Guía de campo para la investigación con Python_ (2015). Anthony Scopatz y Kathryn D. Huff. O'Reilly Media, Inc.\n", + "\n", + "2. _Numerical Python: un enfoque de técnicas prácticas para la industria_. (2015). Robert Johansson. Apretar\n", + "\n", + "2. [\"El mundo de Jupyter\" -un tutorial](https://github.com/barbagroup/jupyter-tutorial). Lorena A. Barba - 2016" + ] + }, + { + "cell_type": "code", + "execution_count": 50, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + "\n", + "\n", + "\n", + "\n" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 50, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Execute this cell to load the notebook's style sheet, then ignore it\n", + "from IPython.core.display import HTML\n", + "css_file = '../style/custom.css'\n", + "HTML(open(css_file, \"r\").read())" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.5.3" + }, + "widgets": { + "state": {}, + "version": "1.1.2" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/notebooks_es/5_Regresion_Lineal_con_datos_reales.ipynb b/notebooks_es/5_Regresion_Lineal_con_datos_reales.ipynb new file mode 100644 index 0000000..72669e6 --- /dev/null +++ b/notebooks_es/5_Regresion_Lineal_con_datos_reales.ipynb @@ -0,0 +1,1227 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "###### Contenido bajo licencia Creative Commons Attribution CC-BY 4.0, código bajo licencia BSD 3-Clause © 2017 L.A. Barba, N.C. Clementi" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Regresión lineal con datos reales\n", + "\n", + "## Temperatura de la tierra en el tiempo\n", + "\n", + "En esta lección, aplicaremos todo lo que hemos aprendido (y más) para analizar datos reales de la temperatura de la Tierra a lo largo del tiempo.\n", + "\n", + "¿Está aumentando la temperatura global? ¿Cuánto cuesta? ¡Esta es una cuestión de gran importancia en el mundo de hoy!\n", + "\n", + "Los datos sobre las temperaturas globales están disponibles en varias fuentes: NASA, el Centro Nacional de Datos Climáticos (NCDC) y la Universidad de East Anglia en el Reino Unido. Consulte la [Corporación Universitaria de Investigación Atmosférica](https://www2.ucar.edu/climate/faq/how-much-has-global-temperature-risen-last-100-years) (UCAR) para un discusión profunda\n", + "\n", + "El [Centro Goddard de Vuelos Espaciales de la NASA](http://svs.gsfc.nasa.gov/goto?3901) es una de nuestras fuentes de datos climáticos globales. Ellos produjeron el siguiente video que muestra un mapa de colores de las cambiantes ** anomalías de temperatura de la superficie ** ** de 1880 a 2015.\n", + "\n", + "El término [anomalía de temperatura global](https://www.ncdc.noaa.gov/monitoring-references/faq/anomalies.php) significa la diferencia de temperatura con respecto a un valor de referencia o un promedio a largo plazo. Es una forma muy útil de ver el problema y, en muchos sentidos, mejor que la temperatura absoluta. Por ejemplo, un mes de invierno puede ser más frío que el promedio en Washington DC, y también en Miami, pero las temperaturas absolutas serán diferentes en ambos lugares." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "data": { + "image/jpeg": "/9j/4AAQSkZJRgABAQAAAQABAAD/2wCEAAUDBAoKCgoICgoJCQgJCAkJCAgJCgkICAkICAgJCAkI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\nAEIQgAQhCAP/2Q==\n", + "text/html": [ + "\n", + " \n", + " " + ], + "text/plain": [ + "" + ] + }, + "execution_count": 1, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from IPython.display import YouTubeVideo\n", + "YouTubeVideo('gGOzHVUQCw0')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "¿Cómo podríamos entender las _trends_ de los datos sobre la temperatura global?\n", + "\n", + "El primer paso para analizar datos desconocidos es generar algunos gráficos simples utilizando ** Matplotlib **. Vamos a ver el historial de anomalías de temperatura, contenido en un archivo, y hacemos nuestro primer diagrama para explorar estos datos.\n", + "\n", + "Vamos a suavizar los datos y luego ajustaremos una línea para encontrar una tendencia, trazando a lo largo del camino para ver cómo se ve todo.\n", + "\n", + "¡Empecemos!" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Paso 1: lee un archivo de datos\n", + "\n", + "Tomamos los datos de la página web [NOAA](https://www.ncdc.noaa.gov/cag/) (Administración Nacional Oceánica y Atmosférica). Siéntete libre de jugar con la página web y analizar datos por tu cuenta, pero por ahora, asegurémonos de que trabajamos con el mismo conjunto de datos.\n", + "\n", + "\n", + "Tenemos un archivo llamado `land_global_temperature_anomaly-1880-2016.csv` en nuestra carpeta` data`. Este archivo contiene el año en la primera columna y los promedios de la anomalía de la temperatura terrestre enumerados secuencialmente en la segunda columna, desde el año 1880 hasta 2016. Cargaremos el archivo, luego haremos una gráfica inicial para ver cómo se ve.\n", + "\n", + "\n", + "##### Nota:\n", + "\n", + "Si descargó este bloc de notas solo, en lugar de la colección completa de este curso, es posible que no tenga el archivo de datos en la ubicación que suponemos a continuación. En ese caso, puede descargar los datos si agrega una celda de código y ejecuta el siguiente código en ella:\n", + "\n", + "```Python\n", + "de urllib.request import urlretrieve\n", + "URL = 'http://go.gwu.edu/engcomp1data5?accessType=DOWNLOAD'\n", + "urlretrieve (URL, 'land_global_temperature_anomaly-1880-2016.csv')\n", + "```\n", + "El archivo de datos se descargará a su directorio de trabajo, y luego tendrá que eliminar la información de ruta, es decir, la cadena `'../../ data /' ', de la definición de la variable` fname` a continuación.\n", + "\n", + "Comencemos importando NumPy." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "import numpy" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Para cargar nuestros datos desde el archivo, utilizaremos la función [`numpy.loadtxt ()`](https://docs.scipy.org/doc/numpy/reference/generated/numpy.loadtxt.html), que nos permite guardar inmediatamente los datos en matrices NumPy. (Le recomendamos que lea la documentación para obtener detalles sobre cómo funciona la función.) Aquí, guardaremos los datos en las matrices `year` y` temp_anomaly`." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "fname = '../data/land_global_temperature_anomaly-1880-2016.csv'\n", + "\n", + "year, temp_anomaly = numpy.loadtxt(fname, delimiter=',', skiprows=5, unpack=True)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "##### Ejercicio\n", + "\n", + "Inspeccione los datos imprimiendo `year` y` temp_anomaly`." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Paso 2: grafica los datos\n", + "\n", + "Primero carguemos el módulo ** Matplotlib ** llamado `pyplot`, para hacer gráficos en 2D. Recuerde que para obtener las tramas dentro del cuaderno, usamos un comando especial \"mágico\", `% matplotlib inline`:" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "from matplotlib import pyplot\n", + "%matplotlib inline" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "La función `plot ()` del módulo `pyplot` hace gráficos de líneas simples. Evitamos las cosas que aparecieron en la parte superior de la figura, que dicen `Out [x]: [<...>]` fealdad, al agregar un punto y coma al final del comando de trazado." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYMAAAD8CAYAAACVZ8iyAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nQmCC\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "pyplot.plot(year, temp_anomaly);" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "collapsed": true + }, + "source": [ + "Ahora tenemos un diagrama de líneas, pero si ve esta trama sin ninguna información, ¡no podrá averiguar qué tipo de datos es! Necesitamos etiquetas en los ejes, un título y por qué no un mejor color, fuente y tamaño de los tics.\n", + "** Las parcelas de calidad de publicación ** siempre deben ser su estándar para trazar.\n", + "La forma en que presente sus datos permitirá a otros (y probablemente a usted en el futuro) comprender mejor su trabajo.\n", + "\n", + "Podemos personalizar el estilo de nuestras tramas usando ** Matplotlib ** 's [`rcParams`](https://matplotlib.org/api/matplotlib_configuration_api.html#matplotlib.rcParams). Nos permite establecer algunas opciones de estilo que se aplican a todos los gráficos que creamos en la sesión actual.\n", + "Aquí, crearemos la fuente de un tamaño y tipo específico. También puede personalizar otros parámetros como el ancho de línea, el color, etc. (consulte la documentación)." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "from matplotlib import rcParams\n", + "rcParams['font.family'] = 'serif'\n", + "rcParams['font.size'] = 16" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Volveremos a hacer la misma trama, pero ahora agregaremos algunas cosas para que sea más bonita y ** la calidad de publicación **. Agregaremos un título, etiquetaremos los ejes y, mostraremos una cuadrícula de fondo. ¡Estudia los comandos a continuación y mira el resultado!" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAogAAAFzCAYAAAC99Pj9AAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nRU5ErkJggg==\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "#You can set the size of the figure by doing:\n", + "pyplot.figure(figsize=(10,5))\n", + "\n", + "#Plotting\n", + "pyplot.plot(year, temp_anomaly, color='#2929a3', linestyle='-', linewidth=1) \n", + "pyplot.title('Land global temperature anomalies. \\n')\n", + "pyplot.xlabel('Year')\n", + "pyplot.ylabel('Land temperature anomaly [°C]')\n", + "pyplot.grid();" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "collapsed": true + }, + "source": [ + "¿Mejor no? Siéntase libre de jugar con los parámetros y ver cómo cambia la trama. No hay nada como prueba y error para entenderlo." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Paso 3: regresión lineal de mínimos cuadrados\n", + "\n", + "Para tener una idea del comportamiento general de nuestros datos, podemos encontrar una curva suave que (aproximadamente) se ajuste a los puntos. Generalmente buscamos una curva que sea simple (por ejemplo, un polinomio) y no reproduzca el ruido que siempre está presente en los datos experimentales.\n", + "\n", + "Deje que $ f (x) $ sea la función que ajustaremos a los $ n + 1 $ puntos de datos: $ (x_i, y_i) $, $ i = 0, 1, ..., n $:\n", + "\n", + "$$\n", + "    f (x) = f (x; a_0, a_1, ..., a_m)\n", + "$$\n", + "\n", + "La notación anterior significa que $ f $ es una función de $ x $, con $ m + 1 $ parámetros variables $ a_0, a_1, ..., a_m $, donde $ m \n", + "```\n", + "\n", + "El ** docstring ** de una función es un mensaje del programador que documenta lo que él o ella construyó. Docstrings debe ser descriptivo y conciso. Son importantes porque explican (o recuerdan) el uso previsto de la función para los usuarios. Más adelante puede acceder a la cadena de documentación de una función usando la función `help()` y pasando el nombre de la función. Si está en una libreta, también puede anteponer un signo de interrogación `'' '` antes del nombre de la función y ejecutar la celda para mostrar la información de una función.\n", + "\n", + "¡Intentalo!" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "?print" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Usando la función `help` en su lugar:" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Help on built-in function print in module builtins:\n", + "\n", + "print(...)\n", + " print(value, ..., sep=' ', end='\\n', file=sys.stdout, flush=False)\n", + " \n", + " Prints the values to a stream, or to sys.stdout by default.\n", + " Optional keyword arguments:\n", + " file: a file-like object (stream); defaults to the current sys.stdout.\n", + " sep: string inserted between values, default a space.\n", + " end: string appended after the last value, default a newline.\n", + " flush: whether to forcibly flush the stream.\n", + "\n" + ] + } + ], + "source": [ + "help(print)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Definamos una función personalizada que calcula el valor medio de cualquier matriz. Estudia el código a continuación con cuidado." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "def mean_value(array):\n", + " \"\"\" Calculate the mean value of an array \n", + " \n", + " Arguments\n", + " ---------\n", + " array: Numpy array \n", + " \n", + " Returns\n", + " ------- \n", + " mean: mean value of the array\n", + " \"\"\"\n", + " sum_elem = 0\n", + " for element in array:\n", + " sum_elem += element # this is the same as sum_elem = sum_elem + element\n", + " \n", + " mean = sum_elem / len(array)\n", + " \n", + " return mean\n", + " " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Una vez que ejecuta la celda de arriba, la función `mean_value ()` está disponible para usar en cualquier argumento del tipo correcto. Esta función funciona en arreglos de cualquier longitud. Podemos intentarlo ahora con nuestros datos." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1948.0\n" + ] + } + ], + "source": [ + "year_mean = mean_value(year)\n", + "print(year_mean)" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.0526277372263\n" + ] + } + ], + "source": [ + "temp_anomaly_mean = mean_value(temp_anomaly)\n", + "print(temp_anomaly_mean)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "¡Ordenado! Aprendió cómo escribir una función de Python, y escribimos una para calcular el valor medio de una matriz de números. No teníamos que hacerlo, porque NumPy tiene una función incorporada para hacer exactamente lo que necesitamos: [`numpy.mean ()`](https://docs.scipy.org/doc/numpy-1.13. 0/reference/generated/numpy.mean.html)." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "##### Ejercicio\n", + "\n", + "Calcule la media de las matrices `year` y` temp_anomaly` utilizando la función incorporada de NumPy, y compare los resultados con los obtenidos utilizando nuestra función personalizada `mean_value`." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Ahora que tenemos valores medios, podemos calcular nuestros coeficientes siguiendo las ecuaciones (12). Primero calculamos $ a_1 $ y luego usamos ese valor para calcular $ a_0 $.\n", + "\n", + "Nuestros coeficientes son:\n", + "\n", + "$$\n", + "    a_1 = \\frac {\\sum_ {i = 0} ^ {n} y_ {i} (x_i - \\ bar {x})} {\\sum_ {i = 0} ^ {n} x_i (x_i - \\ bar {x })} \\quad, \\quad a_0 = \\ bar {y} - a_1 \\ bar {x}\n", + "$$" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Ya calculamos los valores medios de las matrices de datos, pero la fórmula requiere dos sumas sobre nuevas matrices derivadas. Adivina qué, NumPy tiene una función incorporada para eso: [`numpy.sum ()`](https://docs.scipy.org/doc/numpy/reference/generated/numpy.sum.html). Estudia el código a continuación." + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "a_1 = numpy.sum(temp_anomaly*(year - year_mean)) / numpy.sum(year*(year - year_mean)) " + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.0103702839435\n" + ] + } + ], + "source": [ + "print(a_1)" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "a_0 = temp_anomaly_mean - a_1*year_mean" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-20.1486853847\n" + ] + } + ], + "source": [ + "print(a_0)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "##### Ejercicio\n", + "\n", + "Escribe una función que calcule los coeficientes, llama a la función para calcularlos y compara el resultado con los valores que obtuvimos antes. Como una pista, te damos la estructura que debes seguir:\n", + "\n", + "```python\n", + "coeficientes def (x, y, x_mean, y_mean):\n", + "    \"\" \"\n", + "    Escribir docstrings aquí\n", + "    \"\" \"\n", + "\n", + "    a_1 =\n", + "    a_0 =\n", + "    \n", + "    devuelve a_1, a_0\n", + "```" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Ahora tenemos los coeficientes de una función lineal que mejor se ajusta a nuestros datos. Con ellos, podemos calcular los valores predichos de anomalía de temperatura, de acuerdo con nuestro ajuste. Verifique nuevamente las ecuaciones anteriores: los valores que vamos a calcular son $ f (x_i) $.\n", + "\n", + "Llamemos a `reg` la matriz obtenida al evaluar $ f (x_i) $ para todos los años." + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "reg = a_0 + a_1 * year" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Con los valores de nuestra regresión lineal, podemos trazarla sobre los datos originales para ver cómo se ven juntos. Estudia el código a continuación." + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAogAAAFOCAYAAAAFEOyOAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nzMzMzEr+D3e5KbvwEdppAAAAAElFTkSuQmCC\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "pyplot.figure(figsize=(10, 5))\n", + "\n", + "pyplot.plot(year, temp_anomaly, color='#2929a3', linestyle='-', linewidth=1, alpha=0.5) \n", + "pyplot.plot(year, reg, 'k--', linewidth=2, label='Linear regression')\n", + "pyplot.xlabel('Year')\n", + "pyplot.ylabel('Land temperature anomaly [°C]')\n", + "pyplot.legend(loc='best', fontsize=15)\n", + "pyplot.grid();" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Paso 4: aplicar la regresión usando NumPy" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Arriba, codificamos la regresión lineal desde cero. Pero, adivina qué: no tuvimos que hacerlo porque NumPy tiene funciones integradas que hacen lo que necesitamos.\n", + "\n", + "¡Sí! ¡Python y NumPy están aquí para ayudar! Con [`polyfit ()`](https://docs.scipy.org/doc/numpy-1.10.0/reference/generated/numpy.polyfit.html), obtenemos la pendiente y $ y $ -intercept del línea que mejor se ajusta a los datos. Con [`poly1d ()`](https://docs.scipy.org/doc/numpy/reference/generated/numpy.poly1d.html), podemos construir la función lineal desde su pendiente y $ y $ -intercept.\n", + "\n", + "Echale un vistazo:" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "# First fit with NumPy, then name the coefficients obtained a_1n, a_0n:\n", + "a_1n, a_0n = numpy.polyfit(year, temp_anomaly, 1)\n", + "\n", + "f_linear = numpy.poly1d((a_1n, a_0n)) " + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.0103702839435\n" + ] + } + ], + "source": [ + "print(a_1n)" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-20.1486853847\n" + ] + } + ], + "source": [ + "print(a_0n)" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " \n", + "0.01037 x - 20.15\n" + ] + } + ], + "source": [ + "print(f_linear)" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAogAAAFOCAYAAAAFEOyOAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nzMzMzEr+D3e5KbvwEdppAAAAAElFTkSuQmCC\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "pyplot.figure(figsize=(10, 5))\n", + "\n", + "pyplot.plot(year, temp_anomaly, color='#2929a3', linestyle='-', linewidth=1, alpha=0.5) \n", + "pyplot.plot(year, f_linear(year), 'k--', linewidth=2, label='Linear regression')\n", + "pyplot.xlabel('Year')\n", + "pyplot.ylabel('Land temperature anomaly [°C]')\n", + "pyplot.legend(loc='best', fontsize=15)\n", + "pyplot.grid();" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## \"Regresión dividida\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Si nos fijamos en la trama anterior, puede observar que alrededor de 1970 la temperatura comienza a aumentar más rápido que la tendencia anterior. Entonces, tal vez una sola línea recta no nos da un ajuste lo suficientemente bueno.\n", + "\n", + "¿Qué pasa si dividimos los datos en dos (antes y después de 1970) y realizamos una regresión lineal en cada segmento?\n", + "\n", + "Para hacer eso, primero necesitamos encontrar el puesto en nuestra matriz `year` donde se encuentra el año 1970. Afortunadamente, NumPy tiene una función llamada [`numpy.where ()`](https://docs.scipy.org/doc/numpy/reference/generated/numpy.where.html) que nos puede ayudar. Pasamos una condición y `numpy.where ()` nos dice en qué parte de la matriz la condición es `True`." + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(array([90]),)" + ] + }, + "execution_count": 24, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "numpy.where(year==1970)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Para dividir los datos, usamos el poderoso instrumento de _slicing_ con la notación de dos puntos. Recuerde que un punto entre dos índices indica un rango de valores desde un 'inicio' hasta un 'final'. La regla es que `[start: end]` incluye el elemento en el índice `start` pero excluye el del índice` end`. Por ejemplo, para obtener los primeros 3 años en nuestra matriz `year`, hacemos:" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([ 1880., 1881., 1882.])" + ] + }, + "execution_count": 25, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "year[0:3]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Ahora sabemos cómo dividir nuestros datos en dos conjuntos, para obtener dos líneas de regresión. Necesitamos dos sectores de las matrices `year` y` temp_anomaly`, que guardaremos en los nuevos nombres de variables a continuación. Después de eso, completamos dos ajustes lineales utilizando las útiles funciones de NumPy que aprendimos anteriormente." + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "year_1 , temp_anomaly_1 = year[0:90], temp_anomaly[0:90]\n", + "year_2 , temp_anomaly_2 = year[90:], temp_anomaly[90:]\n", + "\n", + "m1, b1 = numpy.polyfit(year_1, temp_anomaly_1, 1)\n", + "m2, b2 = numpy.polyfit(year_2, temp_anomaly_2, 1)\n", + "\n", + "f_linear_1 = numpy.poly1d((m1, b1))\n", + "f_linear_2 = numpy.poly1d((m2, b2))" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAogAAAFOCAYAAAAFEOyOAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nAAAASUVORK5CYII=\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "pyplot.figure(figsize=(10, 5))\n", + "\n", + "pyplot.plot(year, temp_anomaly, color='#2929a3', linestyle='-', linewidth=1, alpha=0.5) \n", + "pyplot.plot(year_1, f_linear_1(year_1), 'g--', linewidth=2, label='1880-1969')\n", + "pyplot.plot(year_2, f_linear_2(year_2), 'r--', linewidth=2, label='1970-2016')\n", + "\n", + "pyplot.xlabel('Year')\n", + "pyplot.ylabel('Land temperature anomaly [°C]')\n", + "pyplot.legend(loc='best', fontsize=15)\n", + "pyplot.grid();" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Tenemos dos curvas diferentes para dos partes diferentes de nuestro conjunto de datos. Un pequeño problema con esto y es que el punto final de nuestra primera regresión no coincide con el punto de partida de la segunda regresión. Hicimos esto con el propósito de aprender, pero no es rigurosamente correcto. Lo arreglaremos en el próximo módulo del curso cuando aprendamos más sobre los diferentes tipos de regresión." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Aprendimos:\n", + "\n", + "* Hacer nuestras parcelas más bellas\n", + "* Definir y llamar funciones de Python personalizadas\n", + "* Aplicación de regresión lineal a datos\n", + "* NumPy incorporados para la regresión lineal\n", + "* ¡¡La Tierra se está calentando !!!" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Referencias\n", + "\n", + "1. [_Habilidades esenciales para la informática de investigación reproducible_](https://barbagroup.github.io/essential_skills_RRC/) (2017). Lorena A. Barba, Natalia C. Clementi, Gilbert Forsyth.\n", + "2. _Métodos numéricos en ingeniería con Python 3_ (2013). Jaan Kiusalaas. Prensa de la Universidad de Cambridge.\n", + "3. _Cálculo eficaz en física: Guía de campo para la investigación con Python_ (2015). Anthony Scopatz y Kathryn D. Huff. O'Reilly Media, Inc." + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + "\n", + "\n", + "\n" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 28, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Execute this cell to load the notebook's style sheet, then ignore it\n", + "from IPython.core.display import HTML\n", + "css_file = '../style/custom.css'\n", + "HTML(open(css_file, \"r\").read())" + ] + } + ], + "metadata": { + "anaconda-cloud": {}, + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.5.3" + }, + "widgets": { + "state": {}, + "version": "1.1.2" + } + }, + "nbformat": 4, + "nbformat_minor": 1 +} From dca3951f0837213d1e921e7d6a27c7392aeda204 Mon Sep 17 00:00:00 2001 From: Sebastian Flores Date: Sun, 15 Apr 2018 11:06:48 -0300 Subject: [PATCH 03/17] Ending review of first notebook --- notebooks_en/1_Interacting_with_Python.ipynb | 2 +- notebooks_es/1_Interactuando_con_Python.ipynb | 121 ++++++++---------- 2 files changed, 54 insertions(+), 69 deletions(-) diff --git a/notebooks_en/1_Interacting_with_Python.ipynb b/notebooks_en/1_Interacting_with_Python.ipynb index dfe30e5..47ae4d8 100644 --- a/notebooks_en/1_Interacting_with_Python.ipynb +++ b/notebooks_en/1_Interacting_with_Python.ipynb @@ -1437,7 +1437,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.5.3" + "version": "3.6.4" }, "widgets": { "state": {}, diff --git a/notebooks_es/1_Interactuando_con_Python.ipynb b/notebooks_es/1_Interactuando_con_Python.ipynb index 412c031..e338666 100644 --- a/notebooks_es/1_Interactuando_con_Python.ipynb +++ b/notebooks_es/1_Interactuando_con_Python.ipynb @@ -415,7 +415,7 @@ "source": [ "### Variables y su tipo\n", "\n", - "Las variables constan de dos partes: un nombre y un valor. Cuando queremos dar a una variable su nombre y valor, usamos el signo igual: `nombre = valor`. Esto se llama una 'asignación'. El nombre de la variable va a la izquierda y el valor a la derecha.\n", + "Las variables constan de dos partes: un nombre (_name_)y un valor (_value_). Cuando queremos dar a una variable su nombre y valor, usamos el signo igual: `nombre = valor`. Esto se llama una 'asignación'. El nombre de la variable va a la izquierda y el valor a la derecha.\n", "\n", "¡Lo primero a lo que hay que acostumbrarse es a que el signo igual en una tarea tiene un significado diferente del que tiene en Algebra! Imagina que es una flecha que apunta de `nombre` a` valor`.\n", "\n", @@ -437,10 +437,8 @@ }, { "cell_type": "code", - "execution_count": 12, - "metadata": { - "collapsed": true - }, + "execution_count": 2, + "metadata": {}, "outputs": [], "source": [ "x = 3 " @@ -448,10 +446,8 @@ }, { "cell_type": "code", - "execution_count": 13, - "metadata": { - "collapsed": true - }, + "execution_count": 3, + "metadata": {}, "outputs": [], "source": [ "y = 4.5" @@ -483,7 +479,7 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 4, "metadata": {}, "outputs": [ { @@ -492,7 +488,7 @@ "7.5" ] }, - "execution_count": 14, + "execution_count": 4, "metadata": {}, "output_type": "execute_result" } @@ -503,7 +499,7 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 5, "metadata": {}, "outputs": [ { @@ -512,7 +508,7 @@ "8" ] }, - "execution_count": 15, + "execution_count": 5, "metadata": {}, "output_type": "execute_result" } @@ -523,7 +519,7 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 6, "metadata": {}, "outputs": [ { @@ -532,7 +528,7 @@ "1.5" ] }, - "execution_count": 16, + "execution_count": 6, "metadata": {}, "output_type": "execute_result" } @@ -550,7 +546,7 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 7, "metadata": {}, "outputs": [ { @@ -567,7 +563,7 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 8, "metadata": {}, "outputs": [ { @@ -588,15 +584,13 @@ "source": [ "### Variables de cadena\n", "\n", - "Además del nombre y el valor, las variables de Python tienen un _typo_ (_type_): el tipo del valor al que se refiere. Por ejemplo, un valor entero tiene el tipo `int`, y un número real tiene el tipo` float`. Una cadena es una variable que consiste en una secuencia de caracteres marcados por dos comillas, y tiene el tipo `str`." + "Además del nombre y el valor, las variables de Python tienen un _tipo_ (_type_): el tipo del valor al que se refiere. Por ejemplo, un valor entero tiene el tipo `int`, y un nmero real tiene el tipo` float`. Una cadena de texto es una variable que consiste en una secuencia de caracteres marcados por dos comillas, y tiene el tipo `str`." ] }, { "cell_type": "code", - "execution_count": 19, - "metadata": { - "collapsed": true - }, + "execution_count": 9, + "metadata": {}, "outputs": [], "source": [ "z = 'this is a string'" @@ -604,10 +598,8 @@ }, { "cell_type": "code", - "execution_count": 20, - "metadata": { - "collapsed": true - }, + "execution_count": 10, + "metadata": {}, "outputs": [], "source": [ "w = '1'" @@ -617,12 +609,12 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "¿Qué pasa si intentas \"agregar\" dos cadenas?" + "¿Qué pasa si intentas \"unir\" dos cadenas?" ] }, { "cell_type": "code", - "execution_count": 21, + "execution_count": 11, "metadata": {}, "outputs": [ { @@ -631,7 +623,7 @@ "'this is a string1'" ] }, - "execution_count": 21, + "execution_count": 11, "metadata": {}, "output_type": "execute_result" } @@ -649,7 +641,7 @@ }, { "cell_type": "code", - "execution_count": 22, + "execution_count": 12, "metadata": {}, "outputs": [ { @@ -659,7 +651,7 @@ "traceback": [ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", "\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)", - "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mx\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0mw\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mx\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0mw\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", "\u001b[0;31mTypeError\u001b[0m: unsupported operand type(s) for +: 'int' and 'str'" ] } @@ -672,9 +664,9 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "_¡Error!_ ¿Por qué? Examinemos lo que Python tiene que decir y exploremos lo que está sucediendo.\n", + "_¡Error!_ ¿Por qué? Examinemos lo que Python acaba de decir y exploremos lo que está sucediendo.\n", "\n", - "Python es un lenguaje dinámico, lo que significa que no necesitas especificar un tipo para llamar un objeto existente. El apodo humorístico para esto es \"duck typing\" (comportamiento de pato):\n", + "Python es un lenguaje dinámico, lo que significa que no necesitas especificar un tipo para definir un objeto existente. El apodo humorístico para esto es \"duck typing\" (comportamiento de pato):\n", "\n", "#### \"Cuando veo un ave que camina como un pato, nada como un pato y suena como un pato, a esa ave yo la llamo un pato.\".\n", "\n", @@ -685,7 +677,7 @@ }, { "cell_type": "code", - "execution_count": 23, + "execution_count": 13, "metadata": {}, "outputs": [ { @@ -694,7 +686,7 @@ "int" ] }, - "execution_count": 23, + "execution_count": 13, "metadata": {}, "output_type": "execute_result" } @@ -705,7 +697,7 @@ }, { "cell_type": "code", - "execution_count": 24, + "execution_count": 14, "metadata": {}, "outputs": [ { @@ -714,7 +706,7 @@ "str" ] }, - "execution_count": 24, + "execution_count": 14, "metadata": {}, "output_type": "execute_result" } @@ -725,7 +717,7 @@ }, { "cell_type": "code", - "execution_count": 25, + "execution_count": 15, "metadata": {}, "outputs": [ { @@ -734,7 +726,7 @@ "float" ] }, - "execution_count": 25, + "execution_count": 15, "metadata": {}, "output_type": "execute_result" } @@ -754,10 +746,8 @@ }, { "cell_type": "code", - "execution_count": 26, - "metadata": { - "collapsed": true - }, + "execution_count": 16, + "metadata": {}, "outputs": [], "source": [ "sum_xy = x + y\n", @@ -766,18 +756,15 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 17, "metadata": {}, "outputs": [ { - "ename": "NameError", - "evalue": "name 'sum_xy' is not defined", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)", - "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'The sum of x and y is:'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0msum_xy\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 2\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'The difference between x and y is:'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdiff_xy\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;31mNameError\u001b[0m: name 'sum_xy' is not defined" + "name": "stdout", + "output_type": "stream", + "text": [ + "The sum of x and y is: 7.5\n", + "The difference between x and y is: -1.5\n" ] } ], @@ -790,12 +777,12 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Observa lo que hicimos arriba: utilizamos la función `print()` con una cadena de texto (string), seguido de una variable, y Python imprimió una combinación útil del mensaje y el valor de la variable. Un consejo profesional: Quieres imprimir mensajes para humanos. Veamos ahora el tipo de las nuevas variables que acabamos de crear:" + "Observa lo que hicimos arriba: utilizamos la función `print()` con una cadena de texto (string), seguido de una variable, y Python imprimió una combinación útil del mensaje y el valor de la variable. Un consejo profesional: Quieres imprimir mensajes fáciles de leer para humanos. Veamos ahora el tipo de las nuevas variables que acabamos de crear:" ] }, { "cell_type": "code", - "execution_count": 28, + "execution_count": 18, "metadata": {}, "outputs": [ { @@ -804,7 +791,7 @@ "float" ] }, - "execution_count": 28, + "execution_count": 18, "metadata": {}, "output_type": "execute_result" } @@ -815,7 +802,7 @@ }, { "cell_type": "code", - "execution_count": 29, + "execution_count": 19, "metadata": {}, "outputs": [ { @@ -824,7 +811,7 @@ "float" ] }, - "execution_count": 29, + "execution_count": 19, "metadata": {}, "output_type": "execute_result" } @@ -860,7 +847,7 @@ "\n", "Retorna ... lo has adivinado ... `False` (Falso).\n", "\n", - "La función de Python `bool()` devuelve un valor de verdad asignado a cualquier argumento. Cualquier número que no sea cero tiene un valor de verdad de `True`, así como cualquier cadena o lista no vacía. El número cero y cualquier cadena o lista vacía tendrán un valor de verdad de `False`. Explore la función `bool ()` con varios argumentos." + "La función de Python `bool()` devuelve un valor de verdad asignado a cualquier argumento. Cualquier número que no sea cero tiene un valor de verdad de `True`, así como cualquier cadena o lista no vacía. El número cero y cualquier cadena o lista vacía tendrán un valor de verdad de `False`. Ahora exploremos la función `bool()` con varios argumentos." ] }, { @@ -1078,10 +1065,8 @@ }, { "cell_type": "code", - "execution_count": 40, - "metadata": { - "collapsed": true - }, + "execution_count": 21, + "metadata": {}, "outputs": [], "source": [ "a = 5\n", @@ -1091,7 +1076,7 @@ }, { "cell_type": "code", - "execution_count": 41, + "execution_count": 22, "metadata": {}, "outputs": [ { @@ -1100,7 +1085,7 @@ "False" ] }, - "execution_count": 41, + "execution_count": 22, "metadata": {}, "output_type": "execute_result" } @@ -1120,7 +1105,7 @@ }, { "cell_type": "code", - "execution_count": 42, + "execution_count": 23, "metadata": {}, "outputs": [ { @@ -1129,7 +1114,7 @@ "True" ] }, - "execution_count": 42, + "execution_count": 23, "metadata": {}, "output_type": "execute_result" } @@ -1147,7 +1132,7 @@ }, { "cell_type": "code", - "execution_count": 43, + "execution_count": 24, "metadata": {}, "outputs": [ { @@ -1156,7 +1141,7 @@ "True" ] }, - "execution_count": 43, + "execution_count": 24, "metadata": {}, "output_type": "execute_result" } From 729bdc77c8fefed5e973bb659584711b6307d916 Mon Sep 17 00:00:00 2001 From: Sebastian Flores Date: Sat, 21 Apr 2018 18:57:37 -0300 Subject: [PATCH 04/17] Updated first notebook in spanish --- notebooks_es/1_Interactuando_con_Python.ipynb | 836 +++--------------- .../2_Strings_y_listas_en_Jupyter.ipynb | 16 +- notebooks_es/3_Ejemplo_con_MAEbulletin.ipynb | 2 +- .../5_Regresion_Lineal_con_datos_reales.ipynb | 6 +- 4 files changed, 157 insertions(+), 703 deletions(-) diff --git a/notebooks_es/1_Interactuando_con_Python.ipynb b/notebooks_es/1_Interactuando_con_Python.ipynb index e338666..c5d646b 100644 --- a/notebooks_es/1_Interactuando_con_Python.ipynb +++ b/notebooks_es/1_Interactuando_con_Python.ipynb @@ -14,7 +14,7 @@ "# Interactuando con Python\n", "\n", "Esta es la primera lección de nuestro curso _\"Computación de Ingeniería\"_, un curso de un semestre para estudiantes universitarios de segundo año. El curso usa Python y no asume experiencia previa en programación.\n", - "Nuestro primer paso será interactuar con Python. Pero primero veamos algunos datos interesantes." + "Nuestro primer paso será interactuar con Python. Pero primero aprenderemos algunos datos interesantes." ] }, { @@ -28,7 +28,7 @@ "Es un lenguaje de propósito general, lo que significa que puede ser usardo para cualquier cosa: organización de datos, web scraping, creación de sitios web, análisis de sonidos, creación de juegos y, por supuesto, \"cálculos de ingeniería\".\n", "\n", "Python es un lenguaje interpretado. Esto significa que puedes escribir comandos de Python y la computadora ejecuta esas instrucciones directamente. Otros lenguajes de programación, como C, C ++ y Fortran, requieren un paso previo de _compilación_: traducir los comandos al lenguaje de la máquina.\n", - "Una buena habilidad de Python es que puede ser utilizada _interactivamente_. [Fernando Perez](https://en.wikipedia.org/wiki/Fernando_Pérez_ (software_developer)) creó famoso ** IPython ** como un proyecto paralelo durante su doctorado. Vamos a usar IPython (el I significa \"interactivo\") en esta lección." + "Una buena habilidad de Python es que puede ser utilizada _interactivamente_. Fernando Perez creó ** IPython ** como un proyecto paralelo durante su doctorado. Vamos a usar IPython (el I significa \"interactivo\") en esta lección." ] }, { @@ -47,7 +47,7 @@ "(Al respecto, consulta la sección Lecturas recomendadas al final).\n", "Y si realmente necesitamos acelerar nuestro programa, podemos volver a escribir las partes lentas en un lenguaje compilado después. Porque Python interactua bien con otros idiomas :-)\n", "\n", - "Las principales compañías tecnológicas usan Python: Google, Facebook, Dropbox, Wikipedia, Yahoo !, YouTube ... Y este año, Python ocupó el lugar número 1 en la lista interactiva de [The 2017 Top Programming Languages](http://spectrum.ieee.org/computing/software/the-2017-top-programming-languages), por _EEEE Spectrum_ ([IEEE](http://www.ieee.org/about/index.html) es la sociedad técnica profesional más grande del mundo )" + "Las principales compañías tecnológicas usan Python: Google, Facebook, Dropbox, Wikipedia, Yahoo!, YouTube ... Y este año, Python ocupó el lugar número 1 en la lista interactiva de [The 2017 Top Programming Languages](http://spectrum.ieee.org/computing/software/the-2017-top-programming-languages), por _EEEE Spectrum_ ([IEEE](http://www.ieee.org/about/index.html) es la sociedad técnica profesional más grande del mundo )" ] }, { @@ -75,7 +75,7 @@ "\n", "##### Nota:\n", "\n", - "Nuestro plan para este curso es trabajar en un laboratorio de computación, donde todos tendrán una computadora con todo instalado con anticipación. Por esta razón, no discutiremos la instalación en este momento. Más adelante, cuando esté ansioso por trabajar en su computadora personal, te ayudaremos a instalar todo lo que necesita. _¡Esto es gratis!_" + "Nuestro plan para este curso es trabajar en un laboratorio de computación, donde todos tendrán una computadora con todo instalado con anticipación. Por esta razón, no discutiremos la instalación en este momento. Más adelante, cuando estés ansioso por trabajar en su computadora personal, te ayudaremos a instalar todo lo que necesita. _¡Sí, es gratis!_" ] }, { @@ -89,17 +89,9 @@ }, { "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "¡Hola mundo!\n" - ] - } - ], + "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "print(\"¡Hola mundo!\")" ] @@ -108,7 +100,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "¡¡Pan comido!! acabas de escribir tu primer programa y aprendiste a usar la función `print()`. Sí, `print()` es una función: pasamos el _argumento_ sobre el que queremos que actúe la función, dentro de los paréntesis. En el caso anterior, pasamos un _string_, que es una serie de caracteres entre comillas. No te preocupes, volveremos a los strings más adelante en esta lección." + "¡¡Pan comido!! acabas de escribir tu primer programa y aprendiste a usar la función `print()`. Sí, `print()` es una función: pasamos el _argumento_ sobre el que queremos que actúe la función, dentro de los paréntesis. En el caso anterior, pasamos un _string_ o _cadena de texto_, que es una serie de caracteres entre comillas. No te preocupes, volveremos a los strings más adelante en esta lección." ] }, { @@ -131,7 +123,7 @@ "Prueba cualquier operación aritmética en IPython. Los símbolos son lo que esperaría, excepto el operador de potencia, que obtiene con dos asteriscos: `**`. Prueba todos estos:\n", "\n", "```python\n", - "+ - */**% //\n", + "+ - * / ** % //\n", "```\n", "\n", "El símbolo `%` es el operador _módulo_ (divide y devuelve el resto), y la barra doble es _división entera_." @@ -139,120 +131,54 @@ }, { "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "4" - ] - }, - "execution_count": 2, - "metadata": {}, - "output_type": "execute_result" - } - ], + "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "2 + 2" ] }, { "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "4.9" - ] - }, - "execution_count": 3, - "metadata": {}, - "output_type": "execute_result" - } - ], + "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "1.25 + 3.65" ] }, { "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "2" - ] - }, - "execution_count": 4, - "metadata": {}, - "output_type": "execute_result" - } - ], + "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "5 - 3" ] }, { "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "8" - ] - }, - "execution_count": 5, - "metadata": {}, - "output_type": "execute_result" - } - ], + "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "2 * 4" ] }, { "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "3.5" - ] - }, - "execution_count": 6, - "metadata": {}, - "output_type": "execute_result" - } - ], + "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "7 / 2" ] }, { "cell_type": "code", - "execution_count": 7, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "8" - ] - }, - "execution_count": 7, - "metadata": {}, - "output_type": "execute_result" - } - ], + "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "2**3" ] @@ -266,20 +192,9 @@ }, { "cell_type": "code", - "execution_count": 8, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "4.5" - ] - }, - "execution_count": 8, - "metadata": {}, - "output_type": "execute_result" - } - ], + "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "9**1/2" ] @@ -296,20 +211,9 @@ }, { "cell_type": "code", - "execution_count": 9, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "3.0" - ] - }, - "execution_count": 9, - "metadata": {}, - "output_type": "execute_result" - } - ], + "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "9**(1/2)" ] @@ -320,45 +224,23 @@ "source": [ "¡Sí! ¡El orden de las operaciones es importante!\n", "\n", - "Si no recuerdas de lo que estamos hablando, revise la [Aritmética/Orden de operaciones](https://en.wikibooks.org/wiki/Arithmetic/Order_of_Operations). Una situación frecuente que expone esto es la siguiente:" + "Si no recuerdas de lo que estamos hablando, revisa la [Aritmética/Orden de operaciones](https://es.wikipedia.org/wiki/Orden_de_evaluaci%C3%B3n). Una situación frecuente que expone esto es la siguiente:" ] }, { "cell_type": "code", - "execution_count": 10, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "4.5" - ] - }, - "execution_count": 10, - "metadata": {}, - "output_type": "execute_result" - } - ], + "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "3 + 3 / 2" ] }, { "cell_type": "code", - "execution_count": 11, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "3.0" - ] - }, - "execution_count": 11, - "metadata": {}, - "output_type": "execute_result" - } - ], + "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "(3 + 3) / 2" ] @@ -379,7 +261,7 @@ "\n", "1. El volumen de una esfera con radio $ r $ es $ \\frac {4} {3} \\pi r ^ 3 $. ¿Cuál es el volumen de una esfera con un diámetro de 6.65 cm?\n", "\n", - "    Por el valor de $ \\pi $ usa 3.14159 (por ahora). Compare su respuesta con la solución hasta 4 números decimales.\n", + "    Por el valor de $ \\pi $ usa 3.14159 (por ahora). Compara tu respuesta con la solución hasta 4 números decimales.\n", "\n", "    Sugerencia: 523.5983 es incorrecto y 615.9184 también es incorrecto.\n", "    \n", @@ -389,9 +271,7 @@ { "cell_type": "code", "execution_count": null, - "metadata": { - "collapsed": true - }, + "metadata": {}, "outputs": [], "source": [] }, @@ -406,7 +286,9 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Respuesta ejercicio 1: 153.9796 Respuesta ejercicio 2: 945.45 " + "Respuesta ejercicio 1: 153.9796 \n", + "\n", + "Respuesta ejercicio 2: 945.45 " ] }, { @@ -415,9 +297,9 @@ "source": [ "### Variables y su tipo\n", "\n", - "Las variables constan de dos partes: un nombre (_name_)y un valor (_value_). Cuando queremos dar a una variable su nombre y valor, usamos el signo igual: `nombre = valor`. Esto se llama una 'asignación'. El nombre de la variable va a la izquierda y el valor a la derecha.\n", + "Las variables constan de dos partes: un nombre (_name_) y un valor (_value_). Cuando queremos dar a una variable su nombre y valor, usamos el signo igual: `nombre = valor`. Esto se llama una 'asignación'. El nombre de la variable va a la izquierda y el valor a la derecha.\n", "\n", - "¡Lo primero a lo que hay que acostumbrarse es a que el signo igual en una tarea tiene un significado diferente del que tiene en Algebra! Imagina que es una flecha que apunta de `nombre` a` valor`.\n", + "¡Lo primero a lo que hay que acostumbrarse es a que el signo igual en una tarea tiene un significado diferente del que tiene en Algebra! Imagina que es una flecha que apunta del `nombre` al ` valor`.\n", "\n", "\n", "\n", @@ -430,14 +312,14 @@ "    nombre_3\n", "    NombreApellido\n", "```\n", - "Ten en cuenta que hay palabras reservadas que no puede usar; son las [palabras reservadas de Python](https://docs.python.org/3/reference/lexical_analysis.html#keywords).\n", + "Ten en cuenta que hay palabras reservadas que no puede usar; son las [palabras reservadas de Python](https://es.wikibooks.org/wiki/Python/Generalidades/Palabras_reservadas,_operadores_y_s%C3%ADmbolos_del_lenguaje).\n", "  \n", "OK. Asignemos algunos valores a las variables y realicemos algunas operaciones con ellos:" ] }, { "cell_type": "code", - "execution_count": 2, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -446,7 +328,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -464,9 +346,7 @@ { "cell_type": "code", "execution_count": null, - "metadata": { - "collapsed": true - }, + "metadata": {}, "outputs": [], "source": [] }, @@ -479,60 +359,27 @@ }, { "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "7.5" - ] - }, - "execution_count": 4, - "metadata": {}, - "output_type": "execute_result" - } - ], + "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "x + y" ] }, { "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "8" - ] - }, - "execution_count": 5, - "metadata": {}, - "output_type": "execute_result" - } - ], + "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "2**x" ] }, { "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "1.5" - ] - }, - "execution_count": 6, - "metadata": {}, - "output_type": "execute_result" - } - ], + "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "y - 3" ] @@ -546,34 +393,18 @@ }, { "cell_type": "code", - "execution_count": 7, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "3\n" - ] - } - ], + "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "print(x)" ] }, { "cell_type": "code", - "execution_count": 8, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "4.5\n" - ] - } - ], + "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "print(y)" ] @@ -584,12 +415,12 @@ "source": [ "### Variables de cadena\n", "\n", - "Además del nombre y el valor, las variables de Python tienen un _tipo_ (_type_): el tipo del valor al que se refiere. Por ejemplo, un valor entero tiene el tipo `int`, y un nmero real tiene el tipo` float`. Una cadena de texto es una variable que consiste en una secuencia de caracteres marcados por dos comillas, y tiene el tipo `str`." + "Además del nombre y el valor, las variables de Python corresponden a un cierto _tipo_ de dato: el tipo del valor al que se refiere. Por ejemplo, un valor entero tiene el tipo `int`, y un nmero real tiene el tipo` float`. Una cadena de texto es una variable que consiste en una secuencia de caracteres marcados por dos comillas, y tiene el tipo `str`." ] }, { "cell_type": "code", - "execution_count": 9, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -598,7 +429,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -609,25 +440,14 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "¿Qué pasa si intentas \"unir\" dos cadenas?" + "¿Qué pasa si intentas \"unir\" dos cadenas de texto?" ] }, { "cell_type": "code", - "execution_count": 11, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "'this is a string1'" - ] - }, - "execution_count": 11, - "metadata": {}, - "output_type": "execute_result" - } - ], + "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "z + w" ] @@ -636,26 +456,14 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "La operación anterior se llama _concatenación_: encadenando dos cadenas juntas en una. Interesante, ¿eh? Pero mira esto:" + "La operación anterior se llama _concatenación_: los dos strings o cadenas de texto se han reunido en una sola. Interesante, ¿eh? Sin embargo, mira esto:" ] }, { "cell_type": "code", - "execution_count": 12, - "metadata": {}, - "outputs": [ - { - "ename": "TypeError", - "evalue": "unsupported operand type(s) for +: 'int' and 'str'", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)", - "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mx\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0mw\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", - "\u001b[0;31mTypeError\u001b[0m: unsupported operand type(s) for +: 'int' and 'str'" - ] - } - ], + "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "x + w" ] @@ -672,65 +480,32 @@ "\n", "En otras palabras, una variable tiene un tipo, pero no necesitamos especificarlo. Simplemente se comportará como se supone que debe hacerlo cuando operemos con él (graznará y caminará como fue la intención de la naturaleza).\n", "\n", - "Pero a veces debe asegurarse de conocer el tipo de variable. Afortunadamente, Python ofrece una función para encontrar el tipo de variable: `type()`." + "Pero a veces es necesario asegurarse de conocer el tipo de variable. Afortunadamente, Python ofrece una función para encontrar el tipo de variable: `type()` (tipo, en inglés)." ] }, { "cell_type": "code", - "execution_count": 13, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "int" - ] - }, - "execution_count": 13, - "metadata": {}, - "output_type": "execute_result" - } - ], + "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "type(x)" ] }, { "cell_type": "code", - "execution_count": 14, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "str" - ] - }, - "execution_count": 14, - "metadata": {}, - "output_type": "execute_result" - } - ], + "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "type(w)" ] }, { "cell_type": "code", - "execution_count": 15, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "float" - ] - }, - "execution_count": 15, - "metadata": {}, - "output_type": "execute_result" - } - ], + "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "type(y)" ] @@ -741,12 +516,12 @@ "source": [ "### Más asignaciones\n", "\n", - "¿Qué sucede si se desea asignar a una nueva variable el resultado de una operación que involucra otras variables? ¡Ningún problema!" + "¿Qué sucede si se desea asignar a una nueva variable el resultado de una operación que involucra otras variables? ¡No hay problema!" ] }, { "cell_type": "code", - "execution_count": 16, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -756,18 +531,9 @@ }, { "cell_type": "code", - "execution_count": 17, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "The sum of x and y is: 7.5\n", - "The difference between x and y is: -1.5\n" - ] - } - ], + "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "print('The sum of x and y is:', sum_xy)\n", "print('The difference between x and y is:', diff_xy)" @@ -782,40 +548,18 @@ }, { "cell_type": "code", - "execution_count": 18, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "float" - ] - }, - "execution_count": 18, - "metadata": {}, - "output_type": "execute_result" - } - ], + "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "type(sum_xy)" ] }, { "cell_type": "code", - "execution_count": 19, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "float" - ] - }, - "execution_count": 19, - "metadata": {}, - "output_type": "execute_result" - } - ], + "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "type(diff_xy)" ] @@ -838,7 +582,7 @@ "`True`,` False`, `None` y` NotImplemented`.\n", "Por ahora, veremos solo los primeros tres de estos.\n", "\n", - "** Las variables booleanas ** se utilizan para representar valores de verdad, y pueden tomar uno de dos valores posibles: `True` y` False`.\n", + "** Las variables booleanas ** se utilizan para representar valores de verdad, y pueden tomar uno de dos valores posibles: `True` (Verdadero) y ` False` (Falso).\n", "_Expresiones lógicas_ devuelven booleanos. Aquí está la expresión lógica más simple, usando la palabra reservada `not`:\n", "\n", "```Python\n", @@ -852,69 +596,34 @@ }, { "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "False" - ] - }, - "execution_count": 2, - "metadata": {}, - "output_type": "execute_result" - } - ], + "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "bool(0)" ] }, { "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "True" - ] - }, - "execution_count": 3, - "metadata": {}, - "output_type": "execute_result" - } - ], + "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "bool('Do we need oxygen?')" ] }, { "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "True" - ] - }, - "execution_count": 4, - "metadata": {}, - "output_type": "execute_result" - } - ], + "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "bool('We do not need oxygen')" ] }, { "cell_type": "markdown", - "metadata": { - "collapsed": true - }, + "metadata": {}, "source": [ "**None no es cero **: `None` (ninguno, nada) es una variable especial que indica que no se asignó ningún valor o que un comportamiento no está definido. Es diferente del valor cero, una cadena vacía o algún otro valor nulo.\n", "\n", @@ -923,10 +632,8 @@ }, { "cell_type": "code", - "execution_count": 33, - "metadata": { - "collapsed": true - }, + "execution_count": null, + "metadata": {}, "outputs": [], "source": [ "a = None\n", @@ -936,21 +643,9 @@ }, { "cell_type": "code", - "execution_count": 34, - "metadata": {}, - "outputs": [ - { - "ename": "TypeError", - "evalue": "unsupported operand type(s) for +: 'NoneType' and 'int'", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)", - "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0ma\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0mb\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", - "\u001b[0;31mTypeError\u001b[0m: unsupported operand type(s) for +: 'NoneType' and 'int'" - ] - } - ], + "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "a + b" ] @@ -966,10 +661,8 @@ }, { "cell_type": "code", - "execution_count": 35, - "metadata": { - "collapsed": true - }, + "execution_count": null, + "metadata": {}, "outputs": [], "source": [ "x = 3\n", @@ -978,20 +671,9 @@ }, { "cell_type": "code", - "execution_count": 36, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "False" - ] - }, - "execution_count": 36, - "metadata": {}, - "output_type": "execute_result" - } - ], + "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "x > y" ] @@ -1005,10 +687,8 @@ }, { "cell_type": "code", - "execution_count": 37, - "metadata": { - "collapsed": true - }, + "execution_count": null, + "metadata": {}, "outputs": [], "source": [ "z = x > y" @@ -1016,40 +696,18 @@ }, { "cell_type": "code", - "execution_count": 38, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "False" - ] - }, - "execution_count": 38, - "metadata": {}, - "output_type": "execute_result" - } - ], + "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "z" ] }, { "cell_type": "code", - "execution_count": 39, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "bool" - ] - }, - "execution_count": 39, - "metadata": {}, - "output_type": "execute_result" - } - ], + "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "type(z)" ] @@ -1058,14 +716,14 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Los operadores lógicos son los siguientes: `and`,` or`, y `not`. Funcionan igual que en el inglés. Una expresión lógica con `and` es verdadera (`True`) sólo si ambos operandos son verdaderos. Una expresión con `or` es verdadera (`True`) cuando cualquiera de los operandos es verdadero. Y la palabra clave `not` siempre niega la expresión que le sigue.\n", + "Los operadores lógicos son los siguientes: `and`, `or`, y `not`. Funcionan igual que en el inglés. Una expresión lógica con `and` es verdadera (`True`) sólo si ambos operandos son verdaderos. Una expresión con `or` es verdadera (`True`) cuando cualquiera de los operandos es verdadero. Y la palabra clave `not` siempre niega la expresión que le sigue.\n", "\n", "Hagamos algunos ejemplos:" ] }, { "cell_type": "code", - "execution_count": 21, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -1076,20 +734,9 @@ }, { "cell_type": "code", - "execution_count": 22, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "False" - ] - }, - "execution_count": 22, - "metadata": {}, - "output_type": "execute_result" - } - ], + "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "a > b and b > c" ] @@ -1105,20 +752,9 @@ }, { "cell_type": "code", - "execution_count": 23, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "True" - ] - }, - "execution_count": 23, - "metadata": {}, - "output_type": "execute_result" - } - ], + "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "a > b or b > c" ] @@ -1132,20 +768,9 @@ }, { "cell_type": "code", - "execution_count": 24, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "True" - ] - }, - "execution_count": 24, - "metadata": {}, - "output_type": "execute_result" - } - ], + "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "not b > c" ] @@ -1178,20 +803,9 @@ }, { "cell_type": "code", - "execution_count": 44, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "True" - ] - }, - "execution_count": 44, - "metadata": {}, - "output_type": "execute_result" - } - ], + "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "a > b and not b > c" ] @@ -1235,169 +849,9 @@ }, { "cell_type": "code", - "execution_count": 45, - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "\n", - "\n", - "\n", - "\n", - "\n" - ], - "text/plain": [ - "" - ] - }, - "execution_count": 45, - "metadata": {}, - "output_type": "execute_result" - } - ], + "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "# Execute this cell to load the notebook's style sheet, then ignore it\n", "from IPython.core.display import HTML\n", @@ -1422,7 +876,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.6.4" + "version": "3.5.2" }, "widgets": { "state": {}, diff --git a/notebooks_es/2_Strings_y_listas_en_Jupyter.ipynb b/notebooks_es/2_Strings_y_listas_en_Jupyter.ipynb index 215c543..9abb5b9 100644 --- a/notebooks_es/2_Strings_y_listas_en_Jupyter.ipynb +++ b/notebooks_es/2_Strings_y_listas_en_Jupyter.ipynb @@ -83,7 +83,7 @@ "Markdown es fácil de aprender, consulte la sintaxis en la página web [\"Daring Fireball\"](https://daringfireball.net/projects/markdown/syntax) (por John Gruber). Algunos consejos:\n", "\n", "* para crear un título, use un hash para comenzar la línea: `# Title`\n", - "* para crear el siguiente encabezado, use dos hashes (y así sucesivamente): `## Heading`\n", + "* para crear el siguiente encabezado, use dos hash (y así sucesivamente): `## Heading`\n", "* para poner en cursiva una palabra o frase, enciérrelo en asteriscos (o en las líneas inferiores): `* italic *` o `_italic_`\n", "* para que sea negrita, enciérrelo con dos asteriscos: `** en negrita **`\n", "* para hacer un hipervínculo, use corchetes cuadrados y redondos: `[texto hipervinculado](url)`\n", @@ -207,7 +207,7 @@ "\n", "\n", "Puede encontrar una lista de los accesos directos seleccionando `Ayuda-> Métodos abreviados de teclado`\n", - "desde la barra de menú del notebook. Es posible que desee dejar esto para más adelante y volver a él, pero se vuelve más útil cuanto más use Jupyter." + "desde la barra de menú del notebook. Puede dejar esto para más adelante y volver a él, pero se vuelve más útil cuanto más use Jupyter." ] }, { @@ -321,7 +321,7 @@ "source": [ "### Indexación\n", "\n", - "Podemos acceder a cada carácter por separado en una cadena (o un segmento continuo de ella) usando _indices_: enteros que denotan la posición del carácter en la cadena. Los índices van entre corchetes, tocando el nombre de la variable de cadena a la derecha. Por ejemplo, para acceder al primer elemento de `new_string`, debemos ingresar` new_string [0] `. ¡Sí! en Python comenzamos a contar desde 0." + "Podemos acceder a cada carácter por separado en una cadena (o un segmento continuo de la misma) usando _indices_: enteros que denotan la posición del carácter en la cadena. Los índices van entre corchetes, tocando el nombre de la variable de cadena a la derecha. Por ejemplo, para acceder al primer elemento de `new_string`, debemos ingresar` new_string [0] `. ¡Sí! en Python comenzamos a contar desde 0." ] }, { @@ -547,7 +547,7 @@ "source": [ "### Cortar cadenas\n", "\n", - "A veces, queremos captar más de un elemento: es posible que deseemos una sección de la cadena. Lo hacemos utilizando la notación _slicing_ entre corchetes. Por ejemplo, podemos usar `[start: end]`, donde `start` es el índice para comenzar el corte, y` end` es el índice (no incluido) para terminar el corte. Por ejemplo, para tomar la palabra `hello` de nuestra cadena, hacemos:" + "A veces, queremos captar más de un elemento: es posible que deseemos una sección de la cadena. Lo hacemos utilizando la notación _slicing_ entre corchetes. Por ejemplo, podemos usar `[start: end]`, donde `start` es el índice para comenzar el corte, y` end` es el índice (no incluido) para terminar el corte. Por ejemplo, para tomar la palabra `hello` de nuestra cadena, lo hacemos:" ] }, { @@ -1662,7 +1662,7 @@ "\n", "1. Agregue dos frutas diferentes a la lista `fruits`.\n", "2. Comprueba si `'mango'` está en tu nueva lista` fruits`.\n", - "3. Dada la lista `alist = [1, 2, 3, '4', [5, 'six'], [7]]` ejecuta lo siguiente en celdas separadas y analiza la salida con tus compañeros de clase:\n", + "3. Dada la lista `alist = [1, 2, 3, '4', [5, 'six'], [7]]` ejecuta lo siguiente en celdas separadas y analiza el resultado con tus compañeros de clase:\n", "\n", "```Python\n", "   4 en alista\n", @@ -1898,7 +1898,7 @@ "source": [ "### Iteración con declaraciones `for`\n", "\n", - "La idea de _iteration_ (en inglés simple) es repetir un proceso varias veces. Si tiene alguna experiencia en programación con otro lenguaje (como C o Java, por ejemplo), puede tener una idea de cómo crear iteraciones con sentencias `for`. Pero estos son un poco diferentes en Python, como puede leer en la [documentación](https://docs.python.org/3/tutorial/controlflow.html#for-statements).\n", + "La idea de _iteration_ (en inglés simple) es repetir un proceso varias veces. Si tiene alguna experiencia en programación con otro idioma (como C o Java, por ejemplo), puede tener una idea de cómo crear iteraciones con sentencias `for`. Pero estos son un poco diferentes en Python, como puede leer en la [documentación](https://docs.python.org/3/tutorial/controlflow.html#for-statements).\n", "\n", "Una instrucción Python `for` itera sobre los elementos de una secuencia, naturalmente. Digamos que tiene una lista llamada `frutas` que contiene una secuencia de cadenas con nombres de fruta; puedes escribir una declaración como\n", "\n", @@ -2199,7 +2199,7 @@ "## Referencias\n", "\n", "1. [Conceptos básicos del cuaderno: editor modal](http://jupyter-notebook.readthedocs.io/en/latest/examples/Notebook/Notebook%20Basics.html)\n", - "2. [\"Indices señalan los elementos,\"](https://blog.nelhage.com/2015/08/indices-point-between-elements/) publicación de blog de Nelson Elhage (2015).\n", + "2. [\"Índices de puntos entre los elementos\"](https://blog.nelhage.com/2015/08/indices-point-between-elements/) publicación de blog de Nelson Elhage (2015).\n", "3. _Python para todos: explorando datos usando Python 3_ (2016). Charles R. Severance. [PDF disponible](http://do1.dr-chuck.com/pythonlearn/EN_us/pythonlearn.pdf)\n", "4. _Piense en Python: cómo pensar como un científico de la computación_ (2012). Allen Downey. Green Tea Press. [PDF disponible](http://greenteapress.com/thinkpython/thinkpython.pdf)" ] @@ -2393,7 +2393,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.6.4" + "version": "3.5.3" }, "widgets": { "state": {}, diff --git a/notebooks_es/3_Ejemplo_con_MAEbulletin.ipynb b/notebooks_es/3_Ejemplo_con_MAEbulletin.ipynb index 5875a1b..60f01f2 100644 --- a/notebooks_es/3_Ejemplo_con_MAEbulletin.ipynb +++ b/notebooks_es/3_Ejemplo_con_MAEbulletin.ipynb @@ -714,7 +714,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.6.4" + "version": "3.5.3" }, "widgets": { "state": {}, diff --git a/notebooks_es/5_Regresion_Lineal_con_datos_reales.ipynb b/notebooks_es/5_Regresion_Lineal_con_datos_reales.ipynb index 72669e6..6d0d3ac 100644 --- a/notebooks_es/5_Regresion_Lineal_con_datos_reales.ipynb +++ b/notebooks_es/5_Regresion_Lineal_con_datos_reales.ipynb @@ -192,7 +192,7 @@ "collapsed": true }, "source": [ - "Ahora tenemos un diagrama de líneas, pero si ve esta trama sin ninguna información, ¡no podrá averiguar qué tipo de datos es! Necesitamos etiquetas en los ejes, un título y por qué no un mejor color, fuente y tamaño de los tics.\n", + "Ahora tenemos un diagrama de líneas, pero si ve esta trama sin ninguna información, ¡no podrá averiguar qué tipo de datos es! Necesitamos etiquetas en los ejes, un título y por qué no un mejor color, fuente y tamaño de los ticks.\n", "** Las parcelas de calidad de publicación ** siempre deben ser su estándar para trazar.\n", "La forma en que presente sus datos permitirá a otros (y probablemente a usted en el futuro) comprender mejor su trabajo.\n", "\n", @@ -440,7 +440,7 @@ "\n", "eso se ajusta a nuestros datos.\n", "\n", - "En nuestro caso, el `x`-data corresponde a` year`, y el `y`-data es` temp_anomaly`. Para calcular nuestros coeficientes con la fórmula anterior, necesitamos los valores medios de nuestros datos. Sine necesitaremos calcular la media tanto para `x` como para` y`, podría ser útil escribir una función_de Python personalizada que calcule el promedio de cualquier matriz, y luego podemos reutilizarla.\n", + "En nuestro caso, el `x`-data corresponde a` year`, y el `y`-data es` temp_anomaly`. Para calcular nuestros coeficientes con la fórmula anterior, necesitamos los valores medios de nuestros datos. Sine necesitaremos calcular la media para ambos `x` y` y`, podría ser útil escribir una función_de Python personalizada que calcule la media de cualquier matriz, y luego podemos reutilizarla.\n", "\n", "Es una buena práctica de codificación * evitar la repetición * de nosotros mismos: queremos escribir código que sea reutilizable, no solo porque lleva a menos tipeo sino también porque reduce los errores. Si se encuentra realizando el mismo cálculo varias veces, es mejor encapsularlo en una * función *.\n", "\n", @@ -886,7 +886,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Si nos fijamos en la trama anterior, puede observar que alrededor de 1970 la temperatura comienza a aumentar más rápido que la tendencia anterior. Entonces, tal vez una sola línea recta no nos da un ajuste lo suficientemente bueno.\n", + "Si nos fijamos en la trama anterior, puede observar que alrededor de 1970 la temperatura comienza a aumentar más rápido que la tendencia anterior. Así que tal vez una sola línea recta no nos da un ajuste lo suficientemente bueno.\n", "\n", "¿Qué pasa si dividimos los datos en dos (antes y después de 1970) y realizamos una regresión lineal en cada segmento?\n", "\n", From 2782ad4cdc3aaedde501f667c89fc7d169ca17d6 Mon Sep 17 00:00:00 2001 From: Sebastian Flores Date: Sun, 22 Apr 2018 22:22:25 -0300 Subject: [PATCH 05/17] Updated translation for notebook #2. --- .../2_Strings_y_listas_en_Jupyter.ipynb | 497 +++++++++--------- 1 file changed, 238 insertions(+), 259 deletions(-) diff --git a/notebooks_es/2_Strings_y_listas_en_Jupyter.ipynb b/notebooks_es/2_Strings_y_listas_en_Jupyter.ipynb index 9abb5b9..83bc8fa 100644 --- a/notebooks_es/2_Strings_y_listas_en_Jupyter.ipynb +++ b/notebooks_es/2_Strings_y_listas_en_Jupyter.ipynb @@ -13,9 +13,9 @@ "source": [ "# Juega con datos en Jupyter\n", "\n", - "Esta es la segunda lección de nuestro curso en _\"Cálculos de ingeniería\". _ En la primera lección, [_Interactuando con Python_](http://nbviewer.jupyter.org/github/engineersCode/EngComp1_offtheground/blob/master/notebooks_en/1_Interacting_with_Python .ipynb), usamos ** IPython **, el shell interactivo de Python. Es realmente genial escribir expresiones de Python de una sola línea y obtener los resultados de forma interactiva. Sin embargo, lo creas o no, ¡hay cosas más grandes!\n", + "Esta es la segunda lección de nuestro curso en _\"Cálculos de ingeniería\"_. En la primera lección, [_Interactuando con Python_](http://nbviewer.jupyter.org/github/engineersCode/EngComp1_offtheground/blob/master/notebooks_es/1_Interactuando_con_Python.ipynb), usamos **IPython**, el shell interactivo de Python. Es genial escribir expresiones de Python de una sola línea y obtener los resultados de forma interactiva. Sin embargo, lo creas o no, ¡hay cosas aún más increíbles!\n", "\n", - "En esta lección, continuarás jugando con datos usando Python, pero lo harás en un ** cuaderno Jupyter **. Esta misma lección está escrita en un cuaderno de Jupyter. Listo? Lo amarás." + "En esta lección, continuarás usando Python para jugar con datos, pero lo harás en un **Jupyter Notebook**. Esta misma lección está escrita en un Jupyter Notebook. ¿Listo? No te arrependirás." ] }, { @@ -24,9 +24,9 @@ "source": [ "## ¿Qué es Jupyter?\n", "\n", - "Jupyter es un conjunto de herramientas de código abierto para la informática interactiva y exploratoria. Trabajas directamente en tu navegador, que se convierte en la interfaz de usuario a través de la cual Jupyter te proporciona un explorador de archivos (el _dashboard_) y un formato de documento: el ** cuaderno **.\n", + "Jupyter es un conjunto de herramientas de código abierto para la informática interactiva y exploratoria. Trabajarás directamente en tu navegador, que se convierte en la interfaz de usuario a través de la cual Jupyter te proporciona un explorador de archivos (el _dashboard_) y un formato de documento: el **notebook**.\n", "\n", - "Un cuaderno Jupyter puede contener: entrada y salida de código, texto formateado, imágenes, videos, bonitas ecuaciones matemáticas y mucho más. El código de la computadora es _executable_, lo que significa que puede ejecutar los bits de código, directamente en el documento, y obtener la salida de ese código que se muestra para usted. Esta forma interactiva de computación, mezclada con la narrativa multimedia, le permite contar una historia (¡incluso a usted mismo) con poderes adicionales!" + "Un Jupyter Notebook puede contener: entrada y salida de código, texto formateado, imágenes, videos, bonitas ecuaciones matemáticas y mucho más. El código de la computadora es _ejecutable_, lo que significa que puede ejecutar el código, directamente en el documento, y obtener la salida de ese código directamente en el navegador. Esta forma interactiva de computación, mezclada con la narrativa multimedia, permite contar una historia (incluso de manera individual y personal) con súperpoderes computacionales." ] }, { @@ -35,38 +35,38 @@ "source": [ "## Trabajar en Jupyter\n", "\n", - "Varias cosas le parecerán contraintuitivas al principio. Por ejemplo, la mayoría de las personas están acostumbradas a iniciar aplicaciones en sus computadoras haciendo clic en algún ícono: esto es lo primero que se debe \"desaprender\". Jupyter se lanza desde la línea de comando_ (como cuando lanzaste IPython). A continuación, tenemos dos tipos de contenido: código y reducción, que se manejan de forma un poco diferente. El hecho de que su navegador sea una interfaz para un motor de cómputo (llamado \"kernel\") lleva a un mantenimiento interno adicional (como cerrar el kernel). ¡Pero te acostumbrarás bastante rápido!" + "Varias cosas te parecerán contraintuitivas al principio. Por ejemplo, la mayoría de las personas están acostumbradas a iniciar aplicaciones en sus computadoras haciendo clic en algún ícono: esto es lo primero que se debe \"desaprender\". Jupyter se lanza desde la _línea de comando_ (como cuando lanzaste IPython). Además, tenemos dos tipos de contenido: código y texto (markdown), que se manejan de forma un poco diferente. El hecho de que el navegador sea una interfaz para un motor de cómputo (llamado \"kernel\") lleva a un mantenimiento interno adicional (como cerrar el kernel). ¡Pero te acostumbrarás bastante rápido!" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "### Start Jupyter\n", + "### Iniciando Jupyter\n", "\n", - "La forma estándar de iniciar Jupyter es escribir lo siguiente en la interfaz de línea de comandos:\n", + "La forma estándar de iniciar Jupyter es escribir en la interfaz de línea de comandos:\n", "\n", - "`cuaderno jupyter`\n", + "`jupyter notebook`\n", "\n", - "Presiona enter y tadah !!\n", - "Después de un poco de tiempo de configuración, su navegador predeterminado se abrirá con la aplicación Jupyter. Debería verse como en la captura de pantalla siguiente, pero es posible que vea una lista de archivos y carpetas, según la ubicación de su computadora donde la lanzó.\n", + "Presiona enter y ... ¡listo!\n", + "Después de un breve tiempo de configuración, tu navegador predeterminado se abrirá con la aplicación Jupyter. Debería ser similar a la siguiente captura de pantalla siguiente, pero es posible que se vea una lista distinta de archivos y carpetas, según la ubicación de su computadora donde la lanzó.\n", "\n", "##### Nota:\n", "\n", - "No cierre la ventana de la terminal donde lanzó Jupyter (mientras todavía está trabajando en Jupyter). Si necesita hacer otras tareas en la línea de comando, abra una nueva ventana de terminal.\n", + "No cierre la ventana de la terminal donde lanzó Jupyter (mientras todavía está trabajando en Jupyter). Si necesitas hacer otras tareas en la línea de comando, abre una nueva ventana de terminal.\n", "\n", - "\n", + "\n", "#### Captura de pantalla del tablero de Jupyter, abierto en el navegador.\n", "\n", + "Para iniciar un nuevo Jupyter Notebook, haz clic en la esquina superior derecha, donde dice **Nuevo** o **New**, y seleccione `Python 3`. Mira la captura de pantalla a continuación.\n", "\n", - "Para iniciar un nuevo cuaderno Jupyter, haga clic en la esquina superior derecha, donde dice ** Nuevo **, y seleccione `Python 3`. Mira la captura de pantalla a continuación.\n", + "\n", "\n", - "\n", "#### Captura de pantalla que muestra cómo crear un nuevo cuaderno.\n", + "Aparecerá una nueva pestaña en su navegador y verás un notebook vacío, con una sola línea de entrada, esperando que ingrese algún código. Observa la siguiente captura de pantalla.\n", "\n", - "Aparecerá una nueva pestaña en su navegador y verá un cuaderno vacío, con una sola línea de entrada, esperando que ingrese algún código. Ver la siguiente captura de pantalla.\n", + "\n", "\n", - "\n", "#### Captura de pantalla que muestra un nuevo cuaderno vacío.\n", "\n", "El notebook se abre de manera predeterminada con una sola celda de código vacía. Intenta escribir allí un código Python y ejecútalo presionando `[shift] + [enter]`." @@ -78,25 +78,25 @@ "source": [ "### Celdas de notebook\n", "\n", - "El cuaderno Jupyter usa _cells_: bloques que dividen fragmentos de texto y código. Cualquier contenido de texto se ingresa en una celda * Markdown *: contiene texto que puede formatear con marcadores simples para obtener encabezados, negrita, cursiva, viñetas, hipervínculos y más.\n", + "El cuaderno Jupyter usa _cells_ (_celdas_): bloques que dividen fragmentos de texto y código. Cualquier contenido de texto se ingresa en una celda *Markdown*: contiene texto que puede formatear con marcadores simples para obtener encabezados, negrita, cursiva, viñetas, hipervínculos y más.\n", "\n", "Markdown es fácil de aprender, consulte la sintaxis en la página web [\"Daring Fireball\"](https://daringfireball.net/projects/markdown/syntax) (por John Gruber). Algunos consejos:\n", "\n", - "* para crear un título, use un hash para comenzar la línea: `# Title`\n", - "* para crear el siguiente encabezado, use dos hash (y así sucesivamente): `## Heading`\n", - "* para poner en cursiva una palabra o frase, enciérrelo en asteriscos (o en las líneas inferiores): `* italic *` o `_italic_`\n", - "* para que sea negrita, enciérrelo con dos asteriscos: `** en negrita **`\n", - "* para hacer un hipervínculo, use corchetes cuadrados y redondos: `[texto hipervinculado](url)`\n", + "* para crear un título, use un hash para comenzar la línea: `# Título`\n", + "* para crear el siguiente encabezado, use dos hash (y así sucesivamente): `## Subtítulo`\n", + "* para poner en cursiva una palabra o frase, enciérrelo en asteriscos (o en las líneas inferiores): `*cursiva*` o `_cursiva_`\n", + "* para que sea negrita, enciérrelo con dos asteriscos: `**en negrita**`\n", + "* para hacer un hipervínculo, use corchetes cuadrados y redondos: `[texto para el enlace](url del enlace)`\n", "\n", "El contenido computable se ingresa en celdas de código. Usaremos el kernel de IPython (\"kernel\" es el nombre utilizado para el motor de computación), pero debe saber que Jupyter se puede usar con muchos lenguajes de computación diferentes. Es asombroso.\n", "\n", "Una celda de código le mostrará una marca de entrada, como esta:\n", "\n", - "`En []:`\n", + "`In []:`\n", "\n", - "Una vez que agregue un código y lo ejecute, Jupyter agregará una ID de número a la celda de entrada, y producirá una salida marcada así:\n", + "Una vez que agregues un código y lo ejecutes, Jupyter agregará un número de ID a la celda de entrada, y producirá una salida marcada así:\n", "\n", - "`Fuera [1]:`\n", + "`Out [1]:`\n", "\n", "##### Un poco de historia:\n", "\n", @@ -109,14 +109,14 @@ "source": [ "### Computación interactiva en el cuaderno\n", "\n", - "Mire los iconos en el menú de Jupyter (vea las capturas de pantalla arriba). El primer ícono a la izquierda (un disquete viejo) es para guardar su computadora portátil. Puede agregar una nueva celda con el gran botón ** + **. Luego tiene los botones cortar, copiar y pegar. Las flechas son para mover su celda actual hacia arriba o hacia abajo. Luego tiene un botón para \"ejecutar\" una celda de código (ejecutar el código), el icono cuadrado significa \"detener\" y la flecha swirly para \"reiniciar\" el núcleo de su computadora portátil (si el cálculo está atascado, por ejemplo). Junto a eso, tiene el selector de tipo de celda: Código o Marcado (u otros que puede ignorar por ahora).\n", + "Mira los iconos en el menú de Jupyter (como se muestran en las capturas de pantalla arriba). El primer ícono a la izquierda (un disquete de los antiguos) es para guardar tu computadora. Puedes agregar una nueva celda presionando el gran botón **+**. Además existen los los botones cortar, copiar y pegar. Las flechas son para mover su celda actual hacia arriba o hacia abajo. Existe un botón para \"ejecutar\" una celda de código (ejecutar el código), el icono cuadrado significa \"detener\" y la flecha circular para \"reiniciar\" el núcleo de su computadora portátil (si el cálculo está atascado, por ejemplo). Junto a eso, existe el selector de tipo de celda: código o texto markdown (u otros que puedes ignorar por ahora).\n", "\n", "Puede probar una celda de código escribiendo algunas operaciones aritméticas. Como vimos en nuestra primera lección, los operadores de Python son:\n", "```python\n", - "    + - */**% //\n", + "    + - * / ** % //\n", "```\n", "\n", - "Hay suma, resta, multiplicación y división. Los últimos tres operadores son _exponent_ (raise to the power of), _modulo_ (divide y devuelve el resto) y _floor division_.\n", + "Hay suma, resta, multiplicación y división. Los últimos tres operadores son _exponente_ (elevar a la potencia), _modulo_ (divide y devuelve el resto) y _división entera_.\n", "\n", "Tecleando `[shift] + [enter]` ejecutará la celda y le dará la salida en una nueva línea, etiquetada como `Out [1]` (la numeración aumenta cada vez que ejecuta una celda).\n", "\n", @@ -185,29 +185,26 @@ "source": [ "### Modo de edición y modo de comando\n", "\n", - "Una vez que haga clic en una celda de la notebook para seleccionarla, puede interactuar con ella de dos maneras, que se llaman _modes_. Más adelante, cuando revise este material nuevamente, lea más sobre esto en la Referencia 1.\n", + "Una vez que haces click en una celda de la notebook para seleccionarla, puede interactuar con ella de dos maneras, que se llaman _modos_. Más adelante, si revisas este material nuevamente y en mayor profundidad, puedes leer más sobre esto en la Referencia número 1.\n", "\n", "**Modo de edición:**\n", "\n", - "* Ingresamos ** al modo de edición ** presionando 'Enter' o haciendo doble clic en la celda.\n", + "* Ingresamos **al modo de edición** presionando 'Enter' o haciendo doble clic en la celda.\n", "\n", "* Sabemos que estamos en este modo cuando vemos un borde de celda verde y un mensaje en el área de la celda.\n", "\n", - "* Cuando estamos en modo de edición, podemos escribir en la celda, como un editor de texto normal.\n", + "* Cuando estamos en modo de edición, podemos escribir en la celda, como un editor de texto normal, tanto para código como para texto markdown.\n", "\n", "\n", - "** Modo de comando: **\n", + "**Modo de comando:**\n", "\n", - "* Ingresamos en ** modo de comando ** presionando `Esc` o haciendo clic fuera del área de la celda.\n", + "* Ingresamos en **modo de comando** presionando `Esc` o haciendo clic fuera del área de la celda.\n", "\n", "* Sabemos que estamos en este modo cuando vemos un borde de celda gris con un margen azul izquierdo.\n", "\n", - "* En este modo, ciertas teclas se asignan a accesos directos para ayudar con\n", - "  acciones comunes.\n", + "* En este modo, ciertas teclas se asignan a accesos directos para ayudar con acciones comunes.\n", "\n", - "\n", - "Puede encontrar una lista de los accesos directos seleccionando `Ayuda-> Métodos abreviados de teclado`\n", - "desde la barra de menú del notebook. Puede dejar esto para más adelante y volver a él, pero se vuelve más útil cuanto más use Jupyter." + "Puede encontrar una lista de los accesos directos seleccionando `Help->Keyboard Shortcuts` (`Ayuda-> Atajos de teclado`) desde la barra de menú del notebook. Puedes continuar con esto más adelante, pero se vuelve más útil cuanto más usas Jupyter. ¡Siempre es más eficiente conocer atajos de teclado!" ] }, { @@ -216,12 +213,11 @@ "source": [ "### Cómo cerrar el kernel y salir\n", "\n", - "Cerrar la pestaña del navegador donde ha estado trabajando en una computadora portátil no \"cierra\" inmediatamente el kernel de cómputo. Entonces a veces necesitas hacer un poco de limpieza.\n", + "Cerrar la pestaña del navegador donde has estado trabajando en un notebook no \"cierra\" inmediatamente el kernel. A veces necesitas hacer un poco de limpieza antes.\n", "\n", - "Una vez que cierre una computadora portátil, verá en la aplicación Jupyter principal que su\n", - "el archivo del cuaderno tiene un símbolo del libro verde al lado. Debería hacer clic en el cuadro a la izquierda de ese símbolo, y luego hacer clic donde dice ** Apagar **. No necesita hacer esto todo el tiempo, pero si tiene un lote de computadoras portátiles en ejecución, usarán recursos en su máquina.\n", + "Una vez que cierres un notebook, verá en la aplicación Jupyter principal que el archivo del notebook tiene un símbolo con un libro verde al lado. Deberías hacer click en el cuadro a la izquierda de ese símbolo, y luego hacer clic donde dice **Shutdown** o **Apagar**. No necesitas hacer esto todo el tiempo, pero si tienes varios notebooks abiertos, permite disminuir los recursos utilizados.\n", "\n", - "Del mismo modo, Jupyter aún se está ejecutando incluso después de cerrar la pestaña que tiene abierto el tablero de Jupyter. Para salir de la aplicación Jupyter, debe ir a la terminal que utilizó para abrir Jupyter, y escriba `[Ctrl] + [c]` para salir." + "Del mismo modo, Jupyter aún se está ejecutando incluso después de cerrar la pestaña del navegador que tiene abierto Jupyter. Para salir de la aplicación Jupyter, debe ir al terminal de comando que se utilizó para abrir Jupyter, y hacer `[Ctrl] + [c]` para salir." ] }, { @@ -230,16 +226,16 @@ "source": [ "### Nbviewer\n", "\n", - "[Nbviewer](http://nbviewer.jupyter.org/) es un servicio web gratuito que le permite compartir versiones estáticas de archivos portátiles alojados, como si se tratara de una página web. Si un archivo de computadora portátil está disponible públicamente en la web, puede verlo ingresando su URL en la página web de nbviewer y presionando el botón ** Ir! **. El cuaderno se representará como una página estática: los visitantes pueden leer todo, pero no pueden interactuar con el código." + "[Nbviewer](http://nbviewer.jupyter.org/) es un servicio web gratuito que le permite compartir versiones estáticas de notebooks, como si se tratara de una página web. Si un archivo de computadora portátil está disponible públicamente en la web, puede verlo ingresando su URL en la página web de nbviewer y presionando el botón **Go!**. El notebook se representará como una página estática: los visitantes pueden leer todo, pero no pueden interactuar con el código." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "## Juega con cadenas de Python\n", + "## Juega con strings en Python\n", "\n", - "Sigamos jugando con cadenas, pero ahora codificamos en un cuaderno Jupyter (en lugar de IPython). Le recomendamos que abra un nuevo cuaderno limpio para seguir los ejemplos de esta lección y escriba los comandos que ve. (Si copia y pega, ahorrará tiempo, pero aprenderá poco. ¡Tipee todo!)" + "Sigamos jugando con strings o cadenas de texto, pero ahora trabajaremos en un Jupyter Notebook (en lugar de IPython). Te recomendamos que abras un nuevo notebook limpio para seguir los ejemplos de esta lección y escribas los comandos que ve. Escribe tu mismo, letra a letra, todos los comandos que quieras probar. Si sólo copias y pegas, ahorrarás tiempo, pero aprenderás poco y retendrás aún menos. ¡Tipea todo!" ] }, { @@ -258,7 +254,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Recuerde que podemos concatenar cadenas (\"agregar\"), por ejemplo:" + "Recuerde que podemos concatenar cadenas (\"unir\"), por ejemplo:" ] }, { @@ -283,7 +279,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "¿Qué ocurre si queremos agregar un espacio que separa `hello` from` world`? Añadimos directamente la cadena `''` en el medio de las dos variables. Un espacio es un personaje!" + "¿Qué ocurre si queremos agregar un espacio que separa `hello` from` world`? Añadimos directamente la cadena `''` en el medio de las dos variables. Un espacio es un carácter de texto (character en inglés, char para los amigos)." ] }, { @@ -310,7 +306,7 @@ "source": [ "##### Ejercicio:\n", "\n", - "Cree una nueva variable de cadena que agregue tres signos de admiración al final de `my_string`." + "Crea una nueva variable de cadena que agregua tres signos de admiración al final de `my_string`." ] }, { @@ -321,7 +317,7 @@ "source": [ "### Indexación\n", "\n", - "Podemos acceder a cada carácter por separado en una cadena (o un segmento continuo de la misma) usando _indices_: enteros que denotan la posición del carácter en la cadena. Los índices van entre corchetes, tocando el nombre de la variable de cadena a la derecha. Por ejemplo, para acceder al primer elemento de `new_string`, debemos ingresar` new_string [0] `. ¡Sí! en Python comenzamos a contar desde 0." + "Podemos acceder a cada carácter de texto por separado en una cadena de texto (o incluso, un pedazo continuo de la misma) usando _índices_: enteros que denotan la posición del carácter en la cadena de texto. Los índices van entre corchetes, tocando el nombre de la variable de cadena a la derecha. Por ejemplo, para acceder al primer elemento de `new_string`, debemos ingresar` new_string[0] `. ¡Sí! en Python comenzamos a contar desde 0 (y hace mucho sentido)." ] }, { @@ -369,9 +365,9 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Es posible que haya notado que en la celda de arriba tenemos una línea antes del código que comienza con el signo `#`. Esa línea parece ser ignorada por Python: ¿sabes por qué?\n", + "Es posible que hayas notado que en la celda de arriba tenemos una línea antes del código que comienza con el signo `#`. Esa línea parece ser ignorada por Python: ¿sabes por qué?\n", "\n", - "Es un comentario: cuando quiera comentar su código de Python, coloca un `#` delante del comentario. Por ejemplo:" + "Es un **comentario**: cuando quieras comentar su código de Python, coloca un `#` delante del comentario. Por ejemplo:" ] }, { @@ -400,7 +396,7 @@ "source": [ "¿Cómo sabemos el índice del último elemento en la cadena?\n", "\n", - "Python tiene una función incorporada llamada `len ()` que proporciona la información sobre la longitud de un objeto. Vamos a intentarlo:" + "Python tiene una función incorporada llamada `len()` que proporciona la información sobre la longitud de un objeto. Vamos a intentarlo:" ] }, { @@ -455,7 +451,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Oops. Tenemos un error: ¿por qué? Sabemos que la longitud de `my_string` es once. Pero el número entero 11 no funciona como un índice. Si esperaba obtener el último elemento, es porque olvidó que Python comienza a contar a cero. No te preocupes: lleva un tiempo acostumbrarse.\n", + "Oops. Tenemos un error: ¿por qué? La longitud de `my_string` es once. Pero el número entero 11 no funciona como un índice. Si esperabas obtener el último elemento, es porque olvidaste que Python comienza a contar desde cero. No te preocupes: lleva un tiempo acostumbrarse.\n", "\n", "El mensaje de error dice que el índice está fuera de rango: esto es porque el índice del _último elemento_ siempre será: `len (cadena) - 1`. En nuestro caso, ese número es 10. Probémoslo." ] @@ -484,7 +480,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Python también ofrece una forma inteligente de captar el último elemento, por lo que no es necesario calcular la longitud y restar uno: está utilizando un 1 negativo para el índice. Me gusta esto:" + "Python también ofrece una forma inteligente y elegante de obtener el último elemento, por lo que no es necesario calcular la longitud y restar uno: se puede utilizar simplemente un `-1` para el índice. ¿Cómo no enamorarse de esta característica?:" ] }, { @@ -547,7 +543,7 @@ "source": [ "### Cortar cadenas\n", "\n", - "A veces, queremos captar más de un elemento: es posible que deseemos una sección de la cadena. Lo hacemos utilizando la notación _slicing_ entre corchetes. Por ejemplo, podemos usar `[start: end]`, donde `start` es el índice para comenzar el corte, y` end` es el índice (no incluido) para terminar el corte. Por ejemplo, para tomar la palabra `hello` de nuestra cadena, lo hacemos:" + "A veces, queremos captar más de un elemento: es posible que deseemos una sección de la cadena. Lo hacemos utilizando la notación de _slicing_ (corte) entre corchetes. Para esto se usa `[start: end]`, donde `start` es el índice para comenzar el corte, y` end` es el índice (no incluido) para terminar el corte. Por ejemplo, para tomar la palabra `hello` de nuestra cadena, lo hacemos:" ] }, { @@ -574,7 +570,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Puede omitir el índice `start`, si desea cortar desde el principio de la cadena, y puede omitir el` end` de una porción, lo que indica que desea llegar hasta el final de la cadena. Por ejemplo, si queremos tomar la palabra `'world'` de` my_string`, podríamos hacer lo siguiente:" + "Puede omitir el índice `start`, si desea cortar desde el principio de la cadena, y puede omitir el` end` de una porción, lo que indica que desea llegar hasta el final de la cadena. Por ejemplo, si queremos tomar la palabra `'world'` de ` my_string`, podríamos hacer lo siguiente:" ] }, { @@ -601,11 +597,11 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Una forma útil de visualizar segmentos es imaginar que los índices apuntan a los espacios _entre_caracteres en la cadena. De esta forma, cuando escriba `my_string [i]`, se estaría refiriendo al \"carácter a la derecha de` i` \"(Referencia 2).\n", + "Una forma útil de visualizar segmentos es imaginar que los índices apuntan a los espacios _entre_ caracteres en la cadena. De esta forma, cuando escriba `my_string[i]`, se estaría refiriendo al \"carácter a la derecha de` i` \"(Referencia 2).\n", "\n", - "Mira el diagrama a continuación. Comenzamos a contar a cero; la letra '' g'` está a la derecha del índice 2. Entonces, si queremos agarrar la subcadena `'gin'` de` 'engineer'`, necesitamos `[start: end] = [2: 5 ] `.\n", + "Mira el diagrama a continuación. Comenzamos a contar a cero; la letra `g` está a la derecha del índice 2. Entonces, si queremos obtener la subcadena `'gin'` de `'engineer'`, necesitamos `[start: end] = [2:5]`.\n", "\n", - "" + "" ] }, { @@ -619,7 +615,7 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 5, "metadata": {}, "outputs": [ { @@ -628,7 +624,7 @@ "'gin'" ] }, - "execution_count": 16, + "execution_count": 5, "metadata": {}, "output_type": "execute_result" } @@ -638,7 +634,7 @@ "eng_string = 'engineer'\n", "\n", "# Grab 'gin'slice\n", - "eng_string[2:5]" + "eng_string[2:5] # O equivalentemente, eng_string[2:-3]" ] }, { @@ -647,9 +643,9 @@ "source": [ "##### Ejercicios:\n", "\n", - "1. Defina una cadena llamada `'banana'` e imprima la primera y última' 'a'`.\n", - "2. Usando la misma cuerda, agarre las 2 rebanadas posibles que corresponden a la palabra \"ana\" e imprímalas.\n", - "3. Cree su propio ejercicio de rebanar y pídales a sus compañeros que lo prueben (trabaje en grupos de 3)." + "1. Defina una cadena de texto llamada `'banana'` e imprima la primera y última `'a'`.\n", + "2. Usando el mismo string, agarre las 2 combinaciones posibles que corresponden a la palabra \"ana\" e imprímalas.\n", + "3. Cree su propio ejercicio de slicing y pídales a sus compañeros que lo intenten (trabaje en grupos de 3)." ] }, { @@ -660,14 +656,17 @@ " \n", "Ejercicio de solución 1:\n", "\n", - " b = 'banana' \n", + " b = 'banana' print (b [1]) \n", + "\n", " print (b [-1]) \n", "\n", "\n", "Ejercicio de solución 2:\n", "\n", " print (b [1: 4]) \n", + "\n", " print (b [3:]) " ] }, @@ -677,21 +676,20 @@ "source": [ "### ¿Qué más podemos hacer con las cadenas?\n", "\n", - "Python tiene muchas funciones integradas útiles para cadenas. Aprenderá algunos de ellos en esta sección. Un detalle técnico: en Python, algunas funciones están asociadas a una clase particular de objetos (por ejemplo, cadenas de caracteres). La palabra ** method ** se usa en este caso, y tenemos una nueva forma de llamarlos: el operador de punto. Es un poco contra-intuitivo que el nombre del método viene después del punto, mientras que el nombre del objeto en particular en el que actúa es lo primero. Me gusta esto: `mystring.method ()`.\n", + "Python tiene muchas funciones integradas útiles para cadenas. Aprenderás algunos de ellos en esta sección. Un detalle técnico: en Python, algunas funciones están asociadas a una clase particular de objetos (por ejemplo, cadenas de caracteres). La palabra **metodo** (method) se usa en este caso, y tenemos una nueva forma de llamarlos: el operador de punto. Es un poco contra-intuitivo que el nombre del método viene después del punto, mientras que el nombre del objeto en particular en el que actúa es lo primero. Así: `mystring.method ()`.\n", "\n", "Si tiene curiosidad acerca de los muchos métodos disponibles para cadenas, vaya a la sección \"Métodos de cadena incorporados\" en este [tutorial](https://www.tutorialspoint.com/python3/python_strings.htm).\n", "\n", - "Usemos una cita de Albert Einstein como una cadena y apliquemos algunos métodos de cadena útiles." + "Usemos una cita de Albert Einstein como un string y apliquemos algunos métodos de cadena útiles." ] }, { "cell_type": "code", - "execution_count": 17, - "metadata": { - "collapsed": true - }, + "execution_count": 9, + "metadata": {}, "outputs": [], "source": [ + "# Todos son genios. Pero si juzgas a un pez por su habilidad de trepar un arbol, creera toda su vida que es un idiota.\n", "AE_quote = \"Everybody is a genius. But if you judge a fish by its ability to climb a tree, it will live its whole life believing that it is stupid.\"" ] }, @@ -699,18 +697,18 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "El método ** `count ()` ** da el número de ocurrencias de una subcadena en un rango. Los argumentos para el rango son opcionales.\n", + "El método **`count()`** retorna el número de ocurrencias de una subcadena en un rango. Los argumentos para el rango son opcionales.\n", "\n", "*Sintaxis:*\n", "\n", "`str.count (subcadena, inicio, fin)`\n", "\n", - "Aquí, `start` y` end` son enteros que indican los índices donde comenzar y finalizar el conteo. Por ejemplo, si queremos saber cuántas letras '' e '' tenemos en toda la cadena, podemos hacer:" + "Aquí, `start` y` end` son enteros que indican los índices donde comenzar y finalizar el conteo. Por ejemplo, si queremos saber cuántas letras ''e'' tenemos en toda la cadena, podemos hacer:" ] }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 10, "metadata": {}, "outputs": [ { @@ -719,7 +717,7 @@ "10" ] }, - "execution_count": 18, + "execution_count": 10, "metadata": {}, "output_type": "execute_result" } @@ -732,12 +730,12 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Si queremos saber cuántos de esos `` e'` caracteres están en el rango `[0:20]`, hacemos:" + "Si queremos saber cuántos de esos `'e'` caracteres están en el rango `[0:20]`, hacemos:" ] }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 11, "metadata": {}, "outputs": [ { @@ -746,7 +744,7 @@ "2" ] }, - "execution_count": 19, + "execution_count": 11, "metadata": {}, "output_type": "execute_result" } @@ -764,7 +762,7 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 12, "metadata": {}, "outputs": [ { @@ -773,7 +771,7 @@ "1" ] }, - "execution_count": 20, + "execution_count": 12, "metadata": {}, "output_type": "execute_result" } @@ -786,22 +784,22 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "El método ** find () ** nos dice si una cadena `'substr'` ocurre en la cadena en la que estamos aplicando el método. Los argumentos para el rango son opcionales.\n", + "El método **find()** nos dice si una cadena `'substr'` ocurre en la cadena en la que estamos aplicando el método. Los argumentos para el rango son opcionales.\n", "\n", "*Sintaxis:*\n", "\n", "`str.find (substr, start, end)`\n", "\n", - "Donde `start` y` end` son índices que indican dónde comenzar y terminar el corte para aplicar el método `find ()`.\n", + "Donde `start` y` end` son índices que indican dónde comenzar y terminar el slicing para aplicar el método `find ()`.\n", "\n", - "Si la cadena `'substr'` está en la cadena original, el método` find () `devolverá el índice donde comienza la subcadena, de lo contrario devolverá` -1`.\n", + "Si la cadena `'substr'` está en la cadena original, el método`find()`devolverá el índice donde comienza la subcadena, de lo contrario devolverá `-1`.\n", "\n", - "Por ejemplo, busquemos la palabra \"pez\" en la cita de Albert Einstein." + "Por ejemplo, busquemos la palabra \"fish\" en la cita de Albert Einstein." ] }, { "cell_type": "code", - "execution_count": 21, + "execution_count": 13, "metadata": {}, "outputs": [ { @@ -810,7 +808,7 @@ "42" ] }, - "execution_count": 21, + "execution_count": 13, "metadata": {}, "output_type": "execute_result" } @@ -823,12 +821,12 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Si conocemos la longitud de nuestra subcadena, ahora podemos aplicar la notación de corte para tomar la palabra \"pez\"." + "Si conocemos la longitud de nuestra subcadena, ahora podemos aplicar la notación de corte para hallar la palabra \"pez\"." ] }, { "cell_type": "code", - "execution_count": 22, + "execution_count": 14, "metadata": {}, "outputs": [ { @@ -837,7 +835,7 @@ "4" ] }, - "execution_count": 22, + "execution_count": 14, "metadata": {}, "output_type": "execute_result" } @@ -848,7 +846,7 @@ }, { "cell_type": "code", - "execution_count": 23, + "execution_count": 15, "metadata": {}, "outputs": [ { @@ -857,7 +855,7 @@ "'fish'" ] }, - "execution_count": 23, + "execution_count": 15, "metadata": {}, "output_type": "execute_result" } @@ -875,7 +873,7 @@ }, { "cell_type": "code", - "execution_count": 24, + "execution_count": 16, "metadata": {}, "outputs": [ { @@ -884,7 +882,7 @@ "-1" ] }, - "execution_count": 24, + "execution_count": 16, "metadata": {}, "output_type": "execute_result" } @@ -897,9 +895,9 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Devuelve `-1` ... pero cuidado, ¡eso no significa que la posición esté al final de la cadena original! Si leemos la [documentación](https://docs.python.org/3/library/stdtypes.html#string-methods), confirmamos que un valor devuelto de `-1` indica que la subcadena que estamos buscar es _no en la cadena_ en la que estamos buscando\n", + "Devuelve `-1` ... pero cuidado, ¡eso no significa que la posición esté al final de la cadena original! Si leemos la [documentación](https://docs.python.org/3/library/stdtypes.html#string-methods), confirmamos que un valor devuelto de `-1` indica que la subcadena que estamos buscar _no está en la cadena_ en la que estamos buscando\n", "\n", - "Un método similar es ** `index ()` **: funciona como el método `find ()`, pero genera un error si no se encuentra la cadena que estamos buscando.\n", + "Un método similar es **`index()`**: funciona como el método `find()`, pero genera un error si no se encuentra la cadena que estamos buscando.\n", "\n", "*Sintaxis:*\n", "\n", @@ -951,18 +949,16 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "En el ejemplo anterior, usamos la función `len ()` para calcular la longitud de la cadena `'fish'`, y usamos el resultado para calcular el índice final. Sin embargo, si la cadena es demasiado larga, tener una línea que calcule la longitud puede ser inconveniente o puede hacer que su código parezca desordenado. Para evitar esto, podemos usar los métodos `find ()` o `index ()` para calcular la posición final. En el ejemplo de \"pez\", podríamos buscar el índice de la palabra \"by\" (la palabra que sigue a \"pez\") y restar 1 de ese índice para obtener el índice que corresponde al espacio correcto. después de `'fish'`. ¡Hay muchas formas de cortar cuerdas, solo limitadas por tu imaginación!\n", + "En el ejemplo anterior, usamos la función `len()` para calcular la longitud de la cadena `'fish'`, y usamos el resultado para calcular el índice final. Sin embargo, si la cadena es demasiado larga, tener una línea que calcule la longitud puede ser inconveniente o puede hacer que su código parezca desordenado. Para evitar esto, podemos usar los métodos `find()` o `index()` para calcular la posición final. En el ejemplo de \"pez\", podríamos buscar el índice de la palabra \"by\" (la palabra que sigue a \"pez\") y restar 1 de ese índice para obtener el índice que corresponde al espacio correcto después de `'fish'`. ¡Hay muchas formas de hacer slicing de cadenas de texto, sólo limitadas por tu imaginación!\n", "\n", "##### Nota:\n", - "Recuerde que el índice final no es inclusivo, por lo que queremos el índice del espacio que sigue a la cadena `'peces'`." + "Recuerde que el índice final no es inclusivo, por lo que queremos el índice del espacio que sigue a la cadena `'fish'`." ] }, { "cell_type": "code", - "execution_count": 27, - "metadata": { - "collapsed": true - }, + "execution_count": 17, + "metadata": {}, "outputs": [], "source": [ "idx_start = AE_quote.index('fish')\n", @@ -971,7 +967,7 @@ }, { "cell_type": "code", - "execution_count": 28, + "execution_count": 18, "metadata": {}, "outputs": [ { @@ -980,7 +976,7 @@ "'fish'" ] }, - "execution_count": 28, + "execution_count": 18, "metadata": {}, "output_type": "execute_result" } @@ -995,29 +991,28 @@ "source": [ "##### Ejercicios:\n", "\n", - "1. Usa el método `count ()` para contar cuántas letras '' a'` están en 'AE_quote`?\n", - "2. Usando el mismo método, ¿cuántas letras aisladas `'a'` están en` AE_quote`?\n", - "3. Usa el método `index ()` para encontrar la posición de las palabras `'genius'`,`' judge'` y `'tree'` en` AE_quote`.\n", - "4. Con la sintaxis de corte, extraiga las palabras del ejercicio 3 de `AE_quote`." + "1. Usa el método `count()` para contar cuántas letras '`a'` están en `AE_quote`?\n", + "2. Usando el mismo método, ¿cuántas letras aisladas `'a'` están en `AE_quote`?\n", + "3. Usa el método `index ()` para encontrar la posición de las palabras `'genius'`,`' judge'` y `'tree'` en `AE_quote`.\n", + "4. Con la sintaxis de corte, extrae las palabras del ejercicio 3 de `AE_quote`." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "Otros dos métodos de cadena resultan útiles cuando trabaja con textos y necesita limpiar, separar o categorizar partes del texto.\n", + "Existen otros dos métodos de cadena resultan útiles cuando se trabaja con textos y se necesita limpiar, separar o categorizar partes del texto.\n", "\n", - "Vamos a trabajar con una cadena diferente, una cita de Eleanor Roosevelt:" + "Para demostrarlos, vamos a trabajar con una cadena diferente, una cita de Eleanor Roosevelt:" ] }, { "cell_type": "code", - "execution_count": 29, - "metadata": { - "collapsed": true - }, + "execution_count": 30, + "metadata": {}, "outputs": [], "source": [ + "# Grandes mentes discuten sobre ideas; mentes promedio discuten sobre eventos; mentes pequeñas discuten sobre personas.\n", "ER_quote = \" Great minds discuss ideas; average minds discuss events; small minds discuss people. \"" ] }, @@ -1025,25 +1020,23 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Tenga en cuenta que la cadena que definimos anteriormente contiene espacios en blanco adicionales al principio y al final. En este caso, lo hicimos a propósito, pero a menudo hay espacios extra molestos cuando leemos texto de un archivo (quizás debido a la sangría de un párrafo).\n", + "Ten en cuenta que la cadena de texto que definimos anteriormente contiene espacios en blanco adicionales al principio y al final. En este caso, fue realizado a propósito, pero a menudo hay espacios extra molestos cuando leemos texto de un archivo (quizás debido a la sangría de un párrafo).\n", "\n", "Las cadenas tienen un método que nos permite deshacernos de esos espacios en blanco adicionales.\n", "\n", - "El método ** `strip ()` ** devuelve una copia de la cadena en la que se eliminan todos los caracteres dados como argumento desde el principio y el final de la cadena.\n", + "El método **`strip()`** devuelve una copia de la cadena de texto en la que se eliminan todos los caracteres dados como argumento desde el principio y el final de la cadena.\n", "\n", "*Sintaxis:*\n", "\n", "`str.strip ([chars])`\n", "\n", - "El argumento predeterminado es el carácter de espacio. Por ejemplo, si queremos eliminar los espacios en blanco en `ER_quote` y guardar el resultado en` ER_quote`, podemos hacer:" + "El argumento predeterminado es el carácter de espacio. Por ejemplo, si queremos eliminar los espacios en blanco en `ER_quote` y guardar el resultado en `ER_quote`, podemos hacer:" ] }, { "cell_type": "code", - "execution_count": 30, - "metadata": { - "collapsed": true - }, + "execution_count": 20, + "metadata": {}, "outputs": [], "source": [ "ER_quote = ER_quote.strip()" @@ -1051,7 +1044,7 @@ }, { "cell_type": "code", - "execution_count": 31, + "execution_count": 21, "metadata": {}, "outputs": [ { @@ -1060,7 +1053,7 @@ "'Great minds discuss ideas; average minds discuss events; small minds discuss people.'" ] }, - "execution_count": 31, + "execution_count": 21, "metadata": {}, "output_type": "execute_result" } @@ -1082,7 +1075,7 @@ }, { "cell_type": "code", - "execution_count": 32, + "execution_count": 22, "metadata": {}, "outputs": [ { @@ -1091,7 +1084,7 @@ "'Great minds discuss ideas; average minds discuss events; small minds discuss people'" ] }, - "execution_count": 32, + "execution_count": 22, "metadata": {}, "output_type": "execute_result" } @@ -1109,7 +1102,7 @@ }, { "cell_type": "code", - "execution_count": 33, + "execution_count": 23, "metadata": {}, "outputs": [ { @@ -1118,7 +1111,7 @@ "'Great minds discuss ideas; average minds discuss events; small minds discuss people.'" ] }, - "execution_count": 33, + "execution_count": 23, "metadata": {}, "output_type": "execute_result" } @@ -1131,13 +1124,13 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Otro método útil es ** `startswith ()` **, para averiguar si una cadena comienza con un cierto carácter.\n", + "Otro método útil es **`startswith()`**, para averiguar si una cadena comienza con un cierto carácter.\n", "Más adelante en esta lección veremos un ejemplo más interesante; pero por ahora, solo \"verifiquemos\" si nuestra cadena comienza con la palabra \"genial\"." ] }, { "cell_type": "code", - "execution_count": 34, + "execution_count": 24, "metadata": {}, "outputs": [ { @@ -1146,7 +1139,7 @@ "False" ] }, - "execution_count": 34, + "execution_count": 24, "metadata": {}, "output_type": "execute_result" } @@ -1164,7 +1157,7 @@ }, { "cell_type": "code", - "execution_count": 35, + "execution_count": 25, "metadata": {}, "outputs": [ { @@ -1173,7 +1166,7 @@ "True" ] }, - "execution_count": 35, + "execution_count": 25, "metadata": {}, "output_type": "execute_result" } @@ -1191,7 +1184,7 @@ }, { "cell_type": "code", - "execution_count": 36, + "execution_count": 26, "metadata": {}, "outputs": [ { @@ -1200,7 +1193,7 @@ "True" ] }, - "execution_count": 36, + "execution_count": 26, "metadata": {}, "output_type": "execute_result" } @@ -1213,7 +1206,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "El último método de cadena que mencionaremos es ** `split ()` **: devuelve una ** lista ** de todas las palabras en una cadena. También podemos definir un separador y dividir nuestra cadena de acuerdo con ese separador, y opcionalmente podemos limitar el número de divisiones a `num`.\n", + "El último método de cadena que mencionaremos es **`split()`**: devuelve una **lista** de todas las palabras en una cadena. También podemos definir un separador y dividir nuestra cadena de acuerdo con ese separador, y opcionalmente podemos limitar el número de divisiones a `num`.\n", "\n", "*Sintaxis:*\n", "\n", @@ -1222,7 +1215,7 @@ }, { "cell_type": "code", - "execution_count": 37, + "execution_count": 27, "metadata": {}, "outputs": [ { @@ -1239,7 +1232,7 @@ }, { "cell_type": "code", - "execution_count": 38, + "execution_count": 28, "metadata": {}, "outputs": [ { @@ -1258,12 +1251,12 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Vamos a dividir el `ER_quote` por un personaje diferente, un punto y coma:" + "Vamos a dividir el `ER_quote` utilizando un carácter distinto, un punto y coma (`;`):" ] }, { "cell_type": "code", - "execution_count": 39, + "execution_count": 29, "metadata": {}, "outputs": [ { @@ -1282,10 +1275,10 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "##### Pensar...\n", + "##### Reflexionando...\n", "\n", "¿Notan algo nuevo en la salida de las llamadas `print()`?\n", - "¿Cuáles son esos `[]`?" + "¿Que significan esos paréntesis cuadrados, `[]`?" ] }, { @@ -1294,14 +1287,14 @@ "source": [ "## Juega con listas de Python\n", "\n", - "Los corchetes de arriba indican una ** lista ** de Python. Una lista es un tipo de datos integrado que consiste en una secuencia de valores, por ejemplo, números o cadenas. Las listas funcionan de muchas maneras de manera similar a las cadenas: sus elementos están numerados a partir de cero, la función `len ()` da el número de elementos, se pueden manipular con notación de división, y así sucesivamente.\n", + "Los corchetes o paréntesis cuadrados indican una **lista** de Python. Una lista es un tipo de datos que ya viene en Python que consiste en una secuencia de valores, por ejemplo, números o strings. Las listas funcionan de manera similar a las cadenas de texto: sus elementos están numerados a partir de cero, la función `len()` regresa el número de elementos, se pueden manipular con notación de slicing, y así sucesivamente.\n", "\n", "La forma más fácil de crear una lista es incluir una secuencia de valores separados por comas entre corchetes:" ] }, { "cell_type": "code", - "execution_count": 40, + "execution_count": 31, "metadata": {}, "outputs": [ { @@ -1310,7 +1303,7 @@ "[1, 4, 7, 9]" ] }, - "execution_count": 40, + "execution_count": 31, "metadata": {}, "output_type": "execute_result" } @@ -1322,7 +1315,7 @@ }, { "cell_type": "code", - "execution_count": 41, + "execution_count": 32, "metadata": {}, "outputs": [ { @@ -1331,7 +1324,7 @@ "['apple', 'banana', 'orange']" ] }, - "execution_count": 41, + "execution_count": 32, "metadata": {}, "output_type": "execute_result" } @@ -1343,7 +1336,7 @@ }, { "cell_type": "code", - "execution_count": 42, + "execution_count": 33, "metadata": {}, "outputs": [ { @@ -1352,7 +1345,7 @@ "[2, 'apple', 4.5, [5, 10]]" ] }, - "execution_count": 42, + "execution_count": 33, "metadata": {}, "output_type": "execute_result" } @@ -1366,17 +1359,15 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "En el último ejemplo de lista, el último elemento de la lista es en realidad _otra lista_. ¡Sí! podemos hacer eso por completo\n", + "En este último ejemplo, el último elemento de la lista es en realidad _otra lista_. ¡Sí! No hay problema. Una lista puede contener elementos de cualquier tipo.\n", "\n", "También podemos asignar listas a nombres de variables, por ejemplo:" ] }, { "cell_type": "code", - "execution_count": 43, - "metadata": { - "collapsed": true - }, + "execution_count": 34, + "metadata": {}, "outputs": [], "source": [ "integers = [1, 2, 3, 4, 5]\n", @@ -1385,7 +1376,7 @@ }, { "cell_type": "code", - "execution_count": 44, + "execution_count": 35, "metadata": {}, "outputs": [ { @@ -1402,7 +1393,7 @@ }, { "cell_type": "code", - "execution_count": 45, + "execution_count": 36, "metadata": {}, "outputs": [ { @@ -1419,10 +1410,8 @@ }, { "cell_type": "code", - "execution_count": 46, - "metadata": { - "collapsed": true - }, + "execution_count": 37, + "metadata": {}, "outputs": [], "source": [ "new_list = [integers, fruits]" @@ -1430,7 +1419,7 @@ }, { "cell_type": "code", - "execution_count": 47, + "execution_count": 38, "metadata": {}, "outputs": [ { @@ -1449,7 +1438,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Tenga en cuenta que esta `new_list` tiene solo 2 elementos. Podemos verificarlo con la función `len ()`:" + "Ten en cuenta que esta `new_list` tiene sólo 2 elementos. Podemos verificarlo con la función `len()`:" ] }, { @@ -1477,12 +1466,12 @@ "metadata": {}, "source": [ "Cada elemento de `new_list` es, por supuesto, otra lista.\n", - "Al igual que con las cadenas, accedemos a los elementos de la lista con índices y notación de división. El primer elemento de `new_list` es la lista de enteros del 1 al 5, mientras que el segundo elemento es la lista de tres nombres de frutas." + "Al igual que con las cadenas, accedemos a los elementos de la lista con índices y notación de slicing. El primer elemento de `new_list` es la lista de enteros del 1 al 5, mientras que el segundo elemento es la lista de tres nombres de frutas." ] }, { "cell_type": "code", - "execution_count": 49, + "execution_count": 39, "metadata": {}, "outputs": [ { @@ -1491,7 +1480,7 @@ "[1, 2, 3, 4, 5]" ] }, - "execution_count": 49, + "execution_count": 39, "metadata": {}, "output_type": "execute_result" } @@ -1502,7 +1491,7 @@ }, { "cell_type": "code", - "execution_count": 50, + "execution_count": 40, "metadata": {}, "outputs": [ { @@ -1511,7 +1500,7 @@ "['apple', 'banana', 'orange']" ] }, - "execution_count": 50, + "execution_count": 40, "metadata": {}, "output_type": "execute_result" } @@ -1522,7 +1511,7 @@ }, { "cell_type": "code", - "execution_count": 51, + "execution_count": 41, "metadata": {}, "outputs": [ { @@ -1531,7 +1520,7 @@ "['apple', 'banana']" ] }, - "execution_count": 51, + "execution_count": 41, "metadata": {}, "output_type": "execute_result" } @@ -1547,8 +1536,8 @@ "source": [ "##### Ejercicios:\n", "\n", - "1. De la lista `enteros`, tome la porción` [2, 3, 4] `y luego` [4, 5] `.\n", - "2. Crea tu propia lista y diseña un ejercicio para agarrar rebanadas, trabajando con tus compañeros de clase." + "1. De la lista `enteros`, toma la sección `[2, 3, 4]` y luego `[4, 5]`.\n", + "2. Crea tu propia lista y diseña un ejercicio para agarrar slices, trabajando con tus compañeros de clase." ] }, { @@ -1557,15 +1546,13 @@ "source": [ "### Agregar elementos a una lista\n", "\n", - "Podemos agregar elementos a una lista usando el método ** append () **: agrega el objeto que pasamos a la lista existente. Por ejemplo, para agregar el elemento 6 a nuestra lista `enteros`, podemos hacer:" + "Podemos agregar elementos a una lista usando el método **append()**: agrega un objeto que pasamos a una lista existente. Por ejemplo, para agregar el elemento 6 a nuestra lista `integers`, podemos hacer:" ] }, { "cell_type": "code", - "execution_count": 52, - "metadata": { - "collapsed": true - }, + "execution_count": 42, + "metadata": {}, "outputs": [], "source": [ "integers.append(6)" @@ -1580,7 +1567,7 @@ }, { "cell_type": "code", - "execution_count": 53, + "execution_count": 43, "metadata": {}, "outputs": [ { @@ -1601,17 +1588,17 @@ "source": [ "### Lista de miembros\n", "\n", - "¡Comprobar la membresía de la lista en Python parece bastante similar al inglés sencillo!\n", + "¡Comprobar la pertenencia a una lista en Python es bastante similar al idioma inglés!\n", "\n", "*Sintaxis*\n", "\n", - "Para verificar si un elemento está ** en ** una lista:\n", + "Para verificar si un elemento está **en** una lista usamos `in`:\n", "\n", - "`elemento en la lista`\n", + "`elemento in lista`\n", "\n", - "Para verificar si un elemento ** no está en ** una lista:\n", + "Para verificar si un elemento **no está en** una lista usamos `not in`:\n", "\n", - "`elemento no en la lista`" + "`elemento not in lista`" ] }, { @@ -1660,15 +1647,15 @@ "source": [ "##### Ejercicios\n", "\n", - "1. Agregue dos frutas diferentes a la lista `fruits`.\n", + "1. Agrega dos frutas diferentes a la lista `fruits`.\n", "2. Comprueba si `'mango'` está en tu nueva lista` fruits`.\n", - "3. Dada la lista `alist = [1, 2, 3, '4', [5, 'six'], [7]]` ejecuta lo siguiente en celdas separadas y analiza el resultado con tus compañeros de clase:\n", + "3. Dada la lista `lista = [1, 2, 3, '4', [5, 'six'], [7]]` ejecuta lo siguiente en celdas separadas y analiza el resultado con tus compañeros de clase:\n", "\n", "```Python\n", - "   4 en alista\n", - "   5 en alista\n", - "   7 en alista\n", - "   [7] en alista\n", + "   4 in lista\n", + "   5 in lista\n", + "   7 in lista\n", + "   [7] in lista\n", "```" ] }, @@ -1678,31 +1665,29 @@ "source": [ "### Modificar elementos de una lista\n", "\n", - "No solo podemos agregar elementos a una lista, también podemos modificar un elemento específico.\n", + "No sólo podemos agregar elementos a una lista, también podemos modificar un elemento específico.\n", "Reutilicemos la lista del ejercicio anterior y reemplacemos algunos elementos." ] }, { "cell_type": "code", - "execution_count": 56, - "metadata": { - "collapsed": true - }, + "execution_count": 44, + "metadata": {}, "outputs": [], "source": [ - "alist = [1, 2, 3, '4', [5, 'six'], [7]]" + "lista = [1, 2, 3, '4', [5, 'six'], [7]]" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "Podemos encontrar la posición de un cierto elemento con el método `index ()`, al igual que con las cadenas. Por ejemplo, si queremos saber dónde está el elemento `'4'`, podemos hacer:" + "Podemos encontrar la posición de un cierto elemento con el método `index()`, al igual que con las cadenas. Por ejemplo, si queremos saber dónde está el elemento `'4'`, podemos hacer:" ] }, { "cell_type": "code", - "execution_count": 57, + "execution_count": 45, "metadata": {}, "outputs": [ { @@ -1711,18 +1696,18 @@ "3" ] }, - "execution_count": 57, + "execution_count": 45, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "alist.index('4')" + "lista.index('4')" ] }, { "cell_type": "code", - "execution_count": 58, + "execution_count": 46, "metadata": {}, "outputs": [ { @@ -1731,13 +1716,13 @@ "'4'" ] }, - "execution_count": 58, + "execution_count": 46, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "alist[3]" + "lista[3]" ] }, { @@ -1749,18 +1734,16 @@ }, { "cell_type": "code", - "execution_count": 59, - "metadata": { - "collapsed": true - }, + "execution_count": 47, + "metadata": {}, "outputs": [], "source": [ - "alist[3] = 4" + "lista[3] = 4" ] }, { "cell_type": "code", - "execution_count": 60, + "execution_count": 49, "metadata": {}, "outputs": [ { @@ -1769,18 +1752,18 @@ "[1, 2, 3, 4, [5, 'six'], [7]]" ] }, - "execution_count": 60, + "execution_count": 49, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "alist" + "lista" ] }, { "cell_type": "code", - "execution_count": 61, + "execution_count": 52, "metadata": {}, "outputs": [ { @@ -1789,13 +1772,13 @@ "True" ] }, - "execution_count": 61, + "execution_count": 52, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "4 in alist" + "4 in lista" ] }, { @@ -1803,7 +1786,7 @@ "metadata": {}, "source": [ "##### Ejercicio\n", - "Reemplace el último elemento de `a list` con algo diferente." + "Reemplaza el último elemento de `lista` con algo diferente." ] }, { @@ -1812,15 +1795,13 @@ "source": [ "Poder modificar elementos en una lista es una \"propiedad\" de las listas de Python; otros objetos Python que veremos más adelante en el curso también se comportan así, pero no todos los objetos Python. Por ejemplo, no puede modificar elementos en una cadena. Si lo intentamos, Python se quejará.\n", "\n", - "¡Multa! Vamos a intentarlo:" + "¡No importa! Vamos a intentarlo. Uno de los principios de computación es comprobar e intentar cosas, aunque no funcionen:" ] }, { "cell_type": "code", - "execution_count": 62, - "metadata": { - "collapsed": true - }, + "execution_count": 53, + "metadata": {}, "outputs": [], "source": [ "string = 'This is a string.'" @@ -1830,12 +1811,12 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Supongamos que queremos reemplazar el período ('.') Por un signo de exclamación ('!'). ¿Podemos simplemente modificar este elemento de cadena?" + "Supongamos que queremos reemplazar el período ('.') Por un signo de exclamación ('!'). ¿Podemos modificar directamente este elemento de cadena?" ] }, { "cell_type": "code", - "execution_count": 63, + "execution_count": 54, "metadata": {}, "outputs": [ { @@ -1844,7 +1825,7 @@ "'.'" ] }, - "execution_count": 63, + "execution_count": 54, "metadata": {}, "output_type": "execute_result" } @@ -1855,7 +1836,7 @@ }, { "cell_type": "code", - "execution_count": 64, + "execution_count": 55, "metadata": {}, "outputs": [ { @@ -1865,7 +1846,7 @@ "traceback": [ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", "\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)", - "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mstring\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m'!'\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mstring\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m'!'\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", "\u001b[0;31mTypeError\u001b[0m: 'str' object does not support item assignment" ] } @@ -1887,36 +1868,36 @@ "source": [ "## Siguiente: cadenas y listas en acción\n", "\n", - "Ha aprendido muchas cosas sobre cadenas y listas en esta lección, y probablemente esté ansioso por ver cómo aplicarlo a una situación realista. Creamos un [ejemplo completo](http://nbviewer.jupyter.org/github/engineersCode/EngComp1_offtheground/blob/master/notebooks_en/3_Example_play_with_MAEbulletin.ipynb) en un cuaderno separado para mostrarle el poder de Python con los datos de texto.\n", + "Has aprendido muchas cosas sobre cadenas de texto y listas en esta lección, y probablemente estás ansioso por ver cómo aplicarlo a una situación realista. Creamos un [ejemplo completo](http://nbviewer.jupyter.org/github/engineersCode/EngComp1_offtheground/blob/master/notebooks_es/3_Ejemplo_con_MAEbulletin.ipynb) en un notebook separado para mostrar el poder de Python con los datos de texto.\n", "\n", - "Pero antes de saltar, deberíamos presentarle las potentes ideas de ** iteration ** y ** conditionals ** en Python." + "Pero antes de avanzar a eso, deberíamos presentarle las potentes ideas de **iteration** y **conditionals** en Python." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "### Iteración con declaraciones `for`\n", + "### Iteración con `for`\n", "\n", - "La idea de _iteration_ (en inglés simple) es repetir un proceso varias veces. Si tiene alguna experiencia en programación con otro idioma (como C o Java, por ejemplo), puede tener una idea de cómo crear iteraciones con sentencias `for`. Pero estos son un poco diferentes en Python, como puede leer en la [documentación](https://docs.python.org/3/tutorial/controlflow.html#for-statements).\n", + "La idea de _iteración_ es básicamente repetir un proceso varias veces. Si tienes experiencia en programación con otro idioma (como C o Java, por ejemplo), puedes tener una idea de cómo crear iteraciones con sentencias `for`. Pero estos son un poco diferentes en Python, como puede leer en la [documentación](https://docs.python.org/3/tutorial/controlflow.html#for-statements).\n", "\n", - "Una instrucción Python `for` itera sobre los elementos de una secuencia, naturalmente. Digamos que tiene una lista llamada `frutas` que contiene una secuencia de cadenas con nombres de fruta; puedes escribir una declaración como\n", + "En Python, la instrucción `for` itera sobre los elementos de una secuencia. Digamos que se tiene una lista llamada `frutas` que contiene cadenas de texto con nombres de fruta. Puedes escribir una ciclo for de la siguiente forma:\n", "\n", "```Python\n", - "para fruta en frutas:\n", + "for fruta in frutas:\n", "```\n", "hacer algo con cada elemento de la lista.\n", "\n", - "Aquí, por primera vez, encontraremos una característica distintiva del lenguaje Python: agrupando por ** sangría **. Para delimitar _what_ Python debe hacer con cada `fruta` en la lista de` fruits`, colocamos las siguientes declaraciones _indented_ desde la izquierda.\n", + "Aquí, por primera vez, encontraremos una característica distintiva del lenguaje Python: agrupanción por **indentación**. Para delimitar _qué_ Python debe hacer con cada `fruta` en la lista de` frutas`, colocamos las siguientes declaraciones _indentadas_ desde la izquierda.\n", "\n", - "¿Cuánto sangrar? Esta es una pregunta de estilo, y todos tienen una preferencia: dos espacios, cuatro espacios, una sola pestaña ... todos son válidos: ¡pero elija uno y sea consecuente!\n", + "¿Cuánto indentar? Esta es una pregunta de estilo, y todos tienen una preferencia: dos espacios, cuatro espacios, una sola tabulación... todos son válidos: ¡lo importante es elegir un estilo y ser consecuente!\n", "\n", "Usemos cuatro espacios:" ] }, { "cell_type": "code", - "execution_count": 65, + "execution_count": 56, "metadata": {}, "outputs": [ { @@ -1948,7 +1929,7 @@ "* la variable `fruit` está implícitamente definida en la declaración` for`\n", "* `fruit` toma el valor (cadena) de cada elemento de la lista` fruits`, en orden\n", "* la sentencia sangrienta `print()` se ejecuta para cada valor de `fruit`\n", - "* una vez que Python se queda sin 'fruits', se detiene\n", + "* una vez que Python se queda sin frutas ('fruits'), se detiene\n", "* ¡no necesitamos saber con anticipación cuántos elementos hay en la lista!" ] }, @@ -1965,7 +1946,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Una función muy útil para usar con declaraciones `for` es **` enumerate () `**: agrega un contador que puede usar como índice mientras se ejecuta su iteración. Para usarlo, define implícitamente _two_ variables en la instrucción `for`: el contador y el valor de la secuencia que se itera.\n", + "Una función muy útil para usar con declaraciones `for` es **` enumerate () `**: agrega un contador que puede usar como índice mientras se ejecuta su iteración. Para usarlo, define implícitamente _dos_ variables en la instrucción `for`: el contador y el valor de la secuencia que se itera.\n", "\n", "Estudia el siguiente bloque de código:" ] @@ -2006,13 +1987,13 @@ "source": [ "##### Ejercicio:\n", "\n", - "Supongamos que tenemos una lista de listas (a.k.a., a _nested_ list), como se muestra a continuación:\n", + "Supongamos que tenemos una lista de listas (a.k.a., una _nested list_ o lista anidada), como se muestra a continuación:\n", "```Python\n", "nombres completos = [['sam', 'jones'], ['zoe', 'smith'], ['joe', 'cheek'], ['tom', 'perez']]\n", "```\n", "Escriba un código que cree dos listas simples: una con los primeros nombres, otra con los apellidos de la lista anidada arriba, pero en mayúscula.\n", "\n", - "Para comenzar, necesita crear dos listas _empty_ utilizando los corchetes con nada dentro. Hemos hecho eso por ti a continuación. _Hint_: ¡Usa el método de lista `append ()`!" + "Para comenzar, necesita crear dos listas _vacías_ utilizando los corchetes pero sin contenido. Hemos hecho eso para tí a continuación. _Pista_: ¡Usa el método de lista `append()`!" ] }, { @@ -2043,12 +2024,12 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "(1) ** Si ** declaración por sí mismo:" + "(1) **If**: Condicional \"si sucede algo\":" ] }, { "cell_type": "code", - "execution_count": 68, + "execution_count": 57, "metadata": {}, "outputs": [ { @@ -2071,15 +2052,13 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "(2) declaración ** If-else **:" + "(2) **if-else**: Condicional \"si esto sino esto otro\": " ] }, { "cell_type": "code", - "execution_count": 69, - "metadata": { - "collapsed": true - }, + "execution_count": 58, + "metadata": {}, "outputs": [], "source": [ "# We pick a number, but you can change it\n", @@ -2088,7 +2067,7 @@ }, { "cell_type": "code", - "execution_count": 70, + "execution_count": 59, "metadata": {}, "outputs": [ { @@ -2110,7 +2089,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "* Nota: * El `%` representa una operación de módulo: da el resto de la división del primer argumento por el segundo" + "*Nota:* El `%` representa una operación de módulo: da el resto de la división del primer argumento por el segundo" ] }, { @@ -2122,10 +2101,8 @@ }, { "cell_type": "code", - "execution_count": 71, - "metadata": { - "collapsed": true - }, + "execution_count": 62, + "metadata": {}, "outputs": [], "source": [ "#x = float(input('Insert your number: '))" @@ -2135,12 +2112,12 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "(3) ** declaración If-elif-else **:" + "(3) **If-elif-else**: Multiples condicionales:" ] }, { "cell_type": "code", - "execution_count": 72, + "execution_count": 63, "metadata": {}, "outputs": [ { @@ -2167,7 +2144,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "* Nota: * Podemos tener tantas líneas `elif` como queramos." + "*Nota:* Podemos tener tantas líneas `elif` como queramos." ] }, { @@ -2206,15 +2183,15 @@ }, { "cell_type": "code", - "execution_count": 73, + "execution_count": 64, "metadata": {}, "outputs": [ { "data": { "text/html": [ - "\n", - "\n", - "\n", + "\n", + "\n", + "\n", "\n", - "\n" - ], - "text/plain": [ - "" - ] - }, - "execution_count": 20, - "metadata": {}, - "output_type": "execute_result" - } - ], + "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "# Execute this cell to load the notebook's style sheet, then ignore it\n", "from IPython.core.display import HTML\n", @@ -714,7 +417,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.5.3" + "version": "3.5.2" }, "widgets": { "state": {}, diff --git a/notebooks_es/4_NumPy_Arrays_y_Graficos.ipynb b/notebooks_es/4_NumPy_Arrays_y_Graficos.ipynb index 55091f2..3704de7 100644 --- a/notebooks_es/4_NumPy_Arrays_y_Graficos.ipynb +++ b/notebooks_es/4_NumPy_Arrays_y_Graficos.ipynb @@ -11,17 +11,17 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "# Juega con matrices NumPy\n", + "# Jugando con matrices NumPy\n", "\n", - "Bienvenido a ** Lección 4 ** del primer módulo de curso en _\"Computaciones de ingeniería_\". ¡Usted ha recorrido un largo camino!\n", + "Bienvenido a la **Lección 4** del primer módulo de curso en _\"Computaciones de ingeniería_\". ¡Ya has recorrido un largo camino!\n", "\n", - "Recuerde, este curso no asume ninguna experiencia de codificación, por lo que las tres primeras lecciones se centraron en crear una base con construcciones de programación de Python utilizando esencialmente _no mathematics_. Las lecciones anteriores son:\n", + "Recuerda, este curso no asume ninguna experiencia de programación, por lo que las tres primeras lecciones se centraron en crear una base con construcciones de programación de Python utilizando esencialmente _no mathematics_. Las lecciones anteriores son:\n", "\n", - "* [Lección 1](http://nbviewer.jupyter.org/github/engineersCode/EngComp1_offtheground/blob/master/notebooks_en/1_Interacting_with_Python.ipynb): interactuando con Python\n", - "* [Lección 2](http://nbviewer.jupyter.org/github/engineersCode/EngComp1_offtheground/blob/master/notebooks_en/2_Jupyter_strings_and_lists.ipynb): juega con los datos en Jupyter\n", + "* [Lección 1](http://nbviewer.jupyter.org/github/engineersCode/EngComp1_offtheground/blob/master/notebooks_en/1_Interacting_with_Python.ipynb): Interactuando con Python\n", + "* [Lección 2](http://nbviewer.jupyter.org/github/engineersCode/EngComp1_offtheground/blob/master/notebooks_en/2_Jupyter_strings_and_lists.ipynb): Juega con los datos en Jupyter\n", "* [Lección 3](http://nbviewer.jupyter.org/github/engineersCode/EngComp1_offtheground/blob/master/notebooks_en/3_Example_play_with_MAEbulletin.ipynb): Cadenas y listas en acción\n", "\n", - "En aplicaciones de ingeniería, la mayoría de las situaciones informáticas se benefician del uso de * arrays *: son secuencias de datos del mismo tipo_. Se comportan como listas, a excepción de la restricción en el tipo de sus elementos. Hay una gran ventaja de eficiencia cuando sabes que todos los elementos de una secuencia son del mismo tipo, por lo que los métodos equivalentes para las matrices se ejecutan mucho más rápido que los de las listas.\n", + "En aplicaciones de ingeniería, la mayoría de las situaciones informáticas se benefician del uso de *arrays*: son secuencias de datos del mismo tipo. Se comportan como listas, a excepción de la restricción en el tipo de sus elementos. Hay una gran ventaja de eficiencia cuando sabes que todos los elementos de una secuencia son del mismo tipo, por lo que los métodos equivalentes para las matrices se ejecutan mucho más rápido que los de las listas.\n", "\n", "El lenguaje Python se amplía para aplicaciones especiales, como la informática científica, con ** libraries **. La biblioteca más importante en ciencia e ingeniería es ** NumPy **, que proporciona la estructura de datos _n-dimensional array_ (a.k.a, `ndarray`) y una gran cantidad de funciones, operaciones y algoritmos para cálculos de álgebra lineal eficientes.\n", "\n", @@ -1627,7 +1627,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.5.3" + "version": "3.5.2" }, "widgets": { "state": {}, From b288e3ed0358ecd022d3e75fd7c8f5e354f78428 Mon Sep 17 00:00:00 2001 From: Sebastian Flores Date: Tue, 5 Jun 2018 00:14:24 -0400 Subject: [PATCH 11/17] Updated LEEME file --- LEEME.md | 22 ++++++++++++++++------ 1 file changed, 16 insertions(+), 6 deletions(-) diff --git a/LEEME.md b/LEEME.md index 5547b4d..96f031d 100644 --- a/LEEME.md +++ b/LEEME.md @@ -1,12 +1,22 @@ -[![Generic badge](https://img.shields.io/badge/--.svg)](https://github.com/engineersCode/EngComp1_offtheground/blob/master/README.md) -[![Generic badge](https://img.shields.io/badge/--.svg)](https://github.com/engineersCode/EngComp1_offtheground/blob/translation_es/LEEME.md) +# Cálculos Computacionales en Ingeniería - Modulo 1 -# Computación de ingeniería +_Cálculos Computacionales en Ingeniería_ es un curso en línea realizado con módulos de aprendizaje intercambiables, proporcionando flexibilidad para adaptarlo a diversas situaciones. Apunta a desarrollar habilidades computacionales para estudiantes en ingeniería, pero también puede ser usado por estudiantes de otras disciplinas científicas. El curso utiliza el lenguaje de programación Python y las herramientas de código abierto de Jupyter para computación interactiva. -Este curso no asume ninguna experiencia previa en programación, por lo que las tres primeras lecciones se centran en crear una base de conocimientos de programación de Python sin hacer uso de Matemáticas. La cuarta lección introduce la estructura de datos básicos en la informática científica: _arrays_. La última lección es un ejemplo de regresión lineal con datos reales. +Este primer módulo no asume ninguna experiencia previa en programación, por lo que las tres primeras lecciones se centran en crear una base de conocimientos de programación de Python sin hacer uso de Matemáticas. La cuarta lección introduce la estructura de datos básicos en la informática científica: _arrays_. La última lección es un ejemplo de regresión lineal con datos reales. ## Módulo 1: Obtener datos +_Aprender a interactuar con Python y manejar datos con Python._ + +> Obten una sesión interactiva en [MyBinder.org](https://mybinder.org/) con el material del curso utilizando el botón inferior. +> Selecciona la carpeta `notebooks_es` para acceder a las 5 lecciones de este curso como notebooks de Jupyter completamente ejecutables. +> +> [![Binder](https://mybinder.org/badge.svg)](https://mybinder.org/v2/gh/engineersCode/EngComp1_offtheground/master) + +* **Puedes unirte al curso [open online course](https://openedx.seas.gwu.edu/courses/course-v1:GW+EngComp1+2018/about)** (en inglés) en nuestra plataforma _Open edX_. + +* **Obtener una versión PDF para imprimir (en inglés) **: _Engineering Computations Module 1: Get data off the ground._ figshare. https://doi.org/10.6084/m9.figshare.5673454.v1 + ### [Lección 1](https://github.com/engineersCode/EngComp1_offtheground/blob/translation_es/notebooks_es/1_Interactuando_con_Python.ipynb): Interactuando con Python. Antecedentes: ¿Qué es Python? Nociones de lenguaje interpretado en comparación a lenguaje compilado. ¿Por qué usar Python? Es un lenguaje de uso general y de alta productividad. @@ -15,7 +25,7 @@ Utilizando Python como una calculadora. Nuevos conceptos: funciones, strings, variables, asignación, tipo, variables especiales (`True`,` False`, `None`). Operaciones matemáticas, operaciones lógicas. Lectura de mensajes de error. -### [Lección 2](https://github.com/engineersCode/EngComp1_offtheground/blob/translation_es/notebooks_es/2_Strings_y_listas_en_Jupyter.ipynb): Juegando con los datos en Jupyter +### [Lección 2](https://github.com/engineersCode/EngComp1_offtheground/blob/translation_es/notebooks_es/2_Strings_y_listas_en_Jupyter.ipynb): Jugando con los datos en Jupyter ¿Qué es Jupyter? Trabajando con Jupyter. Jugando con cadenas de texto en Python: asignación, indexación, subdivisión. Métodos de cadenas de texto: count, find, index, strip, startswith, split. Juegando con listas de Python: asignación, listas anidadas, indexación, segmentación. Métodos de listas: agregar, indexar. Pertenencia a una lista. Iteración con declaraciones for. Condicionales. @@ -35,4 +45,4 @@ Un ejemplo completo que usa datos reales de la temperatura de la tierra a lo lar (c) 2017 Lorena A. Barba, Natalia C. Clementi. Todo el contenido está bajo Atribución de Creative Commons [CC-BY 4.0](https://creativecommons.org/licenses/by/4.0/legalcode.txt), y todo [el código está bajo la cláusula BSD-3](https://github.com/engineersCode/EngComp/blob/master/LICENCE). ¡Estaremos felices si reutilizas el contenido de alguna manera! -[![Licencia](https://img.shields.io/badge/License-BSD%203--Clause-blue.svg)](https://opensource.org/licenses/BSD-3-Clause) [![Licencia: CC BY 4.0](https://img.shields.io/badge/License-CC%20BY%204.0-lightgrey.svg)](https://creativecommons.org/licenses/by/4.0/) +[![Licencia](https://img.shields.io/badge/License-BSD%203--Clause-blue.svg)](https://opensource.org/licenses/BSD-3-Clause) [![Licencia: CC BY 4.0](https://img.shields.io/badge/License-CC%20BY%204.0-lightgrey.svg)](https://creativecommons.org/licenses/by/4.0/) From 917429025ec1aebadb50c84247de38e072a486ae Mon Sep 17 00:00:00 2001 From: Sebastian Flores Date: Tue, 5 Jun 2018 00:17:41 -0400 Subject: [PATCH 12/17] Updated LEEME file: accents and badge --- LEEME.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/LEEME.md b/LEEME.md index 96f031d..f23d06a 100644 --- a/LEEME.md +++ b/LEEME.md @@ -1,4 +1,4 @@ -# Cálculos Computacionales en Ingeniería - Modulo 1 +# Cálculos Computacionales en Ingeniería - Módulo 1 _Cálculos Computacionales en Ingeniería_ es un curso en línea realizado con módulos de aprendizaje intercambiables, proporcionando flexibilidad para adaptarlo a diversas situaciones. Apunta a desarrollar habilidades computacionales para estudiantes en ingeniería, pero también puede ser usado por estudiantes de otras disciplinas científicas. El curso utiliza el lenguaje de programación Python y las herramientas de código abierto de Jupyter para computación interactiva. @@ -45,4 +45,4 @@ Un ejemplo completo que usa datos reales de la temperatura de la tierra a lo lar (c) 2017 Lorena A. Barba, Natalia C. Clementi. Todo el contenido está bajo Atribución de Creative Commons [CC-BY 4.0](https://creativecommons.org/licenses/by/4.0/legalcode.txt), y todo [el código está bajo la cláusula BSD-3](https://github.com/engineersCode/EngComp/blob/master/LICENCE). ¡Estaremos felices si reutilizas el contenido de alguna manera! -[![Licencia](https://img.shields.io/badge/License-BSD%203--Clause-blue.svg)](https://opensource.org/licenses/BSD-3-Clause) [![Licencia: CC BY 4.0](https://img.shields.io/badge/License-CC%20BY%204.0-lightgrey.svg)](https://creativecommons.org/licenses/by/4.0/) +[![Licencia](https://img.shields.io/badge/License-BSD%203--Clause-blue.svg)](https://opensource.org/licenses/BSD-3-Clause) [![Licencia: CC BY 4.0](https://img.shields.io/badge/License-CC%20BY%204.0-lightgrey.svg)](https://creativecommons.org/licenses/by/4.0/) [![Licencia: CC BY 4.0](https://img.shields.io/badge/Original-English-lightgreen.svg)](https://github.com/engineersCode/EngComp1_offtheground/) From 412b8619fb9f4834991fd4022d53dd3a7cf2f6e7 Mon Sep 17 00:00:00 2001 From: Sebastian Flores Date: Wed, 6 Jun 2018 23:11:38 -0400 Subject: [PATCH 13/17] Review and fix of notebook 1-1 --- LEEME.md | 18 +++++--- notebooks_es/1_Interactuando_con_Python.ipynb | 43 +++++++++---------- 2 files changed, 32 insertions(+), 29 deletions(-) diff --git a/LEEME.md b/LEEME.md index f23d06a..c1760ba 100644 --- a/LEEME.md +++ b/LEEME.md @@ -2,11 +2,15 @@ _Cálculos Computacionales en Ingeniería_ es un curso en línea realizado con módulos de aprendizaje intercambiables, proporcionando flexibilidad para adaptarlo a diversas situaciones. Apunta a desarrollar habilidades computacionales para estudiantes en ingeniería, pero también puede ser usado por estudiantes de otras disciplinas científicas. El curso utiliza el lenguaje de programación Python y las herramientas de código abierto de Jupyter para computación interactiva. -Este primer módulo no asume ninguna experiencia previa en programación, por lo que las tres primeras lecciones se centran en crear una base de conocimientos de programación de Python sin hacer uso de Matemáticas. La cuarta lección introduce la estructura de datos básicos en la informática científica: _arrays_. La última lección es un ejemplo de regresión lineal con datos reales. +Este primer módulo no asume ninguna experiencia previa en programación, por lo que las tres primeras lecciones se centran en crear una base de conocimientos de programación en Python sin hacer uso de Matemáticas. La cuarta lección introduce la estructura de datos básicos en la informática científica: _arrays_. La última lección es un ejemplo de regresión lineal con datos reales. + +## Sobre la traducción + +La traducción de los módulos escritos originalmente en inglés se realiza de manera literal, tratando de mantener un español neutro y fácil de leer. Se traducirá los nombres de archivos de notebook, comentarios, mensajes, valores de los strings, y de manera general, lo que ayude a hacer más facil de entender el código. Sin embargo, no se traducirán los nombres de variables ni el contenido de los datos de ejemplo. Es necesario de todas maneras aprender un poco de inglés para comprender y redactar de mejor manera código de Python, por lo que el código en sí mismo se mantendrá casi completamente en inglés. ## Módulo 1: Obtener datos -_Aprender a interactuar con Python y manejar datos con Python._ +_Aprender a interactuar con Python y manejar datos en Python._ > Obten una sesión interactiva en [MyBinder.org](https://mybinder.org/) con el material del curso utilizando el botón inferior. > Selecciona la carpeta `notebooks_es` para acceder a las 5 lecciones de este curso como notebooks de Jupyter completamente ejecutables. @@ -15,7 +19,7 @@ _Aprender a interactuar con Python y manejar datos con Python._ * **Puedes unirte al curso [open online course](https://openedx.seas.gwu.edu/courses/course-v1:GW+EngComp1+2018/about)** (en inglés) en nuestra plataforma _Open edX_. -* **Obtener una versión PDF para imprimir (en inglés) **: _Engineering Computations Module 1: Get data off the ground._ figshare. https://doi.org/10.6084/m9.figshare.5673454.v1 +* **Obtener una versión PDF para imprimir** (en inglés): _Engineering Computations Module 1: Get data off the ground._ figshare. https://doi.org/10.6084/m9.figshare.5673454.v1 ### [Lección 1](https://github.com/engineersCode/EngComp1_offtheground/blob/translation_es/notebooks_es/1_Interactuando_con_Python.ipynb): Interactuando con Python. @@ -27,19 +31,19 @@ Operaciones matemáticas, operaciones lógicas. Lectura de mensajes de error. ### [Lección 2](https://github.com/engineersCode/EngComp1_offtheground/blob/translation_es/notebooks_es/2_Strings_y_listas_en_Jupyter.ipynb): Jugando con los datos en Jupyter -¿Qué es Jupyter? Trabajando con Jupyter. Jugando con cadenas de texto en Python: asignación, indexación, subdivisión. Métodos de cadenas de texto: count, find, index, strip, startswith, split. Juegando con listas de Python: asignación, listas anidadas, indexación, segmentación. Métodos de listas: agregar, indexar. Pertenencia a una lista. Iteración con declaraciones for. Condicionales. +¿Qué es Jupyter? Trabajando con Jupyter. Jugando con cadenas de texto (strings) en Python: asignación, indexación, subdivisión. Métodos de cadenas de texto: count, find, index, strip, startswith, split. Jugando con listas de Python: asignación, listas anidadas, indexación, segmentación. Métodos de listas: agregar, indexar. Pertenencia a una lista. Iteración con declaraciones for. Condicionales. ### [Lección 3](https://github.com/engineersCode/EngComp1_offtheground/blob/translation_es/notebooks_es/3_Ejemplo_con_MAEbulletin.ipynb): Cadenas de texto y listas en acción Un ejemplo completo que utiliza lo aprendido en las lecciones 1 y 2: jugando con un archivo de texto que contiene el boletín MAE (lista de cursos con sus números, descripción, requisitos previos). Lectura de datos de un archivo. Limpieza y organización de datos de un texto. -### [Lección 4](https://github.com/engineersCode/EngComp1_offtheground/blob/translation_es/notebooks_es/4_NumPy_Arrays_y_Graficos.ipynb): Juegando con matrices NumPy +### [Lección 4](https://github.com/engineersCode/EngComp1_offtheground/blob/translation_es/notebooks_es/4_NumPy_Arrays_y_Graficos.ipynb): Jugando con matrices NumPy -Dos de las bibliotecas más importantes para informática científica con Python: **NumPy** y **Matplotlib**. Importación de bibliotecas. Funciones de NumPy para crear matrices: linspace, ones, zeros, empty, copy. Operaciones de un array. Matrices multidimensionales. Ventaja de rendimiento de arrays sobre listas. Graficando líneas 2D de datos a partir de arrays. +Dos de las bibliotecas más importantes para informática científica con Python: **NumPy** y **Matplotlib**. Importando bibliotecas. Funciones de NumPy para crear matrices: linspace, ones, zeros, empty, copy. Operaciones de un array. Matrices multidimensionales. Ventaja de rendimiento de arrays sobre listas. Graficando líneas 2D de datos a partir de arrays. ### [Lección 5](https://github.com/engineersCode/EngComp1_offtheground/blob/translation_es/notebooks_es/5_Regresion_Lineal_con_datos_reales.ipynb): Regresión lineal con datos reales -Un ejemplo completo que usa datos reales de la temperatura de la tierra a lo largo del tiempo. Paso 1: leer datos de un archivo. Paso 2: graficar los datos; haciendo graficos hermosos. Paso 3: regresión lineal de mínimos cuadrados. Paso 4: aplicar regresión lineal usando NumPy. Regresión segmentada. +Un ejemplo completo que usa datos reales de la temperatura de la tierra a lo largo del tiempo. Paso 1: leer datos de un archivo. Paso 2: graficar los datos; haciendo gráficos hermosos. Paso 3: regresión lineal de mínimos cuadrados. Paso 4: aplicar regresión lineal usando NumPy. Bonus: regresión segmentada. ## Derechos de autor y licencia diff --git a/notebooks_es/1_Interactuando_con_Python.ipynb b/notebooks_es/1_Interactuando_con_Python.ipynb index c5d646b..5c2f2b6 100644 --- a/notebooks_es/1_Interactuando_con_Python.ipynb +++ b/notebooks_es/1_Interactuando_con_Python.ipynb @@ -13,7 +13,7 @@ "source": [ "# Interactuando con Python\n", "\n", - "Esta es la primera lección de nuestro curso _\"Computación de Ingeniería\"_, un curso de un semestre para estudiantes universitarios de segundo año. El curso usa Python y no asume experiencia previa en programación.\n", + "Esta es la primera lección de nuestro curso _\"Cálculos Computacionales en Ingeniería\"_, un curso de un semestre para estudiantes universitarios de segundo año. El curso usa Python y no asume experiencia previa en programación.\n", "Nuestro primer paso será interactuar con Python. Pero primero aprenderemos algunos datos interesantes." ] }, @@ -23,12 +23,12 @@ "source": [ "## ¿Qué es Python?\n", "\n", - "Python tiene 26 años de existencia. Su creador, [Guido van Rossum](https://en.wikipedia.org/wiki/Guido_van_Rossum), lo nombró así por la comedia británica \"Flying Circus de Monty Python\". Sus objetivos para el lenguaje eran que era un \"lenguaje fácil e intuitivo, tan poderoso como los principales competidores\", produciendo un código de computadora \"que sea tan comprensible como el inglés\".\n", + "Python tiene más de 25 años de existencia, puesto que su primera versión se liberó en 1991. Su creador, [Guido van Rossum](https://es.wikipedia.org/wiki/Guido_van_Rossum), lo nombró así por la comedia británica \"Monty Python Flying Circus\". Sus objetivos para el lenguaje eran que era un \"lenguaje fácil e intuitivo, tan poderoso como los principales competidores\", produciendo un código de computadora \"que sea tan comprensible como el inglés\".\n", "\n", - "Es un lenguaje de propósito general, lo que significa que puede ser usardo para cualquier cosa: organización de datos, web scraping, creación de sitios web, análisis de sonidos, creación de juegos y, por supuesto, \"cálculos de ingeniería\".\n", + "Es un lenguaje de propósito general, lo que significa que puede ser usardo para cualquier objetivo: organización de datos, web scraping, creación de sitios web, análisis de sonidos, creación de juegos y, por supuesto, *cálculos computacionales en ingeniería*.\n", "\n", "Python es un lenguaje interpretado. Esto significa que puedes escribir comandos de Python y la computadora ejecuta esas instrucciones directamente. Otros lenguajes de programación, como C, C ++ y Fortran, requieren un paso previo de _compilación_: traducir los comandos al lenguaje de la máquina.\n", - "Una buena habilidad de Python es que puede ser utilizada _interactivamente_. Fernando Perez creó ** IPython ** como un proyecto paralelo durante su doctorado. Vamos a usar IPython (el I significa \"interactivo\") en esta lección." + "Una gran habilidad de Python es que puede ser utilizada _interactivamente_. Fernando Perez creó ** IPython ** como un proyecto paralelo durante su doctorado. Vamos a usar IPython (el I significa \"interactivo\") en esta lección." ] }, { @@ -38,16 +38,16 @@ "## ¿Por qué Python?\n", "\n", "\n", - "_¡Porque es divertido!_ Con Python, cuanto más aprendes, más querrás aprender.\n", + "_¡Porque es divertido!_ Con Python, cuanto más aprendes, más te gustará aprender.\n", "Existen muchos recursos en línea y, dado que Python es un proyecto de código abierto, también encontrarás una comunidad amigable de personas que comparten sus conocimientos.\n", "\n", "Python es conocido como un lenguaje de \"alta productividad\". Como programador, necesitarás menos tiempo para desarrollar una solución con Python que con la mayoría de los idiomas.\n", "Esto es importante cuando alguien te diga que \"Python es lento\".\n", "¡Tu tiempo es más valioso que el de una máquina!\n", - "(Al respecto, consulta la sección Lecturas recomendadas al final).\n", - "Y si realmente necesitamos acelerar nuestro programa, podemos volver a escribir las partes lentas en un lenguaje compilado después. Porque Python interactua bien con otros idiomas :-)\n", + "(Al respecto, consulta la sección Lecturas recomendadas al final de este notebook).\n", + "Y si realmente necesitamos acelerar nuestro programa, podemos volver a escribir las partes lentas en un lenguaje compilado más tarde, porque Python interactua bien con otros idiomas :-)\n", "\n", - "Las principales compañías tecnológicas usan Python: Google, Facebook, Dropbox, Wikipedia, Yahoo!, YouTube ... Y este año, Python ocupó el lugar número 1 en la lista interactiva de [The 2017 Top Programming Languages](http://spectrum.ieee.org/computing/software/the-2017-top-programming-languages), por _EEEE Spectrum_ ([IEEE](http://www.ieee.org/about/index.html) es la sociedad técnica profesional más grande del mundo )" + "Las principales compañías tecnológicas usan Python: Google, Facebook, Dropbox, Wikipedia, Yahoo!, YouTube ... Y el 2017, Python ocupó el lugar número 1 en la lista interactiva de [The 2017 Top Programming Languages](http://spectrum.ieee.org/computing/software/the-2017-top-programming-languages), por _EEEE Spectrum_ ([IEEE](http://www.ieee.org/about/index.html) es la sociedad técnica profesional más grande del mundo )" ] }, { @@ -109,7 +109,7 @@ "source": [ "##### Concepto clave: función\n", "\n", - "Una función es una colección compacta de código que ejecuta alguna acción en sus _argumentos_. Cada función de Python tiene un _nombre_, usado para llamarlo, y toma sus argumentos dentro de corchetes. Algunos argumentos pueden ser opcionales (lo que significa que tienen un valor predeterminado definido dentro de la función), otros son obligatorios. Por ejemplo, la función `print()` tiene un argumento requerido: la cadena de caracteres que se desea imprimir.\n", + "Una función es una colección compacta de código que ejecuta alguna acción en sus _argumentos_. Cada función de Python tiene un _nombre_, usado para llamarlo, y toma sus argumentos dentro de paréntesis. Algunos argumentos pueden ser opcionales (lo que significa que tienen un valor predeterminado definido dentro de la función), otros son obligatorios. Por ejemplo, la función `print()` tiene un argumento requerido: la cadena de caracteres que se desea imprimir.\n", "\n", "Python viene con muchas funciones _predefinidas_, pero también puedes construir funciones propias. Dividir los distintos bloques de código en funciones es una de las mejores estrategias para lidiar con programas complejos. Te hace más eficiente, porque puedes reutilizar el código que escribiste en una función. La modularidad y la reutilización son las herramientas diarias de un programador." ] @@ -120,13 +120,13 @@ "source": [ "### Python como calculadora\n", "\n", - "Prueba cualquier operación aritmética en IPython. Los símbolos son lo que esperaría, excepto el operador de potencia, que obtiene con dos asteriscos: `**`. Prueba todos estos:\n", + "Prueba cualquier operación aritmética en IPython. Los símbolos son lo que esperaría, excepto el operador de potencia, que se obtiene con dos asteriscos: `**`. Prueba todos estos operadores:\n", "\n", "```python\n", "+ - * / ** % //\n", "```\n", "\n", - "El símbolo `%` es el operador _módulo_ (divide y devuelve el resto), y la barra doble es _división entera_." + "El símbolo `%` es el operador _módulo_ (divide y devuelve el resto), y la barra doble `//` es _división entera_." ] }, { @@ -259,12 +259,11 @@ "##### Ejercicios:\n", "Usa IPython (como una calculadora) para resolver los siguientes dos problemas:\n", "\n", - "1. El volumen de una esfera con radio $ r $ es $ \\frac {4} {3} \\pi r ^ 3 $. ¿Cuál es el volumen de una esfera con un diámetro de 6.65 cm?\n", - "\n", - "    Por el valor de $ \\pi $ usa 3.14159 (por ahora). Compara tu respuesta con la solución hasta 4 números decimales.\n", + "1. El volumen de una esfera con radio $ r $ es $ \\frac {4} {3} \\pi r ^ 3 $. ¿Cuál es el volumen de una esfera con un diámetro de 6.65 cm? Utiliza 3.14159 como valor para $ \\pi $ (por ahora). Compara tu respuesta con la solución hasta 4 números decimales.\n", "\n", "    Sugerencia: 523.5983 es incorrecto y 615.9184 también es incorrecto.\n", - "    \n", + "\n", + "\n", "2. Supongamos que el precio de un libro es $ \\$ 24.95 $, pero las librerías obtienen un descuento de $ 40 \\% $. El envío cuesta $ \\$ 3 $ por la primera copia y $ 75 $ centavos por cada copia adicional. ¿Cuál es el costo total al por mayor de $ 60 $ copias? Compare su respuesta con la solución hasta 2 números decimales." ] }, @@ -303,7 +302,7 @@ "\n", "\n", "\n", - "Tenemos muchas posibilidades para nombres de variables: pueden estar formados por letras mayúsculas y minúsculas, guiones bajos y dígitos ... aunque los dígitos no pueden ir al principio del nombre. Por ejemplo, los nombres de variable válidos son:\n", + "Tenemos muchas posibilidades para los nombres de variables: pueden estar formados por letras mayúsculas y minúsculas, guiones bajos y dígitos, pero los dígitos no pueden ir al principio del nombre. Por ejemplo, algunos nombres de variable válidos son:\n", "\n", "```python\n", "    X\n", @@ -314,7 +313,7 @@ "```\n", "Ten en cuenta que hay palabras reservadas que no puede usar; son las [palabras reservadas de Python](https://es.wikibooks.org/wiki/Python/Generalidades/Palabras_reservadas,_operadores_y_s%C3%ADmbolos_del_lenguaje).\n", "  \n", - "OK. Asignemos algunos valores a las variables y realicemos algunas operaciones con ellos:" + "Asignemos ahora algunos valores a las variables y realicemos algunas operaciones con ellos:" ] }, { @@ -480,7 +479,7 @@ "\n", "En otras palabras, una variable tiene un tipo, pero no necesitamos especificarlo. Simplemente se comportará como se supone que debe hacerlo cuando operemos con él (graznará y caminará como fue la intención de la naturaleza).\n", "\n", - "Pero a veces es necesario asegurarse de conocer el tipo de variable. Afortunadamente, Python ofrece una función para encontrar el tipo de variable: `type()` (tipo, en inglés)." + "Pero a veces es necesario asegurarse de conocer el tipo de una variable. Afortunadamente, Python ofrece una función para encontrar el tipo de variable: `type()` (tipo, en inglés)." ] }, { @@ -543,7 +542,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Observa lo que hicimos arriba: utilizamos la función `print()` con una cadena de texto (string), seguido de una variable, y Python imprimió una combinación útil del mensaje y el valor de la variable. Un consejo profesional: Quieres imprimir mensajes fáciles de leer para humanos. Veamos ahora el tipo de las nuevas variables que acabamos de crear:" + "Observa lo que hicimos arriba: utilizamos la función `print()` con una cadena de texto (string), seguido de una variable, y Python imprimió una combinación útil del mensaje y el valor de la variable. Un consejo profesional: Imprime mensajes que sean fáciles de leer para otras personas. Veamos ahora el tipo de las nuevas variables que acabamos de crear:" ] }, { @@ -589,7 +588,7 @@ "  not True\n", "```\n", "\n", - "Retorna ... lo has adivinado ... `False` (Falso).\n", + "Retorna... lo has adivinado... `False` (Falso).\n", "\n", "La función de Python `bool()` devuelve un valor de verdad asignado a cualquier argumento. Cualquier número que no sea cero tiene un valor de verdad de `True`, así como cualquier cadena o lista no vacía. El número cero y cualquier cadena o lista vacía tendrán un valor de verdad de `False`. Ahora exploremos la función `bool()` con varios argumentos." ] @@ -656,7 +655,7 @@ "source": [ "### Operadores lógicos y de comparación\n", "\n", - "Los operadores de comparación de Python son: `<`, `<=`, `>`, `> =`, `==`, `!=`. Comparan dos objetos y devuelven `True` o` False`: menor, menor o igual, mayor, mayor o igual, igual, distinto. ¡Intentalo!" + "Los operadores de comparación de Python son: `<`, `<=`, `>`, `> =`, `==`, `!=`. Comparan dos objetos y devuelven `True` o` False`: menor, menor o igual, mayor, mayor o igual, igual, distinto. ¡Inténtalo!" ] }, { @@ -716,7 +715,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Los operadores lógicos son los siguientes: `and`, `or`, y `not`. Funcionan igual que en el inglés. Una expresión lógica con `and` es verdadera (`True`) sólo si ambos operandos son verdaderos. Una expresión con `or` es verdadera (`True`) cuando cualquiera de los operandos es verdadero. Y la palabra clave `not` siempre niega la expresión que le sigue.\n", + "Los operadores lógicos son los siguientes: `and` (y, en inglés), `or` (o, en inglés), y `not` (no, en inglés). Funcionan igual que en el inglés. Una expresión lógica con `and` es verdadera (`True`) sólo si ambos operandos son verdaderos. Una expresión con `or` es verdadera (`True`) cuando cualquiera de los operandos es verdadero. Y la palabra clave `not` siempre niega la expresión que le sigue.\n", "\n", "Hagamos algunos ejemplos:" ] From 58efe376861063070e4ef205facd23a649b10b95 Mon Sep 17 00:00:00 2001 From: Sebastian Flores Date: Mon, 9 Jul 2018 00:30:53 -0400 Subject: [PATCH 14/17] Completando traducciones, de manera consistente. --- ...ynb => 2_Strings_y_listas_en_accion.ipynb} | 1274 +++---------- ... => 3_Jugando_con_archivo_de_cursos.ipynb} | 212 ++- .../4_Conociendo_arrays_y_graficos.ipynb | 1042 +++++++++++ notebooks_es/4_NumPy_Arrays_y_Graficos.ipynb | 1639 ----------------- .../5_Regresion_Lineal_con_datos_reales.ipynb | 601 ++---- 5 files changed, 1617 insertions(+), 3151 deletions(-) rename notebooks_es/{2_Strings_y_listas_en_Jupyter.ipynb => 2_Strings_y_listas_en_accion.ipynb} (53%) rename notebooks_es/{3_Ejemplo_con_MAEbulletin.ipynb => 3_Jugando_con_archivo_de_cursos.ipynb} (54%) create mode 100644 notebooks_es/4_Conociendo_arrays_y_graficos.ipynb delete mode 100644 notebooks_es/4_NumPy_Arrays_y_Graficos.ipynb diff --git a/notebooks_es/2_Strings_y_listas_en_Jupyter.ipynb b/notebooks_es/2_Strings_y_listas_en_accion.ipynb similarity index 53% rename from notebooks_es/2_Strings_y_listas_en_Jupyter.ipynb rename to notebooks_es/2_Strings_y_listas_en_accion.ipynb index 83bc8fa..8549a6d 100644 --- a/notebooks_es/2_Strings_y_listas_en_Jupyter.ipynb +++ b/notebooks_es/2_Strings_y_listas_en_accion.ipynb @@ -11,9 +11,9 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "# Juega con datos en Jupyter\n", + "# Jugando con datos en Jupyter\n", "\n", - "Esta es la segunda lección de nuestro curso en _\"Cálculos de ingeniería\"_. En la primera lección, [_Interactuando con Python_](http://nbviewer.jupyter.org/github/engineersCode/EngComp1_offtheground/blob/master/notebooks_es/1_Interactuando_con_Python.ipynb), usamos **IPython**, el shell interactivo de Python. Es genial escribir expresiones de Python de una sola línea y obtener los resultados de forma interactiva. Sin embargo, lo creas o no, ¡hay cosas aún más increíbles!\n", + "Esta es la segunda lección de nuestro curso en _\"Cálculos Computacionales en ingeniería\"_. En la primera lección, [_Interactuando con Python_](http://nbviewer.jupyter.org/github/engineersCode/EngComp1_offtheground/blob/master/notebooks_es/1_Interactuando_con_Python.ipynb), usamos **IPython**, el shell interactivo de Python. Es genial escribir expresiones de Python de una sola línea y obtener los resultados de forma interactiva. Sin embargo, aunque no lo creas, ¡hay cosas más increíbles!\n", "\n", "En esta lección, continuarás usando Python para jugar con datos, pero lo harás en un **Jupyter Notebook**. Esta misma lección está escrita en un Jupyter Notebook. ¿Listo? No te arrependirás." ] @@ -24,9 +24,9 @@ "source": [ "## ¿Qué es Jupyter?\n", "\n", - "Jupyter es un conjunto de herramientas de código abierto para la informática interactiva y exploratoria. Trabajarás directamente en tu navegador, que se convierte en la interfaz de usuario a través de la cual Jupyter te proporciona un explorador de archivos (el _dashboard_) y un formato de documento: el **notebook**.\n", + "Jupyter es un conjunto de herramientas de código abierto para la informática interactiva y exploratoria. Trabajarás directamente en tu navegador web, que se convierte en la interfaz de usuario a través de la cual Jupyter te proporciona un explorador de archivos (el _dashboard_) y un formato de documento: el **notebook**.\n", "\n", - "Un Jupyter Notebook puede contener: entrada y salida de código, texto formateado, imágenes, videos, bonitas ecuaciones matemáticas y mucho más. El código de la computadora es _ejecutable_, lo que significa que puede ejecutar el código, directamente en el documento, y obtener la salida de ese código directamente en el navegador. Esta forma interactiva de computación, mezclada con la narrativa multimedia, permite contar una historia (incluso de manera individual y personal) con súperpoderes computacionales." + "Un Jupyter Notebook puede contener: entrada y salida de código, texto con formato, imágenes, videos, bonitas ecuaciones matemáticas y mucho más. El código de la computadora es completamente _ejecutable_, lo que significa que puede ejecutar el código, directamente en el documento, y obtener la salida de ese código directamente en el navegador. Esta forma interactiva de computación, mezclada con la narrativa multimedia, permite contar una historia (incluso de manera individual y personal) con súperpoderes computacionales." ] }, { @@ -49,27 +49,29 @@ "`jupyter notebook`\n", "\n", "Presiona enter y ... ¡listo!\n", - "Después de un breve tiempo de configuración, tu navegador predeterminado se abrirá con la aplicación Jupyter. Debería ser similar a la siguiente captura de pantalla siguiente, pero es posible que se vea una lista distinta de archivos y carpetas, según la ubicación de su computadora donde la lanzó.\n", + "Después de un breve tiempo de configuración, tu navegador predeterminado se abrirá con la aplicación Jupyter. Debería ser similar a la siguiente captura de pantalla, pero es posible que se vea una lista distinta de archivos y carpetas, según la ubicación de tu computadora.\n", "\n", "##### Nota:\n", "\n", - "No cierre la ventana de la terminal donde lanzó Jupyter (mientras todavía está trabajando en Jupyter). Si necesitas hacer otras tareas en la línea de comando, abre una nueva ventana de terminal.\n", + "No cierres la ventana del terminal que lanzó Jupyter mientras todavía está trabajando en Jupyter. Si necesitas hacer otras tareas en la línea de comando, abre una nueva ventana de terminal.\n", "\n", - "\n", - "#### Captura de pantalla del tablero de Jupyter, abierto en el navegador.\n", + "#### Captura de pantalla del dashboard de Jupyter, abierto en el navegador.\n", "\n", - "Para iniciar un nuevo Jupyter Notebook, haz clic en la esquina superior derecha, donde dice **Nuevo** o **New**, y seleccione `Python 3`. Mira la captura de pantalla a continuación.\n", + "Para iniciar un nuevo Jupyter Notebook, haz clic en la esquina superior derecha, donde dice **Nuevo** o **New**, y selecciona `Python 3`. Deberías tener algo similar a la siguiente captura de pantalla:\n", "\n", - "\n", + "\n", "\n", "#### Captura de pantalla que muestra cómo crear un nuevo cuaderno.\n", - "Aparecerá una nueva pestaña en su navegador y verás un notebook vacío, con una sola línea de entrada, esperando que ingrese algún código. Observa la siguiente captura de pantalla.\n", "\n", - "\n", + "Aparecerá una nueva pestaña en tu navegador web y verás un notebook vacío, con una sola línea de entrada, esperando que ingreses algún código, como en la siguiente captura de pantalla:\n", + "\n", + "\n", "\n", "#### Captura de pantalla que muestra un nuevo cuaderno vacío.\n", "\n", - "El notebook se abre de manera predeterminada con una sola celda de código vacía. Intenta escribir allí un código Python y ejecútalo presionando `[shift] + [enter]`." + "El notebook se abre de manera predeterminada con una sola celda de código vacía. Intenta escribir allí un código Python y ejecútalo presionando `[shift] + [enter]`.\n", + "\n", + "\n" ] }, { @@ -78,29 +80,29 @@ "source": [ "### Celdas de notebook\n", "\n", - "El cuaderno Jupyter usa _cells_ (_celdas_): bloques que dividen fragmentos de texto y código. Cualquier contenido de texto se ingresa en una celda *Markdown*: contiene texto que puede formatear con marcadores simples para obtener encabezados, negrita, cursiva, viñetas, hipervínculos y más.\n", + "El cuaderno Jupyter usa _celdas_ (_cells_), que corresponden a bloques que pueden contener fragmentos de texto y código. Cualquier contenido de texto se ingresa en una celda *Markdown*: contiene texto que puede formatear con marcadores simples para obtener encabezados, negrita, cursiva, viñetas, hipervínculos y más.\n", "\n", "Markdown es fácil de aprender, consulte la sintaxis en la página web [\"Daring Fireball\"](https://daringfireball.net/projects/markdown/syntax) (por John Gruber). Algunos consejos:\n", "\n", - "* para crear un título, use un hash para comenzar la línea: `# Título`\n", - "* para crear el siguiente encabezado, use dos hash (y así sucesivamente): `## Subtítulo`\n", - "* para poner en cursiva una palabra o frase, enciérrelo en asteriscos (o en las líneas inferiores): `*cursiva*` o `_cursiva_`\n", - "* para que sea negrita, enciérrelo con dos asteriscos: `**en negrita**`\n", - "* para hacer un hipervínculo, use corchetes cuadrados y redondos: `[texto para el enlace](url del enlace)`\n", + "* Para crear un título, usa `#` para comenzar la línea: `# Título`\n", + "* Para crear el siguiente encabezado, use `##` (y así sucesivamente): `## Subtítulo`\n", + "* Para poner en cursiva una palabra o frase, enciérrelo en asteriscos (o con líneas inferiores): `*cursiva*` o `_cursiva_`\n", + "* Para que sea negrita, enciérrelo con dos asteriscos: `**en negrita**`\n", + "* Para hacer un hipervínculo, use corchetes cuadrados y redondos: `[texto para el enlace](url del enlace)`\n", "\n", - "El contenido computable se ingresa en celdas de código. Usaremos el kernel de IPython (\"kernel\" es el nombre utilizado para el motor de computación), pero debe saber que Jupyter se puede usar con muchos lenguajes de computación diferentes. Es asombroso.\n", + "El contenido de código ejecutable se ingresa en celdas de código. Usaremos el kernel de IPython (\"kernel\" es el nombre utilizado para el motor de computación), pero debes saber que Jupyter puede utilizarse con muchos lenguajes de computación diferentes. Es in-cre-í-ble.\n", "\n", - "Una celda de código le mostrará una marca de entrada, como esta:\n", + "Una celda de código le mostrará es espacio para ingresar código:\n", "\n", "`In []:`\n", "\n", - "Una vez que agregues un código y lo ejecutes, Jupyter agregará un número de ID a la celda de entrada, y producirá una salida marcada así:\n", + "Una vez que agregues código y lo ejecutes, Jupyter agregará un número de identificación a la celda de entrada, y producirá una salida marcada así:\n", "\n", "`Out [1]:`\n", "\n", "##### Un poco de historia:\n", "\n", - "Markdown fue co-creado por el legendario pero trágico [Aaron Swartz](https://en.wikipedia.org/wiki/Aaron_Swartz). El documental biográfico sobre él se llama [\"The Own Boy de Internet\"](https://en.wikipedia.org/wiki/The_Internet%27s_Own_Boy) y puedes verlo en YouTube o Netflix. ¡Recomendado!" + "Markdown fue co-creado por el legendario pero trágico [Aaron Swartz](https://es.wikipedia.org/wiki/Aaron_Swartz). El documental biográfico sobre él se llama [\"The Own Boy de Internet\"](https://en.wikipedia.org/wiki/The_Internet%27s_Own_Boy) y puedes verlo en YouTube o Netflix. ¡Recomendado!" ] }, { @@ -109,28 +111,26 @@ "source": [ "### Computación interactiva en el cuaderno\n", "\n", - "Mira los iconos en el menú de Jupyter (como se muestran en las capturas de pantalla arriba). El primer ícono a la izquierda (un disquete de los antiguos) es para guardar tu computadora. Puedes agregar una nueva celda presionando el gran botón **+**. Además existen los los botones cortar, copiar y pegar. Las flechas son para mover su celda actual hacia arriba o hacia abajo. Existe un botón para \"ejecutar\" una celda de código (ejecutar el código), el icono cuadrado significa \"detener\" y la flecha circular para \"reiniciar\" el núcleo de su computadora portátil (si el cálculo está atascado, por ejemplo). Junto a eso, existe el selector de tipo de celda: código o texto markdown (u otros que puedes ignorar por ahora).\n", + "Observa los iconos en el menú de Jupyter como se muestran en las capturas de pantalla anteriores de este notebook. El primer ícono a la izquierda (un disquete de los antiguos) es para guardar el notebook. Puedes agregar una nueva celda presionando el gran botón **+**. Además existen los los botones cortar, copiar y pegar. Las flechas son para mover la celda actual hacia arriba o hacia abajo. Existe un botón para \"ejecutar\" una celda de código (ejecutar el código), el icono cuadrado significa \"detener\" y la flecha circular para \"reiniciar\" el kernel del notebook (si el cálculo está tomando demasiado tiempo, por ejemplo). Además, se puede seleccionar el tipo de celda: código o texto markdown (u otros que puedes ignorar por ahora).\n", "\n", - "Puede probar una celda de código escribiendo algunas operaciones aritméticas. Como vimos en nuestra primera lección, los operadores de Python son:\n", + "Puedes probar una celda de código escribiendo algunas operaciones aritméticas. Como vimos en nuestra primera lección, los operadores de Python son:\n", "```python\n", "    + - * / ** % //\n", "```\n", "\n", - "Hay suma, resta, multiplicación y división. Los últimos tres operadores son _exponente_ (elevar a la potencia), _modulo_ (divide y devuelve el resto) y _división entera_.\n", + "Existe la suma, la resta, la multiplicación y la división. Los últimos tres operadores son _exponente_ (elevar a la potencia), _módulo_ (divide y devuelve el resto) y _división entera_.\n", "\n", - "Tecleando `[shift] + [enter]` ejecutará la celda y le dará la salida en una nueva línea, etiquetada como `Out [1]` (la numeración aumenta cada vez que ejecuta una celda).\n", + "Tecleando `[shift] + [enter]` se ejecutará la celda y obtendrás la salida en una nueva línea, etiquetada como `Out [1]`. La numeración aumenta cada vez que ejecuta una celda.\n", "\n", - "##### ¡Intentalo!\n", + "##### ¡Inténtalo!\n", "\n", - "Agregue una celda con el botón más, ingrese algunas operaciones, y `[shift] + [enter]` para ejecutar." + "Agrega una celda con el botón más, ingresa algunas operaciones, y utiliza `[shift] + [enter]` para ejecutar." ] }, { "cell_type": "code", "execution_count": null, - "metadata": { - "collapsed": true - }, + "metadata": {}, "outputs": [], "source": [] }, @@ -138,42 +138,23 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Todo lo que hicimos usando IPython lo podemos hacer en celdas de código dentro de un portátil Jupyter. Pruebe algunas de las cosas que aprendimos en la lección 1:" + "Todo lo que hicimos usando IPython lo podemos hacer en celdas de código dentro de un Jupyter notebook. Prueba algunas de las cosas que aprendimos en la lección 1:" ] }, { "cell_type": "code", - "execution_count": 1, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Hello World!\n" - ] - } - ], + "outputs": [], "source": [ - "print(\"Hello World!\")" + "print(\"¡Hola mundo!\")" ] }, { "cell_type": "code", - "execution_count": 2, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "False" - ] - }, - "execution_count": 2, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "x = 2**8\n", "x < 64" @@ -185,7 +166,7 @@ "source": [ "### Modo de edición y modo de comando\n", "\n", - "Una vez que haces click en una celda de la notebook para seleccionarla, puede interactuar con ella de dos maneras, que se llaman _modos_. Más adelante, si revisas este material nuevamente y en mayor profundidad, puedes leer más sobre esto en la Referencia número 1.\n", + "Una vez que haces click en una celda del notebook para seleccionarla, puedes interactuar con ella de dos maneras o _modos_. Más adelante, si revisas este material nuevamente y en mayor profundidad, puedes leer más sobre esto en la referencia número 1 al final de este notebook.\n", "\n", "**Modo de edición:**\n", "\n", @@ -202,7 +183,7 @@ "\n", "* Sabemos que estamos en este modo cuando vemos un borde de celda gris con un margen azul izquierdo.\n", "\n", - "* En este modo, ciertas teclas se asignan a accesos directos para ayudar con acciones comunes.\n", + "* En este modo, ciertas teclas permiten utilizar atajos de teclado (accesos directos) para ayudar con acciones comunes.\n", "\n", "Puede encontrar una lista de los accesos directos seleccionando `Help->Keyboard Shortcuts` (`Ayuda-> Atajos de teclado`) desde la barra de menú del notebook. Puedes continuar con esto más adelante, pero se vuelve más útil cuanto más usas Jupyter. ¡Siempre es más eficiente conocer atajos de teclado!" ] @@ -215,7 +196,7 @@ "\n", "Cerrar la pestaña del navegador donde has estado trabajando en un notebook no \"cierra\" inmediatamente el kernel. A veces necesitas hacer un poco de limpieza antes.\n", "\n", - "Una vez que cierres un notebook, verá en la aplicación Jupyter principal que el archivo del notebook tiene un símbolo con un libro verde al lado. Deberías hacer click en el cuadro a la izquierda de ese símbolo, y luego hacer clic donde dice **Shutdown** o **Apagar**. No necesitas hacer esto todo el tiempo, pero si tienes varios notebooks abiertos, permite disminuir los recursos utilizados.\n", + "Una vez que cierres un notebook, verás en la aplicación Jupyter principal que el archivo del notebook tiene un símbolo con un libro verde al lado. Deberías hacer click en el cuadro a la izquierda de ese símbolo, y luego hacer clic donde dice **Shutdown** o **Apagar**. No necesitas hacer esto todo el tiempo, pero si tienes varios notebooks abiertos, permite disminuir los recursos utilizados.\n", "\n", "Del mismo modo, Jupyter aún se está ejecutando incluso después de cerrar la pestaña del navegador que tiene abierto Jupyter. Para salir de la aplicación Jupyter, debe ir al terminal de comando que se utilizó para abrir Jupyter, y hacer `[Ctrl] + [c]` para salir." ] @@ -226,7 +207,7 @@ "source": [ "### Nbviewer\n", "\n", - "[Nbviewer](http://nbviewer.jupyter.org/) es un servicio web gratuito que le permite compartir versiones estáticas de notebooks, como si se tratara de una página web. Si un archivo de computadora portátil está disponible públicamente en la web, puede verlo ingresando su URL en la página web de nbviewer y presionando el botón **Go!**. El notebook se representará como una página estática: los visitantes pueden leer todo, pero no pueden interactuar con el código." + "[Nbviewer](http://nbviewer.jupyter.org/) es un servicio web gratuito que le permite compartir versiones estáticas de notebooks, como si se tratara de una página web. Si un archivo de computadora portátil está disponible públicamente en la web, puede verlo ingresando su URL en la página web de nbviewer y presionando el botón **Go!**. El notebook se representará como una página estática: los visitantes podrán leer todo, pero no podrán interactuar con el código." ] }, { @@ -240,36 +221,26 @@ }, { "cell_type": "code", - "execution_count": 3, - "metadata": { - "collapsed": true - }, + "execution_count": null, + "metadata": {}, "outputs": [], "source": [ - "str_1 = 'hello'\n", - "str_2 = 'world'" + "str_1 = 'hola'\n", + "str_2 = 'mundo'" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "Recuerde que podemos concatenar cadenas (\"unir\"), por ejemplo:" + "Recuerde que podemos concatenar (\"unir\") los strings, por ejemplo:" ] }, { "cell_type": "code", - "execution_count": 4, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "helloworld\n" - ] - } - ], + "outputs": [], "source": [ "new_string = str_1 + str_2\n", "print(new_string)" @@ -279,22 +250,14 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "¿Qué ocurre si queremos agregar un espacio que separa `hello` from` world`? Añadimos directamente la cadena `''` en el medio de las dos variables. Un espacio es un carácter de texto (character en inglés, char para los amigos)." + "¿Qué ocurre si queremos agregar un espacio que separa `hello` from` world`? Añadimos directamente la cadena `' '` en el medio de las dos variables. Un espacio es un carácter de texto (NdlT: se llama character en inglés, abreviado char para los amigos)." ] }, { "cell_type": "code", - "execution_count": 5, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "hello world\n" - ] - } - ], + "outputs": [], "source": [ "my_string = str_1 + ' ' + str_2\n", "print(my_string)" @@ -317,47 +280,25 @@ "source": [ "### Indexación\n", "\n", - "Podemos acceder a cada carácter de texto por separado en una cadena de texto (o incluso, un pedazo continuo de la misma) usando _índices_: enteros que denotan la posición del carácter en la cadena de texto. Los índices van entre corchetes, tocando el nombre de la variable de cadena a la derecha. Por ejemplo, para acceder al primer elemento de `new_string`, debemos ingresar` new_string[0] `. ¡Sí! en Python comenzamos a contar desde 0 (y hace mucho sentido)." + "Podemos acceder a cada carácter de texto por separado en una cadena de texto (o incluso, un pedazo continuo de la misma) usando _índices_: enteros que denotan la posición del carácter en la cadena de texto. Los índices van entre corchetes, tocando el nombre de la variable a la derecha. Por ejemplo, para acceder al primer elemento de `new_string`, debemos ingresar` new_string[0]`. ¡Sí! en Python comenzamos a contar desde 0 (y hace mucho sentido)." ] }, { "cell_type": "code", - "execution_count": 6, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "'h'" - ] - }, - "execution_count": 6, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "my_string[0]" ] }, { "cell_type": "code", - "execution_count": 7, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "'l'" - ] - }, - "execution_count": 7, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ - "#If we want the 3rd element we do:\n", + "#Si queremos el tercer elemento:\n", "my_string[2]" ] }, @@ -372,22 +313,11 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "'e'" - ] - }, - "execution_count": 8, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ - "my_string[1] #this is how we access the second element of a string" + "my_string[1] #así accedemos al segundo elemento del string" ] }, { @@ -396,25 +326,14 @@ "source": [ "¿Cómo sabemos el índice del último elemento en la cadena?\n", "\n", - "Python tiene una función incorporada llamada `len()` que proporciona la información sobre la longitud de un objeto. Vamos a intentarlo:" + "Python tiene una función incorporada llamada `len()` (abreviación de length, que significa largo o extensión en inglés) que proporciona la información sobre la longitud de un objeto:" ] }, { "cell_type": "code", - "execution_count": 9, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "11" - ] - }, - "execution_count": 9, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "len(my_string)" ] @@ -423,57 +342,34 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "¡Estupendo! Ahora sabemos que `my_string` tiene once caracteres. ¿Qué sucede si ingresamos este número como índice?" + "¡Estupendo! Ahora sabemos que `my_string` tiene diez caracteres. ¿Qué sucede si ingresamos este número como índice?" ] }, { "cell_type": "code", - "execution_count": 10, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "ename": "IndexError", - "evalue": "string index out of range", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mIndexError\u001b[0m Traceback (most recent call last)", - "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mmy_string\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m11\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", - "\u001b[0;31mIndexError\u001b[0m: string index out of range" - ] - } - ], + "outputs": [], "source": [ - "my_string[11]" + "my_string[10]" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "Oops. Tenemos un error: ¿por qué? La longitud de `my_string` es once. Pero el número entero 11 no funciona como un índice. Si esperabas obtener el último elemento, es porque olvidaste que Python comienza a contar desde cero. No te preocupes: lleva un tiempo acostumbrarse.\n", + "Oops. Tenemos un error: ¿por qué? La longitud de `my_string` es dies. Pero el número entero 10 no funciona como un índice. Si esperabas obtener el último elemento, es porque olvidaste que Python comienza a contar desde cero. No te preocupes: lleva un tiempo acostumbrarse.\n", "\n", - "El mensaje de error dice que el índice está fuera de rango: esto es porque el índice del _último elemento_ siempre será: `len (cadena) - 1`. En nuestro caso, ese número es 10. Probémoslo." + "El mensaje de error dice que el índice está fuera de rango: esto es porque el índice del _último elemento_ siempre será: `len (cadena) - 1`. En nuestro caso, ese número es 9. Probémoslo." ] }, { "cell_type": "code", - "execution_count": 11, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "'d'" - ] - }, - "execution_count": 11, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ - "my_string[10]" + "my_string[9]" ] }, { @@ -485,20 +381,9 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "'d'" - ] - }, - "execution_count": 12, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "my_string[-1]" ] @@ -512,20 +397,9 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "'l'" - ] - }, - "execution_count": 13, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "my_string[-2]" ] @@ -534,7 +408,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Esa es la última `l` en la cadena` hello world`. ¡Python es tan inteligente que puede contar hacia atrás!" + "Obtenemos la letra `d` del string `hola mundo`. ¡Python es tan inteligente que puede contar hacia atrás!" ] }, { @@ -543,63 +417,41 @@ "source": [ "### Cortar cadenas\n", "\n", - "A veces, queremos captar más de un elemento: es posible que deseemos una sección de la cadena. Lo hacemos utilizando la notación de _slicing_ (corte) entre corchetes. Para esto se usa `[start: end]`, donde `start` es el índice para comenzar el corte, y` end` es el índice (no incluido) para terminar el corte. Por ejemplo, para tomar la palabra `hello` de nuestra cadena, lo hacemos:" + "A veces, queremos obtener más de un elemento: es posible que deseemos una sección de la cadena. Lo hacemos utilizando la notación de _slicing_ (corte) entre corchetes. Para esto se usa `[inicio:fin]`, donde `inicio` es el índice para comenzar el corte, y `fin` es el índice (no incluido) para terminar el corte. Por ejemplo, para tomar la palabra `hola` de nuestra cadena utilizamos:" ] }, { "cell_type": "code", - "execution_count": 14, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "'hello'" - ] - }, - "execution_count": 14, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ - "my_string[0:5]" + "my_string[0:4]" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "Puede omitir el índice `start`, si desea cortar desde el principio de la cadena, y puede omitir el` end` de una porción, lo que indica que desea llegar hasta el final de la cadena. Por ejemplo, si queremos tomar la palabra `'world'` de ` my_string`, podríamos hacer lo siguiente:" + "Puedes omitir el índice `inicio` si desea cortar desde el principio de la cadena, y puedes omitir el `fin` si deseas llegar hasta el final de la cadena. Por ejemplo, si queremos tomar la palabra `'mundo'` de ` my_string`, podríamos hacer lo siguiente:" ] }, { "cell_type": "code", - "execution_count": 15, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "'world'" - ] - }, - "execution_count": 15, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ - "my_string[6:]" + "my_string[5:]" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "Una forma útil de visualizar segmentos es imaginar que los índices apuntan a los espacios _entre_ caracteres en la cadena. De esta forma, cuando escriba `my_string[i]`, se estaría refiriendo al \"carácter a la derecha de` i` \"(Referencia 2).\n", + "Una forma útil de visualizar segmentos es imaginar que los índices apuntan a los espacios _entre_ caracteres en la cadena. De esta forma, cuando escriba `my_string[i]`, se estaría refiriendo al \"carácter a la derecha de `i` \"(Referencia 2).\n", "\n", - "Mira el diagrama a continuación. Comenzamos a contar a cero; la letra `g` está a la derecha del índice 2. Entonces, si queremos obtener la subcadena `'gin'` de `'engineer'`, necesitamos `[start: end] = [2:5]`.\n", + "Mira el diagrama a continuación (NdlT: Engineer significa ingeniero en inglés). Comenzamos a contar a cero; la letra `g` está a la derecha del índice 2. Entonces, si queremos obtener la subcadena `'gin'` de `'engineer'`, necesitamos `[inicio:fin] = [2:5]`.\n", "\n", "" ] @@ -615,25 +467,14 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "'gin'" - ] - }, - "execution_count": 5, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ - "# Define your string\n", + "# Definir un string\n", "eng_string = 'engineer'\n", "\n", - "# Grab 'gin'slice\n", + "# Obtener el sub-string 'gin'\n", "eng_string[2:5] # O equivalentemente, eng_string[2:-3]" ] }, @@ -643,9 +484,9 @@ "source": [ "##### Ejercicios:\n", "\n", - "1. Defina una cadena de texto llamada `'banana'` e imprima la primera y última `'a'`.\n", - "2. Usando el mismo string, agarre las 2 combinaciones posibles que corresponden a la palabra \"ana\" e imprímalas.\n", - "3. Cree su propio ejercicio de slicing y pídales a sus compañeros que lo intenten (trabaje en grupos de 3)." + "1. Define una cadena de texto llamada `'banana'` e imprime la primera y última `'a'`.\n", + "2. Usando el mismo string, obtén las 2 combinaciones posibles que corresponden a la palabra \"ana\" e imprímalas.\n", + "3. Crea tu propio ejercicio de slicing y pídales a sus compañeros que lo intenten (trabajar en grupos de 3)." ] }, { @@ -656,7 +497,7 @@ " \n", "Ejercicio de solución 1:\n", "\n", - " b = 'banana' b = 'banana' \n", "\n", " print (b [1]) \n", "\n", @@ -676,52 +517,43 @@ "source": [ "### ¿Qué más podemos hacer con las cadenas?\n", "\n", - "Python tiene muchas funciones integradas útiles para cadenas. Aprenderás algunos de ellos en esta sección. Un detalle técnico: en Python, algunas funciones están asociadas a una clase particular de objetos (por ejemplo, cadenas de caracteres). La palabra **metodo** (method) se usa en este caso, y tenemos una nueva forma de llamarlos: el operador de punto. Es un poco contra-intuitivo que el nombre del método viene después del punto, mientras que el nombre del objeto en particular en el que actúa es lo primero. Así: `mystring.method ()`.\n", + "Python tiene muchas funciones útiles para cadenas. Aprenderás algunas de ellos en esta sección. Un detalle técnico: en Python, algunas funciones están asociadas a una clase particular de objetos (por ejemplo, strings). La palabra **método** (method) se usa en este caso, y tenemos una nueva forma de llamarlos: el operador de punto. Es un poco contra-intuitivo que el nombre del método viene después del punto, mientras que el nombre del objeto en particular en el que actúa es lo primero. Así, por ejemplo, tendríamos: `mystring.method ()`.\n", "\n", - "Si tiene curiosidad acerca de los muchos métodos disponibles para cadenas, vaya a la sección \"Métodos de cadena incorporados\" en este [tutorial](https://www.tutorialspoint.com/python3/python_strings.htm).\n", + "Si tiene curiosidad acerca de los muchos métodos disponibles para strings, vaya a la sección \"Métodos de strings incorporados\" en este [tutorial](https://www.tutorialspoint.com/python3/python_strings.htm).\n", "\n", - "Usemos una cita de Albert Einstein como un string y apliquemos algunos métodos de cadena útiles." + "Usaremos una cita de Albert Einstein como en un string y aplicaremos algunos métodos de cadena útiles para ejemplificar." ] }, { "cell_type": "code", - "execution_count": 9, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ - "# Todos son genios. Pero si juzgas a un pez por su habilidad de trepar un arbol, creera toda su vida que es un idiota.\n", - "AE_quote = \"Everybody is a genius. But if you judge a fish by its ability to climb a tree, it will live its whole life believing that it is stupid.\"" + "# Everybody is a genius. But if you judge a fish by its ability to climb a tree, \n", + "# it will live its whole life believing that it is stupid\n", + "\n", + "AE_quote = \"Todas las personas son genios. Pero si juzgas a un pez por su habilidad de trepar un árbol, creerá toda su vida que es un idiota.\"" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "El método **`count()`** retorna el número de ocurrencias de una subcadena en un rango. Los argumentos para el rango son opcionales.\n", + "El método **`count()`** retorna el número de ocurrencias de un substring determinado en un rango. Los argumentos para el rango son opcionales.\n", "\n", "*Sintaxis:*\n", "\n", - "`str.count (subcadena, inicio, fin)`\n", + "`str.count(substr, inicio, fin)`\n", "\n", - "Aquí, `start` y` end` son enteros que indican los índices donde comenzar y finalizar el conteo. Por ejemplo, si queremos saber cuántas letras ''e'' tenemos en toda la cadena, podemos hacer:" + "Aquí, `inicio` y `fin` son enteros que indican los índices donde comenzar y finalizar el conteo del string `substr`. Por ejemplo, si queremos saber cuántas letras `'e'` tenemos en toda la cadena, podemos hacer:" ] }, { "cell_type": "code", - "execution_count": 10, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "10" - ] - }, - "execution_count": 10, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "AE_quote.count('e')" ] @@ -730,27 +562,16 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Si queremos saber cuántos de esos `'e'` caracteres están en el rango `[0:20]`, hacemos:" + "Si queremos saber cuántos de esos carácteres `'e'` están en el rango `[0:20]`, hacemos:" ] }, { "cell_type": "code", - "execution_count": 11, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "2" - ] - }, - "execution_count": 11, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ - "AE_quote.count('e', 0, 20)" + "AE_quote.count('e', 0, 20) # O equivalentemente, AE_quote[:20].count('e')" ] }, { @@ -762,106 +583,80 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "1" - ] - }, - "execution_count": 12, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ - "AE_quote.count('Everybody')" + "AE_quote.count('Todas')" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "El método **find()** nos dice si una cadena `'substr'` ocurre en la cadena en la que estamos aplicando el método. Los argumentos para el rango son opcionales.\n", + "El método **find()** nos dice si un string `substr` ocurre en la cadena en la que estamos aplicando el método. Los argumentos para el rango son opcionales.\n", "\n", "*Sintaxis:*\n", "\n", - "`str.find (substr, start, end)`\n", + "`str.find (substr, inicio, fin)`\n", "\n", - "Donde `start` y` end` son índices que indican dónde comenzar y terminar el slicing para aplicar el método `find ()`.\n", + "Donde `inicio` y `fin` son índices que indican dónde comenzar y terminar el slicing para aplicar el método `find()`.\n", "\n", - "Si la cadena `'substr'` está en la cadena original, el método`find()`devolverá el índice donde comienza la subcadena, de lo contrario devolverá `-1`.\n", + "Si la cadena `substr` está en la cadena original, el método `find()` devolverá el índice donde comienza la subcadena, de lo contrario devolverá `-1`.\n", "\n", - "Por ejemplo, busquemos la palabra \"fish\" en la cita de Albert Einstein." + "Por ejemplo, busquemos la palabra `\"pez\"` en la cita de Albert Einstein." ] }, { "cell_type": "code", - "execution_count": 13, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "42" - ] - }, - "execution_count": 13, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ - "AE_quote.find('fish')" + "AE_quote.find('pez')" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "Si conocemos la longitud de nuestra subcadena, ahora podemos aplicar la notación de corte para hallar la palabra \"pez\"." + "Si conocemos la longitud (largo) del substring, ahora podemos aplicar la notación de corte para hallar la palabra `\"pez\"`." ] }, { "cell_type": "code", - "execution_count": 14, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "4" - ] - }, - "execution_count": 14, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ - "len('fish')" + "len('pez')" ] }, { "cell_type": "code", - "execution_count": 15, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "'fish'" - ] - }, - "execution_count": 15, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ - "AE_quote[42: 42 + len('fish')]" + "AE_quote[51: 51 + len('pez')]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "O equivalentemente" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "s = 'pez'\n", + "i = AE_quote.find(s)\n", + "AE_quote[i: i + len(s)]" ] }, { @@ -873,116 +668,73 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "-1" - ] - }, - "execution_count": 16, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ - "AE_quote.find('albert')" + "AE_quote.find('PEZ')" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "Devuelve `-1` ... pero cuidado, ¡eso no significa que la posición esté al final de la cadena original! Si leemos la [documentación](https://docs.python.org/3/library/stdtypes.html#string-methods), confirmamos que un valor devuelto de `-1` indica que la subcadena que estamos buscar _no está en la cadena_ en la que estamos buscando\n", + "Devuelve `-1` ... pero cuidado, ¡eso no significa que la posición esté al final de la cadena original! Si leemos la [documentación](https://docs.python.org/3/library/stdtypes.html#string-methods), confirmamos que un valor devuelto de `-1` indica que la subcadena que estamos buscar _no está en la cadena_ en la que estamos buscando.\n", "\n", "Un método similar es **`index()`**: funciona como el método `find()`, pero genera un error si no se encuentra la cadena que estamos buscando.\n", "\n", "*Sintaxis:*\n", "\n", - "`str.index (substr, start, end)`" + "`str.index (substr, start, end)`\n", + "\n", + "¡Por eso siempre es importante verificar la documentación!" ] }, { "cell_type": "code", - "execution_count": 25, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "42" - ] - }, - "execution_count": 25, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ - "AE_quote.index('fish')" + "AE_quote.index('pez')" ] }, { "cell_type": "code", - "execution_count": 26, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "ename": "ValueError", - "evalue": "substring not found", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mValueError\u001b[0m Traceback (most recent call last)", - "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mAE_quote\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mindex\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'albert'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", - "\u001b[0;31mValueError\u001b[0m: substring not found" - ] - } - ], + "outputs": [], "source": [ - "AE_quote.index('albert')" + "AE_quote.index('PEZ')" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "En el ejemplo anterior, usamos la función `len()` para calcular la longitud de la cadena `'fish'`, y usamos el resultado para calcular el índice final. Sin embargo, si la cadena es demasiado larga, tener una línea que calcule la longitud puede ser inconveniente o puede hacer que su código parezca desordenado. Para evitar esto, podemos usar los métodos `find()` o `index()` para calcular la posición final. En el ejemplo de \"pez\", podríamos buscar el índice de la palabra \"by\" (la palabra que sigue a \"pez\") y restar 1 de ese índice para obtener el índice que corresponde al espacio correcto después de `'fish'`. ¡Hay muchas formas de hacer slicing de cadenas de texto, sólo limitadas por tu imaginación!\n", + "En el ejemplo anterior, usamos la función `len()` para calcular la longitud de la cadena `'pez'`, y usamos el resultado para calcular el índice final. Sin embargo, si la cadena es demasiado larga, tener una línea que calcule la longitud puede ser inconveniente o puede hacer que su código parezca desordenado. Para evitar esto, podemos usar los métodos `find()` o `index()` para calcular la posición final. En el ejemplo de \"pez\", podríamos buscar el índice de la palabra \"por\" (la palabra que sigue a \"pez\") y restar 1 de ese índice para obtener el índice que corresponde al espacio correcto después de `'fish'`. ¡Hay muchas formas de hacer slicing de cadenas de texto, sólo limitadas por tu imaginación!\n", "\n", "##### Nota:\n", - "Recuerde que el índice final no es inclusivo, por lo que queremos el índice del espacio que sigue a la cadena `'fish'`." + "Recuerde que el índice final no es inclusivo, por lo que queremos el índice del espacio que sigue al string `'pez'`." ] }, { "cell_type": "code", - "execution_count": 17, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ - "idx_start = AE_quote.index('fish')\n", - "idx_end = AE_quote.index('by') - 1 # -1 to get the index off the space after 'fish'" + "idx_ini = AE_quote.index('pez')\n", + "idx_fin = AE_quote.index('por') - 1 # Se resta 1 para obtener el indice correcto del espacio después de pez." ] }, { "cell_type": "code", - "execution_count": 18, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "'fish'" - ] - }, - "execution_count": 18, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ - "AE_quote[idx_start:idx_end]" + "AE_quote[idx_ini:idx_fin]" ] }, { @@ -993,7 +745,7 @@ "\n", "1. Usa el método `count()` para contar cuántas letras '`a'` están en `AE_quote`?\n", "2. Usando el mismo método, ¿cuántas letras aisladas `'a'` están en `AE_quote`?\n", - "3. Usa el método `index ()` para encontrar la posición de las palabras `'genius'`,`' judge'` y `'tree'` en `AE_quote`.\n", + "3. Usa el método `index ()` para encontrar la posición de las palabras `'genio'`,`'juzgas'` y `'árbol'` en `AE_quote`.\n", "4. Con la sintaxis de corte, extrae las palabras del ejercicio 3 de `AE_quote`." ] }, @@ -1008,12 +760,12 @@ }, { "cell_type": "code", - "execution_count": 30, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ - "# Grandes mentes discuten sobre ideas; mentes promedio discuten sobre eventos; mentes pequeñas discuten sobre personas.\n", - "ER_quote = \" Great minds discuss ideas; average minds discuss events; small minds discuss people. \"" + "# Great minds discuss ideas; average minds discuss events; small minds discuss people.\n", + "ER_quote = \" Grandes mentes discuten sobre ideas; mentes promedio discuten sobre eventos; mentes pequeñas discuten sobre personas. \"" ] }, { @@ -1035,7 +787,7 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -1044,20 +796,9 @@ }, { "cell_type": "code", - "execution_count": 21, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "'Great minds discuss ideas; average minds discuss events; small minds discuss people.'" - ] - }, - "execution_count": 21, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "ER_quote" ] @@ -1075,20 +816,9 @@ }, { "cell_type": "code", - "execution_count": 22, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "'Great minds discuss ideas; average minds discuss events; small minds discuss people'" - ] - }, - "execution_count": 22, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "ER_quote.strip('.')" ] @@ -1102,20 +832,9 @@ }, { "cell_type": "code", - "execution_count": 23, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "'Great minds discuss ideas; average minds discuss events; small minds discuss people.'" - ] - }, - "execution_count": 23, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "ER_quote" ] @@ -1130,20 +849,9 @@ }, { "cell_type": "code", - "execution_count": 24, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "False" - ] - }, - "execution_count": 24, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "ER_quote.startswith('great')" ] @@ -1157,20 +865,9 @@ }, { "cell_type": "code", - "execution_count": 25, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "True" - ] - }, - "execution_count": 25, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "ER_quote.startswith('Great')" ] @@ -1184,20 +881,9 @@ }, { "cell_type": "code", - "execution_count": 26, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "True" - ] - }, - "execution_count": 26, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "ER_quote.startswith('Gre')" ] @@ -1215,34 +901,18 @@ }, { "cell_type": "code", - "execution_count": 27, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "['Everybody', 'is', 'a', 'genius.', 'But', 'if', 'you', 'judge', 'a', 'fish', 'by', 'its', 'ability', 'to', 'climb', 'a', 'tree,', 'it', 'will', 'live', 'its', 'whole', 'life', 'believing', 'that', 'it', 'is', 'stupid.']\n" - ] - } - ], + "outputs": [], "source": [ "print(AE_quote.split())" ] }, { "cell_type": "code", - "execution_count": 28, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "['Great', 'minds', 'discuss', 'ideas;', 'average', 'minds', 'discuss', 'events;', 'small', 'minds', 'discuss', 'people.']\n" - ] - } - ], + "outputs": [], "source": [ "print(ER_quote.split())" ] @@ -1256,17 +926,9 @@ }, { "cell_type": "code", - "execution_count": 29, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "['Great minds discuss ideas', ' average minds discuss events', ' small minds discuss people.']\n" - ] - } - ], + "outputs": [], "source": [ " print(ER_quote.split(';'))" ] @@ -1294,20 +956,9 @@ }, { "cell_type": "code", - "execution_count": 31, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "[1, 4, 7, 9]" - ] - }, - "execution_count": 31, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "# A list of integers \n", "[1, 4, 7, 9]" @@ -1315,20 +966,9 @@ }, { "cell_type": "code", - "execution_count": 32, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "['apple', 'banana', 'orange']" - ] - }, - "execution_count": 32, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "# A list of strings\n", "['apple', 'banana', 'orange']" @@ -1336,20 +976,9 @@ }, { "cell_type": "code", - "execution_count": 33, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "[2, 'apple', 4.5, [5, 10]]" - ] - }, - "execution_count": 33, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "# A list with different element types\n", "[2, 'apple', 4.5, [5, 10]]" @@ -1366,7 +995,7 @@ }, { "cell_type": "code", - "execution_count": 34, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -1376,41 +1005,25 @@ }, { "cell_type": "code", - "execution_count": 35, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[1, 2, 3, 4, 5]\n" - ] - } - ], + "outputs": [], "source": [ "print(integers)" ] }, { "cell_type": "code", - "execution_count": 36, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "['apple', 'banana', 'orange']\n" - ] - } - ], + "outputs": [], "source": [ "print(fruits)" ] }, { "cell_type": "code", - "execution_count": 37, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -1419,17 +1032,9 @@ }, { "cell_type": "code", - "execution_count": 38, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[[1, 2, 3, 4, 5], ['apple', 'banana', 'orange']]\n" - ] - } - ], + "outputs": [], "source": [ "print(new_list)" ] @@ -1443,20 +1048,9 @@ }, { "cell_type": "code", - "execution_count": 48, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "2" - ] - }, - "execution_count": 48, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "len(new_list)" ] @@ -1471,60 +1065,27 @@ }, { "cell_type": "code", - "execution_count": 39, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "[1, 2, 3, 4, 5]" - ] - }, - "execution_count": 39, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "new_list[0]" ] }, { "cell_type": "code", - "execution_count": 40, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "['apple', 'banana', 'orange']" - ] - }, - "execution_count": 40, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "new_list[1]" ] }, { "cell_type": "code", - "execution_count": 41, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "['apple', 'banana']" - ] - }, - "execution_count": 41, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "# Accessing the first two elements of the list fruits\n", "fruits[0:2]" @@ -1551,7 +1112,7 @@ }, { "cell_type": "code", - "execution_count": 42, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -1567,17 +1128,9 @@ }, { "cell_type": "code", - "execution_count": 43, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[1, 2, 3, 4, 5, 6]\n" - ] - } - ], + "outputs": [], "source": [ "print(integers)" ] @@ -1603,40 +1156,18 @@ }, { "cell_type": "code", - "execution_count": 54, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "False" - ] - }, - "execution_count": 54, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "'strawberry' in fruits" ] }, { "cell_type": "code", - "execution_count": 55, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "True" - ] - }, - "execution_count": 55, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "'strawberry' not in fruits" ] @@ -1671,7 +1202,7 @@ }, { "cell_type": "code", - "execution_count": 44, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -1687,40 +1218,18 @@ }, { "cell_type": "code", - "execution_count": 45, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "3" - ] - }, - "execution_count": 45, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "lista.index('4')" ] }, { "cell_type": "code", - "execution_count": 46, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "'4'" - ] - }, - "execution_count": 46, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "lista[3]" ] @@ -1734,7 +1243,7 @@ }, { "cell_type": "code", - "execution_count": 47, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -1743,40 +1252,18 @@ }, { "cell_type": "code", - "execution_count": 49, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "[1, 2, 3, 4, [5, 'six'], [7]]" - ] - }, - "execution_count": 49, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "lista" ] }, { "cell_type": "code", - "execution_count": 52, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "True" - ] - }, - "execution_count": 52, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "4 in lista" ] @@ -1800,7 +1287,7 @@ }, { "cell_type": "code", - "execution_count": 53, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -1816,41 +1303,18 @@ }, { "cell_type": "code", - "execution_count": 54, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "'.'" - ] - }, - "execution_count": 54, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "string[-1]" ] }, { "cell_type": "code", - "execution_count": 55, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "ename": "TypeError", - "evalue": "'str' object does not support item assignment", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)", - "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mstring\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m'!'\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", - "\u001b[0;31mTypeError\u001b[0m: 'str' object does not support item assignment" - ] - } - ], + "outputs": [], "source": [ "string[-1] = '!'" ] @@ -1897,21 +1361,9 @@ }, { "cell_type": "code", - "execution_count": 56, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Eat your apple\n", - "Eat your banana\n", - "Eat your orange\n", - "Eat your cherry\n", - "Eat your mandarin\n" - ] - } - ], + "outputs": [], "source": [ "fruits = ['apple', 'banana', 'orange', 'cherry', 'mandarin']\n", "\n", @@ -1953,17 +1405,9 @@ }, { "cell_type": "code", - "execution_count": 66, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "['Sam', 'Zoe', 'Naty', 'Gil', 'Tom']\n" - ] - } - ], + "outputs": [], "source": [ "names = ['sam', 'zoe', 'naty', 'gil', 'tom']\n", "\n", @@ -1998,10 +1442,8 @@ }, { "cell_type": "code", - "execution_count": 67, - "metadata": { - "collapsed": true - }, + "execution_count": null, + "metadata": {}, "outputs": [], "source": [ "fullnames = [ ['sam','jones'], ['zoe','smith'],['joe','cheek'],['tom','perez'] ]\n", @@ -2029,17 +1471,9 @@ }, { "cell_type": "code", - "execution_count": 57, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "a is bigger than b\n" - ] - } - ], + "outputs": [], "source": [ "a = 8 \n", "b = 3\n", @@ -2057,7 +1491,7 @@ }, { "cell_type": "code", - "execution_count": 58, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -2067,17 +1501,9 @@ }, { "cell_type": "code", - "execution_count": 59, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Your number is a multiple of 17.\n" - ] - } - ], + "outputs": [], "source": [ "if x % 17 == 0: \n", " print('Your number is a multiple of 17.')\n", @@ -2101,7 +1527,7 @@ }, { "cell_type": "code", - "execution_count": 62, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -2117,17 +1543,9 @@ }, { "cell_type": "code", - "execution_count": 63, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "a is smaller than b\n" - ] - } - ], + "outputs": [], "source": [ "a = 3\n", "b = 5\n", @@ -2162,9 +1580,9 @@ "source": [ "## Lo que hemos aprendido\n", "\n", - "* Cómo usar el entorno de Jupyter.\n", - "* Jugar con cadenas: acceder a valores, cortar y métodos de cadena.\n", - "* Jugar con listas: acceder a valores, cortar y enumerar métodos.\n", + "* Cómo usar el entorno de Jupyter y un notebook.\n", + "* Jugar con strings: acceder a valores, cortar (slicing) y métodos de strings.\n", + "* Jugar con listas: acceder a valores, cortar y enumerar métodos de listas.\n", "* Iteración con declaraciones `for`.\n", "* Condicionales con declaraciones `if`." ] @@ -2175,179 +1593,17 @@ "source": [ "## Referencias\n", "\n", - "1. [Conceptos básicos del cuaderno: editor modal](http://jupyter-notebook.readthedocs.io/en/latest/examples/Notebook/Notebook%20Basics.html)\n", - "2. [\"Índices de puntos entre los elementos\"](https://blog.nelhage.com/2015/08/indices-point-between-elements/) publicación de blog de Nelson Elhage (2015).\n", - "3. _Python para todos: explorando datos usando Python 3_ (2016). Charles R. Severance. [PDF disponible](http://do1.dr-chuck.com/pythonlearn/EN_us/pythonlearn.pdf)\n", - "4. _Piense en Python: cómo pensar como un científico de la computación_ (2012). Allen Downey. Green Tea Press. [PDF disponible](http://greenteapress.com/thinkpython/thinkpython.pdf)" - ] - }, - { - "cell_type": "code", - "execution_count": 64, - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "\n", - "\n", - "\n", - "\n", - "\n" - ], - "text/plain": [ - "" - ] - }, - "execution_count": 64, - "metadata": {}, - "output_type": "execute_result" - } - ], + "1. [Conceptos básicos del notebook: editor modal](http://jupyter-notebook.readthedocs.io/en/latest/examples/Notebook/Notebook%20Basics.html) (En inglés).\n", + "2. [\"Índices de puntos entre los elementos\"](https://blog.nelhage.com/2015/08/indices-point-between-elements/) publicación de blog de Nelson Elhage (2015, en inglés).\n", + "3. _Python para todos: explora datos usando Python 3_ (2016). Charles R. Severance. [PDF disponible](http://do1.dr-chuck.com/pythonlearn/EN_us/pythonlearn.pdf) (en inglés).\n", + "4. _Piense en Python: cómo pensar como un científico de la computación_ (2012). Allen Downey. Green Tea Press. [PDF disponible](http://greenteapress.com/thinkpython/thinkpython.pdf) (en inglés)." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "# Execute this cell to load the notebook's style sheet, then ignore it\n", "from IPython.core.display import HTML\n", diff --git a/notebooks_es/3_Ejemplo_con_MAEbulletin.ipynb b/notebooks_es/3_Jugando_con_archivo_de_cursos.ipynb similarity index 54% rename from notebooks_es/3_Ejemplo_con_MAEbulletin.ipynb rename to notebooks_es/3_Jugando_con_archivo_de_cursos.ipynb index 73c1c03..9360eb1 100644 --- a/notebooks_es/3_Ejemplo_con_MAEbulletin.ipynb +++ b/notebooks_es/3_Jugando_con_archivo_de_cursos.ipynb @@ -4,34 +4,31 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "###### Contenido bajo licencia Creative Commons Attribution CC-BY 4.0, código bajo licencia BSD 3-Clause © 2017 L.A. Barba, N.C. Clementi\n", - "\n", - "\n", - "TO DO: ¿Directorios? ¿Arriba? ¿Abajo? ¿Padre-hijo?" + "###### Contenido bajo licencia Creative Commons Attribution CC-BY 4.0, código bajo licencia BSD 3-Clause © 2017 L.A. Barba, N.C. Clementi" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "# Strings y listas en acción\n", + "# Jugando con archivo de cursos\n", "\n", - "Después de completar las lecciones [1 - Interactuando con Python](http://nbviewer.jupyter.org/github/engineersCode/EngComp1_offtheground/blob/master/notebooks_en/1_Interacting_with_Python.ipynb) y [2 - Strings y Listas](http://nbviewer.jupyter.org/github/engineersCode/EngComp1_offtheground/blob/master/notebooks_en/2_Jupyter_strings_and_lists.ipynb) de este curso en _\"Engineering Computations_\", en este notebook se desarrolla un ejemplo práctico y completo usando todo lo que has aprendido.\n", + "Después de completar las lecciones [1 - Interactuando con Python](./1_Interactuando_con_Python.ipynb) y [2 - Strings y listas en acción](2_Strings_y_listas_en_accion.ipynb) de este curso _\"Cálculos Computacionales en ingeniería\"_, en este notebook se desarrolla un ejemplo práctico y completo usando todo lo que has aprendido.\n", "\n", - "Quizás te estés preguntando por qué estamos dedicando las primeras lecciones del curso a jugar con strings y listas. _\"¡Los cálculos de ingeniería implican números, fórmulas y ecuaciones!\"_, estás pensando. La razón es que este curso no asume ninguna experiencia de programación, por lo que queremos que todos estén acostumbrados a Python primero, sin agregar la complejidad adicional de la utilización de números. La idea es familiarizarse primero con los reglas de la programación, aplicándolas a situaciones que no implican matemáticas ... ¡por ahora!" + "Quizás te preguntes por qué estamos dedicando las primeras lecciones del curso a jugar con strings y listas. _\"¡Ingeniería se trata de números, fórmulas y ecuaciones!\"_, puedes estar pensando. La razón es que este curso no asume ninguna experiencia de programación, por lo que buscamos que todos se acostumbren a Python, sin agregar la complejidad adicional de la utilización de números. La idea es familiarizarse primero con los reglas de la programación, aplicándolas a situaciones que no implican matemáticas... ¡al menos por ahora!" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "## Juega con el boletín MAE\n", + "## Jugando con el boletín MAE\n", "\n", - "Vamos a jugar con el texto de un archivo que contiene una copia del [MAE Bulletin](http://bulletin.gwu.edu/engineering-applied-science/mechanical-aerospace-engineering/#coursestext) para 2017-2018 (Nota de la traducción: El MAE Bulletin corresponde al detalle de los cursos dictados por la Universidad GSW en los periodos de invierno y otoño entre septiembre 2017 y agosto 2018). Crearemos diferentes listas para permitirnos ubicar el título, los créditos y la descripción de un curso en función del código del curso.\n", + "Vamos a jugar con el texto de un archivo que contiene una copia del [Boletín MAE](http://bulletin.gwu.edu/engineering-applied-science/mechanical-aerospace-engineering/#coursestext) para el año 2017-2018 (_Nota de la traducción: El Boletín MAE corresponde al detalle de los cursos dictados para Ingeniería Mecánica y Aeroespacial por la George Washington University, entre septiembre 2017 y agosto 2018_). Crearemos diferentes listas para ubicar el título, los créditos y la descripción de un curso en función del código del curso.\n", "\n", - "El archivo de datos para este ejemplo debe ubicarse en una carpeta llamada `data`, correspondientes a dos niveles anteriores a la ubicación de esta lección, si has copiado los materiales del curso tal como fueron almacenados. Si tienes los datos en otro lugar, deberás editar tu mismo la ruta según la ubicación correcta para el archivo.\n", + "El archivo de datos para este ejemplo se encuentra en una carpeta llamada `data`, que puedes encontrar en un nivel superior a la ubicación de esta lección, si has copiado los materiales del curso tal como fueron almacenados. Si tienes los datos en otro lugar, deberás editar tu mismo la ruta según la ubicación correcta para este archivo.\n", "\n", - "Comenzaremos leyendo el archivo de datos en el Jupyter notebook, luego limpiaremos un poco los datos y finalmente presentaremos algunas formas de interactuar con él." + "Comenzaremos leyendo el archivo de datos en el notebook de Jupyter, luego limpiaremos un poco los datos y finalmente interactuaremos con sus datos de varias maneras." ] }, { @@ -40,15 +37,15 @@ "source": [ "### Leer datos de un archivo\n", "\n", - "Tenemos un archivo de datos y nos gustaría leer su contenido en el Jupyter notebook. Por lo general, es una buena idea echar un vistazo primero al archivo, para ver cómo se ve su contenido. Esto también nos da la oportunidad de enseñarte un truco muy útil.\n", + "Nos gustaría leer el contenido de este archivo en el notebook de Jupyter. Por lo general, es una buena idea echar un vistazo primero al archivo, para ver cómo se ve su contenido. Esto también nos da la oportunidad de enseñarte un truco que te será muy útil.\n", "\n", - "Recuerde que las celdas de código en una computadora portátil Jupyter pueden manejar cualquier declaración válida **IPython**. Bueno, IPython es capaz de hacer algo más que solo Python: también puede ejecutar cualquier [comando del sistema](https://ipython.org/ipython-doc/3/interactive/reference.html#system-shell-access). Si conoce un poco de Unix, esto puede ser muy útil; por ejemplo, podría enumerar todos los archivos en el directorio de trabajo (su ubicación en el sistema de archivos de la computadora).\n", + "¿Recuerdas que las celdas de código en un notebook pueden manejar cualquier declaración válida de **IPython**?. Bueno, IPython es capaz de hacer algo más que sólo Python: también puede ejecutar cualquier [comando del sistema](https://ipython.org/ipython-doc/3/interactive/reference.html#system-shell-access). Si conoces un poco de Unix, esto te será muy útil; por ejemplo, podrías enumerar todos los archivos en el directorio de trabajo.\n", "\n", - "Para ejecutar un comando de sistema (a.k.a., shell), antepone `!` -un \"bang\" o signo de exclamación. El comando que necesitamos es `head`, que imprime las primeras líneas de un archivo.\n", + "Para ejecutar un comando de sistema (o comando de la shell), antepone `!` -un \"bang\" o signo de exclamación. El comando que necesitamos es `head`, que imprime las primeras líneas de un archivo.\n", "\n", - "Nuestra carpeta de datos se encuentra dos directorios arriba de las lecciones (este Jupyter noteboko): en Unix, ir a un directorio superior (padre) está indicado por dos puntos; así que necesitamos tener `../../ data/` antes del nombre del archivo, `mae_bulletin.txt`, como parte de la ruta.\n", + "Nuestra carpeta de datos se encuentra en un directorio superior al de los notebooks: en Unix, ir a un directorio superior se obtiene con 2 puntos seguidos ('..'). Así que necesitamos tener `../ data/` antes del nombre del archivo, `mae_bulletin.txt`, como parte de la ruta.\n", "\n", - "Llamemos `head` con un signo de exclamación:" + "Como ya se indicó, el comando `head` (que no es de python) puede utilizarse si se coloca antes un signo de exclamación:" ] }, { @@ -66,9 +63,119 @@ "source": [ "¡Se ve bien! El siguiente paso es abrir el archivo y guardar sus contenidos en una variable de Python que podamos usar.\n", "\n", - "La función **`open()`** con el nombre del archivo como un argumento _string_ (tenga en cuenta las comillas) devuelve un objeto de archivo Python. Tenemos varias opciones posibles, y definitivamente debes leer la [documentación](https://docs.python.org/2/tutorial/inputoutput.html#reading-and-writing-files) sobre cómo leer y escribir archivos.\n", + "La función **`open()`** se utiliza con el nombre del archivo indicado como un argumento _string_ (tenga en cuenta las comillas) y devuelve un objeto de archivo Python. Tenemos varias opciones posibles, y definitivamente es recomandable que leas la [documentación](https://docs.python.org/2/tutorial/inputoutput.html#reading-and-writing-files) sobre cómo leer y escribir archivos. Sin embargo, describiremos las principales opciones:\n", + "\n", + "**Método read**\n", + "\n", + "Si usas el método de archivo **`read()`**, obtendrás un único string (cadena de texto) con todos los contenidos del archivo. Este string tendrá todas las líneas, con los saltos de líneas indicadas por el carácter `\\n`." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "mae_bulletin_file = open('../data/mae_bulletin.txt')" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "mae_bulletin_text = mae_bulletin_file.read()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "type(mae_bulletin_text)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "len(mae_bulletin_text)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "print(mae_bulletin_text)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Método list**\n", "\n", - "Si usa el método de archivo **`read()`**, obtendrás un único string (cadena de texto) con todos los contenidos del archivo. Si utiliza el método **`readlines()`**, obtendrás una lista de strings, donde cada cadena de texto contiene una línea del archivo. Otra opción es usar la función **`list()`** para crear una lista de líneas a partir del contenido del archivo. ***<- No se explica bien. cual es la equivalencia?***" + "Otra opción es usar la función **`list()`** para crear una lista de líneas a partir del contenido del archivo." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "mae_bulletin_file = open('../data/mae_bulletin.txt')" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "mae_bulletin_text = list(mae_bulletin_file)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "type(mae_bulletin_text)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "len(mae_bulletin_text)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "print(mae_bulletin_text)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Método readlines**\n", + "\n", + "Lo más común es utilizar el método **`readlines()`**, con lo cual obtendrás una lista, donde cada elemento de esta lista es una string con una de las línea del archivo. El orden de la lista corresponde al orden de las líneas en el archivo como es esperable. " ] }, { @@ -107,17 +214,26 @@ "len(mae_bulletin_text)" ] }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "print(mae_bulletin_text)" + ] + }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Limpieza y organización de datos de texto\n", "\n", - "Al manipular datos de texto, una de las acciones más comunes es deshacerse de líneas y espacios en blanco innecesarios. En nuestro caso, eliminaremos los espacios al principio y al final de cada línea.\n", + "Al manipular datos de texto, una de las acciones más comunes es deshacerse de líneas innecesarias y espacios en blanco. En nuestro caso, eliminaremos los espacios al principio y al final de cada línea.\n", "\n", - "Ten en cuenta que también hay algunas líneas en blanco: las omitiremos. El objetivo es obtener dos listas nuevas: una con la línea de identificación del curso y otra con las descripciones de los cursos.\n", + "Ten en cuenta que también hay algunas líneas en blanco, que omitiremos. El objetivo es obtener dos listas nuevas: una con la identificación de cada curso y otra con la descripción de cada curso.\n", "\n", - "Estudia el siguiente bloque de código:" + "Considera el siguiente código:" ] }, { @@ -130,20 +246,20 @@ "descriptions = []\n", "\n", "for line in mae_bulletin_text:\n", - " line = line.strip() #Remove white spaces\n", - " if line == '': #Skip the empty lines \n", + " line = line.strip() #Eliminar los espacios en blanco\n", + " if line == '': #Saltarse las lineas en blanco \n", " continue\n", " elif line.startswith('MAE'): \n", - " courses.append(line) #Save lines that start with MAE in list\n", + " courses.append(line) #Guardar las lineas que comienzan con MAE en la lista de cursos\n", " else:\n", - " descriptions.append(line) #Save descriptions in other list" + " descriptions.append(line) #Guardar las líneas que NO comienzan con MAE en la lista de descripciones" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "Asegúrate de visitar la [documentación](https://docs.python.org/3/library/stdtypes.html#string-methods) para conocer los métodos de strings, para tener una idea de todas las cosas que pueden hacerse con Python. Aquí, usamos el método **`strip()` ** para deshacernos de los espacios iniciales y finales, y también usamos **`startswith()`** para identificar las líneas de identificación del curso.\n", + "Asegúrate de visitar la [documentación](https://docs.python.org/3/library/stdtypes.html#string-methods) para conocer los métodos de strings y tener una idea de todas las cosas que pueden hacerse con Python. Aquí, usamos el método **`strip()`** para deshacernos de los espacios iniciales y finales, y también usamos **`startswith()`** para saber si el string correspondía al código de un curso.\n", "\n", "Para verificar lo que hemos obtenido, sólo es necesario imprimir algunos elementos de cada lista:" ] @@ -189,9 +305,9 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "### Separa la lista de \"cursos\" en la identificación del curso, título y créditos\n", + "### Separa la lista de cursos en la identificación del curso, título y créditos\n", "\n", - "Es posible que deseemos tener la información de la identificación, título y créditos del curso en listas separadas. Una forma posible es la siguiente:" + "La lista `course` contiene strings con la información del código del curso, su título y cantidad de créditos, resultaría conveniente tener por separado. Una forma posible es la siguiente:" ] }, { @@ -215,7 +331,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Ten en cuenta que dividimos la información del curso utilizando el string ''. '' (punto + espacio) para evitar tener un espacio en blanco adicional al comienzo de cada cadena en las listas de títulos y créditos del curso.\n", + "Ten en cuenta que dividimos la información del curso utilizando el string `'. '` (punto + espacio) para evitar tener un espacio en blanco adicional al comienzo de cada cadena en las listas de títulos y créditos del curso. Otra forma de conseguir lo mismo sería dividir con sólo el punto y después utilizar `strip`.\n", "\n", "Imprimamos los primeros elementos de las nuevas listas." ] @@ -255,7 +371,7 @@ "\n", "Las listas que hemos creado están alineadas: cada elemento en la misma ubicación de índice corresponde al mismo curso. Al encontrar la ubicación (el índice) de un identificador de curso, podemos acceder a toda la otra información.\n", "\n", - "Usamos el método `index()` para encontrar el índice de un identificador de curso y rastrear el resto de la información. ¡Pruébalo!" + "Usamos el método `index()` para encontrar el índice de un identificador de curso y rastrear el resto de la información. ¡Inténtalo!" ] }, { @@ -273,10 +389,11 @@ "metadata": {}, "outputs": [], "source": [ - "print(course_id[17])\n", - "print(course_title[17])\n", - "print(course_credits[17])\n", - "print(descriptions[17])" + "n = course_id.index('MAE 3190')\n", + "print(course_id[n])\n", + "print(course_title[n])\n", + "print(course_credits[n])\n", + "print(descriptions[n])" ] }, { @@ -287,7 +404,7 @@ "\n", "Exploremos una nueva idea: podemos buscar todos los cursos que tengan requisitos previos usando una declaración `for`. En este caso, iteraremos sobre los _indices_ de los elementos en la lista `descriptions`.\n", "\n", - "Esto nos da la oportunidad de presentar un objeto (***METODO??***) Python muy útil: **`range`**: crea una secuencia de números en la progresión aritmética para iterar. Con un único argumento, `range(N)` creará una secuencia de longitud `N` comenzando en cero:` 0, 1, 2, ..., N-1`." + "Esto nos da la oportunidad de presentar un objeto de Python muy útil: **`range`**: crea una secuencia de números en la progresión aritmética que permite iterar. Con un único argumento, `range(N)` creará una secuencia de longitud `N` comenzando en cero:` 0, 1, 2, ..., N-1`." ] }, { @@ -304,11 +421,11 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Un detalle interesante del método `range` es que se crea sobre la marcha, al iterar sobre él. No es realmente una lista, aunque para la mayoría de los propósitos prácticos, se comporta como tal.\n", + "Un detalle interesante del método `range` es que se crea sobre la marcha, al iterar sobre él. No es realmente una lista, aunque para la mayoría de los propósitos prácticos se comportará como una lista.\n", "\n", "Una forma típica de usarlo es con un argumento que sale de la función `len ()`. \n", "\n", - "Analiza el siguiente bloque de código:" + "Observa el siguiente bloque de código:" ] }, { @@ -319,9 +436,9 @@ "source": [ "course_with_pre = []\n", "\n", - "for i in range(len(descriptions)):\n", - " if 'Prerequisite' in descriptions[i]:\n", - " course_with_pre.append(course_id[i])" + "for i in range(len(descriptions)): #La variable i tomará los valores 0, 1, ..., 318\n", + " if 'Prerequisite' in descriptions[i]: #Se verá si el elemento i-esimo de la lista contiene 'Prerequisite'\n", + " course_with_pre.append(course_id[i]) #Se almacenará en la lista si se cumple el condicional" ] }, { @@ -350,6 +467,19 @@ "2. Utilizando una declaración `for` y declaraciones` if-elif-else`, separa los cursos que se ofrecen en el semestre de otoño, los ofrecidos en el semestre de primavera, los que se ofrecen en ambos semestres y los que no especifican un semestre. Crea 4 listas: `fall_and_spring`,` fall`, `spring` y` not_spec`." ] }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "#Anota tu respuesta acá\n", + "course_with_cor = []\n", + "fall_and_spring = []\n", + "fall = []\n", + "not_spec = []" + ] + }, { "cell_type": "markdown", "metadata": {}, @@ -383,7 +513,7 @@ "## Lo que hemos aprendido\n", "\n", "* Los comandos del sistema en una celda de código comienzan con un bang o exclamación (`!`).\n", - "* Abrir un archivo de texto y guardar su contenido en una cadena o lista de variables.\n", + "* Abrir un archivo de texto y guardar su contenido en un string o una lista de strings.\n", "* Limpiar datos de texto usando métodos de cadena.\n", "* Manipular texto en listas." ] diff --git a/notebooks_es/4_Conociendo_arrays_y_graficos.ipynb b/notebooks_es/4_Conociendo_arrays_y_graficos.ipynb new file mode 100644 index 0000000..5d76349 --- /dev/null +++ b/notebooks_es/4_Conociendo_arrays_y_graficos.ipynb @@ -0,0 +1,1042 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "###### Contenido bajo licencia Creative Commons Attribution CC-BY 4.0, código bajo licencia BSD 3-Clause © 2017 L.A. Barba, N.C. Clementi" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Conociendo arrays y gráficos\n", + "\n", + "Bienvenido a la **Lección 4** del primer módulo del curso _\"Cálculos Computacionales en ingeniería\"_. ¡Ya has recorrido un largo camino!\n", + "\n", + "Recuerda, este curso no asume ninguna experiencia de programación por lo que las tres primeras lecciones se centraron en crear una base con construcciones de programación de Python sin utilizar Matemáticas. Las lecciones anteriores son:\n", + "\n", + "* [Lección 1](./1_Interactuando_con_Python.ipynb): Interactuando con Python\n", + "* [Lección 2](./2_Strings_y_listas_en_accion.ipynb): String y listas en acción.\n", + "* [Lección 3](./3_Jugando_con_archivo_de_cursos.ipynb): Jugando con archivo de cursos.\n", + "\n", + "En la mayoría de las necesidades informáticas en ingeniería es conveniente el uso de *arrays*: secuencias de datos del mismo tipo. Se comportan como listas, a excepción de la restricción en el tipo de sus elementos. Hay una gran ventaja de eficiencia cuando sabes que todos los elementos de una secuencia son del mismo tipo, por lo que los métodos equivalentes de arrays se ejecutan mucho más rápido que los de las listas (*Nota de la traducción*: arrays y matrices son distintos tipos en python, por lo que se utilizará la palabra arrays sin traducirla).\n", + "\n", + "El lenguaje Python se extiende con la utilización de **librerías** o bibliotecas. La librería más importante en ciencia e ingeniería es **NumPy**, que proporciona la estructura de datos _array n-dimensional_ (llamado `ndarray`) y una gran cantidad de funciones, operaciones y algoritmos para cálculos de álgebra lineal extremadamente eficientes.\n", + "\n", + "En esta lección, comenzarás a jugar con arrays de NumPy y descubrirás su poder. También se encontrará con la librería **Matplotlib**, muy apreciada para crear gráficos bidimensionales de datos." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Importando librerías\n", + "\n", + "Primero, algunos consejos sobre al importar librerías para expandir Python. Debido a que las librerías son grandes colecciones de código y son para fines especiales, no se cargan automáticamente al iniciar Python (o IPython, o Jupyter). Tienes que importar una librería usando el comando `import`. Por ejemplo, para importar **NumPy** y recibir todos los beneficios del álgebra lineal, ingresamos:\n", + "\n", + "```python\n", + "import numpy\n", + "```\n", + "\n", + "Una vez que se ejecuta ese comando en una celda de código, puedes llamar a cualquier función de NumPy usando la notación de puntos, anteponiendo el nombre de la librería. Por ejemplo, algunas funciones comúnmente usadas son:\n", + "\n", + "* [`numpy.linspace()`](https://docs.scipy.org/doc/numpy/reference/generated/numpy.linspace.html)\n", + "* [`numpy.ones()`](https://docs.scipy.org/doc/numpy/reference/generated/numpy.ones.html#numpy.ones)\n", + "* [`numpy.zeros()`](https://docs.scipy.org/doc/numpy/reference/generated/numpy.zeros.html#numpy.zeros)\n", + "* [`numpy.empty()`](https://docs.scipy.org/doc/numpy/reference/generated/numpy.empty.html#numpy.empty)\n", + "* [`numpy.copy()`](https://docs.scipy.org/doc/numpy/reference/generated/numpy.copy.html#numpy.copy)\n", + "\n", + "Los enlaces anteriores te llevarán a la documentación de estas útiles funciones de NumPy." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "##### Advertencia:\n", + "\n", + "Encontrará gran variedad de código en internet con distintas sintaxis para importar librerías. Algunos usarán:\n", + "```python\n", + "import numpy como np\n", + "```\n", + "\n", + "Lo anterior crea un alias para `numpy` con la cadena más corta `np`, por lo que llamaría a una función **NumPy** de esta manera: `np.linspace()`. Esta es sólo una forma alternativa de hacerlo, para personas que les resulta demasiado largo escribir `numpy` y quieren evitar escribir 3 caracteres cada vez. En estos notebooks escribiremos `numpy` porque nos parece más legible y hermoso. Por lo tanto, usaremos simplemente:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Creando arrays\n", + "\n", + "Para crear un array de NumPy a partir de una lista existente de números homogéneos, llamamos **`numpy.array ()`**, así:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "numpy.array([3, 5, 8, 17])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "NumPy ofrece muchas [formas de crear arrays](https://docs.scipy.org/doc/numpy/reference/routines.array-creation.html#routines-array-creation) además de lo anterior. Ya hemos mencionado algunos de ellos anteriomente en el notebook.\n", + "\n", + "Juega con `numpy.ones ()` y `numpy.zeros ()`: estas funciones permiten crear arrays llenos de unos y ceros, respectivamente. Pasamos como argumento la cantidad de elementos del array que queremos obtener." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "numpy.ones(5)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "numpy.zeros(3)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Otra función útil: `numpy.arange ()`, nos regresa un array de valores espaciados uniformemente en un intervalo definido. Es el equivalente de la función range pero en su versión rápida de Numpy.\n", + "\n", + "*Sintaxis:*\n", + "\n", + "`numpy.arange(start, end, step)`\n", + "\n", + "donde `start` (inicio) por defecto es cero, `stop` (fin) no se incluye, y el valor predeterminado\n", + "para `step` (el paso) es 1. ¡Te aconsejamos jugar con algunos valores para acostumbrarte!" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "numpy.arange(4)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "numpy.arange(2, 6)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "numpy.arange(2, 6, 2)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "numpy.arange(2, 6, 0.5)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "La funcion `numpy.linspace()` es similar a `numpy.arange()`, pero permite que digas el número de elementos a obtener en lugar del un tamaño de paso. Devuelve un array con números espaciados uniformemente durante el intervalo especificado.\n", + "\n", + "*Sintaxis:*\n", + "\n", + "`numpy.linspace(start, stop, num)`\n", + "\n", + "`stop` está incluido por defecto (se puede eliminar, como indica la documentación), y ` num` de forma predeterminada es 50." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "numpy.linspace(2.0, 3.0)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "len(numpy.linspace(2.0, 3.0))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "numpy.linspace(2.0, 3.0, 6)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "numpy.linspace(-1, 1, 9)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Operaciones de arrays\n", + "\n", + "Creemos algunas variables de tipo array para poder realizar algunas operaciones con ellos." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "x_array = numpy.linspace(-1, 1, 9)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "collapsed": true + }, + "source": [ + "Ahora que lo hemos guardado como una variable, podemos hacer algunos cálculos con el array. Por ejemplo, aplicar el cuadrado a cada elemento del array (¡de una sola vez!):" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "y_array = x_array**2\n", + "print(y_array)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "También podemos tomar la raíz cuadrada de un array de valores positivos, usando la función `numpy.sqrt()`:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "z_array = numpy.sqrt(y_array)\n", + "print(z_array)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Ahora que tenemos dos arrays diferentes `x_array`, ` y_array` y `z_array`, podemos hacer más cálculos, como sumarlos o multiplicarlos. Por ejemplo:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "add_array = x_array + y_array \n", + "print(add_array)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "La adición de arrays se define elemento a elemento (en inglés, esto se dice element-wise). La multiplicación de arrays también se realiza elemento a elemento:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "mult_array = x_array * z_array\n", + "print(mult_array)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "También podemos dividir arrays, pero debes tener cuidado de no dividir por cero. Esta operación dará como resultado **`nan`** que significa *Not a Number* (No un Número). Python todavía realizará la división, pero nos contará sobre el problema.\n", + "\n", + "Veamos cómo se vería esa situación:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "x_array / y_array" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Arrays multidimensionales\n", + "\n", + "### Arrays 2D\n", + "\n", + "NumPy puede crear arrays de N dimensiones. Por ejemplo, un array 2D es como una matriz de Matemática, y se crea a partir de una lista anidada de la siguiente manera:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "array_2d = numpy.array([[1, 2], [3, 4]])\n", + "print(array_2d)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Los arrays 2D se pueden sumar, restar y multiplicar:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "X = numpy.array([[1, 2], [3, 4]])\n", + "Y = numpy.array([[1, -1], [0, 1]])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "La adición de estos dos arrays funciona exactamente como era de esperar:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "X + Y" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "¿Qué pasa si tratamos de multiplicar arrays utilizando el operador `'*'`?" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "X * Y" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "La multiplicación usando el operador `'*'` es elemento a elemento. Si queremos hacer una multiplicación matricial usamos el operador `'@'`:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "X @ Y" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "O de manera equivalente, podemos usar `numpy.dot ()`:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "numpy.dot(X, Y)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Arrays 3D\n", + "\n", + "Vamos a crear un array 3D a partir de un array 1D. Podemos usar [`numpy.reshape()`](https://docs.scipy.org/doc/numpy/reference/generated/numpy.reshape.html), donde pasamos el array que queremos reacomodar y la forma queremos obtener, es decir, la cantidad de elementos en cada dimensión.\n", + "\n", + "*Sintaxis*\n", + " \n", + "`numpy.reshape(array, newshape)`\n", + "\n", + "Por ejemplo:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "a = numpy.arange(24)\n", + "print(a)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "a_3D = numpy.reshape(a, (2, 3, 4))\n", + "print(a_3D)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Podemos verificar la forma de un array de NumPy usando la función `numpy.shape ()`:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "numpy.shape(a_3D)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Visualizar las dimensiones del array `a_3D` puede ser complicado, así que proporcionamos un diagrama que lo ayudará a comprender cómo se asignan las dimensiones. Cada dimensión se muestra como un eje de coordenadas. Para un array 3D, en el \"eje x\", tenemos los sub-array que son bidimensionales. Tenemos dos de estos sub-array 2D, en este caso; cada uno tiene 3 filas y 4 columnas. Estudie este boceto cuidadosamente, mientras compara con la forma en que se imprime el array `a_3D`.\n", + "\n", + "" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "collapsed": true + }, + "source": [ + "Cuando tenemos arrays multidimensionales, podemos acceder a secciones de sus elementos realizando slicing en cada dimensión. Esta es una de las ventajas del uso de arrays; no podemos hacer esto con listas.\n", + "\n", + "Accedamos a algunos elementos del array 2D que llamamos `X`." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "X" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Tomar el primer elemento en la primera fila y la primera columna\n", + "X[0, 0]" + ] + }, + { + "cell_type": "code", + "execution_count": 88, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "2" + ] + }, + "execution_count": 88, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Tomar el elemento de la primera fila y segunda columna\n", + "X[0, 1]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "##### Ejercicios:\n", + "\n", + "Del array X:\n", + "\n", + "1. Coge el segundo elemento en la primera columna.\n", + "2. Coge el segundo elemento en la segunda columna." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Juega con algunos cortes (slicing) de este array:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Tomar la primera columna\n", + "X[:, 0]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Cuando no especificamos el punto inicial y/o final en el slicing, el símbolo `':'` significa \"todo\". En el ejemplo anterior, le estamos diciendo a NumPy que queremos todos los elementos del índice 0 en la segunda dimensión (la primera columna)." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Tomar la primera fila\n", + "X[0, :]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "##### Ejercicios:\n", + "\n", + "Del array X:\n", + "\n", + "1. Coge la segunda columna.\n", + "2. Coge la segunda fila." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Practiquemos con el array 3D." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "a_3D" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Si queremos tomar la primera columna de los arrays bidimensionales de nuestro array `a_3D`, debemos hacer:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "a_3D[:, :, 0]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "La línea de arriba le está diciendo a NumPy:\n", + "\n", + "* El primer `':'`: en la primera dimensión queremos tomar todos los elementos (2 arrays).\n", + "* El segundo `':'`: desde la segunda dimensión queremos tomar todos los elementos (todas las filas).\n", + "* El `'0'`: desde la tercera dimensión queremos tomar el primer elemento (primera columna).\n", + "\n", + "Si queremos los primeros 2 elementos de la primera columna de ambos arrays:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "a_3D[:, 0:2, 0]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "A continuación, desde el primer array bidimensional de nuestro array `a_3D`, tomaremos los dos elementos intermedios de la segunda fila:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "a_3D[0, 1, 1:3]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "##### Ejercicios:\n", + "\n", + "Del array llamada `a_3D`:\n", + "\n", + "1. Toma los dos elementos del medio (es decir, 17 y 18) del segundo array.\n", + "2. Coge la última fila de ambos arrays.\n", + "3. Tome los elementos del primer array bidimensional que excluyen la primera fila y la primera columna.\n", + "4. Tome los elementos del segundo array bidimensional que excluyen la última fila y la última columna." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## NumPy es rápido y limpio\n", + "\n", + "Cuando trabajamos con números, los arrays son la mejor opción porque la librería NumPy tiene funciones que están optimizadas y, por lo tanto, son más rápidas que las de Python. Esto es especialmente cierto si tenemos arrays grandes. Además, usar arrays de NumPy y sus propiedades hace que nuestro código sea más legible.\n", + "\n", + "Por ejemplo, si quisiéramos sumar 2 listas de python elemento a elemento, necesitaríamos hacerlo con una declaración `for`. Si queremos agregar dos arrays de NumPy, simplemente usamos el símbolo de suma `'+'`.\n", + "\n", + "Para ilustrar lo anterior, sumaremos dos listas y dos arrays (con elementos aleatorios) y compararemos el tiempo que requiere cada suma." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Suma de elementos de una lista de Python\n", + "\n", + "Usando la librería de Python [`random`](https://docs.python.org/3/library/random.html) generaremos dos listas con 100 elementos pseudoaleatorios en el rango [0,100), sin números repetido." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "#Importar la librería random\n", + "import random" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "#Generar 2 listas de enteros con 100 elementos\n", + "lst_1 = random.sample(range(100), 100)\n", + "lst_2 = random.sample(range(100), 100)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "#Imprimir los primeros 10 elementos\n", + "print(lst_1[0:10])\n", + "print(lst_2[0:10])" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Verificar el tipo de las variables\n", + "print(type(lst_1))\n", + "print(type(lst_2))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Necesitamos escribir una declaración `for`, añadiendo el resultado de la suma de elementos a una nueva lista que llamamos `result_lst`.\n", + "\n", + "Para contabilizar el tiempo, podemos usar el comando \"mágico\" de IPython `%% time`. Escribiendo al comienzo de la celda de código, el comando `%%time` nos dará el tiempo que lleva ejecutar todo el código en esa celda." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "%%time\n", + "res_lst = []\n", + "for i in range(100):\n", + " res_lst.append(lst_1[i] + lst_2[i])" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "print(res_lst[0:10])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Suma de arrays en NumPy\n", + "\n", + "En este caso, generamos arrays con enteros aleatorios usando una función especial de NumPy: [`numpy.random.randint ()`](https://docs.scipy.org/doc/numpy-1.13.0/reference/generated/numpy. random.randint.html). Los arrays que generamos con esta función no serán como las listas: en este caso, tendremos 100 elementos en el rango [0, 100) pero pueden repetirse.\n", + "\n", + "Nuestro objetivo es comparar el tiempo que lleva calcular la suma de los elementos de una lista, de modo que todo lo que importa es que los arrays y las listas son de la misma longitud y tipo (enteros)." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "arr_1 = numpy.random.randint(0, 100, size=100)\n", + "arr_2 = numpy.random.randint(0, 100, size=100)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "#print first 10 elements\n", + "print(arr_1[0:10])\n", + "print(arr_2[0:10])" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Verificar el tipo de las variables\n", + "print(type(arr_1))\n", + "print(type(arr_2))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Ahora podemos usar la magia de la celda `%% time`, nuevamente, para ver cuánto tarda NumPy en calcular la suma de elementos." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "%%time\n", + "arr_res = arr_1 + arr_2" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Ten en cuenta que en el caso de los arrays, el código no solo es más legible (sólo una línea de código), sino que también es más rápido que con las listas. Esta vez, la ventaja será mayor con arrays y listas más grandes.\n", + "\n", + "Tus mediciones de tiempo pueden variar a los que mostramos en este notebook, porque estará calculándolos en una máquina diferente." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "##### Ejercicio\n", + "\n", + "1. Repite la comparación entre listas y arrays, usando arrays más grandes; por ejemplo de tamaño 10,000.\n", + "2. Repite el análisis, pero ahora en lugar de sumar realiza la operación que eleva cada elemento de un array/lista a la potencia dos. Usa arrays de 10,000 elementos." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Tiempo de Graficar\n", + "\n", + "¡Te encantará la librería **Matplotlib**! Aprenderás a continuación sobre el módulo `pyplot`, que hace gráficos de líneas.\n", + "\n", + "Necesitamos algunos datos para graficar. Definiramos un array NumPy, para luego calcular su cuadrado, cubo y raíz cuadrada, elemento a elemento. Graficaremos estos valores con el array original en el eje x." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "#Crear el array base\n", + "xarray = numpy.linspace(0, 2, 41)\n", + "print(xarray)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "#Generar los arrays a graficar\n", + "pow2 = xarray**2\n", + "pow3 = xarray**3\n", + "pow_half = numpy.sqrt(xarray)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Para graficar los arrays resultantes como una función de la original (`xarray`) en el eje x, necesitamos importar el módulo `pyplot` de **Matplotlib**." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from matplotlib import pyplot\n", + "%matplotlib inline" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "El comando `%matplotlib inline` permite obtener nuestros gráficos dentro del notebook (en lugar de una ventana emergente, que es el comportamiento predeterminado de `pyplot` para jupyter).\n", + "\n", + "Utilizaremos la función `pyplot.plot()`, especificando el color de línea (`'k'` para negro) y el estilo de línea (`' -'`, `'-'` y `':'` para línea continua, punteada y punteada), y dando a cada línea una etiqueta. Tenga en cuenta que los valores para `color` (color),` linestyle` (tipo de línea) y `label` (etiqueta) deben darse entre comillas." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "#Plot x^2\n", + "pyplot.plot(xarray, pow2, color='k', linestyle='-', label='square')\n", + "#Plot x^3\n", + "pyplot.plot(xarray, pow3, color='k', linestyle='--', label='cube')\n", + "#Plot sqrt(x)\n", + "pyplot.plot(xarray, pow_half, color='k', linestyle=':', label='square root')\n", + "#Plot the legends in the best location\n", + "pyplot.legend(loc='best')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Para ilustrar otras características de Matplotlib, trazaremos los mismos datos, pero variando los colores en lugar del estilo de línea. También usaremos la sintaxis LaTeX para escribir fórmulas en las etiquetas. Si deseas obtener más información sobre la sintaxis de LaTeX, hay una [guía rápida de LaTeX, en inglés](https://users.dickinson.edu/~richesod/latex/latexcheatsheet.pdf) disponible en línea.\n", + "\n", + "Agregar un punto y coma (`';'`) a la última línea del bloque de código de trazado evitar que se imprima `` junto al gráfico." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "#Plot x^2\n", + "pyplot.plot(xarray, pow2, color='red', linestyle='-', label='$x^2$')\n", + "#Plot x^3\n", + "pyplot.plot(xarray, pow3, color='green', linestyle='-', label='$x^3$')\n", + "#Plot sqrt(x)\n", + "pyplot.plot(xarray, pow_half, color='blue', linestyle='-', label='$\\sqrt{x}$')\n", + "#Plot the legends in the best location\n", + "pyplot.legend(loc='best'); " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "¿No es increíble? Esperamos que ahora estés imaginando todo lo que puedes hacer con los notebooks de Jupyter, Python y sus librerías científicas **NumPy** y **Matplotlib**. \n", + "\n", + "Acabamos de realizar una introducción a los gráficos, pero seguiremos aprendiendo sobre el poder de **Matplotlib** en la próxima lección.\n", + "\n", + "Si tienes curiosidad, puedes explorar muchos gráficos increíbles en la [galería de ejemplos de Matplotlib](http://matplotlib.org/gallery.html)." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "##### Ejercicio:\n", + "\n", + "Elige dos operaciones diferentes para aplicar a `xarray` y realiza la operación de manera directa en el mismo gráfico." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Lo que hemos aprendido\n", + "\n", + "* Cómo importar librerías\n", + "* Arrays multidimensionales usando NumPy\n", + "* Acceder a valores y slicing en arrays de NumPy\n", + "* Usar `%%time` para cronometrar la ejecución de la celda.\n", + "* Comparar rendimientos: listas versus arrays\n", + "* Grafico básico con `pyplot` de Matplotlib." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Referencias\n", + "\n", + "1. _Effective Computation in Physics: Field Guide to Research with Python_ (Computación efectiva en Física, Guía práctica para investigación con Python, 2015). Anthony Scopatz & Kathryn D. Huff. O'Reilly Media, Inc.\n", + "\n", + "2. _Numerical Python: A Practical Techniques Approach for Industry_. (Python Numérico: Técnicas Prácticas para la Industria, 2015). Robert Johansson. Appress. \n", + "\n", + "2. [\"The world of Jupyter\"—a tutorial](https://github.com/barbagroup/jupyter-tutorial) (El mundo de Jupyter-un tutorial, 2016). Lorena A. Barba." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Execute this cell to load the notebook's style sheet, then ignore it\n", + "from IPython.core.display import HTML\n", + "css_file = '../style/custom.css'\n", + "HTML(open(css_file, \"r\").read())" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.5.2" + }, + "widgets": { + "state": {}, + "version": "1.1.2" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/notebooks_es/4_NumPy_Arrays_y_Graficos.ipynb b/notebooks_es/4_NumPy_Arrays_y_Graficos.ipynb deleted file mode 100644 index 3704de7..0000000 --- a/notebooks_es/4_NumPy_Arrays_y_Graficos.ipynb +++ /dev/null @@ -1,1639 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "###### Contenido bajo licencia Creative Commons Attribution CC-BY 4.0, código bajo licencia BSD 3-Clause © 2017 L.A. Barba, N.C. Clementi" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Jugando con matrices NumPy\n", - "\n", - "Bienvenido a la **Lección 4** del primer módulo de curso en _\"Computaciones de ingeniería_\". ¡Ya has recorrido un largo camino!\n", - "\n", - "Recuerda, este curso no asume ninguna experiencia de programación, por lo que las tres primeras lecciones se centraron en crear una base con construcciones de programación de Python utilizando esencialmente _no mathematics_. Las lecciones anteriores son:\n", - "\n", - "* [Lección 1](http://nbviewer.jupyter.org/github/engineersCode/EngComp1_offtheground/blob/master/notebooks_en/1_Interacting_with_Python.ipynb): Interactuando con Python\n", - "* [Lección 2](http://nbviewer.jupyter.org/github/engineersCode/EngComp1_offtheground/blob/master/notebooks_en/2_Jupyter_strings_and_lists.ipynb): Juega con los datos en Jupyter\n", - "* [Lección 3](http://nbviewer.jupyter.org/github/engineersCode/EngComp1_offtheground/blob/master/notebooks_en/3_Example_play_with_MAEbulletin.ipynb): Cadenas y listas en acción\n", - "\n", - "En aplicaciones de ingeniería, la mayoría de las situaciones informáticas se benefician del uso de *arrays*: son secuencias de datos del mismo tipo. Se comportan como listas, a excepción de la restricción en el tipo de sus elementos. Hay una gran ventaja de eficiencia cuando sabes que todos los elementos de una secuencia son del mismo tipo, por lo que los métodos equivalentes para las matrices se ejecutan mucho más rápido que los de las listas.\n", - "\n", - "El lenguaje Python se amplía para aplicaciones especiales, como la informática científica, con ** libraries **. La biblioteca más importante en ciencia e ingeniería es ** NumPy **, que proporciona la estructura de datos _n-dimensional array_ (a.k.a, `ndarray`) y una gran cantidad de funciones, operaciones y algoritmos para cálculos de álgebra lineal eficientes.\n", - "\n", - "En esta lección, comenzarás a jugar con matrices NumPy y descubrirás su poder. También se encontrará con otra biblioteca muy apreciada: ** Matplotlib **, para crear gráficos bidimensionales de datos." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Importación de librerías\n", - "\n", - "Primero, una palabra sobre la importación de bibliotecas para expandir la sesión en ejecución de Python. Debido a que las bibliotecas son grandes colecciones de código y son para fines especiales, no se cargan automáticamente al iniciar Python (o IPython, o Jupyter). Tienes que importar una biblioteca usando el comando `import`. Por ejemplo, para importar ** NumPy **, con todas sus bondades de álgebra lineal, ingresamos:\n", - "\n", - "```python\n", - "importar numpy\n", - "```\n", - "\n", - "Una vez que ejecutas ese comando en una celda de código, puedes llamar a cualquier función de NumPy usando la notación de puntos, anteponiendo el nombre de la biblioteca. Por ejemplo, algunas funciones comúnmente usadas son:\n", - "\n", - "* [`numpy.linspace ()`](https://docs.scipy.org/doc/numpy/reference/generated/numpy.linspace.html)\n", - "* [`numpy.ones ()`](https://docs.scipy.org/doc/numpy/reference/generated/numpy.ones.html#numpy.ones)\n", - "* [`numpy.zeros ()`](https://docs.scipy.org/doc/numpy/reference/generated/numpy.zeros.html#numpy.zeros)\n", - "* [`numpy.empty ()`](https://docs.scipy.org/doc/numpy/reference/generated/numpy.empty.html#numpy.empty)\n", - "* [`numpy.copy ()`](https://docs.scipy.org/doc/numpy/reference/generated/numpy.copy.html#numpy.copy)\n", - "\n", - "¡Siga los enlaces para explorar la documentación de estas útiles funciones de NumPy!" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "##### Advertencia:\n", - "\n", - "Encontrará _un lote_ de código de muestra en línea que usa una sintaxis diferente para importar. Ellos harán:\n", - "```python\n", - "importar numpy como np\n", - "```\n", - "Todo lo que hace es crear un alias para `numpy` con la cadena más corta` np`, por lo que llamaría a una función ** NumPy ** como esta: `np.linspace ()`. Esta es solo una forma alternativa de hacerlo, para personas perezosas que les resulta demasiado largo para escribir `numpy` y quieren guardar 3 caracteres cada vez. Para el no perezoso, escribir `numpy` es más legible y hermoso.\n", - "\n", - "Nos gusta más así:" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": { - "collapsed": true - }, - "outputs": [], - "source": [ - "import numpy" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Creando matrices\n", - "\n", - "Para crear una matriz NumPy a partir de una lista existente de números (homogéneos), llamamos ** `numpy.array ()` **, así:" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array([ 3, 5, 8, 17])" - ] - }, - "execution_count": 2, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "numpy.array([3, 5, 8, 17])" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "NumPy ofrece muchas [formas de crear matrices](https://docs.scipy.org/doc/numpy/reference/routines.array-creation.html#routines-array-creation) además de esto. Ya hemos mencionado algunos de ellos más arriba.\n", - "\n", - "Juega con `numpy.ones ()` y `numpy.zeros ()`: crean arrays llenos de unos y ceros, respectivamente. Pasamos como argumento la cantidad de elementos de matriz que queremos." - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array([ 1., 1., 1., 1., 1.])" - ] - }, - "execution_count": 3, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "numpy.ones(5)" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array([ 0., 0., 0.])" - ] - }, - "execution_count": 4, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "numpy.zeros(3)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Otro útil: `numpy.arange ()` da una matriz de valores espaciados uniformemente en un intervalo definido.\n", - "\n", - "*Sintaxis:*\n", - "\n", - "`numpy.arange (inicio, parada, paso)`\n", - "\n", - "donde `start` por defecto es cero,` stop` no es inclusivo, y el predeterminado\n", - "para `paso` es uno. ¡Juega con ello!" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array([0, 1, 2, 3])" - ] - }, - "execution_count": 5, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "numpy.arange(4)" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array([2, 3, 4, 5])" - ] - }, - "execution_count": 6, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "numpy.arange(2, 6)" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array([2, 4])" - ] - }, - "execution_count": 7, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "numpy.arange(2, 6, 2)" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array([ 2. , 2.5, 3. , 3.5, 4. , 4.5, 5. , 5.5])" - ] - }, - "execution_count": 8, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "numpy.arange(2, 6, 0.5)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "`numpy.linspace ()` es similar a `numpy.arange ()`, pero usa número de muestras en lugar de un tamaño de paso. Devuelve una matriz con números espaciados uniformemente durante el intervalo especificado.\n", - "\n", - "*Sintaxis:*\n", - "\n", - "`numpy.linspace (start, stop, num)`\n", - "\n", - "`stop` está incluido por defecto (se puede eliminar, lea los documentos), y` num` de forma predeterminada es 50." - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array([ 2. , 2.02040816, 2.04081633, 2.06122449, 2.08163265,\n", - " 2.10204082, 2.12244898, 2.14285714, 2.16326531, 2.18367347,\n", - " 2.20408163, 2.2244898 , 2.24489796, 2.26530612, 2.28571429,\n", - " 2.30612245, 2.32653061, 2.34693878, 2.36734694, 2.3877551 ,\n", - " 2.40816327, 2.42857143, 2.44897959, 2.46938776, 2.48979592,\n", - " 2.51020408, 2.53061224, 2.55102041, 2.57142857, 2.59183673,\n", - " 2.6122449 , 2.63265306, 2.65306122, 2.67346939, 2.69387755,\n", - " 2.71428571, 2.73469388, 2.75510204, 2.7755102 , 2.79591837,\n", - " 2.81632653, 2.83673469, 2.85714286, 2.87755102, 2.89795918,\n", - " 2.91836735, 2.93877551, 2.95918367, 2.97959184, 3. ])" - ] - }, - "execution_count": 9, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "numpy.linspace(2.0, 3.0)" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "50" - ] - }, - "execution_count": 10, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "len(numpy.linspace(2.0, 3.0))" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array([ 2. , 2.2, 2.4, 2.6, 2.8, 3. ])" - ] - }, - "execution_count": 11, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "numpy.linspace(2.0, 3.0, 6)" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array([-1. , -0.75, -0.5 , -0.25, 0. , 0.25, 0.5 , 0.75, 1. ])" - ] - }, - "execution_count": 12, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "numpy.linspace(-1, 1, 9)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Operaciones de matriz\n", - "\n", - "Asignemos algunas matrices a nombres de variables y realicemos algunas operaciones con ellos." - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "metadata": { - "collapsed": true - }, - "outputs": [], - "source": [ - "x_array = numpy.linspace(-1, 1, 9)" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "collapsed": true - }, - "source": [ - "Ahora que lo hemos guardado con un nombre de variable, podemos hacer algunos cálculos con la matriz. Por ejemplo, toma el cuadrado de cada elemento de la matriz de una sola vez:" - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[ 1. 0.5625 0.25 0.0625 0. 0.0625 0.25 0.5625 1. ]\n" - ] - } - ], - "source": [ - "y_array = x_array**2\n", - "print(y_array)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "También podemos tomar la raíz cuadrada de una matriz positiva, usando la función `numpy.sqrt ()`:" - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[ 1. 0.75 0.5 0.25 0. 0.25 0.5 0.75 1. ]\n" - ] - } - ], - "source": [ - "z_array = numpy.sqrt(y_array)\n", - "print(z_array)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Ahora que tenemos diferentes matrices `x_array`,` y_array` y `z_array`, podemos hacer más cálculos, como agregarlos o multiplicarlos. Por ejemplo:" - ] - }, - { - "cell_type": "code", - "execution_count": 16, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[ 0. -0.1875 -0.25 -0.1875 0. 0.3125 0.75 1.3125 2. ]\n" - ] - } - ], - "source": [ - "add_array = x_array + y_array \n", - "print(add_array)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "La adición de matriz se define como elemento, como cuando se agregan dos vectores (o matrices). La multiplicación de matrices también se basa en los elementos:" - ] - }, - { - "cell_type": "code", - "execution_count": 17, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[-1. -0.5625 -0.25 -0.0625 0. 0.0625 0.25 0.5625 1. ]\n" - ] - } - ], - "source": [ - "mult_array = x_array * z_array\n", - "print(mult_array)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "También podemos dividir matrices, pero debe tener cuidado de no dividir por cero. Esta operación dará como resultado ** `nan` ** que significa * Not a Number *. Python todavía realizará la división, pero nos contará sobre el problema.\n", - "\n", - "Veamos cómo podría verse esto:" - ] - }, - { - "cell_type": "code", - "execution_count": 18, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "//anaconda/envs/future/lib/python3.5/site-packages/ipykernel/__main__.py:1: RuntimeWarning: invalid value encountered in true_divide\n", - " if __name__ == '__main__':\n" - ] - }, - { - "data": { - "text/plain": [ - "array([-1. , -1.33333333, -2. , -4. , nan,\n", - " 4. , 2. , 1.33333333, 1. ])" - ] - }, - "execution_count": 18, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "x_array / y_array" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Arrays multidimensionales\n", - "\n", - "### matrices 2D\n", - "\n", - "NumPy puede crear matrices de N dimensiones. Por ejemplo, una matriz 2D es como una matriz, y se crea a partir de una lista anidada de la siguiente manera:" - ] - }, - { - "cell_type": "code", - "execution_count": 19, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[[1 2]\n", - " [3 4]]\n" - ] - } - ], - "source": [ - "array_2d = numpy.array([[1, 2], [3, 4]])\n", - "print(array_2d)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Las matrices 2D se pueden agregar, restar y multiplicar:" - ] - }, - { - "cell_type": "code", - "execution_count": 20, - "metadata": { - "collapsed": true - }, - "outputs": [], - "source": [ - "X = numpy.array([[1, 2], [3, 4]])\n", - "Y = numpy.array([[1, -1], [0, 1]])" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "La adición de estas dos matrices funciona exactamente como era de esperar:" - ] - }, - { - "cell_type": "code", - "execution_count": 21, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array([[2, 1],\n", - " [3, 5]])" - ] - }, - "execution_count": 21, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "X + Y" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "¿Qué pasa si tratamos de multiplicar matrices utilizando el operador `'*'`?" - ] - }, - { - "cell_type": "code", - "execution_count": 22, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array([[ 1, -2],\n", - " [ 0, 4]])" - ] - }, - "execution_count": 22, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "X * Y" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "La multiplicación usando el operador `'*'` es por elementos. Si queremos hacer una multiplicación matricial usamos el operador `'@'`:" - ] - }, - { - "cell_type": "code", - "execution_count": 23, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array([[1, 1],\n", - " [3, 1]])" - ] - }, - "execution_count": 23, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "X @ Y" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "O de manera equivalente, podemos usar `numpy.dot ()`:" - ] - }, - { - "cell_type": "code", - "execution_count": 24, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array([[1, 1],\n", - " [3, 1]])" - ] - }, - "execution_count": 24, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "numpy.dot(X, Y)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### matrices 3D\n", - "\n", - "Vamos a crear una matriz 3D remodelando una matriz 1D. Podemos usar [`numpy.reshape ()`](https://docs.scipy.org/doc/numpy/reference/generated/numpy.reshape.html), donde pasamos la matriz que queremos remodelar y la forma queremos darlo, es decir, la cantidad de elementos en cada dimensión.\n", - "\n", - "*Sintaxis*\n", - " \n", - "`numpy.reshape (array, newshape)`\n", - "\n", - "Por ejemplo:" - ] - }, - { - "cell_type": "code", - "execution_count": 25, - "metadata": { - "collapsed": true - }, - "outputs": [], - "source": [ - "a = numpy.arange(24)" - ] - }, - { - "cell_type": "code", - "execution_count": 26, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[[[ 0 1 2 3]\n", - " [ 4 5 6 7]\n", - " [ 8 9 10 11]]\n", - "\n", - " [[12 13 14 15]\n", - " [16 17 18 19]\n", - " [20 21 22 23]]]\n" - ] - } - ], - "source": [ - "a_3D = numpy.reshape(a, (2, 3, 4))\n", - "print(a_3D)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Podemos verificar la forma de una matriz NumPy usando la función `numpy.shape ()`:" - ] - }, - { - "cell_type": "code", - "execution_count": 27, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "(2, 3, 4)" - ] - }, - "execution_count": 27, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "numpy.shape(a_3D)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Visualizar las dimensiones de la matriz `a_3D` puede ser complicado, así que aquí hay un diagrama que lo ayudará a comprender cómo se asignan las dimensiones: cada dimensión se muestra como un eje de coordenadas. Para una matriz 3D, en el \"eje x\", tenemos las sub-matrices que son bidimensionales (matrices). Tenemos dos de estas sub-matrices 2D, en este caso; cada uno tiene 3 filas y 4 columnas. Estudie este boceto cuidadosamente, mientras compara con la forma en que se imprime la matriz `a_3D`.\n", - "\n", - "" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "collapsed": true - }, - "source": [ - "Cuando tenemos matrices multidimensionales, podemos acceder a porciones de sus elementos cortando en cada dimensión. Esta es una de las ventajas del uso de matrices: no podemos hacer esto con listas.\n", - "\n", - "Accedamos a algunos elementos de nuestra matriz 2D llamada `X`." - ] - }, - { - "cell_type": "code", - "execution_count": 28, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array([[1, 2],\n", - " [3, 4]])" - ] - }, - "execution_count": 28, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "X" - ] - }, - { - "cell_type": "code", - "execution_count": 29, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "1" - ] - }, - "execution_count": 29, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# Grab the element in the 1st row and 1st column \n", - "X[0, 0]" - ] - }, - { - "cell_type": "code", - "execution_count": 30, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "2" - ] - }, - "execution_count": 30, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# Grab the element in the 1st row and 2nd column \n", - "X[0, 1]" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "##### Ejercicios:\n", - "\n", - "De la matriz X:\n", - "\n", - "1. Coge el segundo elemento en la primera columna.\n", - "2. Coge el segundo elemento en la segunda columna." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Juega con cortar en esta matriz:" - ] - }, - { - "cell_type": "code", - "execution_count": 31, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array([1, 3])" - ] - }, - "execution_count": 31, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# Grab the 1st column\n", - "X[:, 0]" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Cuando no especificamos el punto inicial y/o final en el corte, el símbolo `':'` significa \"todo\". En el ejemplo anterior, le estamos diciendo a NumPy que queremos todos los elementos del índice 0 en la segunda dimensión (la primera columna)." - ] - }, - { - "cell_type": "code", - "execution_count": 32, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array([1, 2])" - ] - }, - "execution_count": 32, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# Grab the 1st row\n", - "X[0, :]" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "##### Ejercicios:\n", - "\n", - "De la matriz X:\n", - "\n", - "1. Coge la segunda columna.\n", - "2. Coge la segunda fila." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Practiquemos con una matriz 3D." - ] - }, - { - "cell_type": "code", - "execution_count": 33, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array([[[ 0, 1, 2, 3],\n", - " [ 4, 5, 6, 7],\n", - " [ 8, 9, 10, 11]],\n", - "\n", - " [[12, 13, 14, 15],\n", - " [16, 17, 18, 19],\n", - " [20, 21, 22, 23]]])" - ] - }, - "execution_count": 33, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "a_3D" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Si queremos tomar la primera columna de ambas matrices en nuestra matriz `a_3D`, hacemos:" - ] - }, - { - "cell_type": "code", - "execution_count": 34, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array([[ 0, 4, 8],\n", - " [12, 16, 20]])" - ] - }, - "execution_count": 34, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "a_3D[:, :, 0]" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "La línea de arriba le está diciendo a NumPy que queremos:\n", - "\n", - "* first `':'`: desde la primera dimensión, toma todos los elementos (2 matrices).\n", - "* second `':'`: desde la segunda dimensión, toma todos los elementos (todas las filas).\n", - "* `'0'`: desde la tercera dimensión, toma el primer elemento (primera columna).\n", - "\n", - "Si queremos los primeros 2 elementos de la primera columna de ambas matrices:" - ] - }, - { - "cell_type": "code", - "execution_count": 35, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array([[ 0, 4],\n", - " [12, 16]])" - ] - }, - "execution_count": 35, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "a_3D[:, 0:2, 0]" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "A continuación, desde la primera matriz de nuestra matriz `a_3D`, tomaremos los dos elementos intermedios (5,6):" - ] - }, - { - "cell_type": "code", - "execution_count": 36, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array([5, 6])" - ] - }, - "execution_count": 36, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "a_3D[0, 1, 1:3]" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "##### Ejercicios:\n", - "\n", - "De la matriz llamada `a_3D`:\n", - "\n", - "1. Toma los dos elementos del medio (17, 18) de la segunda matriz.\n", - "2. Coge la última fila de ambas matrices.\n", - "3. Tome los elementos de la primera matriz que excluyen la primera fila y la primera columna.\n", - "4. Tome los elementos de la 2da matriz que excluyen la última fila y la última columna." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## NumPy == ¡Rápido y limpio!\n", - "\n", - "Cuando trabajamos con números, los arreglos son una mejor opción porque la biblioteca NumPy tiene funciones integradas que están optimizadas y, por lo tanto, son más rápidas que las de Python. Especialmente si tenemos grandes arreglos. Además, usar matrices NumPy y explotar sus propiedades hace que nuestro código sea más legible.\n", - "\n", - "Por ejemplo, si quisiéramos agregar elemento-sabio los elementos de 2 listas, necesitamos hacerlo con una declaración `for`. Si queremos agregar dos matrices NumPy, simplemente usamos el símbolo de suma `'+'`!\n", - "\n", - "A continuación, agregaremos dos listas y dos matrices (con elementos aleatorios) y compararemos el tiempo que lleva computar cada adición." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Suma de elementos de una lista de Python\n", - "\n", - "Usando la biblioteca de Python [`random`](https://docs.python.org/3/library/random.html), generaremos dos listas con 100 elementos pseudoaleatorios en el rango [0,100), sin números repetido." - ] - }, - { - "cell_type": "code", - "execution_count": 37, - "metadata": { - "collapsed": true - }, - "outputs": [], - "source": [ - "#import random library\n", - "import random" - ] - }, - { - "cell_type": "code", - "execution_count": 38, - "metadata": { - "collapsed": true - }, - "outputs": [], - "source": [ - "lst_1 = random.sample(range(100), 100)\n", - "lst_2 = random.sample(range(100), 100)" - ] - }, - { - "cell_type": "code", - "execution_count": 39, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[69, 21, 55, 9, 12, 57, 75, 81, 15, 17]\n", - "[57, 29, 94, 67, 51, 71, 78, 55, 41, 72]\n" - ] - } - ], - "source": [ - "#print first 10 elements\n", - "print(lst_1[0:10])\n", - "print(lst_2[0:10])" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Necesitamos escribir una declaración `for`, añadiendo el resultado de la suma de elementos a una nueva lista que llamamos` result_lst`.\n", - "\n", - "Para el tiempo, podemos usar el IPython \"mágico\" `%% time`. Escribiendo al comienzo de la celda de código, el comando `%% time` nos dará el tiempo que lleva ejecutar todo el código en esa celda." - ] - }, - { - "cell_type": "code", - "execution_count": 40, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "CPU times: user 36 µs, sys: 1 µs, total: 37 µs\n", - "Wall time: 38.9 µs\n" - ] - } - ], - "source": [ - "%%time\n", - "res_lst = []\n", - "for i in range(100):\n", - " res_lst.append(lst_1[i] + lst_2[i])" - ] - }, - { - "cell_type": "code", - "execution_count": 41, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[126, 50, 149, 76, 63, 128, 153, 136, 56, 89]\n" - ] - } - ], - "source": [ - "print(res_lst[0:10])" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Suma de elementos de las matrices NumPy\n", - "\n", - "En este caso, generamos matrices con enteros aleatorios usando la función NumPy [`numpy.random.randint ()`](https://docs.scipy.org/doc/numpy-1.13.0/reference/generated/numpy. random.randint.html). Las matrices que generamos con esta función no serán como las listas: en este caso, tendremos 100 elementos en el rango [0, 100) pero pueden repetirse. Nuestro objetivo es comparar el tiempo que lleva computar la adición de una lista o un grupo de números, de modo que todo lo que importa es que las matrices y las listas son de la misma longitud y tipo (enteros)." - ] - }, - { - "cell_type": "code", - "execution_count": 42, - "metadata": { - "collapsed": true - }, - "outputs": [], - "source": [ - "arr_1 = numpy.random.randint(0, 100, size=100)\n", - "arr_2 = numpy.random.randint(0, 100, size=100)" - ] - }, - { - "cell_type": "code", - "execution_count": 43, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[31 13 72 30 13 29 34 64 26 56]\n", - "[ 3 57 63 51 35 75 56 59 86 50]\n" - ] - } - ], - "source": [ - "#print first 10 elements\n", - "print(arr_1[0:10])\n", - "print(arr_2[0:10])" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Ahora podemos usar la magia de la celda `%% time`, nuevamente, para ver cuánto tarda NumPy en calcular la suma de elementos." - ] - }, - { - "cell_type": "code", - "execution_count": 44, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "CPU times: user 20 µs, sys: 1 µs, total: 21 µs\n", - "Wall time: 26 µs\n" - ] - } - ], - "source": [ - "%%time\n", - "arr_res = arr_1 + arr_2" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Tenga en cuenta que en el caso de las matrices, el código no solo es más legible (solo una línea de código), sino que también es más rápido que con las listas. Esta vez, la ventaja será mayor con matrices/listas más grandes.\n", - "\n", - "(Sus resultados de tiempo pueden variar a los que mostramos en este cuaderno, porque estará computando en una máquina diferente)." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "##### Ejercicio\n", - "\n", - "1. Pruebe la comparación entre listas y matrices, usando matrices más grandes; por ejemplo, de tamaño 10,000.\n", - "2. Repita el análisis, pero ahora calcula la operación que eleva cada elemento de una matriz/lista a la potencia dos. Usa arreglos de 10,000 elementos." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Tiempo para trazar\n", - "\n", - "¡Te encantará la biblioteca de Python ** Matplotlib **! Aprenderá aquí sobre su módulo `pyplot`, que hace gráficos de líneas.\n", - "\n", - "Necesitamos algunos datos para trazar. Definamos una matriz NumPy, calcule los datos derivados usando su cuadrado, cubo y raíz cuadrada (elemento-sabio), y trace estos valores con la matriz original en el eje x." - ] - }, - { - "cell_type": "code", - "execution_count": 45, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[ 0. 0.05 0.1 0.15 0.2 0.25 0.3 0.35 0.4 0.45 0.5 0.55\n", - " 0.6 0.65 0.7 0.75 0.8 0.85 0.9 0.95 1. 1.05 1.1 1.15\n", - " 1.2 1.25 1.3 1.35 1.4 1.45 1.5 1.55 1.6 1.65 1.7 1.75\n", - " 1.8 1.85 1.9 1.95 2. ]\n" - ] - } - ], - "source": [ - "xarray = numpy.linspace(0, 2, 41)\n", - "print(xarray)" - ] - }, - { - "cell_type": "code", - "execution_count": 46, - "metadata": { - "collapsed": true - }, - "outputs": [], - "source": [ - "pow2 = xarray**2\n", - "pow3 = xarray**3\n", - "pow_half = numpy.sqrt(xarray)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Para trazar las matrices resultantes como una función de la original (`xarray`) en el eje x, necesitamos importar el módulo` pyplot` de ** Matplotlib **." - ] - }, - { - "cell_type": "code", - "execution_count": 47, - "metadata": { - "collapsed": true - }, - "outputs": [], - "source": [ - "from matplotlib import pyplot\n", - "%matplotlib inline" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "El comando `% matplotlib inline` está ahí para obtener nuestros trazados dentro del portátil (en lugar de una ventana emergente, que es el comportamiento predeterminado de` pyplot`).\n", - "\n", - "Utilizaremos la función `pyplot.plot ()`, especificando el color de línea (`'k'` para negro) y el estilo de línea (`' -'`, `'-'` y `':'` para línea continua, punteada y punteada), y dando a cada línea una etiqueta. Tenga en cuenta que los valores para `color`,` linestyle` y `label` se dan entre comillas." - ] - }, - { - "cell_type": "code", - "execution_count": 48, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 48, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAW8AAAEACAYAAAB8nvebAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n5C2EEDZIkrcQQtggSd5CCGGD/j+RWiKuPrsMFQAAAABJRU5ErkJggg==\n", - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "#Plot x^2\n", - "pyplot.plot(xarray, pow2, color='k', linestyle='-', label='square')\n", - "#Plot x^3\n", - "pyplot.plot(xarray, pow3, color='k', linestyle='--', label='cube')\n", - "#Plot sqrt(x)\n", - "pyplot.plot(xarray, pow_half, color='k', linestyle=':', label='square root')\n", - "#Plot the legends in the best location\n", - "pyplot.legend(loc='best')" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Para ilustrar otras características, trazaremos los mismos datos, pero variando los colores en lugar del estilo de línea. También usaremos la sintaxis LaTeX para escribir fórmulas en las etiquetas. Si desea obtener más información sobre la sintaxis de LaTeX, hay una [guía rápida de LaTeX](https://users.dickinson.edu/~richesod/latex/latexcheatsheet.pdf) disponible en línea.\n", - "\n", - "Agregar un punto y coma (`';'`) a la última línea del bloque de código de trazado evita esa salida fea, como ``. Intentalo." - ] - }, - { - "cell_type": "code", - "execution_count": 49, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAW8AAAEACAYAAAB8nvebAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n", - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "#Plot x^2\n", - "pyplot.plot(xarray, pow2, color='red', linestyle='-', label='$x^2$')\n", - "#Plot x^3\n", - "pyplot.plot(xarray, pow3, color='green', linestyle='-', label='$x^3$')\n", - "#Plot sqrt(x)\n", - "pyplot.plot(xarray, pow_half, color='blue', linestyle='-', label='$\\sqrt{x}$')\n", - "#Plot the legends in the best location\n", - "pyplot.legend(loc='best'); " - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Eso es muy bueno! Por ahora, probablemente estés imaginando todo lo bueno que puedes hacer con los cuadernos Jupyter, Python y sus bibliotecas científicas ** NumPy ** y ** Matplotlib **. Acabamos de ver una introducción al trazado pero seguiremos aprendiendo sobre el poder de ** Matplotlib ** en la próxima lección.\n", - "\n", - "Si tiene curiosidad, puede explorar todas las parcelas hermosas que puede hacer navegando por la [galería Matplotlib](http://matplotlib.org/gallery.html)." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "##### Ejercicio:\n", - "\n", - "Elija dos operaciones diferentes para aplicar a `xarray` y grábelas con los datos resultantes en la misma gráfica." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Lo que hemos aprendido\n", - "\n", - "* Cómo importar bibliotecas\n", - "* Arrays multidimensionales usando NumPy\n", - "* Acceder a valores y cortar en matrices NumPy\n", - "* Magia `%% time` para cronometrar la ejecución de la celda.\n", - "* Comparación de rendimiento: listas vs matrices NumPy\n", - "* Trazado básico con `pyplot`." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Referencias\n", - "\n", - "1. _Eficaz de Computación en Física: Guía de campo para la investigación con Python_ (2015). Anthony Scopatz y Kathryn D. Huff. O'Reilly Media, Inc.\n", - "\n", - "2. _Numerical Python: un enfoque de técnicas prácticas para la industria_. (2015). Robert Johansson. Apretar\n", - "\n", - "2. [\"El mundo de Jupyter\" -un tutorial](https://github.com/barbagroup/jupyter-tutorial). Lorena A. Barba - 2016" - ] - }, - { - "cell_type": "code", - "execution_count": 50, - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "\n", - "\n", - "\n", - "\n", - "\n" - ], - "text/plain": [ - "" - ] - }, - "execution_count": 50, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# Execute this cell to load the notebook's style sheet, then ignore it\n", - "from IPython.core.display import HTML\n", - "css_file = '../style/custom.css'\n", - "HTML(open(css_file, \"r\").read())" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.5.2" - }, - "widgets": { - "state": {}, - "version": "1.1.2" - } - }, - "nbformat": 4, - "nbformat_minor": 2 -} diff --git a/notebooks_es/5_Regresion_Lineal_con_datos_reales.ipynb b/notebooks_es/5_Regresion_Lineal_con_datos_reales.ipynb index 2bc50e2..d864947 100644 --- a/notebooks_es/5_Regresion_Lineal_con_datos_reales.ipynb +++ b/notebooks_es/5_Regresion_Lineal_con_datos_reales.ipynb @@ -13,13 +13,13 @@ "source": [ "# Regresión lineal con datos reales\n", "\n", - "## Temperatura de la tierra en el tiempo\n", + "## La temperatura de la tierra variando en el tiempo\n", "\n", "En esta lección, aplicaremos todo lo que hemos aprendido (y más) para analizar datos reales de la temperatura de la Tierra a lo largo del tiempo.\n", "\n", "¿Está aumentando la temperatura global? ¿Cuánto? ¡Esta es una cuestión de gran importancia en el mundo de hoy!\n", "\n", - "Los datos sobre las temperaturas globales están disponibles en varias fuentes: NASA, el Centro Nacional de Datos Climáticos (NCDC) y la Universidad de East Anglia en el Reino Unido. Consulta la [Corporación Universitaria de Investigación Atmosférica](https://www2.ucar.edu/climate/faq/how-much-has-global-temperature-risen-last-100-years) (UCAR) para un discusión profunda\n", + "Los datos sobre las temperaturas globales están disponibles en varias fuentes: NASA, el Centro Nacional de Datos Climáticos (NCDC) y la Universidad de East Anglia en el Reino Unido. Consulta la [Corporación Universitaria de Investigación Atmosférica](https://www2.ucar.edu/climate/faq/how-much-has-global-temperature-risen-last-100-years) (UCAR) para un discusión profunda.\n", "\n", "El [Centro Goddard de Vuelos Espaciales de la NASA](http://svs.gsfc.nasa.gov/goto?3901) es una de estas fuentes de datos climáticos globales. Ellos produjeron el siguiente video que muestra un mapa de colores de las cambiantes **anomalías de temperatura de la superficie** de 1880 a 2015.\n", "\n", @@ -28,32 +28,9 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/jpeg": "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\n", - "text/html": [ - "\n", - " \n", - " " - ], - "text/plain": [ - "" - ] - }, - "execution_count": 1, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "from IPython.display import YouTubeVideo\n", "YouTubeVideo('gGOzHVUQCw0')" @@ -63,11 +40,11 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "¿Cómo podríamos entender las _tendencias_ de los datos de temperatura global?\n", + "¿Cómo podríamos entender las _tendencias_ de los datos de la temperatura global?\n", "\n", "El primer paso para analizar datos desconocidos es generar algunos gráficos simples utilizando **Matplotlib**. Vamos a ver el historial de anomalías de temperatura, contenido en un archivo, y hacemos nuestro primer diagrama para explorar estos datos.\n", "\n", - "Vamos a suavizar los datos y luego ajustaremos una línea para encontrar una tendencia, trazando a lo largo del camino para ver cómo se ve todo.\n", + "Vamos a suavizar los datos y luego ajustaremos una línea para encontrar una tendencia, graficando para ver cómo se ve todo.\n", "\n", "¡Empecemos!" ] @@ -76,15 +53,15 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "## Paso 1: lee un archivo de datos\n", + "## Paso 1: leyendo un archivo de datos\n", "\n", - "Tomamos los datos de la página web [NOAA](https://www.ncdc.noaa.gov/cag/) (National Oceanic and Atmospheric Administration - Administración Nacional Oceánica y Atmosférica). Siéntete libre de jugar con la página web y analizar datos por tu cuenta, pero por ahora, asegurémonos de que trabajamos con el mismo conjunto de datos.\n", + "Tomamos los datos de la página web [NOAA](https://www.ncdc.noaa.gov/cag/) (National Oceanic and Atmospheric Administration - Administración Nacional Oceánica y Atmosférica). Siéntete libre de jugar con la página web y analizar datos por tu cuenta, pero por ahora, buscaremos asegurarnos que trabajaremos con el mismo conjunto de datos.\n", "\n", - "Tenemos un archivo llamado `land_global_temperature_anomaly-1880-2016.csv` en nuestra carpeta` data`. Este archivo contiene el año en la primera columna y los promedios de la anomalía de la temperatura terrestre enumerados secuencialmente en la segunda columna, desde el año 1880 hasta 2016. Cargaremos el archivo, luego haremos una gráfica inicial para ver cómo se ve.\n", + "Tenemos un archivo llamado `land_global_temperature_anomaly-1880-2016.csv` en nuestra carpeta `data`. Este archivo contiene el año en la primera columna y los promedios de la anomalía de la temperatura terrestre enumerados secuencialmente en la segunda columna, desde el año 1880 hasta 2016. Cargaremos el archivo y luego haremos una gráfica inicial para ver cómo se ven estos datos.\n", "\n", "##### Nota:\n", "\n", - "Si descargó este bloc de notas solo, en lugar de la colección completa de este curso, es posible que no tenga el archivo de datos en la ubicación que suponemos a continuación. En ese caso, puede descargar los datos si agrega una celda de código y ejecuta el siguiente código en ella:\n", + "Si descargó este notebook por separado en lugar de la colección completa de este curso, es posible que no tenga el archivo de datos en la ubicación que suponemos a continuación. En ese caso, puede descargar los datos si agrega una celda de código y ejecuta el siguiente código en ella:\n", "\n", "```Python\n", "from urllib.request import urlretrieve\n", @@ -92,14 +69,14 @@ "urlretrieve (URL, 'land_global_temperature_anomaly-1880-2016.csv')\n", "```\n", "\n", - "El archivo de datos se descargará a su directorio de trabajo, y luego tendrá que eliminar la información de ruta, es decir, la cadena `'../../ data /'`, de la definición de la variable `fname` a continuación.\n", + "El archivo de datos se descargará a su directorio de trabajo, y luego tendrá que eliminar la información de ruta, es decir, la cadena `'../data /'`, de la definición de la variable `fname` a continuación.\n", "\n", "Comencemos importando NumPy." ] }, { "cell_type": "code", - "execution_count": 2, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -110,12 +87,12 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Para cargar nuestros datos desde el archivo, utilizaremos la función [`numpy.loadtxt()`](https://docs.scipy.org/doc/numpy/reference/generated/numpy.loadtxt.html), que nos permite guardar inmediatamente los datos en matrices NumPy. (Le recomendamos que lea la documentación para obtener detalles sobre cómo funciona la función). Guardaremos los datos en las matrices `year` y` temp_anomaly`." + "Para cargar nuestros datos desde el archivo, utilizaremos la función [`numpy.loadtxt()`](https://docs.scipy.org/doc/numpy/reference/generated/numpy.loadtxt.html), que nos permite guardar inmediatamente los datos en arrays de NumPy. (Le recomendamos que lea la documentación para obtener detalles sobre cómo funciona la función). Guardaremos los datos en los arrays `year` y `temp_anomaly`." ] }, { "cell_type": "code", - "execution_count": 3, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -137,14 +114,14 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "## Paso 2: grafica los datos\n", + "## Paso 2: graficando los datos\n", "\n", - "Primero carguemos el módulo ** Matplotlib ** llamado `pyplot`, para hacer gráficos en 2D. Recuerda que para obtener los gráficos dentro del jupyter notebook, usamos un comando especial \"mágico\", `%matplotlib inline`:" + "Primero cargaremos el módulo `pyplot` de **Matplotlib**, para hacer gráficos en 2D. Recuerda que para obtener los gráficos dentro del notebook de jupyter, usamos un comando especial \"mágico\", `%matplotlib inline`:" ] }, { "cell_type": "code", - "execution_count": 4, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -156,25 +133,14 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "La función `plot()` del módulo `pyplot` hace gráficos de líneas simples. Evitaremos los textos que aparecieron en la parte superior de la figura, que dicen `Out [x]:[<...>]`, al agregar un punto y coma al final del comando de trazado." + "La función `plot()` del módulo `pyplot` hace gráficos de líneas simples. Evitaremos los textos que aparecen en la parte superior de la figura, que dicen `Out [x]:[<...>]`, al agregar un punto y coma al final del comando de trazado." ] }, { "cell_type": "code", - "execution_count": 5, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYYAAAEACAYAAAC3adEgAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAIABJREFUeJztnXl8VdW5938PsyBDwpBQRgdETUFAEZwwVVGsVLRaq963Sq2tH1vbXm1ftVorvFatvY7V3o7i0F6l1PY6V4HWgAMgKAIGMEAGIZAQICTMkGS9fzxn9ey9s8+8T845ye/7+eRz9rzX2UnWbz/DepYYY0AIIYRYOmW6AYQQQrILCgMhhBAXFAZCCCEuKAyEEEJcUBgIIYS4oDAQQghxEYgwiMjTIlIrIqsj7D9XRHaLyMehn58GcV9CCCHB0yWg6zwD4EkAz0c5ZrEx5tKA7kcIISRNBGIxGGPeA1Af4zAJ4l6EEELSS1vGGCaLyEoReUNETm7D+xJCCEmAoFxJsfgIwAhjzH4RuRjAywBOaKN7E0IISYA2EQZjzF7H8j9E5L9FJN8Ys8t5nIiwcBMhhCSBMSYwd32QriRBhDiCiBQ4lk8HIF5RsBhjcvbn3nvvzXgb2P7Mt4Ptz72fXG67McG/TwdiMYjICwCKAfQXkc8B3AugGwBjjPk9gCtF5GYARwAcAPD1IO5LCCEkeAIRBmPMtTH2/xrAr4O4FyGEdBRefBE47zygoCD2sUHCkc8BUlxcnOkmpATbn1nY/syRjW1vagK++93M3FvS4Z9KFhEx2dQeQgjJFEuXAjfdBKxaFftYEYHJ0uAzIYSQgFiwALjggszcm8JACCFZyIIFwNSpmbk3XUmEEJJl7N0LFBYCtbVAr16xj6criRBC2jmLFgETJ8YnCumAwkAIIVlGJt1IAIWBEEKyjoULMxd4BhhjIISQrGLbNqCoCKirAzp3ju8cxhgIIaQds349MGZM/KKQDigMhBCSRdTVAQMHZrYNFAZCCMki6uqAAQMy2wYKAyGEZBG0GAghhLjYsYPCQAghxAEtBkIIIS4oDIQQQlww+EwIIcRFNsQYOPKZEEKyBGOAbt20umr37vGfx5HPhBDSTtm9G+jZMzFRSAcUBkIIyRKyIfAMUBgIISRryIb4AkBhIISQrCEbMpIACgMhhGQNdCURQghxQWEghBDigjEGQgghLmgxEEIIccHgMyGEEBe0GAghhLhgjIEQQtoJTU1AQ0Pq16HFQAgh7YS5c4Ebb/TfZwzw2Wexr7F/P9DSAvTqFWzbkoHCQAghKbJ2LVBe7r/vo4+AqVNjX8MGniWwGqnJQ2EghJAUKSsDPv/cf195ObB5M7BvX/RrZEt8AaAwEEJIypSVacd+4EDrfRUV+rlxY/RrZEt8AaAwEEJIQuzZA9x5Z3i9pUU7/cJCtQy8VFbqZ1lZ9Ou2O2EQkadFpFZEVkc55lciskFEPhGRcUHclxBC2pr164Ff/lJnWQOALVuAvDzg5JP93UkVFcAXv9gBhQHAMwAuirRTRC4GcJwxZhSAmwD8NqD7EkJIm7J5s2YaffyxrpeVASecAAwbFlkYLrootjDs2JEdo56BgITBGPMegPooh8wA8Hzo2GUA+opIQRD3JoSQtmTLFv1cvlw/rTAMH95aGFpadNvUqZGF4dNPgVtvBX7/e6CoKH3tToS2ijEMAeD0vlWHthFCSE6xebO6jeIRhpoaoE8fYPx4f2HYuRM46yzg6KOBpUuByy5Lf/vjoUumG+Bl1qxZ/14uLi5GcXFxxtpCCCFetmwBvvpV4IUXdL2sDDj/fKB7dx3o5qSiAjjmGI0dNDerEPTvH97/1lvAl74E3HdfYm0oKSlBSUlJSt8jGm0lDNUAhjnWh4a2tcIpDIQQkm1s3gzcdBPwxBPArl06qnn0aHUbebOSKiuBkSN10NoJJ6iInHFGeP9rrwHTpyfeBu9L8+zZs5P5KhEJ0pUkoR8/XgVwHQCIyGQAu40xtQHemxBC2oTNm9VtNGEC8MEHQHW1WgU2+GxM+FhrMQAqHk530pEjwNtvA5dc0rbtj4eg0lVfAPABgBNE5HMR+aaI3CQi3wEAY8ybACpEZCOA3wH4bhD3JYSQRPn5z4HGxuTObW4Gtm0DhgwBJk5U19Hw4UDXrlrjqGdPzS6yVFaGhcFaDJb33weOPx4YPDjpr5I2AnElGWOujeOYW4K4FyGEpMIjj6g75/zzEz+3tlbHLHTvrsJwww2AMwxqA9B2PEJFBXDVVbp8wgnASy+Fj3399eTcSG0BRz4TQjoMBw8Cu3cDpaXRj1u6VDt9L1u2qMsIUGHYt087fIs3M8npSvJaDBQGQgjJAmpq9DOWMLz8MvDMM8A777i3b94cFoaRIzXDyCkMzkFuTU0afxg+XNdHjdLSGS0twIYN6s4aPz7lr5QWKAyEkA5DTQ3QubOWyY7GokXAd76jNZGcweQtW4ChQ3VZBLjmGmDy5PD+4cPDmUnV1epS6t5d148+GujXTzOazjlHLZJOWdoDZ904BkIISRfbtqkLqLRUO3y/uQ/27QPWrAEWLtQO/O9/B664Qvc5LQYAePJJ97nDhwMrVuiy041kmTlTPxct0iylbIXCQAjpMNTUAGPHqiunpsY/I2jpUmDcOM0y+sUvgO9/H5gxA+jSRYVhwoTI13fGGJwZSZb77w/sq6SVLDVkCCEkeLZtUzEoKoocZ1i0CJgyRZenTtWSFjbW4Aw++2GFYdcuYP58jUPkIhQGQkiHwVoJ0YRh8WLg3HN1WQS4+mpg3jxd97qSvAwerOMYjj1WXVV+mU25AF1JhJAOw7ZtOqFOUxOwalXr/YcOaYzgzDPD2668EjjtNOCpp1RYvvCFyNfv3BkoKdEie/36Bd78NoMWAyGkw1BTo8IQyWJYvhw46SSgd+/wthEjgOOO06J5/fsD3bpFv8eZZ+a2KAC0GAghHQgbYzjqKE1Z9WYmOeMLTr72NeDRR8Opqu0dWgyEkA5BSwuwfTtQUKDjC7p2VaFwsmSJzo/g5cordUKdaPGF9gSFgRDSIdi5U11EdsCZnztpwwbgxBNbnztiBDBpEoWBEELaFTa+YDn5ZLcwNDUBVVWaUeTHXXdlb22joGGMgRDSIfAOaCsqAlauDK9v3gwMGgT06OF//qWXprd92QQtBkJIh8Cmqlq8rqSNG3V+BEJhIIS0M5qagNtua73dz2KwNZMACoMTCgMhpF2xfTvw2GMqEE68FsOAAeo22rpV1ykMYSgMhJB2xfbt+tnQ4N7uVzTP6U7asEHnTCAUBkJIO6OuTj/r693bvRYD4BYGWgxhKAyEkHaFFYbdu93bo1kMzc06f0KkVNWOBoWBENKusK4krzD4WQx2LEN1NZCfr3MwEAoDIaSd4edK2r9fK6d6i9sVFWnNpA0b6EZyQmEghLQrtm/XuZSdFoMd9eydyrN/fy2ot2gRhcEJhYEQ0q6oq9OZ0/yEwY+iIuCVVygMTigMhJB2xfbtwAknuIXBVlX1o6gIWL2awuCEwkAIaVfU1el4BGeMoa5OB7T5UVSknxSGMBQGQki7oq6utcVQV6dzMPhhheG449LftlyBwkAIaTccOgTs29c6xhBNGMaO1XLaffq0SRNzAgoDIaTdsGOHuozy892upB07IgtDnz7Aa6+1TftyBQoDIaTdsH27zqnQr19riyFSjIG0hsJACGk3WJdRXl78riTSGgoDISSrMQa45x7gyJHYxzotBm9WEoUhfigMhJCspq4O+PnPgZdeiu/YgQN1ngVjgIMH9ZPCkBgUBkJIVrNpE9C9O/Doo+HZ1iJRV6cWg0g4zrB/v+7r2TP9bW0vUBgIIVmFd+a18nLg0kt14p333ot+7vbtYcvAxhmsteCtk0QiE4gwiMg0EVkvImUicofP/utFZLuIfBz6uSGI+xJC2h9TpgBLl4bXy8t1JPOttwKPPBL9XGsxAOE4A91IiZOyMIhIJwBPAbgIQBGAa0TkRJ9D5xpjJoR+5qR6X0JI++PwYWDFCuDjj8Pbyst1Ap3rrwfef19LZEfCaTFYVxKFIXGCsBhOB7DBGFNljDkCYC6AGT7H0ZAjhERl7VrNPrLTbQIaYzj2WI0RXHEF8I9/RD7fKQJeVxKJnyCEYQiAzY71LaFtXr4qIp+IyDwRGRrAfQkh7YyVK7U8tlMYysvDdYyGD9eZ2CLh50qyo6FJ/LRV8PlVACONMeMALATwXBvdlxCSQ6xcCVxzTVgYDh7Ujn1I6FVz8ODIwnDoEHDgANC3r67TlZQ8XQK4RjWA4Y71oaFt/8YY4xhqgj8C+GWki82aNevfy8XFxSguLg6giYSQtuC11zS19MILw9seewy47DLgmGNin79yJTBrFjBnjnboO3eqldC5s+7/wheArVv9z/VmH+Xlqajs3Nn+KqeWlJSgpKQkbdcPQhiWAzheREYA2AbgagDXOA8QkUJjTE1odQaAtZEu5hQGQkhu8fLL6rZxCsPcuSoKsYShpQVYtQoYP15LYZeWaqVUZ6cezWJwBp4BtRg2bGifFoP3pXn27NmBXj9lYTDGNIvILQDmQ11TTxtj1onIbADLjTGvA/iBiFwK4AiAXQBmpnpfQkj2UVUVfru31NfrGIRYbNqkb/n5+WFhaGnRwLNl8ODoFoONLwBuVxJjDIkRhMUAY8xbAEZ7tt3rWL4LwF1B3IsQkr1UVWnn7qS+3l3QLhIrV6q1AISFoXt3tzD07w/s3avxhO7d3ed7LQablRSt5DbxhyOfCSGB0NICfP65u3idMfFbDH7C4MxIAoBOnXTu5pqa1ueXlwPDhoXXGXxOHgoDISQQamt1gJpTGPbsAZqbk7cY7BgGJ5EC0P/8J/ClL4XX+/VTK2LfPl0m8UNhIIQEQmWlxgd27QpvsyIRy2Iwxi0MhYUqKOvXtw5a+wWg9+zR8885J7ytXz9g82Z1P3ViT5cQfFyEkECoqtKO3Wkx2OVYFkNNjQrB0NDQVxG1Gvr3B3r3dh/rF4BevBiYONFdQbVfPxUcBp4Th8JACAmEqipg7Niw+whQYRCJLQwrVgCnnuqugFpU1NqNBKgryWsxLFgAXHCBe1vXrkCvXowvJAOFgRASCFVV6vbp3TvsOqqv11HLsVxJy5frG7+TU07Rqqpe/FxJCxcCU6e2PrZfPwpDMlAYCCGBUFUFjBihaaLWhVRfD4wcGZ/FcNpp7m3f+hbw5JOtj/UGn7du1Z8JE1ofm5dHYUgGCgMhJBCsMOTnh4Vh1y61IqJZDMb4Wwzdu4frHjnxWgwLFwLnndd6YB2gFgNjDIlDYSCEpIwxmpXkZzEcc4xaDJGm5ayq0njAEL+azD54g88LF7aOL1joSkoOCgMhJGV27QK6dNGO2CsMBQXa8du5l734WQvRGDhQLZDDh3VQ3fz57tpMTr78ZWDSpMS+CwmoJAYhpGNj3UiACoMdy1Bfr+t9+2pn3qtX63NXrEhMGDp10ppItbWa5pqf75+9BAA335zY9yAKLQZCSMp4hcFpMeTlhctT+LF8eevAcyxsAPq114Dp05NvN/GHwkAISZlYwmAtBi8tLcBHHyUuDDYA/frrFIZ0QGEghKSMDTwDbmHYtSu6xVBWpqObE80cGjxYLY2qKuDMM1NqOvGBwkBIB+eBB4B3303tGsm6khKNL1i+8AXgmWeAadM06E2ChcJASAdnyRJg3brUrlFVpQPZgPA4hpYWdR9FcyV9/LGWwkgU60qiGyk9UBgI6eA0NACNjcmf39Ki5bFtFVRrMezZo0XtbBqrn8WwaRNw/PGJ33PwYB3QdtFFybebRIbCQEgHp7FRO/FkWbdOYwQ2TmCFwbqRgMgWQ2Vl7Lmg/Rg7Fvje99Q6IcFDYSCkg5OqxbBkCXDGGeF1O47BKQx+FoMxQEVFcsIwfDjwxBPJt5lEh8JASAensTFYYejbV+dlrqtzC4PXYqiv18FqnF0t+6AwENKBMSYYi8GZMtqpE9Cnj7qJnK4kr8WQrLVA0g+FgXQYmpuB738/cjG3bOXZZ4GSkvRce/9+fS6xYgwHDwK33dZ6e329Tp85Zox7e14eUF4e3ZVEYcheKAykw1BaCjz1lHvqyWynrg74wQ+A999Pz/WtpRDLYti2DXjsMW2Pk2XLdNSydyyBVxj8gs+VleEUV5JdUBhIh2HJEv2sqclsOxLhgQf0M9ZEN8liO+tYwmCPW7HCvd0bX7Dk56sw2KwhWgy5BYWB5BxNTRrcTBQrDLW1wbbn0CF1tQRNVRXw/PPAj34Ue2rMZGls1Eql8QrD8uXu7ZGEIS9PxyhECz5XVNBiyFYoDCTn+MtfgCuuSPy8JUuAk04K3mJ49FHg5z8P9poA8LOfaa7+6NHpE4aGBmDo0NgxhoYGdRc5LYaWFuDDDyMLw+7dYWHo1UvF88iR8DHJjmEg6YfCQHKO9et11i6vvzsaO3eqIJx3XvAWQ3k5UF0d/DXfeAP48Y8jDw4LAisMjY3Rg/INDcDkyWox2OPWrlVrw68AnhUE+yni/h52xjdaDNkJhYHkHOXlwFFHAX//e/znLF2qxdqGDAneYqiuTkyk4uGJJ4Bvf1vTPv1SPYOisVGrm3bvHnmGNUA79DFjNIPJiuCrrwLnn+9/vFcYALcw1NaqFXH00al/BxI8FAaSc5SXA9/5DjBvXvznWF94QUHwwrBlC7BjR/zHv/++ClUk6uuBP/0JuOUWXU+3xdCnD9C7d3R3UkODtuO009SdZAwwZw7wzW/6H+8nDM4ANN1I2Q2FgeQc5eXqe//oI2D79vjOscJQWBi8KylRi2HOHOC++yLv/8MfgEsuUesG8A/cBkVjo3b4ffq4A9D33ecO8FthmDhR3Unvvgv06BG5ZHYkYbDfgxlJ2Q2FgeQUe/boz7HH6kTvXndSVRXwrW9p5pKluVk7s8mTVRiCtBgOHNA3/ESEoawMWLDAfzzFkSPAk0+6B5Ol22LwE4bHH9esIosVECsMc+YAN9ygsQM/nNlIFqdLjBlJ2Q2FgeQU9k1TBPja14C//tW9//e/VzfMI4+Et336qb595+cH70qqrtYJag4e1LTVeCgrAyZMAF55pfW+N95Q0Rs/PrytVy+9tjOjJyisK8kpDE1NWgRv5073cVYYPvwQePll4P/8n8jXzc/XazoHvtGVlDtQGEhOUV6uHSegs3d98gmwcaOuNzcDzz2nVsTDD2vWTH09cPfdmo0EaBbNjh16bBBs2aJZPQMGxBdn2L1bg7w/+IF/jGTp0tYBXRHtZNNhNVhLwBljsIKwa1f4OCsMBQXalvPO02cZiSFD3OIGuC0fWgzZDYWB5BSbNgHHHafLRx2lLpd77tH1BQt0ysfp04H77weuvlo7p+OO07EGANC1q765Ot+GU6G6WoVh4MD43EkbNgAnnAB85SvAe++1dietXNm6QwXSF2fwsxiswPlZDABw3XXArbdGv25BQev6Tk6LgTGG7IazpZKcorxcB3xZ/vM/gVGjNBBt/d6ApnquXq1v35df7r5GQYEGoL1vvCtXascNqMskno5ryxZ9O66ri08YyspUGHr3Bi64QF0yNrPHmMjCkK44g1+MwX4PP4sBSH4wX79+wGefaSFDgBZDNkOLgeQUTlcSoP73e+7Rzmb+fLUSAHW/PPVUa1EA/APQe/eqe+Svf9Xg7+23x9ceazEMGJCYMADAVVe53Ulbt6o42GwkJ+kay9DY2NpisN8jksWQLH37Ar/9rX7PFSt07ATJTgIRBhGZJiLrRaRMRO7w2d9NROaKyAYRWSIiw4O4L+l4bNrkFgYAuPFG7cymT49v0he/APRLLwFnn63C8Kc/aTpmPOW5q6u1I4/XleQUhksuUXeS7ZCtteCX6ZNui8EZY6ir007bKwx9+qR2rwsu0Gf70kucnCfbSVkYRKQTgKcAXASgCMA1InKi57BvAdhljBkF4HEAv0z1vqTj0dys6aheF0/XrhpwtpVIY+E3lsHphho5UjvGsrLY17LB54ED4ws+O4Whd2+d4GbBAl2P5EYC0hdj8BvHsGOHuuesK6m5Gdi3T9ubCsOGaSZTpBRXkj0EYTGcDmCDMabKGHMEwFwAMzzHzADwXGj5JQARBtITEpnqanXZHHVU631jxug8wPHgdSWVlanv+5JLwtumTAEWL46vTfFaDMbovUaNCm+bPh14/XVdjiYMqVoM99yjouqkqUnTbHv1au1KOvHEsMWwZ48e07lz8vcnuUUQwjAEwGbH+pbQNt9jjDHNAHaLSH4A9yYZZu9eHWjWFrOieeMLyeJ1JT37rL7JdusW3haPMDQ16cjrwYPjizFs2wb07Ol2o0yfDrz5plYq/eST6MKQbIzh4EHgoYfCmVmWxka1Amw6rNOVNHp02GIIIr5AcotMBZ9pTLYTPvgA+Mc/gq8u6oczVTUVnK6kpiYd++Ct+XPuucCiRdEFr7ZWC9B17RqfxeB0I1mOOUbPnT9fz3daE05iWQy7d2sdI79CeB99pO6uP/3JnR5rA8+ACoTTYhg9OmwxWHcT6TgEka5aDcBpxA8NbXOyBcAwAFtFpDOAPsaYXfBh1qxZ/14uLi5GcXFxAE0k6WLRIv0sLdXOJxFsx+ocHbtjh38ZZyA4i8HpSpo/X9v9xS+6jxk1Cjh8WN0vkdIqbXwBiC/GUFbmTrW1TJ+uKaBjxwKdIryq9esHrFsX+dpz56oALFsGfOlL7n1Llug96uu1DpPNuHJaAt4Yg7UYjKHFkI2UlJSgJF0TgSMYYVgO4HgRGQFgG4CrAVzjOeY1ANcDWAbgawD+FeliTmEg2c/ixeqPLi0FLroo9vHGAC+8APzxjzoA6pVXgEsvDe8vKlIrxM8yKC93xwGSxY5jANxBZyciYXdSJGGw8QUgeYsB0E77oYe0MGAkYlkMc+ZomY1Fi/yF4cortbO/9FIdnNa1q9ti8MYYhgzRInl79lAYshHvS/Ps2bMDvX7KrqRQzOAWAPMBlAKYa4xZJyKzRWR66LCnAQwQkQ0A/hPAnanel2SeAwc0YHrjjVp+Ih7+93+BWbO0pPR116nf3XL4sPrsP/ig9XnGaO67980+GQYM0Lfnbdt0wh879sHLuedGjzPYwW2A1gaqr49eaiOSMEyerOdHii8A0WMMa9bo2IDZs1u31xh9nmecocIxalR47ISzw7fpqsaErbb8fLUaKAwdj0BiDMaYt4wxo40xo4wxvwhtu9cY83po+ZAx5qrQ/snGmMog7ksyy7Jl2lFPnKgWQyyamoC77gJ+9SudmnPoUHfZbOuK8ROGsjL1n59ySurt7txZO77HHtPSFJE6vSlTwq4yP+zgNkDdYX37ukcLe4kkDF266DP58pcjnxvNYnjmGWDmTOCcc7TAnbOYn81EGjFCP2fO1Al2AH9XUkODZn11765uvp07KQwdEY58Ji6MUbdGPFlGixdr51lUpBZDrHOefVb9+9Om6fqgQW73S12dujiWLGl97uuvq8slqBz4ggLgN7/xdyNZTj5Zq4BGqmrqdCUBsd1JTiHx8h//odlNkYg0juHwYeDPf9YOv29fdRc552W281DY53bqqZr9BLhdSb16qQVYWxuO8TgthlQHt5HcgsLQznjgAWDqVP35zW8SP3/HDuDOO+ObzGbxYnW39O+vb5lbtkQ+9sABdXU89FC4kxo40G0xbN8OTJqk9Yq8s4lZYQiKwkK9/7nnRj7GWhbONpaXA9dfr+2prHR39NEC0IcP65t8soPEIlkMr74KnHQScPzxuu51f1lhsJx4ov6e9u51WwKdOuk0mxUV+j0AWgwdGQpDO2PuXJ2n4Pzz/ev9x8K6HmKN+j18WF1JZ52l60VF0d1Jzz2n6ZSTJoW3+VkMQ4cC48bpZDCW3bs14ybS/MLJMGyYTugTKQvIMniwe8zD8uX6Rv7AAzpFpzMwHc1i2LVL38CTtXgixRieeCI8BSjQ2v3lFYYuXdQSWrXKbTEAKlqbNoWFIT+fwtBRoTAEzL59QHEx8Pnnmbn/tm3AjBnAhRcmNyFNZaV+xhKGjz7St1Q7WMsrDF63UllZWEQs3o60rk63nXGG25309tva4fXsmdBXicrjj8dXKK+w0B0gr65Wa+yDD9Q6cKbPRhvktnOndrTJ0qOHfh48GN724Yf69u8sFHj22dq2pia10tauVfeRk/HjNWnA2+H36eMWhv79GXzuqFAYAuauu/SNLVrOebo4fFj/iQcOTH5u46oqfauMJQwffKCdkMXGGQDgL3/RyqFObKfvZNCg1q6kQYO0fpBTGIJ2IwHqU+/aNfZxXoth61ad8wHQjtNJNIth587WxyeCSGt30qOPAj/8oXscyIABWhrkJz/R388557QuIeIUBqfF0KePusqcMQZaDB0TCkOALFqklSNnzAA2b459fNDU1GjH2qlT2N+d6ExlVVX6xh5LGD79VAdkWazFcOgQcMcdrd1KttN3MmCAdjwtLbrutBiWLlWro6lJR1YHLQzx4rUYnMLgJVqMwbqSUsEpDFVVWnzPL3g+c6ZaNg8+qFOFerHC4B3RbIXBazFw5HPHg8IQEPv26T/pb3+rHWa0QGy62LYt3GnZmcriqfjppKpKXSWffRb9uNJSFQOLtRh+8xt/a8XPYujaVf3atkzD9u16zODBGgh9913NYDrrrMRHVQeF12LwZiI5cVoMq1e7y1OkajEA7jjDk09qGQ+/bKEf/1gHEV54oX/hu7FjgfXr9W/D2eH37u0WBloMHRcKQ0A88ojm83/lKxrYzITFsHWrO+UxGXdSVZUGeSsq9G3dj5YWdZWdfHJ4W16edub33qvi2NjoTvOsq/OfI9jZmTqPOeMMFaizztKS2pkiEYvBxhjeew84/XTgtdfC+4KwGGzKqjHqrvv2t5O7Ts+eGjT/+OPWrqR9+xhjIBSGQNi+XbND7HwAQ4dmRhi2bWstDIkGoCsrNaWxsLB1mWbL559rR+GdbKWoSEsujBvnDsQaE7YGvDhTVp3H3H67jkqePTuz5Z6dFoMxsV1JpaU6eG/MGPezD8piaGjQ31Fzs/9guXgZP17dfl5XEkCLgXDO50C4/37g2mvDGSrDhmXelQT4z1QWjYYG7XDy8rSM2EC+AAAV00lEQVTTKSvzr1lUWuq2FixPPKGCAuibf22ttmfPHi1p7TePgjNl1WkxRCsP0ZY4LYaGBhWpSGMRCgr02OefV/F0Pvtdu+KbQzoaVhgWLdIsrVQG+40fr+4mb7oqEA4+23EMtjw36TjQYkiRigodefrTn4a3WYuhLeYocJKqK6mqSksniISFwQ9vfMFy8slhd4mzUF0kawEIWwyHDqkbI9umfLRWVyxrAdDYw/r1wDe+0frZBxljsCPOU8EKbzSLIS9PBa1Hj/gyuEj7gcKQIo89Btx8s3aEFvvPZqtVthVeiyFRV5IVBiC6MKxd6y8MTpzC4Bd4tliLwRZuy7ZpH21aa0ND9MCzxZbV9j77VMcxAOEYgx1xngrjx+tLhHNyoj59tEbS0Ufruq3/RDdSx4PCkCKrV7cucyySWAD6wIFg2uK1GBJ1JcUrDJEsBidei8Ev8AyEg8+RgtPZgI0zxLIYnHif/a5dwVgM69ap1XDSSaldKz+/9SDMPn309+EU5/79KQwdEQpDimzcGK5T42To0PjjDGPGBBOT8As+J+JKqqz0F4bm5nAn55eR5EciFsP27dHdTZnGxhkSEQY/V1IQ4xjeflsHrcUq5REPXTwRxt69W0+SlJ9PYeiIUBhSYP9+dYH45djHazEcOqRlCJIpX+HkyBEdD+B8607GlWRr/4wYoZ31/v3Ad7+r5bUbG/WYvLzYnUVBQTjbKJo1kEsWQzyuJIt1kdnBe0FZDHv2pO5GikRRkdbZckKLoWNCYUiB8nLNNPFLp4w3ZdUe45yLNxlsuWRnW1JxJXXurFlW3/qWFo477zzg4YfjcyPZe8cTfM4ViyFRV1K3bvoGvnOniqsx/llZiWAD86kGniNx7LFa0sUJLYaOCdNVUyCSGwlQi8FvwhkvdqxAqsLgDTwD+rbX0KDWRDxZJU5hANSdtGyZfo9Dh3QGsL174xMGm64K6JvzhAn+x+WCxZCMK8meV1urHXr//qkH1vv2VbEJYrKieOnf3124j3QMaDGkQCxhiMdiCEoYvIFnwH8+gUgcOKAi4syumj0beOcd7eBGjNCpOJ94IliLYcAAdbPU1GSvxZCMKwkIW2xBxBcAjUX97W9tO+Cvf//sSyEm6YfCkALRhCHe4HNVlb5JBmEx+M0AFm+coapKxcwZ1Bw71m1B3H23pm+OGRP7egMHaofY3Bw9+Nyli2bDfPZZ9gpDYaGKQm1teABfvOfV1AQTXwDUPTV1aurXSYTvfhe49da2vSfJPBSGOLjxRi0O5x2wFo/FEGuQW1WVTtAeba7gePBzJQHxZyZ53Uh+DBigcZWJE2Nfr2tXdX3s3Bk9XRXQfaWl2etKGjxY05L79tU8/3ixzz4oiyETDBqUmPuMtA8oDDE4cgR48UUtDPf1r7vr4UcThj599O070gTulspKrS2UDlcSEH8A+t1346u9401njIZ1J0WzGADdZ+eRyEYKCzX7LBE3EuB2JQVhMRDSVlAYYlBaqm/Sy5ZpVcqbb9bthw7pW3q0t+x44gxVVcEIQzSLIZYwrF4N/O53OrlLkBQU6PzNPXqEZyDzwwpCtloMNtsr0TdnazEEUVmVkLak3QuDNeWTZflydZ306KHpmm+8oemH5eU6U5Z3kJCTWMLQ3Kxv+qeckj6LIZYr6cgRndjloYe0vUEyaJBO6BPLEhg0KOx6ykY6dVKRS0YYaDGQXKTdC8OsWToFYrIsX66T2AP65jhpEvDmm9HdSJZYAeitW7XDKChIX/A5livpwQe1A/vmN1O7vx8FBcCaNbEtgYEDs7NOkpPBg5N3JdFiILlGuxeG1atjz0YWjRUr3MHWq64C5s1TYRg1Kvq5w4a1rkfjxAZ88/JiC0NNjaaO+tHUpG+lzlRTSzSLYfNm4PHH1Y2Ujk65oCB+iyFb3UiWwsLkXUm0GEiu0a6FoaVF31hjzV8ciYMHtYzyuHHhbZdfrvVqVq2KbTFMmaKzj9myCF6sMOTnxxaG2bOBW27x37d9u17Dz60VLcYwaxZw003Bu5AsNsYQjzBka+DZcvfdOglRIgwcqNaC/f0Qkiu065HPVVXqu964UTvneAqP/e1vmlE0dSrwySc6m5kzcNq/v047OXeuWg/RKC7W3PO33wYuvti/fSNH6v327tWYg9/gpR079H5NTf4ZPps2hScJ8hLJlbR2LfDqq9pxp4uCAv1OsayBL385dlG+THPGGYmf07mzCsJnn9FiILlFu7YY1qzRmEBeXvzVS198Ud+iDx92xxecfO1rmpUUy2IQAX70o8gxDlvNtFMnFQc70buX3/5WLZVzztG0Ui/r1qmA+ZGXp5aPc2J6QN+Ab789vaNarWsrljVw9NFapK89Ulio1iAtBpJLtGthWL1aR+mOHh2/O6myUq2L3/2udXzBcvnl+g9vK5FG4+tf17fz1atb73MOKosUZzh0CPj1r3X06ZQpOkmLl/XrI9fnF9Hvv26d+/hlyyK7poLCCkO2xw/SiX0GFAaSS7R7YRg7NvqkM14qKoA//EHncX73XX9hyM/XjCLn7FeR6NZNO2A/qyEeYXjxRf0OY8ZoueVFi1ofs359ZIsB0HOdwrRsmV4r1WqfsbCCkO3xg3RSWKjjX6KN4yAk22jXwrBmTWLC0Niob+gXXACcf76mgEYqGJdIFs9NNwEvv6yxAosxmrEUSxjmzAm/2Z96qsZLvC6naK4kQJ/BmjXh9ZUrw3P+ppMePdRF1pEthsJCxhdI7pHVwrBvn7phkuHAAXULjR4dvzBUVqp7SAR44AHgpz8NZhL0/Hxg+nTghRfC2+rq9E3Szq/rJwx79mgnfv75ut6tG3D66cD774eP2b9fg8vHHBP5/mPHui2GthIGAPje92LHYtozBQV0I5HcI6uF4Xvf01G5ybB2rY4z6NYtfmGoqAh3sCNGaIA2KG64AXj66XBRvYoKdzmNvLzWhfQWLVIh6NkzvM3rTtqwATjuuOgjsJ2upJYWzbZqK2F44AGdQ6CjQouB5CJZm676xhvAggX65p8M1o0EaGe/ZYtmGkWLC1RUxBdQTobiYnVV2bf1++9XK8LiN5Zh4UJ1azmZMgW4887weiw3EqADs5qbdbDV3r3q3kmkGB5JnqlTO7YrjeQmWWkx1NerX/5//kffcJMpSW0Dz4C6g4YP1/pG0aisjO6SSYVOnbTsxJw5wJ//rPdyTqPo50pasKB1/f1Jk3Q0cWOjrkfLSLKIhN1JbelGIioKbT2HAiGpknXCsHs3cO21mhJaXKz+6Y0bE7+OUxgAdSfFKo2RTosBAK6/XrOMfvQj4Nln3bX9vcJQXa2xA28nftRRakX89a+6HisjyUJhIITES0rCICJ5IjJfRD4TkbdFxLc+pog0i8jHIrJSRF6Ods0JE1QMHn5Y1xMVhk8/BX78Yx2c5ixlEU+cwRljSAcjRugI2ltuaT0HslcY/vlP4Lzz/EdC33AD8MwzurxuXWyLAdA4w5o1FAZCSGxStRjuBLDQGDMawL8ARKrov88YM8EYM94Yc1m0C/7XfwFPPhl+m45HGHbtAp56SkcpT5umrqMPP3RPwxhLGIxJryvJ8vLLwM9+1nq7Vxj83EiWiy/WZ7JunQaf45lghxYDISReUhWGGQCeCy0/ByBSpx931v8VV7jXYwnD/v36Fv7ee5oBU1WlpaRHj3YfF0sYdu3SOEC6Jz6PlD3kFAZj/APPlq5dgeuu0yJ4AwaEU16jUVSk1tShQxpvIYSQSKQqDIOMMbUAYIypARAp/6K7iHwoIh+IyIxEbhBLGO6+Wy2FuXOBCy/0d70A4TfmSFVM0+1GioUzXXXdOh0cFqkwHqCB7Hnz4nMjAUCvXurKGjcuu+c9IIRknpjpqiKyAICz0r8AMAB+6nO4iXCZEcaYbSJyDIB/ichqY0yF34GzZs3693JxcTFOPLE4ojC8+y7wl7+4R/VGYsAATQ/9wx+0eJyXtnAjRcNpMSxerOMVonHSSWopxRN4towdm97gOiGkbSgpKUFJSUnari/GROrL4zhZZB2AYmNMrYgUAnjHGBP1HVZEngHwmjHm7z77jLc9xugAqepq99SPhw6pe+SRR4AZcdogK1dqTf3ycnXHlJbq8le+orGNbdtSm+0tFVpadIzFwYPAN76h1k+sWdWWLFHLIt6YwXvvqQBFKvNBCMlNRATGmMB8Aam6kl4FMDO0fD2AV7wHiEg/EekWWh4A4EwAcRe6EPF3J731lk61GK8oANqBjhqlLpjKSuCiizSFdP36zLuSOnVS4du9Wy2GKVNin3PGGYkFks8+m6JACIlNqiOfHwIwT0RuAFAF4CoAEJFTAdxkjPkOgJMA/E5EmqFC9KAxZn0iNxk1SoXh1FPD2+bNA66+OvEG33abDiw7fBi4447wwLM+ffwn02lL8vK01LdI9PgCIYSkk5RcSUHj50oCgJ/8RDNvbO2iAwe0zMP69f7zHEejpUV97ZdcAjz0kK5fcIHOp7xmTWYnjJk4UQPpDQ3ugnuEEBKNbHMltQleV9Lbb6sLJVFRANRCWLFCRcGuz5mj6a2ZdCUBajG88kp8biRCCEkXOSkM8+bFnm85Gt5JU0aO1BTRXr2Sv2YQ5OVpADxWRhIhhKSTnBOGAweAN98EvvrVYO+RDbn9eXmaVptICiohhARN1pbddjJ4sPrdn3xS00tPPbV9ljLOy1M3UjaIFCGk45ITwtCpE3DffeHZ3O6/P7PtSRdf/apmSxFCSCbJiawkQgghkemQWUmEEELaDgoDIYQQFxQGQgghLigMhBBCXFAYCCGEuKAwEEIIcUFhIIQQ4oLCQAghxAWFgRBCiAsKAyGEEBcUBkIIIS4oDIQQQlxQGAghhLigMBBCCHFBYSCEEOKCwkAIIcQFhYEQQogLCgMhhBAXFAZCCCEuKAyEEEJcUBgIIYS4oDAQQghxQWEghBDigsJACCHEBYWBEEKICwoDIYQQFxQGQgghLigMhBBCXFAYCCGEuEhJGETkShH5VESaRWRClOOmich6ESkTkTtSuSchhJD0kqrFsAbA5QAWRTpARDoBeArARQCKAFwjIiemeN+spKSkJNNNSAm2P7Ow/Zkjl9ueDlISBmPMZ8aYDQAkymGnA9hgjKkyxhwBMBfAjFTum63k+h8X259Z2P7MkcttTwdtEWMYAmCzY31LaBshhJAspEusA0RkAYAC5yYABsDdxpjX0tUwQgghmUGMMalfROQdAD8yxnzss28ygFnGmGmh9TsBGGPMQz7Hpt4YQgjpgBhjorn0EyKmxZAAkRq1HMDxIjICwDYAVwO4xu/AIL8YIYSQ5Eg1XfUyEdkMYDKA10XkH6Htg0XkdQAwxjQDuAXAfAClAOYaY9al1mxCCCHpIhBXEiGEkPZD2rOSRORpEakVkdWObaeIyBIRWSkiH4rIaaHtfUTkVRH5RETWiMhMxznXhwbIfSYi16W73THaP1ZEPhCRVSLyiogc7dj3ExHZICLrRORCx/aMDPJLpP0icoGIrAhtXy4iX3KcM0FEVofa/3i2td2xf7iI7BGR2xzbsv7Ze/Z9GtrfLbS9zZ99ou0XkS4i8myonaWhWKI9J1PPf6iI/CvUnjUi8oPQ9jwRmR/qS94Wkb6Oc34V+v/9RETGOba3af+TaNtF5NrQ72SViLwnImMd10r8+Rtj0voD4GwA4wCsdmx7G8CFoeWLAbwTWv4JgAdDywMA7ITGQfIAbALQF0A/u5zutkdp/4cAzg4tzwTw/0LLJwNYGWrzSAAbobGXTqHlEQC6AvgEwIlZ2P5TABSGlosAbHGcswzAxNDymwAuyqa2O/b/FcBfANwWWs+VZ98ZwCoAXwyt5yFs0bf5s0+i/dcAeCG0fBSACgDDM/z8CwGMCy0fDeAzACcCeAjA7aHtdwD4RWj5YgBvhJYnAVjq+F20af+TRNsn2zYBmOZoe1LPP+0WgzHmPQD1ns0t0IcM6IOutocD6B1a7g1gpzGmCTpqer4xpsEYsxsar5iW1obbBvm3f1RoOwAsBHBFaPlSaAylyRhTCWADdIBfxgb5JdJ+Y8wqY0xNaLkUQA8R6SoihQB6G2OWh855HsBl2dR2ABCRGQDKobEsS048ewAXAlhljPk0dG69McZk6tmH2pBI+w2AXiLSGUBPAIcANCKzz7/GGPNJaHkvgHUAhobu/1zosOcc7ZkBfb4wxiwD0FdECpCB/ieBtl8WOmapMaYhtH0pwmPFknr+mSqidyuAh0XkcwC/hFoKgJbOOFlEtkLfnn4Y2u4dJFeNzA6SKxWRS0PLV0F/YUDkdmbbIL9I7f83InIlgI9Df0xDoG22ZLL9vm0PuTRuBzAb7gy5XHn2JwCAiLwVcuf939D2bHr2QOT2vwRgPzTzsBLAw6FONCuev4iMhFo/SwEUGGNqAe2AER6nFamtGe1/YrR9kM8pNwL4R2g5qeefKWG4GcAPjTHDoSIxJ7R9GoCVxpgvABgP4NdeH3KWcAOA74nIcgC9ABzOcHsSJWr7RaQIwIMAvpOBtsUiUtvvBfCYMWZ/xloWH5Ha3wXAWVCXzDkALnfGeLKISO2fBKAJ6gI5FsCPQx1axgn1IS9B+5y9UOvGSaQMnIynzyfa9tDfzDehbqakCXIcQyJcb4z5IQAYY14SkT+Gts+EdkgwxmwSkQqoX60aQLHj/KEA3mmz1nowxpRBzUuIyCgAl4R2VQMY5jh0aGibQP2t3u0ZIUr7ISJDAfwdwDdC7jAg8vdqc6K0fRKAK0Tkl1CfcLOIHATwMXLj2W8BsNgYUx/a9yaACQD+B1ny7IGo7b8GwFvGmBYAdSLyPoDToN8rY89fRLpAO9Y/GWNeCW2uFZECY0xtyFW3PbQ90t95RvqfBNuOUMD59wCm2b+jUNsTf/7pDKA4AikjAaxxrJcCODe0fD6A5aHl/wZwb2i5AGoC5cMd/LHL/dqi7RHaP9CEAzvPAZgZWrfB524AjkE4+NwZ4QBQN2gA6KQsbH+/UNsu87nGUqi/UqAB0GnZ1HbPOfciHHzOpWe/AkAP6AvbAvuMM/Xs42z/9aH12wE8HVruFfofL8qC5/88gEc92x4CcEdo+U6EA7hfRjj4PBn+wec263/iaLsz+DwcGtOc7Dk+qeffFr+YFwBshQajPoeaOWeG/glWAlgCYHzo2MHQjKXVoZ9rHNeZGfriZQCua8M/LL/2/wCaJbAewAOe438S+kWsQyjzKrR9WuicDQDuzMb2A7gbwB7oW/bK0OeA0L5ToWXWNwB4Itva7jnv38KQK88+dPy1AD4N/e0/6Nje5s8+ib+dXgDmhdr/aZY8/7MANEM7Q/v3PA36srkw1Kb5cHTy0DjnRmiMc4Jje5v2P4m2HcAfoFmc9n/3w1SePwe4EUIIccGpPQkhhLigMBBCCHFBYSCEEOKCwkAIIcQFhYEQQogLCgMhhBAXFAZCCCEuKAyEEEJc/H9G3Dlhzt2+EAAAAABJRU5ErkJggg==\n", - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "pyplot.plot(year, temp_anomaly);" ] @@ -185,17 +151,20 @@ "collapsed": true }, "source": [ - "Ahora tenemos un diagrama de líneas, pero si ve esta grafica sin ninguna información, ¡no podrás averiguar qué tipo de datos son! Necesitamos etiquetas en los ejes, un título y por qué no un mejor color, fuente y tamaño de los ticks.\n", + "Ahora tenemos un diagrama de líneas, pero si miras esta gráfica sin ninguna información, ¡no podrás averiguar qué tipo de datos son! Necesitamos etiquetas en los ejes, un título y un mejor color, fuente y tamaño para los ejes.\n", + "\n", "Siempre debes apuntar a generar **gráficos de calidad de publicación**.\n", + "\n", "La forma en que presentes tus datos permitirá a otros (y probablemente a tí mismo en el futuro) comprender mejor tu trabajo.\n", "\n", - "Podemos personalizar el estilo de nuestras tramas usando **Matplotlib**'s [`rcParams`](https://matplotlib.org/api/matplotlib_configuration_api.html#matplotlib.rcParams). Esto nos permite establecer algunas opciones de estilo que se aplican a todos los gráficos que creamos en la sesión actual.\n", - "Por ejemplo, crearemos la fuente de un tamaño y tipo específico. También puedes personalizar otros parámetros como el ancho de línea, el color, etc. (consulta la documentación)." + "Podemos personalizar el estilo de nuestras tramas usando los parámetros de configuración de **Matplotlib**: [`rcParams`](https://matplotlib.org/api/matplotlib_configuration_api.html#matplotlib.rcParams). Esto nos permite establecer algunas opciones de estilo que se aplican a todos los gráficos que se crearán a continuación. \n", + "\n", + "Por ejemplo, crearemos la fuente de un tamaño y tipo específico. También puedes personalizar otros parámetros como el ancho de línea, el color, etc. Consulta la documentación para más detalle." ] }, { "cell_type": "code", - "execution_count": 6, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -208,34 +177,23 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Volveremos a hacer el mismo grafico, pero ahora agregaremos algunas cosas para que sea más bello y de **calidad de publicación**. Agregaremos un título, etiquetaremos los ejes y, mostraremos una cuadrícula de fondo. ¡Estudia los comandos a continuación y observa el resultado!" + "Volveremos a hacer el mismo grafico, pero ahora agregaremos algunas cosas para que sea más bello y de **calidad de publicación**. Agregaremos un título, etiquetaremos los ejes, y mostraremos una cuadrícula de fondo. ¡Estudia los comandos a continuación y observa el resultado!" ] }, { "cell_type": "code", - "execution_count": 9, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAApIAAAF5CAYAAAAs48q6AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAIABJREFUeJzs3Xl8XHW5+PHP0zRLm2ZP973QFlqgZbetQtlRFhFB8ScKXBUUEa4oi8hFxVsQXK4XxR1ElquyCwiyp0ALBSxl6Zq0TfekTZqtSZs0yfP745xJJzNnMsuZyTJ53q/XvNI55zvnPPPMyeTb73ZEVTHGGGOMMSZeQ/o6AGOMMcYYMzBZRdIYY4wxxiTEKpLGGGOMMSYhVpE0xhhjjDEJsYqkMcYYY4xJiFUkjTHGGGNMQqwiaUwKicgQEVkqIutFZExfx2OMMcYkk1UkjW8iMlJE2kSksq9j6U0icpOI7BCRdhHZEKHY94GpwGmqWtWL4UUkIvPcuFtEpFNEJvV1TMaIyG/d67JTRF7xcZxnRGSne5x7kxljbxy/N4nIKBHZKiJ/7OtYzMBlFUmTDF8GhgITReTUvg6mt6jqbao6FtjitV9EjgW+BZyhqpEqmr1OVd904/47kLI7EvitEBiHiFT28B+VtKGq33CvS7/HORs4Ngkh9cnxky3K9ZMNjACKezEkk2asImmS4VLgPUCA/+jbUPqVg4GzVfWDvg7EDGh2+zHjR8TrR1W3ACNV9bO9GI9JM0P7OgAzsInI8cB44HhgNXCeiBSoakPfRtb3VPWvfR2DMcb0RFX393UMZmCzFknj16XAX1W1HHgZp6vk/wUXEJEvuWOfWkWkwx2X85CIbBGRXSLymIiM8zq4iJwiIv8SkWoRqRKRj0Tk+yKSFVRmYciYv8NF5I8isllEdrvnyheRLBH5pYhsdI93v4jke5zz6yLyrNsltFNEtonIgyIyLZaEiMhBbjxNbjwnhOy/0H3PG9z3VC0iT4rIkRGOd7WIrHDj2Cwib4nILbFO3nHzfZ+I1IjIdvf1Z0d5zeki8pKI1LqPD0XkeyIS9T+fInK9iOzAaQmZ755zh/szM6jcWBH5vTtGq8b9eb+IHBRUJjSXp4nIHeJMXmoQkadFZKJb9mYRWed+5v8Ivqbcz36HiNS7x/maiNwqImvdc1eKyA+93l+CcZ7qfkarRaTZ3fZlt2xMn7+IfMHN4wScYSPBeZwmIj8SjzGFcmAMbKuIdIQc83338+wUkR+IyOdF5F33fXWN+ROR49z3vMY9X52IvCEiF0T7/D3yd7V7nDoRqRCRX4nIue75mgLvJ4bjZLrX4Idu3qpE5EUROS3K6z7lXvPb3ff5ZxEZFVKmyL1+lorzvbTbvZbuEJHceN9zhDiy3HOsduPYJSLPi8jJIeVCP6Mvishy99pdJSJfifF80a6fSyNdJ+7rRUSuEpH35MD3wOsicmFIuW5jRsX5zn7D/Xw6ReRVCRlPLiJT3d+BzW6ZTvdYKf8cTAqoqj3skdADyAHqgKPd5xcBncA7Ecq/CnQAjwCHuNuOAhqAtzzKX+6Wvx3Idrd9AqgFyoChIeX/7Jb/J3CEu+1EoB14FFgUtP0kd/ufPM7bCfwaGO4+nwq8AewExnqU3whs8Nj+AzeeEzzKPwoUuc9HAU8AzYH4gsp+H2gE5gdt+yzQCnw5hs9oBLDWjf14d1uxe/7VbnyTQl5zhbt9Ec5/DAQ4F2gCno7j+ugEXomwbxKwHXgHmBK0bal7TU33yGUn8Bqw0N02C6gH3gWuBU5ytx/mXlMveZz3Evc424Cbgq6rr7jv+aEkxfmWe64MIB9YF/i84vn8e7q+ouUZ9/fNY/uJ7mv+DdwFDHM/478C9wb9Lq0GZrjPs4Fb3Nd9LY5r4Hb3NTfj9IBl4Ax/2ezm+79ieT/ua1/F+d0PfP5ZwH+7x7kipPxk9zircb5vit3txwO73O25ITlpBy4N2vZxYAfwukeMgePfG2MeAvHvDIo/F/i9G//nI3xGy4H/AjLdY/zZ3X5mHJ9BtOsn0nXyINCC830jbr4D18B1EfLxvnsdFbrb7wz+LN1YdgLPAYe6284KnD/ez8Ee/ePR5wHYY+A+gIuBD4KeZwO73S/GwzzKByqSnwnZ/pC7fULQtnHAXmCNx3FudL+0rg/ZHqhIXhWy/TVgv8f214E9Hsd/E8gI2TbbPecij/LxViSfAUaHbMt3v0BDKzL/Bt71OPZvgU/H8Bnd6sbw9ZDtBTgV1G4VSTfv+/Cu2P/ELR/1vG75niqSz7jHOjRk+0z3dU945LIT+FnI9vvd49wRsv0Bd/vIkO2BiuSrHjE97L7m5CTE+aeQ7adyoFIW8+ff0/UVLc9Er0iuAyRo+6EcqIz/EDjL47XvAFtj/PwPct+T17UU+NxuieX9AN91t3/Po/xq95oN/v4IVGzqgbyQ8le6+24N2nY08AePY3/TjfO0kO3xViQD8X8jZPtQnEr1DiDT4zP6IKT8dK/rK8q5465IAhe457nDo/xbON/NI4O2BfKxm+4V9AkEfV+4sXQAHw/aNgS4MpHPwR7942Fd28aPy4Cu5S9UtRXnf6PgtPBEsiTk+Sb354SgbRfiVEz/4fH6J9yfX4xw/LdCnm/B+bLy2j5MREqCN6rqPFUN7epZ7f6cE+GcMVPVs1W1OmRbI04rWejxq4Aj3S6ukUHlv6GqXrkJ9Rn35/Mh52sA3vYofyFOy8NzHvvexmmZ6LFbPBoRKQI+CWxW1dXB+1R1LU4F93QRyQh5qeL9GYJTwfHaHmlpoxc9tj2L8/4+m4Q4Xwop/5KqrnP/Hc/nn0qvqPtX2o1htaq+6v77h6r6T4/XrALGikhpDMc/Dyefz3vse8HdF6uLcfL6pMe+J3Fa7C702Pe2qjaFbHvW/dk1wURV/62ql3u8frUbp9/PJRD/s8EbVbUdZ6LiKOA4j9e9EfLc67syFTzjdb2N8x1xutc+VW0OPFHVrR7fU22q+kZQmU5V/Y3771R/DiYFbLKNSYiITAEWAJ8P2XUf8A3giyJynftF2Y2q7gzZ1Or+zAraNgPni2ybx+m3BZXxUhPyvC3C9sB5c3G6zICuZXuuxul2L3bjCPzRGx7hnDETkUOA/wTm4/wB6XSPPxKndSLYVTiV81uAm0VkKU636IOqWhfD6Q52f2732Oe1bab78z9F5IqQfRnAHiCWSkRPpuO837Ei4hUDOC1ZI3Eq0sES+Wy97PDYttX9GciZnzgjrhka5+efSj3FWISzdNXZOJPpAtd/ofszlt+DeK+9nkx3f0b6PhAOXLvBevqcDwre6I7//Ip7rlyc3/ts96ff3/vAd9WbImH152ycYQ1e48S7fVeqapv7+iyPsskUiPdhj/GTWTjxeo3RjmWt3Oqedqb4czApYBVJk6jLcLoaPvD4YtwPlOCMq3u8l+MC5w9zPNu7uAP3n8VpCThXVdcH7Yv6+hiOPxtYhtPFc7Gqvh+0b2NoeVXdCHzMrdxeiDMO9X+BW0TkHFUNbaGLJJsDlaueqPu4RVV/FeOx4xVoBVulqkfF+dqEP9sYZIc8T3qc8X7+PkXrcYoUYw7O8I5xwBeA5wP/IRSRP+OsGxuP0Lz2tbB4RORWnHGcv8L5XGrd7SfidP36FbiWZnq0kPYkGdd1IgLxnqqqH8bxuljijVimFz4HkwLWtW3iJk7N8cs4Y6jGhT5wJj74XVNyrXsMry6c8UFlku0KnN+L64MrkUl0Gc7khluDKxGRiMgQAFV9R1WvV9VJwNdxKuq3x3C+CvenV2uH17ZA3j27hEXkWBGZ7rUvDuU4f0w8u+dEZIL7hyOVvBa+DlxXgZylIs64Pv8YteN07YYaneDxTsVpkXpAVf/p1asQowqcaynWa68ngd/1nr4P1njs6+lzDv79vhJoVtVrApWXJAvEH/Z7JSK57kzn/jQruad4h7jxloTuS4JUfw4mBawiaRJxKs4g/bII+/8Pp8vxdBFJ9E4Vj+C0oH3GY9/5OP9jfjDBY/fEc001EZma4uPn4N1VtN5tjeyiqn/AGdReFMP5Hsf5Y35OyPkK8L47RyDv50tIU7M4S6a8hjMpIxYtBFVwRORaETlJVetxWn1LRGShx+t+BVwT4zkS5bVkzGdwrqvHAFIUZ7yfPzjdiMF5vDRkCZathPzBF5EJQEzLVcUaoyueYz6JUxH3GlN7GvEttP4gQeNXQ3wG55p9xGPfcSIywqM8OENEAvYDGnrNk3gOQwXi9xrH+VV3fyw9BomIdv146Snec3AmjMUzxjVWcX8OIjJagpYVM73PKpImEZfizLr05I7dewZn6MQlQbsiffGEbVfVHTjjFKeKyJ3uH9pAF8d3cSo0v4xwnNDjxbM9UDm9U0TGu+ccgzNLOl5e7/dhnC/LW0Rkpnv8AuAPRO4CXBQUyxAR+SpOJTLiZxDkpzizc78rIh9zj1GCM0kqMCi+K86gvE8GfiUiee5rpuH84X0ZeDqG8wJ8ABwsIsPdiUI3c2CM01U44+R+LSKHuefIFpH/Ak7AWZonWMzXTpTtASUicoN7ThFnbb7TcdZEDb6tY7LiDEjk8/8AGOX+wczFWbUgeB3Ex4AJIvIl93jFOJ97pPGW0WJ8A6fr/Usicrp7zAwRuRpn+a1YjoHbon8ncKg4a2oOdR+XAkdEe32Iu3CW/LpWRE5xY8oWkUU4YzGvUdXg8ZOB+JqBP7s5wf0d+A5O6+WdQeUfwBmP90sRGe6WPQpnbLJXhTfeSlQg/m+LyDnu8UVEPo2zssK1IS2/yaykRbt+vL5/H8dZTeMLIvIf4k4oE5FP4HwX/lBVa3o6RoLi+hxE5LM442C9Jg6a3tLX08btMXAeOC0mO3BaG2uBxR5lhrhlGnDGULbg/CFux1mio8N9fq1bfgcHlqGpAZ4NOd7JwL9wBmhXASuB7wFZQWVmucdpdo9TjfOHdEwc2+8JOt5ncMaI1eMM5H8T+Jxbdp8b/8k4lYgdOBWD/e7263AG8Ye+r3eDjn8CToWsxn1Py3EmKG0MOs4lbtkzcb5c17mxbMVZtuiiOD63kTgVx13usZfjzMq8N+j9Px0h77twZkB/iPMHKCeO8x6FM8t6J85s0ztD9o8G7nb37cDpanwQZxxZoEyeRy7/5u7bEuP2F4KOd4m7/RLg2zizkGvc3N9CyLJPPuPcDizwOF7Mn79bfirOLPCdOJXDe+m+VEwO8HOg0i3zipv7Vznw+3aXW/ZF97wdbqzbCVkT0C03BacisRWn9XsNzu/Oo0HXzO9jvA6+iTPrtg6ny3QRznXdCdwcVO63bg6Df88uCtqf6V6DH7p5q3bfz6kh53vGzUMHcA/ODRLec4+9y81f6LJQGcAN7vXQ5ObyaZxhOsG5ynGPX+1ub470OXvkITj+Xe45XiR8aaGwz8jd/h2P/Jwcw3k9rx+cBoEddP9evivktVfgrIhQ4772DcLXvLw3KN/NEY7zVcK/K72WNYv5c3DLn4jzt+ixWL+X7JH8h7gfhjHGpD0RuQTnD99lqhpLi65JARG5CGcIzDdU9fd9HY8xJnHWtW2MMSYlROT2QFduiE/gLgzfyyEZY5LMlv8xxgwmQmomCRhvU4BPi8g6VV3rToq4CGdFh7vVXaTdGDNwWde2MSbtiUgWzhjHHJzbETbi3OZtvNqXYMq4s90vx7lry3CciRTrcG6D98c+DM0YkyRWkTTGGGOMMQmxMZLGGGOMMSYhPY6RFJF4b4UVsFdVvRaHNcYYY4wxaaLHrm0f9xauUudWecYYY4wxJk1Fm7W9GvhUnMcU4B+JhWOMMcYYYwaKaBXJNlXdFO9BfbRkGmOMMcaYASLaZJsrEjxuoq8zxhhjjDEDhC3/Y4wxxhhjEhL1zjYiIsDh7tM6Vd0Ssn8SkKmq61MQnzHGGGOM6adiWUdyHrACWA5c6bF/JrBGRK5NZmDGGGOMMaZ/i+Ve258BVgLnebU6quqLInI+cI+IfKSqLyQ7SGOMMcYY0/9EHSMpIsuB/1DVFVHKnQJ8V1U/mcT4jDHGGGNMPxVL13ZhtEokgKq+DIz1H5IxxhhjjBkIYqlI1sVxPFs/0hhjjDFmkIilIikikh1DoRwgw39IsRGRsSLyL1v83BhjjDGmb8RSkXwJ+H4M5W4EXvYXTmzcyT1LgWlAXAthisirIvKRiCx3H++5Py9OSbDGGGOMMWkqllnbPwU+dNeLvAtYoaqdACIyBDgSuAo41f13b7jOPd/NwEFxvlaBT4auh2mMMcYYY+ITtSKpqrtE5JPAE8CXgDYRqXV3lwBZwAbgdFWtSVmk3S1Q1U5nrfS4ifswxhhjjDE+xNIiiaq+JyKzga8AZwBT3F0fAM8Cf1LVfSmJ0DseGxdpjDHGGNPHBvS9tkXkz8CXVTXmST4i8ipOBfhonBbVncCfVfW+lARpjDHGGJOmYplsk27qgHLgRGAWzrjP34rInX0alTHGGGPMABPLnW2GAN8GPgG8BfxUVTt6IbaoEmmRjHCcXwNXAFNVdWtSgjPGGGOMSXOxjJG8FTgOZ7LNuUAhzlI/6WQZ8A3gWCCsIikiA7f/3xhjjDGDjqr2ysTiWLq2zwQ+paq/BT4NnJ7akFJHRDJFJN9jVwfOTO6ILZuqao8EHj/4wQ/6PIaB/LD8Wf4sdwPzYfmz/PXlozfFUpFsBOa5/z4WaEpdOMklIsUikhm0aT7wsEfRY3DWl3yvVwIbRCorK/s6hAHN8ueP5S9xljt/LH/+WP4GjlgqkjcCj4rIDuAfwE2pDSkuEZttRWQKsB14MmTXye66mIFyC4HLgftVdX3yQzTGGGOMSU+xLEj+tohMA2YC5ara5y2S7gzr04CJ7vPl7q7jVLXd/fdeoAbYFvTS5cD1wE0ichswAmjFGQf6s14IfdC59NJL+zqEAc3y54/lL3GWO38sf/4M5vxVV7cwatQwErzpSq8b0OtI9hYRUcuTMcYYY1Kpra2Dk056nEcf/RRjx+YmfBwRQfvDZBtJ9B6EA6UabVKurKysr0MY0Cx//lj+Eme588fy589gzd+SJTuYOjXfVyWyt0UbI/nvBI+b6OuMMcYYYwalp5/eyDnnTO3rMOLSY9e2iCxX1aPiPqjIe6p6pK/I+hHr2jbGGGNMKu3Z08bJJz/BCy+cR2Fhtq9j9WbXdrTJNrNFZEMCx82MXsQYY4wxxgC8+OIWjj12tO9KZG+L1rX9V2BxAo/HUhSvGWAG6ziXZLH8+WP5S5zlzh/Lnz+DMX/PPDPwurUhSoukql7aS3EYY4wxxgxKO3e2sHLlbu6+e3xfhxI3W/4nBjZG0hhjjDGpct99qygvb2DRonnRC8eg3yz/Y4wxxhhjUuuZZyo5++wpfR1GQqwiaVJqMI5zSSbLnz+Wv8RZ7vyx/PkzmPK3fn0DNTV7Oe640X0dSkKsImmMMcYY00eeeWYjn/rUFDIyBmaVzMZIxsDGSBpjjDEmFc4552luu20ehx9emrRjDtgxkiJyfjKPZ4wxxhiTrlSVrVv3MG1aQV+HkrCEK5IiMlpEJgU/gFuTGJtJA4NpnEsqWP78sfwlznLnj+XPn8GSv4aGNrKzM8jNHbj3cYl2Z5tuRCQbuAP4CjA8JREZY4wxxgwC1dUtjBo1rK/D8CWuMZIisgj4BPAQcBNwi7trLPBV4ClVvTbZQfY1GyNpjDHGmGRbvHgbDz20hj/84ZSkHrc/3Ws71FnAJ1S1SUSuUNW/BHaIyH3A75MZnDHGGGNMuqqubmH06IHdwRvvGMlOVW1y/92tEqqqVcC4pERl0sZgGeeSKpY/fyx/ibPc+WP582ew5M/p2h5cFUkRkXz337Ui8umgHacCY5IWmTHGGGNMGquubmHMmIFdkYx3jOSvgIXAmcBJwF+ADwEFDgfusjGSxhhjjDHRfe1rL/OlLx3CCSeMT+px+/MYyR8CBwO7VfVBERkBfAnIBhYBtyU3PGOMMcaY9JQOLZLxdm0vAEYHXqeqv1PVBap6jKr+QFVbkx6hGdAGyziXVLH8+WP5S5zlzh/Lnz+DJX+DcYzkk8BlwMBe9MgYY4wxpg81N+9n//5OCgqy+joUX+IdI7lKVWelMJ5+ycZIGmOMMSaZNmxo4JvfLOO55z4dvXCc+vO9titEJC/SThG5x2c8xhhjjDFpLx3WkIT4K5L/AzwkIueLyCyPe20fn4IYzQA2WMa5pIrlzx/LX+Isd/5Y/vwZDPlLl4pkvLO2X3Z/npXsQIwxxhhjBouqqvSoSMY7RnITB+6vHbYb+KGqTklCXP2KjZE0xhhjTDLdeuvbHHxwAf/v/81M+rH78zqSLwTfXzuUiAy6iTjGGGOMMfGqrm5m/vyxfR2Gb/GOkdwjIr8QkVFeO1X1+iTEZNLIYBjnkkqWP38sf4mz3Plj+fNnMOSvqmrgL0YO8VckvwVsBppSEIsxxhhjzKCwc+feQTlG8l1VPaaH/Wk5mDBN35Yxxhhj+kBbWwfHHPN3Vqz4AkOGJH8oY39eR/JdETm0h/3/9hOMMcYYY0y627lzLyNHDktJJbK3xVuRfB94TETuEpErReTLwQ+gOAUxmgFsMIxzSSXLnz+Wv8RZ7vyx/PmT7vlLl/GREP+s7bvdn4dE2G/9v8YYY4wxPdi5Mz3WkIT4x0iuBD4VaTfwT1WdnYzA+hMbI2mMMcaYZLn33lXs2tXCDTdEnHbiS39eR/IuVd0UaaeI/MhnPMYYY4wxaa26uoWxY9OjRTKuMZKq+vso+x/2F45JN+k+ziXVLH/+WP4SZ7nzx/LnT7rnz7nPdm5fh5EU8U62QURmiMi9IrJBRDa4224VkfOTH54xxhhjTOr0xdA1pyI5rNfPmwrxjpE8FngVqAPWAAep6jQROQP4JXCzqj6Wkkj7kI2RNMYYY9LTV77yEt/4xuEcc8zoXjvnySc/zgMPnM748SNScvz+vI7kT4AfAJNV9TSgHkBVnwdOB65NbnjGGGOMManR0dHJihW7WL26LubXfPvbr1FeXu/rnDU1+xg5Mj1aJOOtSE5S1Z+ramfoDlXdAuQkJyyTLtJ9nEuqWf78sfwlznLnj+XPn97KX2VlE3v3drBxY2NM5VWV11/fzrvvVid8ztrafRQWZpGVlZHwMfqTeCuSmSLi+RoRyQRK/YcUGxEZKyL/EpGwSq0xxhhjTDQrV9ZSVJQdc0Vy+/ZmWlraWblyd8LnrKpKnzUkIf6K5DLgURGZGrxRRAqBPwJvJCuwnrgTe5YC00hgEXQR+U8RWSkiK0TkXRH5dNKDNAAsXLiwr0MY0Cx//lj+Eme588fy509v5W/Vqt2ceeZkNm5siKl8RUU9RUXZviqSzkSbwVuR/C5wDFAhIjuAmSJSAVQBJwDXJTm+SK4DTgWWxPtCEbkRuAk4S1XnAjcCj7gThowxxhiTRt56q4r6+lbPfStX7uaUUybS1NTGnj1tUY9VUdHAGWdMZtOmRlpbOxKKp7o6fW6PCPGvI7kFmAvcDlQC24FdwJ3A0aq6PdkBRrBAVdfH+yIRKQBuBu5W1UoAVX0JeAH4WVIjNICNE/LL8ueP5S9xljt/LH/+JDN/v/jFcp56akPY9s5OZc2aOmbNKmby5PyYurfLy+uZPbuYyZPzWLcu9gk6waqrWxg1apBWJAFUdbeq3qyq81R1uvvzFlVNLKMJ8JrsE6NPAsOAspDtrwCzRGSGn7iMMcYY03+oKpWVTSxZsiNs36ZNjRQVZVNYmM20abFVJCsqGpg+vZBZs0oS7t6uqhrELZLRiMjbyTxeChzu/twYsj3w/IhejGVQsHFC/lj+/LH8Jc5y54/lz59k5a+2dh+dncry5btoa+veFb1y5W5mzSoGYOrUgqgVyY6OTjZubOCggwqYPbuYVasSq0im2xjJqPfadieiNKrqqyJyb5Ti05ITVsoEZpU3hWxvBAQo6d1wjDHGGJMqlZVNzJhRiCr8+987mTdvbNe+4IrktGn5PP/85h6PtXVrM8XFOeTmZjJ7djGPPVYRUwytrR38+987ef317SxZsp36+lYOOqgg8TfVz8TSIvknnDGQAF8ETurhkZol2s2AZeOE/LH8+WP5S5zlzh/Lnz/Jyt+mTY1MmZLP/PljWbq0e/f2qlW1zJ7tVCSnTInetV1eXs/BBxcCMGNGERs3Noa1cobq7FQuuOBZfv3r98nPz2TRonm8+ur5lJamx2LkEEOLJHAUEJjutEpVj4xUUETeS0pUqVPj/szDuc1jQL77s7Z3wzHGGGNMqlRWNjJ5cj7HHTeaH//4bb7zHWd7Z6eyenUds2c7HZFTpuSzeXMTHR2dZGR4t7FVVNQzfbpTkRw2bCgTJ+a5k28id2a+9VYVmZlDeOihMxDplTsW9rqoFUl3pnbAl7zKiEgW0BFpfz/ygftzChDchj0VZz3KD0JfEHDppZcyZcoUAAoLC5k7d27XGI7A/5zsefjzhQsX9qt4Btpzy5/lz57bc3ue+PM33niNefPGcPjhs9i+vZl//ON5CgqymTLlKPLzs1ix4s2u8iUlOTz66L8YPXq45/GcNSS3UFbWwMKFC5k9u5iHH36Ok06aEPH8v/jFwxx2WHFXJTJV7zfw78rKSnqbqMa+nreI/FJV/9Nj+6eBvwJXqWq0cZRJIyJ/Br6sqp73GRKRYqBJVfe7zwuAbcCdqnprULlncO4ffniE42g8eTLGGGNM3zvnnKf52c8+zsyZRVxzzWJOOWUi5547jWefreRf/9rEXXed2FX28stf5otfnMmJJ07wPNZ55z3DbbfN7xpX+eCDaygvr+dHP/qYZ/na2n2cddZTvPjieeTlZSX/zfVARFDVXmkCHRJn+RO8NqrqP4A5wLW+I4pPxCSJyBScdS6fDGxT1Qbgx8A3A3fnEZFTgdOA76Qy0MEq+H9LJn6WP38sf4mz3Plj+fMnGfnr6Ohk69Y9TJqUB9BtnOTKlbVdFcKAnmZu79/fyaZNTUyblt+1bfbskh5nbj/55HpOOWVir1cie1u8FcmetAA5STxeRCJypzse82z3+XL3EdxVvxdnTOS24Neq6h3AIuAZEVkB3AFcoKov9EbsxhhjzGC2Zk0dO3e2pPw8O3a0UFSUzbCH9lqVAAAgAElEQVRhTtVgwYJxLFmyg85OZdWq3WFjG6dOjTzhZtOmRsaMGU5OzoFqxiGHFLF+fYPnhBtV5ZFHKvjc5w5O4jvqn2JZ/ucHwC1Bz3uaovSPZAQVjapeH0OZasCzfVpV7wLuSnZcJlxgHIdJjOXPH8tf4ix3/lj+Ivvd7z7k4IMLuOqqORHLJCN/lZWNTJ16oAVxwoQRjBiRydq1daxatdujRTKff/6z0vNYFRUNXTO2A4YNG8qECSOoqGgIO9bbb1eTnZ3BEUeUku5imbVd5v4U4Argdx5l9uMs6v14csIyxhhjTDraunUPzc37E359Y2MbublDI86uDqisdJb+CbZgwVj+/vdycnMzKSnp3onq3N2mwfNY5eX1TJ8evvbjrFnFrFoV3k3+6KMVXHjhwWk7UztY1K5tVV2sqj9S1R8Cz7n/Dn3cpqp/VVXvu6KbQcvGCflj+fPH8pc4y50/lr/Itm7dw/vv19DZGXkSa0/5u+qqMn7843einqeysimsIjl//lieeGJ9WMUPoLR0GG1tndTXh1dl1q8Pb5EEZ5xk6K0S6+r28frr2znnnKlRY0wHcY2RVNX/SFUgxhhjjElvTU1t7N/fSVFRNuvXe7f+9WTXrhbWratnyZLtvPTSlh7LbtrUyOTJed22HX/8GFS1ayHyYCLC1Kn5VFaGj5N0WiTDK5JOi2T3iuRTT21k4cLxFBRkx/KWBrxYuraNSZiNE/LH8ueP5S9xljt/LH/etm1rZvz4XA49tJgVK3Z5Vs4gcv5eemkLJ5wwjosumsE117zGEUeUMGqU932rN24M79rOzc1k3ryxHHXUKM/XTJ2az4YNjcydO7JrW2trB9u3N4dVSsGZcFNRUc+2bXt4660qlizZwZIl2/nDH072PH46SuasbWOMMcaYiLZu3cOECSOYO7eUFStqor8gxAsvbOH00ydx1FGj+Pznp/O97y317CLft6+dmpq9jBuXG7bv978/meOPH+N5fGcJoO4tpRs3NjJhwgiyssKXrM7NzWTixDw++9lnWbp0Bx//+Diefvoc5swZGVY2XVlF0qSUjRPyx/Lnj+UvcZY7fyx/3rZv38P48SOYM2ck77+/K2I5r/zV1e1j5cpaFiwYB8DXv344+/Z18Je/rA4ru2WLU2EdOjS+ao4z4aZ713ZFRT0HHxw+0SbggQdOZ8mSC/j5zz/B+ecfFLGFNF1ZRdIYY4wxvWLr1j2MH5/LjBmFVFW1eE5sieSVV7Yyf/7YrnUhhw4dwp13LuCee1ZSXl7frWzgHtvx8lpLMtL4yIC8vKyoM8jTWVLfuYhMSubxzMBn44T8sfz5Y/lLnOXOH8uft23bDrQUHn54CR984N297ZW/F17YzOmnd69mjB8/gssum8Uf//hRt+3O0j/hYxqjmTQpj23b9rB/fyeqypo1dbz1VpXnjG3jSHYV+snoRYwxxhgzGDmTbUYAuN3bsY2TbGxsY/nyXZx44viwfRdeOJ3XXttOVVVz1zavpX9ikZWVwZgxuXznO69z4omP8Z//+RpHHFHKggVj4z7WYBFXRVJE8kXkv0XkDREpF5ENwQ9gVoriNAOUjRPyx/Lnj+UvcZY7fyx/4VTV7dp2KpJz55by3nve4yRD81dWtpXjjhtFbm5mWNn8/CzOO28aDz20tmvbpk3hM7ZjdfnlhzFv3hgefPAM/vWvT/P97x/reV7jiHf5nz8BJwNvAuuBzqB9gnvva2OMMcaYYPX1rQwdOoT8/CwA5swp5cMPa+no6Iw6xtDp1p4ccf/FFx/C5z73HF//+uHk5mZ63tUmVueff1BCrxus4q1ILgBmu/exDiMij/gPyaQTGyfkj+XPH8tf4ix3/lj+wgXWkAwoKsqhtDSHiooGZs4s6lY2OH/NzftZtqyaRYvmRTz2hAkjOO640Tz++HrOPXcqra2dlJbmRCxvkifeMZIVkSqRAKp6oc94jDHGGJOGgru1A+bOHcmKFZGXAQJ47bXtHHlkadQ7xVx22aE88MAadyHyvEFxn+v+IN6K5D0i8nWJ8OmIyJtJiMmkERsn5I/lzx/LX+Isd/5Y/sJt2xZekZwzp9Rzwk1w/srKtnLKKROjHn/OnJGUluZw772rEu7WNvGLtyJ5GfADoFpE3hKRV4IfwOzkh2iMMcaYgW7btmYmTIi/RXLlytputyzsySWXHMpLL23xvJ2hSY14K5LHAGuAlcBenAk2wQ9jurFxQv5Y/vyx/CXOcueP5S9cYDHyYNOnF7Br1z7q6vZ12x7IX0tLO9u3NzN1amwtjKecMpHx43NjLm/8i3eyTYWqnhRpp4i85zMeY4wxxqQhr67tjAxnYfL3369h4cIJYa8pL69n6tR8z/tcexk6dAj33386I0cOS0rMJrp4WyQ/FWV/5ClVZlCycUL+WP78sfwlznLnj+WvO1Vl+/bmsIokOOtJrljRfZxkIH9r1uzm0EOL4zrX2LG5cd9j2yQurkyr6g4AERkmIieIyLnu8xJ3/76eXm+MMcaYwaemZi+5uUMZPjy8I9S5w433OMk1a+o45JAiz32mf4i7yi4iNwPVwKvAb93NvxORJ0XE2pJNNzZOyB/Lnz+Wv8RZ7vwZTPlraGhl7972Hsts3erdGgkHFiZvbz9wj5NA/pyKZHwtkqZ3xXuLxGuBq4G7gUuAenfXxUAl8ONkBmeMMcaY/u2Xv1zBI4+U91hm27Y9YTO2AwoLsxk9ejjl5fXdtnd0dLJuXT0zZxYmLVaTfPG2SH4V+ISqfk9VHwRaAVS1Ffguzu0Tjeli44T8sfz5Y/lLnOXOn8GUv23bmtm1a2+PZbwWIw8Wup5kWVkZmzc3UVqaQ15eVtJiNckXd9e2qq6NsL0dsE/bGGOMGUSqq1uore15ioQzYzs34n6v9SRtfOTAEG9FcqiIzPDaISLTgUz/IZl0MpjGCaWC5c8fy1/iLHf+DKb8VVU1s3t3tIpk+GLkwY48ciTvvXegIrlw4UJWr7aK5EAQb0XyPmCJiPxIRM4AhonIAhH5JvAi8MdkB2iMMcaY/qm5eT9NTftjqEj23LV90EEF1Ne3dmvZXLNmt020GQDirUjeDjwC3Aw8C8wEXgPuAp5S1Z8lNzwz0A2mcUKpYPnzx/KXOMudP4Mlf1VVLWRnZ7B7d2vEMh0dnVRVtTBuXOSu7SFDhMMPL+1aBqisrIzVq+s49FBrkezv4l1HUlX1SpwK5JXAf7k/Z6jq1SmIzxhjjDH9VHV1CzNnFrF79z5UNUKZvRQX50S9O82cOQcWJq+vb6WjQxk9enjSYzbJFe8tEgFQ1QqgIsmxmDQ0mMYJpYLlzx/LX+Isd/4Mlvzt2NHMtGn5lJfX0dLSTm5u+FSJaBNtAubOHcmf/vQRACUlh3PIIasQkaTHbJLL7iFkjDHGmIRUV7cwevRwiopyIo6TjLb0T8ARR5SwcuVu2ts73fGR1q09EFhF0qTUYBknlCqWP38sf4mz3PkzWPJXVdXCmDHDKSnJiThOsqfFyIMVFGQzZkwu69bV8eKLr1hFcoCwiqQxxhhjElJV1cyYMbkUF0dukdy+vbnHiTbB5s51xklu3tzEoYfajO2BwCqSJqUGyzihVLH8+WP5S5zlzp/Bkr9Ai2RPFcnqaqdMLI48ciRLl+5g//5pTJmSn8xQTYoktSIpIpOSeTxjjDHG9F8HKpLZEe9uU13dwqhRsVUk58wpZfHibRx0UAGZmdbWNRAk+1N6MsnHMwPcYBknlCqWP38sf4mz3PkzGPK3Z08bHR2d5Odn9dgiGahsxmLatAJyczPJyalMYqQmleJe/kdEzgO+BkwDskN2j0tGUMYYY4zp35wKYi4iQklJDqtX7w4rs2dPGwAjRsR2B+UhQ4Qjjihl1Kie75Rj+o+4KpIi8mXg58BLwCjgKXfXGOAU4PmkRmcGvMEyTihVLH/+WP4SZ7nzZzDkL7D0D+C2SIbP2q6qcsrEsx7kf//3x8jLy0panCa14m2RvBqYp6oVIvKeql4W2CEi84HLIr/UGGOMMekiuMs60hjJ4MpmrGIdT2n6h3jHSGa4d7UJe62qLgWmJyUqkzYGwzihVLL8+WP5S5zlzp/BkL+qqhbGjnWW9Yk0RrK6em/M4yODDYb8pYu4J9vIgfbpvSIyPWj7eGBGsgIzxhhjTP9VVdXcrWu7rq417H7b1dXNdr/sNBdvRXIt8GcRyQeeBRaLyP+IyP8AbwNvJTtAM7ANhnFCqWT588fylzjLnT/9OX/793fS0dHp+zjB60NmZWUwbFgGjY1t3coExkjGqz/nz3QXb0XydmA1kAP8FHgNuAq4BqgAvpXU6IwxxhiTVL/73Yd897tv+D7Ojh3dl/Xx6t5OZIykGVjirUhuBH6rqjtVda+qXgTkAQWqeqKqbkt+iGYgs3Eu/lj+/LH8Jc5y509/zt9HH9Xy8stbWLp0h6/jBJb/CSguzqG2tvvM7erqvQlVJPtz/kx38VYk64E1IjI5sEFV96lqU3LDMsYYY0wqrFtXz3XXHc1tt71DW1tHQsfYs6eNzk4lL+/A+pDOOElrkRxs4q1IbgcOUtVNqQgmViIyUkQeFJE1IrJaRB5xJ/vE8tpKEVke9HjP/XlyquMejGyciz+WP38sf4mz3PnTX/NXX9/Knj37+eIXZzJhwggefHBtQsfZsaOFsWO7rw8ZugTQvn3tNDfvp6go9N4l0fXX/Jlw8VYky1V1b6SdIvINn/FEJSKZOAuiZwKHArOAZuBVEYnlvz2dqnpU0ONI9+crKQzbGGOM6RXLllWxePFWz33l5fVMn17AkCHCjTcew5/+tJKdO1viPocz0Sa327aSku5jJHfudLq1hwyJfTFyM/DEPdlGRH4hIiUR9n/Nb0AxuBQ4DLheXcANOLdsTHlF1sTHxrn4Y/nzx/KXOMudP32Zv7//vZyHHy733Ld2bR0zZhQBMGVKPp/73HR++tPlcZ8jeOmfgKKi7hXJ6uoWRo0aFvexwa6/gSTeiuTvgf8AdorIThHZEPzAaR1MtfOBzcHd66paDawCPtsL5zfGGGP6JVXl7berWLGiJmxNR3BaJGfOLOx6fvnlh7F8+S7efXdnXOcJvqtNQElJTreuba8yJv3EW5HMB54A7gf+CSwOerwG7ElqdN6OwJk9HmojcHgMrxcRuUNElrhjLJ8XkXOSG6IJsHEu/lj+/LH8Jc5y509f5a+iooHc3EyyszPYvDn8T/LatfVMn17U9Xz48KFcdNF0Xn55S1zn8aokBhYlD/Az0cauv4Ej3nttbw6+v3YoEemNcYalwLse2xuB4SKSrarhd44/oBr4t6reICIZwBXAP0TkKlX9TQriNcYYY3rFsmVVHHfcaJqb21mxYheTJ+d17evsVMrL65kxo7DbayZPzueDD7zaZyKLNEYyuEWyurqFSZPyQl9q0kxcLZKqemSU/f1+5rOqfkxVH3b/3eFWHp8FbhORrL6NLv3YOBd/LH/+WP4SZ7nzp6/yt2xZNccdN4a5c0tZsWJXt31btuyhsDCb/Pzuf+omTBjB1q3xreIXuhg5QFFRto2RHITibZHskYj8RlWvTOYxPdTgLIIeKh9oidIaGcky4JPAbOA9rwKXXnopU6ZMAaCwsJC5c+d2Nb0HLnh7bs/tuT1Pl+cB/SWegfY8oDfP39mpvPzyK5x88jzmzDmGJ57Y0G1/eXkdI0ZUUlZW1u31LS372bJlD6rK4sWLo55PVamqambMmOHd9hcWZrN9+wpefrmEU045merqFrZseY+yso0DIn8D+Xng35WVlfQ28RqMG7GwyJejFLlVVaf4iih6DM8BM1V1Wsj2D4A9qjq/h9fmABmq2hyy/Sbgx8DxqhrWbS4iGk+ejDHGmICXXtrM8uW7uP76oz33P//8JtasqeOaa+b6Os+qVbu57ro3+Oc/z6WtrYN58x7mtdcuIDfXWTT87rs/oK2tg29/O7xz8WMfe5jnnjuXoqKcqOdpamrj5JOf4J13Ph+2b8GCR3jqqXMoKclh4cLH+NvfzgzrAjepJyKoaq+suxRvi+R9PezrrZrW48DvRGSSqm4GEJHROGtK3hBcUERGAbuCaoGfB+YBXw855jFAK87Mb2OMMSZpVqyooaKiPuL+DRsaqKho8H2et992xkcCZGVlcMghxXz4YS0f+9gYANatq+OMMyZ7vnbixBFs2bInpopkVVXkSTSB+23n52exe3crpaWJdW2bgWNInOVXA1NDHocBF+DM5j41qdF5uw/4ELhDRDJEZAjwE2AD8LtAIRGZj3Mnnl+HvP4iETk6qNzngXOBO1Q1/lVZTY9CuylMfCx//lj+Eme58yc4fxs2NFBTsy9i2drafWG3FkzEsmXVHH/8mK7nc+Z0Hye5bl34RJsAZ5xkbAuvVFU5d7XxEphwU1Ozl+LibIYOjbea4bDrb+CIt0Xy6gi3R1zldjn/DXjVf1iRqep+ETkN+B+cFsRO4CPg5JCK4B6ce4NvD9r2HDAB+I17h5wiYDdwharek8q4jTHGDE7r1zewb1/ke1rX1OzrNkklEe3tnSxfvpNFi+Z1bTvyyJE89lgFAC0t7VRVtTB5cr7n6ydOzGPLllgrkuGLkQcEJtwMG5Zh99geJOKqSKrqyz3s2ysih/gPKaY4dgEXRynzAc5SQcHbdgKL3IfpBYEBwSYxlj9/LH+Js9z5E8jfvn3tVFe30NnpLL/jdbtAp0UykXmiB6xatZsxY3IpLj7QNT13bim33PIWqkpFRT1Tp+aTmendQjhhwgg+/LAmpnP1tNB44DaJGRniqyJp19/AEVdFUkRO8NqM07J3HuC/bd4YY4xJExs3NjJpUh47d+6loaHVcwxibe1eGhraaG/vTLgrOLB+ZLCRI4eTm5tJZWWje0ebogivdiqSzz1XGdO53nxzB1dccZjnvsAYyc5OtRbJQSLeK7YMp+s6+PEKzgSYk4FvJTM4M/DZOBd/LH/+WP4SZ7nzJ5C/9esbmDatgNLSnIjjJGtr95GZOYT6+sRbJd9+u/v4yABnPcka9x7b3uMj4cBkm2i2bGli8+Ym5s8f57m/uNgZI+n39oh2/Q0c8VYk1+NUGIMfJwKHAFNV9bXkhmeMMcYMXBs2NHDQQQVhd30JaG3tYO/eDiZOHJFw93ZbWwfvvbeLY48dFbZvzpyRrFixq8eJNgBjxuSya9de9u/v7PFczzyzkTPPnByxi9xpkWxl584WRo2yFsnBIN7JNner6uKURGLSko1z8cfy54/lL3GWO38C+Vu/voEzz5zMxo2NnhNqdu/eR0lJTleXcCI+/LCWyZPzKCjIDts3d24pjz5awc6dLcyYEblrOzNzCKNGDWPHjuaItzVUVZ55ppLbbpvnuR8C99t23oefFkm7/gaOeFskPUfiisgpIvKSiBybhJiMMcaYtLB+fSPTpkVukaytdSqSRUXZCbdILltW5dmtDTBzZhFbtjSRkSGUlva8RuSECXk9LgG0atVu2ts7OeKI0ohlSkqyqa3dR3V15LUmTXqJtyJ5bYTt7wN/J2gdR2PAxrn4Zfnzx/KXOMudP2VlZezf38nWrU1MmZJPSUkONTV7w8rV1u51K5I5Ca8luXTpDhYsGOu5Lysrg9mzS5g+vQiRnm904oyTjHzP7aef3sjZZ0/t8TjFxc5Y0F279vqqSNr1N3AkNj0shKrWqOofgehL4htjjDGDwObNTYwZk0t2dgalpd4tkjU1ga7tbHbvjr9FsqmpjTVr6jj66PDxkQFHHz2KQw+N3K0d0NOi5O3tnTz7bCVnnz2lx2Pk52fR2trO8OGZZGdnRD2nGfiijpEUkUuAS9ynB4vIK17FgPE4C4Ab08XGufhj+fPH8pc4y50/Cxcu5IUXNnPQQQXAgdnMoQ50beewaVNj3OdZtqyKuXNHkpMT+c/5N75xOJ2d0e9iPHHiCJ5/fnPE84wZM5ypUwt6PIaIUFSU0209y0TY9TdwxNoiKVEe+3GWAvpiCmI0xhhjBpz16+u7KpIlJcOorfXq2j7QIpnIGMklSyJ3awdkZ2cwbFj0ubU9tUg+80wl55wzLaaYiotzfE20MQNL1Iqkqv5FVU9S1ZOAisC/Qx6nq+oVqlreCzGbAcTGufhj+fPH8pc4y50/ZWVlbNjQ2FWRjLSOpDNGchhFRTkJdW33ND4yXhMnek+22bu3nVde2cKZZ06O6TglJTmMGjXMVyx2/Q0c8Y6RPLqnnSIS73JCxhhjTFqqqGhg2jTn3taBWweqdu9irq1tDZq1Hd9km02bmti3r4Pp0yOvDxmPgoIsOjqUhobuFdpXX93KnDmljBwZW+WwuDjbWiQHkbgqkqra80ql8LaPWEwasnEu/lj+/LH8Jc5y588nPnECmzY5S/8A5OQMJTMzgz179ncrV1u7l9LSxNaRXLp0OwsWjI06GztWIsKECSPYtq17q+QTT6yPuVsb4KyzpnLiiRN8xWLX38ARdwuiiBwFfAWYBoSufnpwMoIyxhhjBrJt25opLMwmNzeza1tgLcm8vKyubc4YyWHk5WVSX9+KqsZcMVyyZEfM3c2xCtwqcdasEgC2bt3DypW7+fWvF8Z8jBNPHJ/UmEz/FleLpIh8EngdOAr4OAcm24wFFgJrkhyfGeBsnIs/lj9/LH+Js9z58/jj/+Lgg7vPcA4dJ9ne3klTUxuFhVlkZWWQkzOUpqb9oYfytH9/J++8U828eckZHxkQOuHmsccqOOecqb2+lI9dfwNHvGMkbwFOUdV5dJ94cyjweZxKpjHGGDOobdu2p2uiTYCzBNCBmdt1dfsoKMgmI8P5U1xUlB1z9/b779cwcWIeJSXJXb450CIJTkX38cfXc8EF1tloIou3IjlMVd9y/92t7V1VHwGOTEpUJm3YOBd/LH/+WP4SZ7nzJzNzZtf4yIDQ2yQGFiMPcO5uE9vM7aVLtzN/fnJbI6H7bRIXL97GhAkjkjaZJx52/Q0c8VYkO4L+3S4iXVexiBQChyQlKmOMMWYAW7++IaxFMrQiGVhDMsC5u01sLZKxrB+ZiODbJD7ySDkXXmitkaZn8VYkt4nIrSKSDSwGXhCRa0TkGqAMWJXsAM3AZuNc/LH8+WP5S1w65a66uoW//31dr51PVVmx4s2wFsnS0mHdKpK7d4e3SNbXR2+RrK9vZcOGRo48cmTygnaNG5dLdXULW7fuYcWKGs44I7mTeWKVTtdfuou3IvkLYKT7WAQ0Af/jPkYA30pqdMYYY4xPH31Uy2OPVfTa+aqrW8jKyqCwsPvCJt5d2wfWZox1jOSbb1ZxzDGjyMpK/gSYrKwMiotz+M1vPuDss6fEdEccM7jFdYWoahlOyyMAIrIAZ8mfbGCNqrYnMzgz8Nk4F38sf/5Y/hKXTrmrr2+lvr6t1863fn0DRx89P2y7U5E8MNnGuatNcItktufdb0J99FENc+cmvzUyYMKEETz11EYeffRTKTtHNOl0/aW7eJf/qRORKhGZBqCOclX9yCqRxhhj+qP6+tawu7Wk0vLluzjssJKw7c79tnsaI5kT091tyssbmD69IGq5RE2YMILZs4s55JCilJ3DpI9EJtvMUdUNqQjGpB8b5+KP5c8fy1/i0il3dXWtNDXtp7092s3ZkqOsbCt5eZvCtoeuI+k92SZ6hbeioj6lM6nPPHMyV189J2XHj0U6XX/pLt6K5CpVrY60U0Q+7TMeY4wxJqkCE1gaG1PfvV1d3cL27c1hi5EDDB8+lM5OpaXF6cCrqdlHaWnoZJueWySbmtpoaGhl/PgRyQ08yAknjGfBgnEpO75JL/FWJH8vIjeKSKSxlT/wG5BJLzbOxR/Lnz+Wv8SlU+4CazP2Rvf24sXb+PjHx3HKKSeH7RORbuMknTGSoZNteo4xsKzQkCHJub92f5VO11+6i3c61leBQ4HrRGQ9sCdkvy04ZYwxpl9paGhFBBoaUt8iWVa2lbPOmhJxf2Dm9vjxI6ivb6Wo6MDM7ljGSJaX13Pwwb2/QLgxkcTbInkMsBr4AGjmwL22Aw9jurFxLv5Y/vyx/CUunXJXV9fK2LG5KW+R3Lu3nXfe2cmCBeMi5q+01KlINjS0Mnx4ZrclfIYPH0pHh7J3b+S5qxUVDYOiIplO11+6i7ciGXx/7bAHsD4VQRpjTG/7+c+Xx7Q4tIEdO5r53/9d0ddhRFRf38qUKfkJLwFUUVHPAw+siVru7berOPTQorD1I4MFZm6Hjo8Ep+vbaZWMfN05LZKpm7FtTLzirUhGW1RqXqKBmPRk41z8sfz5k2j+amr2cs89q1i7ti65AQ0gseauo6OTG29cwoMPrk1tQAnq7FQaG9uYNCkv4RbJjz6q5Q9/+IjOTu2xXFnZNhYunABEzl9gjGTojO2AwsLsHru3y8tTO2O7v7DvvoEjroqkqu4AEJFhInKCiJzrPi9x98d2k1BjjOnHFi/eBsD27c19HEn/d++9q+jshLa2DtraOvo6nDCNjW0MHz6UkpKchMdI1tW1Ulu7j3Xr6iOWUVUWL97GwoXjezxWYIxk6ESbgOLinIgTburq9tHa2sGYMcPjewPGpFC8LZKIyM1ANfAq8Ft38+9E5EkRCf+tMIOajXPxx/LnT6L5W7x4GxMmjGDbttD5hINHLLn78MMa/vKX1dxxxwK3Ja3/DQWor2+lsDCbgoKshIcq1NW1MnSosGTJ9ohl1q6tJzNzCFOn5gOR81dS4qwlGalFsqgocoukMz6yAJH0n5Jg330DR7x3trkWuBq4G7gECPz37GKgEvhxMoMzxphIdu1qidrVmIi2tg7eequKz31uer9qkdyypamvQ+imuXk/11+/hO9//zjGjculuLh/VyQLC7MT7tqur29l/vyxLFmyI2KZsrKtLFw4IWolL9Ai6dxnO7wi2dMYyVQvRG5MIuJtkfwq8AlV/Z6qPgi0AqhqK/BdIHzhLLVMIB4AACAASURBVDOo2TgXfyx/kX3966/yt7+t67FMIvl7551qpk8vZPbs4n5TkWxr6+Css56mqan37hcdLXe33/4uRx45kk9+cjIAhYU57N7d/0Y3BZbYKSjITrhru76+lTPOmMz779dEnFFdVraNE0880K0deYzksB7HSDprSXrnsbx8cMzYBvvuG0ji7tpWVc8R1e69trN8R2SMMVHs399JRUUD99+/JumtkoEKwbhxI/pNRXLr1j20t3dSVdXS16EAsGTJdt5+u5rvf//Yrm1FRdn9cpZ7Xd2Bru1EWyTr6lqZOHEEs2YV8+67O8P219TsZePGBo45ZlTUY5WUOGMgd+/uqWs7coukzdg2/U28FcmhIjLDa4eITAcy/Ydk0omNc/HH8uetsrKRceNyKSjI4tVXt0YsF2/+gidMjB07nOrqFjo6euf+zD3ZtMnp1q6u7r2KZKTctbV1sGjRO9x00zHk5h74yu/PXduBFslEl/8JVEYXLBjrOU7yuec28fGPj+u2JmSk/BUUZLF3bztVVc09TLYJb5FU1UG1GLl99w0c8VYk7wOWiMiPROQMYJiILBCRbwIvAn9MdoDGGBNq3bo6Zs4s4pJLDuUvf1mdtOOuX99AR4cyfXohWVkZFBVls3Pn3qQdP1GbN/d+RTKS++9fw+TJ+V3L3AQUFkbuku1LdXWtFBRkU1iYeItkff0+iopy3Ipk93GS+/a1c889K/nKV2bFdKzAWpHr1zeGrSMJzv22vSrkNTX7EBHP1xjTl+KtSN4OPALcDDwLzAReA+4CnlLVnyU3PDPQ2TgXfyx/3taurWfGjEJOP30S27Y189FHtZ7l4s1fWdk2TjppfNeEifHjR7BtW993b2/a1ER+flbSurZbWzu46aalPS7X45W7qqpm7r13Fd/73jFh+4qKcvpl13ZDg9MimZeXRUtLO+3t8bUwd3YqDQ1tFBRkMWtWMTU1e9mx48A18be/reOII0qZNauk2+t6uvZKSnJob++MMNnGe9a2s37k4JixDfbdN5DEu46kquqVwCHAN4H/Aq4EZqjq1SmIzxhjwqxbV8eMGUUMHTqEiy+embRWybKyrZx44oGWtnHjctm+ve+XANq8uYljjhnFzp3JqUiuWVPHk09u4LnnNsX1up/+dDkXXTSdSZPywvb1NLavLwVmbQ8ZIowYkUljY3j39tateyJO3GpsbCM3N5OhQ4eQkTGEefPGsnSp0yrZ0tLOPfes4pvfPCKumIqLc8jNzSQnZ6jnPq91JNevHzwTbczAEvdkGwBVLVfV36nqIlX9vararRGNJxvn4o/lz9u6dfXMnOn8Ub3ggoN5443t3VqJAoLz98QT66mqity6WF/fyrp19Rx33OiubU5Fsj+0SDZy/PFjktYiuWpVLRMnjuC++1aj6j1ZKfTaW7asivffr+FrXzvMs3xP6x/2pbo6p0USiLgE0PLlO3niCe8/Y4GKaMCCBQcqkv/3f2s59tjRzJxZFPa6nn53S0tzKC72vo1ifn4Wzc372b+/e8vpYLmjTYB99w0ciSxIfoiI3C8i5SLS7P78i4jMTEWAxhgTrKGhlcbGNsaPHwFAXl4W5503jYceinyLvvLyem699W0uv/yViOPkXn99O8cdN5rs7AMTJsaNy+3zRcnb2jrYtWsvRx45MmljJFet2s0llxxKe3snb71VFbV8e3snixa9ww03HM2wYeGtaBB5bF9fC64IRloCqLq6hV27vMfCBldEAebPH8ubb1bR2NjGfffF3xoJTtd2aan3/TuGDBHPxdNtxrbpr+JdkPwM4H3gLGA7zgSbHcA5wPsiclrSIzQDmo1z8cfyFy7QMjNkyIGxYhdffAiPPVZBc/P+bmUD+bv77g+46qojmDdvLN/61mJaW7uPDVRVXnppMyed1H0Cyfjxfb8E0NatexgzJpfx43OTVpFcuXI3s2eXcMklh0QcFhB87a1cWYuIcOqpEyMes792bQdmXAMR725TXd1CTc0+z9bZurp93SqSY8fmUlycw003LWX+/LEcdJB35S7aGEmv8ZEBoeNNVdW9q83gaZG0776BI94WyZ8BtwFjVfVEVT1PVU8AxgA/AX6e7ACNMSbYunXORJtg48eP4OSTJ/Kzny0PK79mTR3Ll+/kC1+YyQ03HE1JSQ433LCka1mfDz+s4UtfeoHNm5s45ZTuFSWnRbJvK5KbNjUxaVIehYXZ7NvXEXFB7Fi1tnZQWdnIzJmFnHPONFau3M369Q09vmbZsmrmzRvT40SPQEUyUld5X1B1JsoEKpJO17ZXi+Re2ts7PffV17d169oG+PjHx7J48TauvDL+1kiAefPGcs45UyPuLy7uPgO+qqqFnJyMsDiM6Q/irUjmqeqPVLXbb5uqtqnqDwFrdzfd2DgXfyx/4daurfMck3bjjUezZMkOXn55S9e2srIyfv3r9/nqV2czfPhQhgwRfvKTBdTV7eNHP3qb6657g299azGf+cxBPProp8L+UI8bl0tVVXNKbsUYq82bm5g8OQ8RYdSoYb5bJdetq2Py5DxycoaSnZ3BRRfN4P77w1slg6+9Zcuquo0d9ZKVlUF2dgZ79uzvsVxv2rNnP1lZQ7rWd4y0KHl1tfOfBa/u7dAWSYBzz53G1VfPYcqU/Ijn7ul3d+bMIk47bVLE/UVF3SfcDLbxkWDffQNJvBXJHRLhv6QiMgTYErJtdqKBGWOMF68WSXDGSt5xxwJ++MNlXbObN25s4KOPavnc56Z3lcvOzuBXv1rIli17mDQpj3/+81w++9mDycgI/zrMyRlKXl4WNTV9t5bkpk1ORRJg9OjhviuSK1fu7rZUzUUXzeD55zdHXAOyra2D99+v4Zhjeq5IQv/r3g4sRh4QaYxkVVULU6fme1YkQyfbAMyaVRxx0lEyBCYuqSovv7yF229/l+OPH5Oy8xnjR7wVyf8F/iQi3e4DJSJjgLuBRSHlH/ARW0QiMlJEHhSRNSKyWkQeEZHx0V8JIjJURH7svu4DEXlDRBakIk5j41z8svx119mpPbbOHHnkSC66aAY33fQmnZ3KsmV5XH75YWHLrOTnZ/HnP5/Kt741p9vdWbzEMnN77952zjjjSWbNerDrcdxxf0/KRJ3Nm5u6lttJRkVy9erdzJpV3PW8pCSH00+fFLb8TeDa++CD/8/emYdHVZ6N+36yk5AQspCNXRHCFgRRKi4golRFrWurfm612kX9aau1rVar1n7V9qt7W63dbLWLlCq1LmwiIAqCsq9J2CVAAkkg+/L+/jgzYTKZ7cxMkpnkua9rruGc8573vPNwMvOcZ61g2LA00tL8d8CNtMxt1/hI8Bwj2dTUSmVlI6NG9ff4wOCebBMoofztZmQksWbNIW65ZSHPPruWH/1oMrff3nmKaySi333RQzAFyb+GZZksF5FSESkH9gPXAS869pWKSCkQWKl/G4hIPLAQqx1joeMaNcAHIpIcwBQvAFcDU40x44E/AvNFJLhgF0VRuoz9+4+TlpZAv37ef9jvuGMs9fXN/OhHK9i+vZKrrjo5pGsGkrn9+uvbKCzMYNOm69tes2YN4f3394R0bbBK/wwZYrlQc3PDY5EcMyaj3b4bbxzF3/623WOB8lWrygK2hkW6RdJT+Z/Dh+vIykoiJyfZi2u7gfT0ru0mk5eXzKpVB7nooqHMnXsxZ5+d36XXVxQ72FUk04B/AK8C/wE+dLy/Csx1bDtfS4HOqJtxMzAW+L6jQLoBHgCGA9/ydaKjT/g3gP81xhwBMMb8HthJR2uqEgY0ziU0VH7tcXa08UVcXAxPPjmVxYv3cdZZNe36HweDv8ztmpom/vSnLXznO+MRkbbXzJmDWbAgNEWysbGFQ4fqyM9PAWDAgNAUycbGFkpLqzrEmJ58cjonndSPxYtP9C133nuBxEc6ibQSQJWVDe0eOjy5tg8erCUnJ5ns7D5eXdvBWCRD+dv9yldOYtGir3DNNSOIiwuq3HPUo9990YPngmDe2WOMuSXQwSLyuc35A+EKxzraWjIYYw6KyGbgSnxnjl/heF/itn8xcIeIJBtjur+ZraIoHnF2tPFHQUFf/vvf2WzcuDLka+bnp7B9e6XX43/96zbOOCOng7v9jDNyuP/+asrKasjNTQnq2vv2HScvL4X4eEuZyM21LFXBsmNHJYMGpXqsBXn11SczZ04xs2YNadtXX9/Mxo1HmDRpQIfxnujfP7L6bXeMkezo2i4rsxTJrKw+bNrUsdWmp2SbziY2NobY0J5/FKXLsNsi8VRfx0Wk3V+bv/FBMh7LgujOTmCcn3PHAa2Au5lgJ5ZSHXZXfG9H41xCQ+XXHteONv7Izk5m+vTpIV+zoMB7jOSxY428+uoWj2VgEhJimT59IAsX7vVwZmA4S/84sWIkgy9HtHlzR7e2k/PPH8yWLUfYu/cYYN17a9eWc8op6X7jSJ3075/YJf22jx9vZP58/9Ze90QZT+V/Dh3ybZHsjhhJReUXTYTbZv5xmOfzRBZwzMP+aiDZXZn1cG6t6VjorNrxnomi9BJ27KgMW4HrriJQi2Q4yc/v67Xf9quvbuXss/MZPtxz5bOZMweF5N52lv5xkpOTHFKbRCtj27MimZgYy6WXDmPOnOK2fStXBh4fCV0XI/nuu7u5996lHi2IrrgrgZ7K/zgtkp4UyZaWVo4fbwoo0UhReit2O9vEicitIvIXEVkgIotdX0BoUe1Kj0PjXEKjM+X3xBOf8vrr3tsKRhp1dc0cOFDrs3afO+GQnzNr2/35s7Kygdde28a3vuU9T2/q1Hy2bj0adPkg19I/YPVorqxs7NCHOVA2b67wqkgCXHXVCP797xKamlpZsmQJq1YdDDg+EiA9PSmorO3WVsO+fYGH1C9Zsp+pU/P46U8/9Vnj090imZqaQG1tM83NJ+R38GAtublORbL92qurG0lNTfBYGsr/GpfYPkc5gcoverAbI/kCcBuwBagAuqNKbzmQ6mF/Gpa10dfjcDmW1VLcrJLOXyavj7c333wzQ4cOBSA9PZ0JEya0md6dN7xu63a0bFdVNbJ69eGIWU8g25mZYxk6NI2PPlrapdf/9NOPqK/fypEjDWRmJrUdX7cunRkzBrJz5xp27vR8fmJiLEOGHOS55+bw2GP/Y/v6e/Yco1+/3SxZUsa0adMcsXPFvPXW+1x11ZdtzXfmmWdTXFzFoUMbWLIk1uP4k07qR2JiKc899wajR2eydetRjh3bzJIl2wJab0ZGIlu3fsqSJWJL3h9+uJ93341n6dIrWbFimc/x8+cvYuHCD/nkkx/xzW9+wBNPvM7ZZxd4HF9Z2UBJyRqWLNnFtGnTiIkRWlq28847C7n00gsA2LDhY0aOLCc1dQhNTS28994ikpIs+Rw92kBLyzaWLFli+/5xEil/P9G27SRS1hPp285/79q1iy7HGBPwC6vMz2gfxz+xM18wL+BdoNTD/vXACj/nPgC0AIPd9j8HNADJXs4zitKT+Mc/tpvbbltoJk36m2lqaumUazQ1tZjW1lavx1taWn0ed2fOnB3mgQeWh2Nptrnyyv+a9esPt20fOVJnpkz5h9m375jfc999d5f5+tcXBnXd88+fa3btqm6379pr3zWffXbI9lybN1eYSy6Z53fcW2+VmG98Y5FZunS/+Z//ed/WNUpLK82sWW/aOqehodnMmDHXnHPOHLN06X6/45cs2WduuMFa14YN5ebss98wVVUNHsdefvl/zObNFe32zZr1piktrWzbnjFjrtm71/p/PP/8uWb37hPyXr36oLnuuvdsfR5FiQQcekun6mPOl117/TZjzGYfSukUm/MFw1xgiIi09ZcSkRysmpJzXAeKyAC3Tjz/drxPc5tzOvC+0YxtpZewYMEerrjiZHJzfWck28EYQ2lpFa++uoXbb1/E5Mn/aFdOxp3vfneZrUSU7du7r01cQUH7ntu///1mZs0aQkFBX7/nnn12PuvWldtOQnEv/eMkNze4OElfiTauXHDBYDZurODNN0tsubUhuPI/c+eWMGxYGjffXBhQPOmHH+5n2jSr/8TYsZlMnz6QF15Y53Gse0FyaF8CqLXVcPhwHQMG9AHoECfp6XxFUdpjV5F8RkRu8tEmsSuSbf4EbACeFJFYR2vGnwOlwG9d1nIm8AWWOx4AY8x24GXghyKS6Rh3C1YNyge7YO29Dnc3hWKPzpBfVVUDa9eWc845+UyYkMW6dYdDnrO11fDtby/httsWUVJSxdVXj+DSS4exe7envDiLXbuqbSWirFtXTmGhf0XIlXDJz7W7TXl5HXPmFAfcaSQlJZ4pU3L54APvSrUn3Ev/OMnJSW5rAWkHqxC5/3zCpKQ4Lr54KHPmvGe7LV9aWgI1NU0Bx3A2NLTw8ssbueuuImbOHMzixXvbxS+6Y4xhyZJ9TJs2sG3fPfdM4J13drFt29EOYz21N3QtAVRRUU9qanxbrdHs7D7t4lkrK4Mv/aPffaGh8ose7CqS7wBTgDIR+cRDsk2n99Y2xjQBM7Fc1JuBTUBf4Dw3i+JxoBJLmXTlTuAN4CMRWY8V8znTGLOhs9euKJHABx/sY8qUXFJS4pkwIYvPPw9dkfzzn7dw7Fgj8+dfzqOPTmHmzMEMH97PZ1Z4WVkty5Z94VNxcFJSUsUXXxxn8mR7FrJw4Zq5/corm5g9exh5eYHXhgwme9u99I+TYDO3N22qCFgRv+aaEaSkxFFUlGXrGjEx4jEz2htvvLGDUaP6M358FgMH9iU3N4U1aw55Hb99eyXx8TEMH34i4ap//yTuvLOIX/2qfdni2tpmYmKkQ81M1xJAztI/TrKyOloku7qGpKJEG3YVyV9jdYY5CNQD4vbqEowxh40xNxhjRhpjCo0xVxtj9ruNWW+MyTLGPOG2v8UY87AxZpQxZrwxZqoxZkVXrb234QwIVoKjM+S3YMEeZs4cBEBRUTbr1pWHNN/mzUf4/e838eSTU9t14bBcsJ5rHtbUNNHY2EJubkpA158zZwdf+cpJHaxz/giX/JwWyYMHa3nzzVJuv93eM/P06QNZteogNTVNAZ/jXvrHSU5OH9tlm1paWikurqSwMLDSSSNGpLNmzY+D6gpkZW77VyTr65v53e82ceedJ7Le/XUDWrJkP+eeW4C7U2z27GGsXn2I+vrmtn2erJHQvgRQWZmVse0knK5t/e4LDZVf9GBXkbwUGOtQwKYZY6a7vrAshIqidAJr1hxi7drQrIc1NU2sWnWozTV40kn9qKxsoKIiuG4kdXXNfP/7y/nBD07rEC/oK5bP2ZZu+vQClizx7fJtaGhh3rydXHll91UXKyjoy/79Nfzudxv5yldOIjs72f9JLqSmJpCfn8LevYGXuHEv/eMkJyfFtiJZUVFPcnJ8wIXFAY/dbwIhIyMxoBJAf//7doqKshg9+oS7/YILBrFw4V6vJX0+/LC9W9tJSko8p5ySztq1Jx5Kqqq8KZInLJIHD9YyYIB3RdLqjNO1fbYVJdqwq0juMMZs9Xawi5JtlCiiJ8e57NlzjN/8Zn27V6jWPXdc5Td3bgn//OeOkOb78MP9TJyY3VZgOSZGGD8+K2gF9ckn1zBmTCaXXDKsw7Hc3BSviqTTEjRt2kCWLNnvcYyThQv3MGpUf49uXn+EM0Zyz55jvP32Lm67LbgInoED+/qslThvXimffnqQxsYWwLq/PH3m3Fz7/bYPH64jO7uPrXOClV0gRclrapr4/e83t7NGAgwb1o9+/RI9/h1VVNRTUlLFaad5btd4xhm5rFpV1rbtzS2dnn6i+47zgcZJVlYS5eX17eZIT0/w+Vm80ZO/+7oClV/0YFeRfEVEvt7NyTaKEhG8884uPv64jKamVpqaWtmy5WinFvguKaliy5YjIc0xf/4eLrhgcLt9EyYE595evHgvK1Yc4KGHJns8npVluTidipErliKZwtixmVRWNrS15fPEG28Uc/XVI2yvL5ykpSWQkBDDNdeMIDMzOAtVfn5f9u/3rEg2Nrbw4x9/wi9+sYazzprDnXcuYfPmIwwZ0rH4+oABfTh0qM5nIW53ysvtK5LBkp7uX5F86aWNnHlmnscuRTNnDvLY/nDZsv186Ut5Xt3tp5+ew8qVJ/qQB+LadhYjd6IWSUWxj11F8mbgp3Rjso0SXbjGuTQ3t3L4cM+psLRv33Fmzx7G3XdP4O67J3DDDSO9KgrB4pSfs7TOzp3V7eLA7FBX18yKFQc477z2rsEJE4KzSM6dW8JddxWRmurZYhMbG0NWVpLH/sVlZTXk5iYTEyOcc04BH37o2Sq5a1c1JSVVHdYcKOGMs7rvvonceuvooM8fODDF6/2xf/9xcnOT+ec/L+Lddy/jwguHcMUVJ1FQ0DGhJyEhlrS0eFvhCIcP15GVZU+RDFZ2GRm+u9vs3FnFnDnF3HffqR6PX3CBFSdp3DoJOeMjvXHqqdls3Xq0LQ7Vm0XS3bXtapF0z9oOJdlGY/xCQ+UXPdhVJE8DtmLFQtbRTck2SvRhjOHhhz/hjjs+6O6lhI19+44zcOCJuMCCgr5tJWLCzaFDdSQmxjJ8eD+2bQuu7uNHH33B2LGZHSws48dnsWnTkQ4lWxobW2hp8Z5RXVZW6zGGzxVvcZKuP+DTpnlXJOfMKeayy4YHlfQRbq6+ekRINQUHDvRukdyz53ibGzszM4nZs4dx330T2yUvuZKTY8+9HYxrO1h8ubaNMfzsZ6u5/fYxXuNMR4xIJz4+hk2bTljfGxtb+PjjA5x9dr7X6/bpE8eYMRltVQgqKxvo18+zRdLp2nb22XaSkZFEVVVDWyUBb1ZNRVFOYFeRLHZPsHFLtinpjEUq0YszzuXZZ9exfXslu3ZV23LJRTJ79x5n0KATilROTjIVFfVB90H2hFN+JSVVnHRSP8aMyWDzZq+dPH3y4Yf7PVr2UlMTKChIaVeHr7Gxheuue5+33trpdb6DB2vJy/OddJKb6zkx5MCBE+eeeWYen39+uENGc2NjC2+9VcpVVwWfZBNJcVb5+X3Zt8/zg8bevcfa3Uv+sKtIlpfXd1mMpC/X9qJF+zhwoJbrrx/l9XwRYebMwfzrX8XMnVvC9763jHPP/Rdnnpnn16pqubetOEnLLe05RrKqqhFjTIfyP7GxMfTrl8iRI9bfcU1NU1s8sV0i6d6LRlR+0YNdRfIiP8e/FOxClJ7L3/62jfff383LL59HamqC7USBSKSxsYXy8rp28VVxcTFkZdkvzRIIJSVVDB/ejzFjMtm8Obg4yc8/L2fSJM+JChMmZLdzbz/77FpKSqrYtava4/jGxhaqqhrJyPAdP5aTk8yBAx2VJ8siabltrXqW2axYcaDdmMWL93HSSf0YOrRjnGA04rRIurtswflQ4r9LjpNgLJJZWV0T6+etu01dXTNPPrmahx6a7LeM08UXD2XRor0sX/4FZ56Zx5tvXsLTT5/j99pWwo0VJ+kvRrK6upG4uJgOmezOOMmqqgb69UsgJkadbYriC1uKpDHmAICI9BGRc0TkUsd2puN4cDVElB5Lc/NwXnppIy+/fB4ZGUkMG5bmVTmJJr74ooacnOQOrkerlV744iSdcUKlpZZFsrAwo53LL1Cqqho4eLDWa4vBoqKstoSbFSsO8M47u7n33gkelUBwlk3pQ2ys76+QvDzPrm1njKSTadMK2mVvf/TRFzz99Odce21oSTaRFGeVlpZAXFyMx1aJe/d6ztD2ht2i5MG4toOPkfRc/ueVVzYxblwWU6b475YzcmR/li69il/96myuvPLkdlZDXxQVZVFSUsWxY41ea0CmpiZQW9vMF1/UtCv948SpSFrnB698R9K9F42o/KIHuxZJROQhrILkHwC/cez+rYi8KSJdE4SjRAWbNlXwk5+s5Ne/ntbmthsyJLVHKJLu8ZFOXFvphRPLIpnGyJHp7NpVTUNDx0xoX6xbV87YsRleY+6cFsmjR+t58MGPeeKJLzF6dIZXRdK9kLM3PLm2nS30+vU74TI899wCli7dz44dldxxx2Ief/xT7r9/IrNmDbHxKSOf/PwUjyWAXGMkA8G9TWJxcSX337/ca9hId2dtHz5cy+uvb+P++yd26rUTEmIZPz6L1asPeXVtx8QIqakJ7NhR6fEedibcWBbN4NzaitKbsKVIish3gbuBF4GbsFoQAtwA7AIeD+filOilpqaJ++5bzuzZLe0KDg8dmsauXd5LvUQL+/Z5dkVahavDZ5F0jZE8+eR+JCXFMWRIKtu3H/V9ohvr1pVTVJTt9fiwYWkcO9bEvfcu48tfHsKZZ+aRl+ddKQ5UkbQsZ+3ncJ7rWkVs0KBU0tMTufHG+Uydmse8eZdw/vmDO3QwsUukxVlZ7u328mhtNezf7/nBxBuuru1ly77g5psXsHDhXo8Z8sYYysvrbWdtB19H0nJtu7rw339/D9OmDbTVVjJYTj89h1WryqisbPSaKNOvXwLbth31aOl0tkm0MraDt0hG2r0Xbaj8oge7FsnbgLONMT80xvwVaAAwxjQA9wHnhXl9SpTy85+v5tRTsznjjPZuLEuRVIukHY4cqae5ubVNERg9OtO2e3vt2sNMmOC9b3JMjFBUlEV1dSP33DMBgAEDkikv95w8ZLmm/SsFnlzbZWU1bfGRrjz//Lm8++5l3HhjYURkaXcGnh40Dh6sJS0twVYnmdzcZA4cqOWvf93Kgw+u4Nlnz2XkyP4e773q6kbi42OC7lRjl+TkOESgru6E1dy1LWdnM2VKLitXHqSyst6HIpnI9u2VHhVJy7Vdz9Gj9dpnW1ECwLZr2xjjseKyMaYZUD+Awvz5e1i16iAPPji5Q5zL0KE9ybXd0RUZbkVy2rRpbfGRTuvc6NEZtgqTt7S0smFDBUVF3hVJsOok/vrX09qUuPh4qw6kqwvViXv9PW9kZiZRVdXYrih5WZnnbO+h2igBJwAAIABJREFUQ9PCXmol0uKsCgo6uratjO3ArZFgWST37DnGP/+5g9dfn8WkSQPIz/ccnxts6Z9QZGe5t604yYqKerZuPcrUqd5L94STMWMy2bv3OM3NhuRkz8qzL4vkCde2d4tmIETavRdtqPyiB7uKZJyInOLpgIiMAAJv5Kr0SMrKanj88VU89dRZHvv6FhT05eDBWo/dTqIJbz/+vrqXBIuz9I+TMWPsJdyUlFSRlZXk1003YkR6Bytjfn6KxzhJ1/I9vrCKkrfvFhKoW7wn4sm1vXevvfhIsDLdH3nkdF5//cI2y3hBgeeHGMut3bXdWVxrSS5atJezzsonMbFrrMzx8TGcemo2/fsneg2NSE9PpLy83odFso7KSrVIKkog2FUk/wR8JCKPisiFQB8RmSoi3wEWAL8L9wKV6KG11fDDH67g+utHtlm/3ONcEhJiyc31nHAQLRhj2LvXs2s7Ly+ZQ4fq2goah8qSJUvaSv84GTmyP6WlVQEr42vXljNhgvf4SF94i5O03NOBKYNON2ww54ZKpMVZeXJte+up7Y9rrz2Fvn1POIG8xecGa5EMRXZWdxtLkbTc2oP9nBFezjgjx6c10Zno5TlGMsklRjJ4RTLS7r1oQ+UXPdhVJP8XeAN4CHgHGAksBZ4D5hljfhne5SnRxGefHeLIkQa+8Q3fnTKj3b3tbK/mmnXsJCEhlv79Ezl0qGPSQ7CUlla3s0j26RPHoEGp7NgRWIebtWsP+3Vre8ObImn1KA4sccLqbnNiDjvn9jScoQ+u2dV79th3bXsiL8+z9bgru9o4cbq2q6oaWLeu3GdHms5gxoxBzJjhPSbT2fHGV9b2kSOhKZKK0luwW0fSGGO+jaVAfhv4seP9FGPM3Z2wPiWK2LLlKKedNqBdbUFPcS7RnrntTLTx5jYLZ6vEadOmdXBtA44ON4G5t61Em+Askp5c2w0NLRw71kRmZmDuUvfi2QcOdJ1rO9LirFJS4klJiaOi4sSDhnuHpGCxaph6cm3b77MNocnO6dr+4IN9TJmS6zHMpTMZOjSNu+4q8no8PT2RxMRYjw+DSUlxJCbGsmfPMa0j2Y2o/KIHu+V/RgEYY4qNMS8ZY54wxrwE9BWRh5yFyZXeyZYtRxg1qr/fcUOHprF7d+gWyU8/PciPf/xxyPPYxV8XEsvqFB7X/fHjjVRXN3YomxJoYfLKygbKy+s5+eR+fsd6wpOVy1mMPNCOH9YcJxRJyyLZO2MkwXrQcLZKtMIkgnNtu5Of35cDB2o6dM7pDoukU5GcP7/r3dqB0K9fAgMG9PH6MJiV1Ye9e49pn21FCQC7ru3XvexvAEYB/whtOUo0s2XL0Q6KpKc4lyFDUtm5M3RFct268nb9obsKfzX/wpm5/fe/v8vw4WkdlDb3ntuNjS088sgn/OUvW9uNW7fuMGPHZvrtQOMN67N0LN9jxzWdm3vCInn8eCMtLa1B9y+2SyTGWVmKpPWg4StMwi7JyXH06RNHRUX7rjLBWiRDkV3//kns23eMTz89xLRpBUHP01kMGNDHpxU4O7sPxqAxkt2Iyi96sPvr4vHxzRiz1RhzAxBcIJYS9TQ2trB7d7XXFnyuhKuWZGlpFeXlXd+V08rY9v4jFM6i5AcOHG+XaONk1KgMiouthJsjR+q59daFlJfX8/LLG1m/vrxtnJVoE/yfZV5eMgcOtO8PbTfr2rUoueXWTgm50Hg04+y5Dc74yNSwycPTQ8zhw/XdYpFctGgfkyZlk5oaeVXhJk/O4fnnz/V6PDu7D7GxQmqqFiJRFH/4rVArIucA0xybOSLyYzoqlAIMBHpnBL1CSUkVAwf2JSmp/S3lKc4lJyeZmpomjh9vbJd1Gsw1KyrqMcZ0qWKyb99xn+66/PwU3n9/d1iu1adPITk5HWWUnBxHQUFf3ntvNy+8sJ6LLx7KXXcVsWDBHu6/fzlz515MSko8a9eWc8sthUFfv2/fBOLjY6mqOlFTz64i6VqUvKvd2pEYZ1VQkMLGjZY1OZgakr7ntsoLjR9/4uEh2PaIocZINjS0RKRbG0BEfBZoz8rqQ3q69/JBgRCJ9140ofKLHgJpdTAdeMTxbwM86mFMM7AT+F6Y1qVEGVu3dnRreyMmRhg8OI3du48xZkxwYbXGGEpLqzEGjh1r6jJXKXjvauPEW9JDMJSUVHHllSd7PDZmTAYPP/wJjz02hUsvHQ7AhRcOYdmyL3jiiU95/PEpbNzovxC5P6zM7ePtFMnhw9MCPj8jI4nqaqsoeVeW/olUCgr68v77e4DgS/94w/l/5aS+vpm6uuawuM7t0L9/ErGx4jNzOpKx6q5qfKSiBIJf17Yx5lFjTIwxJgZY7/y32yvBGDPSGDOvC9asRCCWIpnRYb+3OJdQSwCVldWSnBxHXl5yuwzYzqa5uZWyslry870b3/PyUigra1/iJVhWr/7Ia6LMrbeO5rXXLmxTIp388Ien8fnnh3n++fXk5PRpK3USLPn5ye3iJA8etBcjGRsbQ3Z2Hw4dqnN0tek6x0Ukxlm5uraDKUbuC/ei5M4e28FY1kKR3dChaTz99NlRm6ySnd0nZEUyEu+9aELlFz3YjZG8o1NWoUQ9W7cGlrHtJNQSQM4i3VlZfTokF3QmZWW1ZGYm+ewFnZQUR2pqAuXloSm49fXNHD3a4NX6ecop/T1adFNS4nnqqan84Q+bKCoKruyPK3l5fdtlbgfa1cYVZy3JsrLAWiv2ZPLzUygrq6WlpTVsNSRd53aNz7USbbq2qw1Y3WXOPz8y3dqBcPrpOXztayO7exmKEhXYrSO5qrMWokQmlZUNfscYY7y6tr3FuYSacOPsP52ZmdSlimSgMW3hyNzeubOaMWPOIC7Ofsb1uHFZPPbYFC6/fLj/wX7Iy0tu91kC7bPtirO7jcZInihaf/BgXdhqSDpxr2EaSumfSJRdV5Gbm8KsWUNCmqM3yy8cqPyih+Bqgii9gvXryznrrDk88sgnPq1r+/fXkJwcT0ZG4JaPoUNTQ6olaRXpTutyRdKKj/T/wx+OzG1PhcjtcPnlJzF5ck5Ia4AT9QnBspIeP95k6/8aThQl78pi5JHMwIF9KS6upLq6MawWWssieaKWZHfUkFQUpXehiqTilWXLvuCKK04iOTmeSy99m5de2kh9fXOHcb7c2t7iXIYMsVzb7sWTA8WpZHWHIhmoRTKUhJvm5lbmzSslNrY46DnCRX5+cpsiefBgHTk5yQEXI3eSm5vicG3bi68MlUiNsyoo6Msnn5RRUJBiW5a+SE1NID4+pq0+ZbA1JCFyZRctqPxCQ+UXPagiqXhlxYoDzJo1hAcemMTf/z6LzZsruO669zskkXgqRO6P9PRE4uJigqoDaYyhuPhEjGSosYh28Jex7cQ96cEOxhgefXQlIFx4YWjutXDg2m/bUgTtW9Dy8pIpLq7CGLQ2H9b98fHHZWF1azvJyzsRJ6kWSUVROhtVJBWPVFc3sm3bUSZOtJI1Bg9O5ZlnziEmRli6dH+7sb5K//iKcwnWvV1RUY8IZGYmkZHRHa7tQGMkg3Ntv/DCerZuPcrTT5/N+eefF9Qc4SQrqw/V1Y3U1zcHHeOYk5PMhg3l5OUld2nNz0iNsyoo6Mu2bUfDmrF9Yu4Tir/GSHYfKr/QUPlFD0ErkiIyWEROdfw7kHqUSog0Nrbwi1+s6ZJrrVxZxsSJ2e0KjIsIN91UyJ//vKXd2K1bj1JY2LH0jz+CTbhxJtqISDck2wSqSPYNyiL5z3/u4O23d/Kb30wnJSUyLHcxMeLIuq5t60xjl9zcFOrqWrrUrR3JOO+hcGZsO3HN3C4v7/quNoqi9C5sK5IicoOIlGAVIH/bsfuvIvKM9Oa+Z13A+vUV/PGPWzh8uNb/4BD56KMDnHlmXof9s2YNYdeuY2zefASwsrqrqxu9Kle+4lyccZJ2cU1CycxM4siRrlEkjx1rpKGhmcxM/4kmzqxtOzGgH364nxdeWMdLL53XFtcWKXFCzs8TrGs7MzOJuLiYLi/9Eynyc6egwKlIdoZFsm87i2Sw5X8iVXbRgsovNFR+0YMtRVJEbgB+B6zC6nbj1AK+B+QDD4Z1dUo71qw5BNCmxHUWxhg++ugLpk7N73AsPj6GG24Y2WaV3LbtKCNHpgeVMDBsWBo7d1bZPq+kpLpNkczKSgq63/ahQ7WsW1fuf6ADZ8Z2IM9LKSnxJCXFceSI//JJzrU89NDHPP30OQwdGnjXmK4iLy+FAwdqgir9A5ZVMyenj2ZsO8jNTSY2Vhg8uLMskjW0tLRy9Gg9mZlqkVQUpfOwa5G8D5hhjPmaMeanQC2AMWY/cAvwlTCvT3FhzZpDDB+exqZNnatI7t59jKamVq8dVa666mQ+/HA/Bw/WsmXLEY8dbZz4inOZNGkAn39ebluZdBYjB0tha2011NZ2zCb3hTGGBx/8mIcf/iTgcwKNj3RitUr0HyfZ2mr44Q9XcO21I5g0aUC7Y5ESJ+RMuAmmGLmTnJzkLlckI0V+7sTFxfDEE1/q1BjJI0caSEuzsriDIVJlFy2o/EJD5Rc92P2GSTTGrPB0wBhTQ2C9u5UgaGlpZd26w9xww6iwKpKHD3fMeF6xwnJre7O89euXyOzZw3jttW2O+Eh7GdtOMjOT+MY3xvCzn6225QIuKalss0ieiJO0l7m9aNFeyspqqaxsCDhOs6SkimHDArcWBlqU/M9/3kJ9fQvf/Oa4gOfuavLzXS2SwcU5fvWrp3DGGblhXln0cumlw4mNDX++oxWfezyk0j+KoiiBYluRFBGPFY4d+8P/eK0AsG1bJdnZfZg6NS9sru3i4krOP//fbNnSfj7Lrd0xPtKVG28cxZw5xaxdW+6z9I+/OJcbbhjFgQO1LFq0L6A1V1U1UFvb3M6yZTfhpq6umZ//fA0PPjiZmTMHMX/+noDO27ChnHHjOrYk9EZ+vv+i5Js3H+GVVzbx5JNTPXawiZQ4oby8FEpLq6mtbSIjI7gexJdcMqxTLHC+iBT5dSX9+iXQ0mLYubM6pESb3ii7cKLyCw2VX/RgV5GcCywTkVtEZCQQKyIFInIx8A7w97CvUAEst/akSQMYOLAvdXXNYamduH17Jf36JXD//cupq7Ncw42NLXz66SGPiTauDBqUyuTJA9i//zgnn5we9Bri42N46KHJPPnk6rY1+KK0tLotY9uJ3TjJV17ZxPjxWUyZksvMmYNZsMC/ImmMYf36CsaNywr4OoMH9/Vp7ayra+b731/OD35wmi2XeXeQn5/C5s1HyMnp2vI9in1EhPz8FNatK9eMbUVROh27iuRDwA7g98BmYBywB5gH7MNKwFE6AaciKSIUFmaExSq5Y0cl11wzgtGjM3jqKaus0Pr15QwZkkr//v4zPW+9dQxTp+aRmBjrdUwgcS5TpuQyblwWr7yyye/Y0tIT8ZFOMjICz9zes+cYf/vbdr7//YmAFad54ECNX8vhgQNWpryd+MCiomw+++yw1+N//etWTjmlP7NnD/M6JlLihHJzk2lubo26ZJlIkV9XU1DQl3XrykNybfdW2YULlV9oqPyiB1uKpDGm3hhzMXAB8BSWQvkUMNMYc5kxpqkT1tjrMca0KZIAY8aER5EsLq7i5JPT+fGPT2f58i9YvHgvy5d7LvvjiaKiLH772/AUzL7//om8/vo29u71XQ6ouLhj/+nMzD4Bx0g++eRqbrmlsK2eYVxcDOedN8ivVXLjxgrGjcu0ZY0bOTKd8vI6r273jz46wGWXDQ94vu4kKSmOzMwkrQMZJTgtyGqRVBSlswkq0tsYs9AY80NjzDcc74sBREQj6TuB3buPER8fQ36+9SM+ZkxGWBJuduyoZMSIdFJTE3jyyak88shKFizYw1lndSz7EyyBxrnk5aVwyy2jeeqpz3yOcxYjdyXQGMmPPz5AaWk1N91U2G6/5d7e6/Ncu/GRALGxMQ6r5KEOxxoaWtiwoYLTThvg4cwTRFKcUH5+SpfXgQyVSJJfV5Kfn0Jzc2tIFsneKrtwofILDZVf9BDulMF3wjyfQnu3NsDo0Zls2lQR0px1dVa7O2fyw8SJA7j22hGUldVSVBR4HGA4uemmQjZtqmDDBu+1HV1L/zgJNEZy7twSbrqpkISE9q74M87IoaSkioMHvRd637DBXnykk0mTBrTV/3Rl7drDjBiRHjHdawIhLy8l6NI/SteSn2/F3GZnB1eMXFEUJVB8KpIistjOCzi5i9YdETQ1tfLGGztobQ28dE0wuLq1wUriqKlpCqmjy86dVQwZktquxtw3vzmOv/99VgdFKxTsxLkkJsZy++1jeeGF9R6POz/zwIHt3auBWCRrappYunQ/F144uMOxhIRYpk0rYOFCz1bJlpZWNm06wtix9iySYCmSniySK1eWccYZHgsgtCOS4oTuu28il1ziPZ4zEokk+XUlBQXW34jGSHYfKr/QUPlFD/4skpMBcXuNAyYB6Y7t/o7t04HVnbbSCMMYw6OPruSRR1YG1S/aDu6KZDgSbnbsqOpQcDwuLoYRI4LPwA4HV1xxEsXFVaxd2zFJpbTUUn7da+8FEiO5aNFeJk0a4DWJyFf2dmlpNZmZSaSn2y97M25cJiUl1dTUtA8fXrXqYNTVVBw4sC+pqQndvQwlAJxhMBojqShKZ+NPkSw2xkx3voA/Ai8BOcaYiY79pwI5wHPAm5283ojhhRfWs337Uc46K4+tW4922nUOH66lurqxQ1zg6NGhxUkWF1eGVLYnUOzGuSQkxPKtb43luefWtdtfU9PE44+v4qKLhnY4JxCL5Ntv7/SZHT11ah5bthzxaOV1JtoEQ2JiLIWF/du1YqytbWbLlqOcemq23/M1Tig0eqv8MjOTePjh00MKneitsgsXKr/QUPlFD/4UyRlu27cbYx4yxrT7tXVkc/8IuCGsq4tQ/vGP7bz99k5+85vzOPXU7E5VJNesOczEidkdellbmdvBx0nu2NE1imQwXHbZSezff5xPPz0IWCEE9967lJEj+3PbbWM6jE9LS6CuroXGxhaP8x0+XMf69RVMmzbQ6zWTkuI466x8Fi3q6N624iODUyShY5zkZ58dYvToDPr00UZQSucgInz1q6d09zIURekF+FQkjTHuJi+vJh2xMkG8/1KHERG5R0Q2ichaEVktIpcFeN4jIrJbRD5zez0T6LUXLdrLiy+u5+WXZ5CZmcSoURls3dp5va/XrDnExIkdM3vHjMkM0SJZ1SVu7GDiXOLjY/jWt8bx/PPrMMbwyCOfEBsbwyOPnOGx/E5MjJCRkejVKvnee7uZPn2gX8XtoouG8sYbOzq0a7QytoNPQHJXJFetOsjpp/uPjwSNEwoVlV/wqOxCQ+UXGiq/6MFu1vY+EXnFvU2io+zPK8DusK3MCyLyA+BHwMXGmAnAD4A3ROTCAKf4scMt7/q6x99JlZUN/Oxnn/Lww5/w4ovTGDLEynYuLOzPli2daZE85LFEzODBqVRVNVJZ2WB7zpqaJo4e7Zi0Eklccskwysvr+M53llBSUsX//d/ZHlsIOvHl3v7Pf0p9urWdTJ8+kKamVpYs2d+2r6GhhZKSqqD7iQOcemo2GzZUtFlMA020URRFUZRIx64ieTdwFZZCuVdENojIPmAv8BXgznAv0BUR6YfVXedFY8wusGpaAvOBX3bmtS++eB7NzYZ582a3s07l5CTT0mI4fNh76Rg7GGMoLa3i1Ve3cPvtizh8uI7CwowO42JihMLC/kEl3BQXVzFsWL8OSSudQbBxLnFxMdx99wT27j3Ob34zneRk39ZEbwk3O3dWUVZWG5DiFhMjfOc7RTz//Lq2TPytW48wbFgaSUnBu6FTUxMYMiSVzZuPcOxYI8XFVRQV+Y+PBI0TChWVX/Co7EJD5RcaKr/owdavozFmpYiMAO4FpgC5wDbgT8DTxpjQihv658tAH2CJ2/7FwC9E5BRjzPbOuPCf/zzTY0yhiDBqlGWVzM4OrsbesWONfPJJGcuXf8Hy5QcwxnD22flcffUIpkzJ9VqOxypMXhFwJxonxcWV3Z6dHQizZg3hwgsHB9RNxlstybff3sVFFw0NWGmeMWMgv/3tBhYt2svMmYPZsKEiqLI/7jjd25WVDYwfn+WzraSiKIqiRAu2zSzGmMNYruXuYJzjfafbfuf2eMCfIvllEbkRGAA0Av8Ffm6M8Vk/xldiyqhR/dm69SjnnFPg59Ltqaio5/77l7N+fTmnnprNWWflc+ONhQwfnhaQ8jR6dKbH5BB/WBnb/fwPDAOhxrkE2pLQk2vbGMPbb+/kV78629b17rprPL/61VpmzBjEhg0VAccz+mLSpAHMm1dKeXm9Lbe2xgmFhsoveFR2oaHyCw2VX/TQ+b7N8OL0Kbs3ZK7Gqmnpz3RUCxwHrjDGjAe+jpVpvlBEgjYRORVJO9TUNPGtby1m7NhMli27it/9bgY33VTISSf1C1h5GjMmgw0bKmwXRLdqSEa+RdIOmZlJHUr3rF9fTlxcDKNHdwwN8MU55xTQp08c77+/O6jWiJ6wCpMf5pNPysKimCqKoihKJNCtiqSIzBCR1gBei8NxPWPMLxz9wasd2+uAB4AvAdcEO29hob3MbauczTJOOaU/9947IegyMMOGpZGd3Yc33yy1dZ5V+qdrLJJdFeeSkdHRIvnee7v58peHBKyYOxER7r67iGeeWcuhQ3UdangGQ3Z2H9LTE9mz55gtV7nGCYWGyi94VHahofILDZVf9NDdhew+AkYFMM6ZyeKs6pwKuJoA0xzvwcRornS8TwH+5m3QzTffzNChQwFIT09nwoQJbab33bs/Y8eO1dTUXERKSnzbH4DzuOu2MYabb/41x4418uKL9yAiPsf7237ooclcd90LJCaeycUXz/Q7vrKygbKydWzfnkFBwXTb14vU7T17Kigv79e2bYxhwYJKfv3raUHNZ4whO7sPOTnJLFu2NCzrnTRpAIcP17JixbJul5du67a/bSeRsp5o23YSKeuJtm0nkbKeSN92/nvXrl10NeJeMy+SEZFrgdeB6caYpS77vwv8Aij0lWwjIlnGmHK3ffnAPuDXxhiPWeciYvzJ6eqr3+HBByczYYLvbNxnn13LihUH+OMfZ/rNRA6Un/xkJfHxMTz44OR2+1tbDbt3VzNs2AmL2urVh/jlLz/j73+fFZZrRwrbth3l/vuXM2/ebMDqRnP//ct5551LbVsknezYUcmBAzW2Y1+9sW5dOTU1TbaToxRFURTFDiKCMSa4Hz+bxHTFRcLIe0AdMM1t/3nAZlclUkT6iEia27jd0lGrOM3xviaUhQUSJ7ljRyVz5hQHVM7GDvfcM4F3393Ftm0nrl9X18z3vreM2bPfZv78PW37rYztrnFrdyXuyTbz5+9h5szAMr69MWJEetiUSICioixVIhVFUZQeRVgVSRH5Uzjnc8cYUwU8DnxHRIY5rnk+MBP4ntvwtcAOEenjsi8JeFREYhznDgH+F9iCD7d2IIwalcGWLb7jJP/85y1cf/1IMjKSQrlUB9LTE7nzziIef3wVxlg1LW++eQHx8TG89toFPPbYSlavtjqrdFWPbSfuborOon//RI4da6S5uRVjDPPn7+GCCwZ3ybU7k66SX09F5Rc8KrvQUPmFhsoverBtFhORFOAiYDiQ6Hb4gnAsyhfGmCdFpA54W0SagBbgKmPMfLehXwANQLPLvuuB64DPRSQOqyblu8DD7v3D7VJY2J9587wnvZSX17Fw4V7efffSUC7jlauvPpk5c4p57rl1vPVWKddcM4I77hiLiPDUU2dx771L+cMfzqe4uIrzzhvUKWvoTmJjY+jXL5GjR+s5cqSB5uZWxoyxl62tKIqiKIo9bMVIishIYCFQABiskjuuGGNMj6u0HEiMZE1NE+ecM4eVK6/12Mrv+efXceRIPY88ckZnLZO1aw9z++2LefzxKVx44ZB2x/7zn50888xaamqamDfvEgYMCK54eiRz+eVv8/OfT2XBgj3U1jbzwAOTuntJiqIoitLlRHKM5C+BXwHJwHpjTIwxJgbIB16kk1skRjIpKfFkZyeza1d1h2P19c388587uPHGQBLUg2fChGxWrLi6gxIJMHv2MK677hTi4oTs7D4ezo5+rDjJOhYs6BlubUVRFEWJdOwqkkOMMU873MBtJjpjTJkx5i6sPty9Fm8JN/Pm7WTcuMx22dOdhSdrqJNbbx3Nf/8bfBZzMHRlnEtGRhKrVx+iurqRoqIs/ydEARonFBoqv+BR2YWGyi80VH7Rg11F0jWOMFZE2rJGHAksw8KyqijFkyLZ2mp49dUt3HxzYTet6gQiQr9+7mGtPYesrCTmzCnm/PMHERPTdcqyoiiKovRW7CqSjY4saYCNwO9FpEhEioBXsNoP9loKCzsqksuWfUFiYiyTJ/fOtnjOoqldQWZmHyoq6pk5s+e4tbtSfj0RlV/wqOxCQ+UXGiq/6MFu1varwHMicjnwU2AZ8FXHsSZCaDPYExg1KoNNmyp4991dbftefXUrN988ukvdyb2VzMwkMjISmTRpQHcvRVEURVF6BbYsksaYl40xo40x240xW4DxwDeB/wcUGWPmdcYio4UBA/pw8cVDWbBgb9ursDCDCy/sORYyu3RlnMvEiQP47ncn+owTjTY0Tig0VH7Bo7ILDZVfaKj8ogevFkkR+TLwsTGm0tsYY8wXwO9czplljHkvvEuMHkSEhx46vbuX0WsZMiSVIUNSu3sZiqIoitJr8FpHUkTuBW4DLjTG7AtoMpHPjDETw7i+iCCQOpKKoiiKoiiRQFfWkfRqkTTGPC0izcBiEbncGLNZRFpxKfujKIqiKIqi9F58BpMZY54HZgOnOHYdBB7z8nrccVxR2tA4l9BQ+YWGyi94VHahofILDZVf9OA3a9sYsw3Y5tj8zBg5n93jAAAVEElEQVTzqLexIjI5XAtTFEVRFEVRIhtbvbZ7KxojqSiKoihKtBDJvbZ9IiKrwjmfoiiKoiiKErn4VCRF5A92XsDwLlq3EiVonEtoqPxCQ+UXPCq70FD5hYbKL3rwFyN5PfCFjfn6hrAWRVEURVEUJYrwGSMpIp8bY04NeDKb46MFjZFUFEVRFCVaiKQYydtszmd3vKIoiqIoihKl+KsjucbmfHeFsBalB6JxLqGh8gsNlV/wqOxCQ+UXGiq/6MFvHUl3RCQFuAgrsSbR7fAF4ViUoiiKoiiKEvnYqiMpIiOBhUABVqtEd/+7McbEhm95kYHGSCqKoiiKEi1EUoykO78EfgUkA+uNMTHGmBggH3gRuDPM61MURVEURVEiFLuK5BBjzNPGmHosiyQAxpgyY8xdwFVhXZ0S9WicS2io/EJD5Rc8KrvQUPmFhsoverCrSNa7/DtWRJKcGyISAwwLy6oURVEURVGUiMdujORy4CfGmIUi8ppj91OO9/8HnGaMGR/mNXY7GiOpKIqiKEq00JUxknYVyduBe4DLgVhgGdDfcbgJuMYYMy/ci+xuVJFUFEVRFCVaiNhkG2PMy8aY0caY7caYLcB44JtY1siinqhEKqGhcS6hofILDZVf8KjsQkPlFxoqv+jBdh1JV4wxXwC/c26LyFRjzEchr0pRFEVRFEWJeGy5tv1OJvKZMWZi2CaMENS1rSiKoihKtBCxrm0RyRORV0Vkr4g0iUiL6wso6qR1KoqiKIqiKBGG3fI/fwa+BLwJPAE85vJ6HDgY1tUpUY/GuYSGyi80VH7Bo7ILDZVfaKj8oge7MZKjgFHGmFpPB0UkK/QlKYqiKIqiKNGA3fI/bxljLvNxfIwxZlNYVhZBaIykoiiKoijRQiTXkRwFXAPMBYodrRJdj2uyjaIoiqIoSjcSsck2QDUwBVgH1GiyjeIPjXMJDZVfaKj8gkdlFxoqv9BQ+UUPdmMk/wIMAl4EjgCuZjoBbg/TuhRFURRFUZQIx65rex8wwhhT5+X4C8aYO8O1uEhBXduKoiiKokQLkeza3uRNiXTwm1AWoyiKoiiKokQPdhXJB0XkFyIyRkSSPBz/SzgWpfQcNM4lNFR+oaHyCx6VXWio/EJD5Rc92I2RXIUVF/ldsEyniqIoiqIoSu/EbozkAeC33g4Dtxtj8sOxsEhCYyQVRVEURYkWujJG0q5F8jNjzKPeDorIySGuR1EURVEURYkSbMVIGmMu9nP8htCWo/Q0NM4lNFR+oaHyCx6VXWio/EJD5Rc92E22AUBELheRF0XkH453r20TOwOx+L6I1IvIjV15bUVRFEVRFMXCboxkMvAfYLrbIQN8AFxqjKkN3/I8rmEQ8CqQBkwAbjHGvGrj/EnA/wEZQDzwNvCQMabBxzkaI6koiqIoSlQQyXUknwDSgcuAPCDR8X65Y/9Pw7o6z3wPeAUrc9yWkERkBLAYmGOMGQ+cAVwI/CHci1QURVEURenp2FUkLwVmGGP+Y4w5aIxpcrz/B5iJpVB2Nt81xrwW5Lk/ASqMMS8AGGOqgceArzkslUqY0TiX0FD5hYbKL3hUdqGh8gsNlV/0YFeRbDTGVHo6YIw5CjSGviTfGGNagzlPRGKxFOEP3Q4tdrxfGcq6FM+sXbu2u5cQ1aj8QkPlFzwqu9BQ+YWGyi96sKtINovI6Z4OiMgUoCn0JXUaw4EUYKfrTmPMEeAYML47FtXTqaz0+NyhBIjKLzRUfsGjsgsNlV9oqPyiB7t1JJ8BForI68Bq4ChW0spk4KvAPeFdXljJcrwf83CsGsjswrUoiqIoiqJEPbYUSWPM70UkE3gYuB0rW1uAWuBRY4ytpBURmQEsCGDoEmPMeXbmViKDXbt2dfcSohqVX2io/IJHZRcaKr/QUPlFD7bK/7SdJJIGfAnLylcOfOxIXLE7TxIwOIChtcaYfW7nnotVcujmQMr/ODK2twE/McY85nasClhmjLnEy7la+0dRFEVRlKghUlskAm3Zzu+77xeRK4wxc23MUw9sD2YNQVAK1ABDXXeKSAaQCqzzdmJX/WcoiqIoiqJEE0EpkiISB+QAsW6HHgMCViQ7ExGJB1IdyTQYY1pEZB5wrtvQ87Bc9P/q4iUqiqIoiqJENbaytkWkUESWAw3AHqwMaNdXYdhX6GM5fo6/DewTEVfX+SNApoh8B0BE+gEPAX8zxnzWOctUFEVRFEXpmdgt//MHoBn4PnAbcKvL6+vAPu+nhgcROUtEPgdexrIkPiYin4nIFW5DDwBHgD+KSCuAMaYYywJ5tYhsBFYC8x3rV9wQkTwRec8pP8UeKr/g6SzZicgMEWkVkR7dzUrvvdBQ+SmKDYwxAb+wrI4xPo4/YGe+znwBVzjWux1o8TEuF6vl4hZgLbAB+CEQ5zYuHvgxsMkxbhPwEjDAw5yTgCXAese8vwASu1smnSS/wcDrWDGo24BVWD3XPY293iG7tQ7Z3OZl3AVYSv46YDPwAxyJYdHyCqf8gD5YVRKWAxsd995SYHZPlF9n3HuO8QJ8DrQAf+iJsuss+WElVv4a+Mzxt7sL+AeQ5jZOv/s6jus1vx1AEZaRZ7Pjb2gj8CyQ5TYuBXgB2OoY8x4w2sN8ccDjDlmsd3wHTvVy7XtcZLwauKy75dFdssPSax51zLPeMee/gLGdITu7H/Q9P8fHdPd/hstaPgZOAv7o7cuAEz8s64F0x74JWOWMnnIb+yxwHBjv2O6PpXR+4jZuBFAF3OnYTnPM/1p3y6QT5JeNZYWeA8Q69l2LZbW+yG3sV4F6YJJje5xDnt9wG3cWVujEbMf2QGA/8ER3y6S75OfYVwec5bLvu0ArcEtPk1+47z2Xc24B5jnk1kGR7Amy6wz5YdXY3Q7c4bLvVMf35GCXffrd51l+vea3A0u5eQNIcmznYSmBW3FRiIF3sR6GEx3bjwGHgDy3+X7rODfDsf11rKTZ8W7jfuA4f6hj+3ysTnsXdrdMukN2LnLLd2wnAP90yG6M23VDlp3dD3oa8DSWEpDk4fhn3f2f4bKWGMe7ry+DQqwflbvd9r8J7HfbdxD4t9u+e7CsGyNc9r0GlLqNu8pxnUndLZcwy+8xx+c/2W3/cmCTy7ZgxdT+0W3cC8BhIN5l30dYdUNdx92HpYTmdrdcukl+1wKvejh/N7DObV/Uyy+csnPZn+yQ10i8K5JRL7vOkB+W9ew/HuY4z/V3QL/7vMqv1/x2YFm+hrntu9XxWb/i2J7p+EznuoyJByqA5132neI47ya3+Ta63o9APyxF/RG3cW8DG7pbJt0ku1/T0cgw3HHus+GWnd0YyVXA3VjmzxoRaXF9YZlmIwITWE/uZsd7vNv+eDpmpDfTMcvdeV4s9Kx+3gHKbxLQZKzYU1fWA6NE5GTH9ulY1p0lbuMWY3VGmg4gIrlY9Uk/8DAuAUu2UUE45WeM+Qdws4fzD2BZN4CeI78w33tOHgDeNsZs8zRZT5EdhFd+jlq/1wH/8XCdxcYq4abffSfwdP/1pt+O8caYnW77vsAyJji/q67Esnh95BxgjGlybLt+TmfewxK3+RYDF4hIsmP7y1jhP57GjRaRU2x/iu4hnLK70xjzRw9z4TIXhEl2dhXJg1hPYp5ejzuORw3GmB1YT4F3iMgQABE5D5gBPOc2/DFghuM4IjIUuANYaIzZ6hjT2/p51+A5e975RTzK8T4eKzHK/Y9kp+N8p1zGuex3Hwe9V34dftxEJAbrfnNVfHqT/AKWnYjkA9/Aqtrgjd4kO7D3t5sM1InIb0RknYhsFZE/iMggl/P0u8+iw/1HL/rtMMY0e9jt9AI4leRxwBcexu4EckQky2VcK5Y3y31cHDDaZZxzv/s46IWy8/IwNNLxHvbfDLt1JD8zxjzq7aCITLI5XyRwM/ArYIeIHAL6AvcYY37rOsgY85KINAP/EpFarBiZ39G+v3hv6+f9OXCliIwzxmxw2X+q4z3N8e5NLs5uSJku40wA43oKgcrPE1diPUm6dmnqTfKzI7ufYrl9yn3M15tkB4HLbxCWwvQC8G1jzLccTRzmAB+LSJExpgL97nPS4f7rzb8djgfeW4FXjDEljt1ZeP+cYH3Wcse4WuPwtXoZ55wPD3NWY927vVF2nrgdKyzgry77wiI7WxZJY8zFnvaLSIyIXIIVQxk1iEgilkl3MlbQ+EBgGvAjEfmR29hfAD8DLjDGFAAFWE9EcxwF2nsjL2CZy58WkQyx+AYnnnLqum9pUUFQ8hORPKxY5dtcvmB6GwHJTkQmYIVO/F/3LDNiCfTeS3K8f2KMeQ3arGR3A/nAt7twzZFEwH+7vfy342EsV+y93b2QKCRsshORGcDVwNUOV3hYsevaboeIjBeR/8PKbJwHDAjLqrqOrwNnAvcZY8oAjDFrgV8Cj4vIeAARGQ18DytI9VPHuMPA/wNmA99yzOd8Ekj1cK00rIDYHoMx5hhWput+4BOs0iBjsDKKAfY63r3JxfnUXuEyTgIY1yOwIb82RCQd+C/wv47YSVd6jfwCkJ3THfZLrEDyRj9T9hrZga17z2mpWOd2/kagCeshHPS7z6P8evNvh4jcgpUsNMsY4/pQXI73zwntfw+SRcQ9hMDTODzMGbV/u2GQnetcRcCfsKpRuMeIh0V2tp+GRCQbqx7gTVj+82asVPQnge/Yna+bGet4dw+Y3o71ozIZK3h6LJbby9M4sJJJIIR+3tGKMWY31r3Qhoh8HysTbL1j13oseQ7FulecDMOSq3Oc00U01O0yw1zm6VEEKD/n/nSsHvd/NMa86GG6XiU/P7LbICKpWJafe0XE6UZ0/ihdKiKfAXuMMZfTy2QHAd97zhg+T0aHVpf9+t2HR/n1yt8OEfkfLEvadEfogyvrgUkiEucW6zcMOOgSgrIeq2zcINrHSQ7D0js2u4wDS3bu41x/X6KCMMnOOdd44N/ANcaYlR4uFxbZBWSRFJF4EblSrF7V+7DcRNWOC2caY2YaY56hY4JKpHPI8T7Ybf9QLCFWuIwTL+PAodUbY1qwLLPnuo3rkf28RaSPw2TuzsXAX1ysQKuw7ptpbuPOw+o+tATAYRX+2Mu4RjxkjkYzNuSHiKRhKZF/NcY877L/Lee/e5P8ApGdMeaYMSbfGHOqMWai4+WMYXvLsX059C7ZQeD3njFmO5bSM97t/BFAItbftn73ncD9b7fX/XaIyA3A/cAMh/UVEbnY4foHmIuVtX6myznxwFSs2Fsn/3a8T3O7xHTgfWNMrWP7PaxQAvdx5wGbHfdwVBBG2TmVyDeB640xHzv25YqIa/5HeGTnrz4Q8CLWzd6K9aP/DFDoOBYxdSN9rP9PeK8FNhSodAizr2PfYGAH1pens+BnDJbrYjdwkmNfMvAWVlHesS5znuyY8zvmRJ2mtVgKQLfLI8zyG+K4CSc4tgWr7t52HAVkXcZe65DVRMf2OCy32W1u46Zi1e27xLE9EEsJ/Wl3y6K75IflZliJlW13vcvrBuBQT5VfuO49D+d6qyPZY2QXTvlhlaVpcpFLItYPlNOQ4Byn330d/3Z71W+H43upFsvF7/pd9VvgYZdx72BlIvdxbD+KVfXFvSD5b7CKcmc6tm/BstyOcxv3gOP8YY7t87GaC1zQ3TLpDtlh/b4ewqon6TrXPcDicMsukA/X4pj0u7i1aiKCFUngKazMunLHZ/jM8XJvfXgKVpurzZxoX/Ucbu2rgHQs9/0Gx7gtWE8HRR6uPRHLyrYRyzX0FJDQ3TIJt/wcX3T/wCoVsM4x/te4tXRyGf81xzhni8Svexk3E8vSsdbx/xIxrTe7Q37AXY45PL2ae5r8OuPec5zzFidaJJY75ry9J8mus+QHXAascXyflWKVTRvkYZx+93Wcr9f8dmB58bx9V7kqQ8nA81itJTdheVsKPcwXi1WZYivWb8ZHwJlern03J9r8rcFLC9lIfYVTdlgWbG9zLQq37MQxiVccNdj+B8uitAV4yRiz1HHsM2PMRJ8TKIqiKIqiKD0Sv4pku8Eip2EFFxdhaby3GWPGuRwfYawi34qiKIqiKEoPx5Yi2XaSFdx5CVaMlmCZVt/G6n+pFkpFURRFUZReQFCKZLsJrJY81wM3YgXAJoRjYYqiKIqiKEpkE7Ii2W4ykbXGmAlhm1BRFEVRFEWJWMKtSGYYq32WoiiKoiiK0sMJqyKpKIqiKIqi9B5C6rWtKIqiKIqi9F5UkVQURVEURVGCQhVJRVGULkZErhSRtSLysoikiMgrjv7ViqIoUYUqkoqiKGFERPJFpEVEXvQx7AbgLGAxVt/cOG3moChKNKLJNoqiKGFERB7A6g98DMgzxjR185IURVE6DbVIKoqihJdrgR8CGcCl3bwWRVGUTkUVSUVRlDAhIqcBW4AXgUrgJrfj/xWRAyLSKiKnich7IrJTRD4WkUIP831dRDaIyBYRKRGRp0UkuWs+jaIoin9UkVQURQkfNwEvGWMagFeBC0Uk23nQGHMx8FvAANcbY2YBJwENwO9cJxKR7wNPA183xhQCk4BzgP90xQdRFEUJBFUkFUVRwoCIxANFxpiljl0vAXHA9V5O+QOAMaYVSzn8kojEOeZKAx4GXjfGrHKMqwR+AkwXkcs763MoiqLYQRVJRVGU8HAJ8C/nhjFmC7AcN/e2C65Z2s7WsjmO9y8BycBqt3NWOd5nhrRSRVGUMBHX3QtQFEXpIdwAnCIiropjf2CwiIw3xqx3HWyMqXfZbHW8xzres7Dc30fdrnHE5biiKEq3o4qkoihKiIhIFlY5tXFu+/sCFVhWye/ZmLIcEKzMb1cyXI4riqJ0O+raVhRFCZ3rgffddxpjjgNLgetExM737cdALTDZbf/pWJbK+UGuU1EUJayoIqkoihI6NwJvezn2X6zYx4sc2+JhTLt9xphq4FHgqyIyBUBE+gOPAB8YY94Kx6IVRVFCRTvbKIqiBImIZGC1ORwNbASudW11KCJ3AXcDw4FDWMkzk7AUy3XA/2Al6XwbGIhVg/JhY8xcx/m3AvcC8UAC8CbwkDGmtis+n6Ioij9UkVQURVEURVGCQl3biqIoiqIoSlCoIqkoiqIoiqIEhSqSiqIoiqIoSlCoIqkoiqIoiqIEhSqSiqIoiqIoSlCoIqkoyv9vt44FAAAAAAb5W89hd1EEAItIAgCwiCQAAItIAgCwiCQAAEtC5ramVE6lBwAAAABJRU5ErkJggg==\n", - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ - "#You can set the size of the figure by doing:\n", + "#Puedes modificar el tamaño de la figura\n", "pyplot.figure(figsize=(10,5))\n", "\n", - "#Plotting\n", + "#Graficando\n", "pyplot.plot(year, temp_anomaly, color='#2929a3', linestyle='-', linewidth=1) \n", - "pyplot.title('Anomalías de temperatura global en tierra.\\n') # Land global temperature anomalies\n", + "pyplot.title('Anomalías de temperatura global.\\n') # Land global temperature anomalies\n", "pyplot.xlabel('Año') # Year\n", - "pyplot.ylabel('Anomalía de temperatura en tierra [°C]') # Land temperature anomaly\n", + "pyplot.ylabel('Anomalía de temperatura [°C]') # Land temperature anomaly\n", "pyplot.grid();" ] }, @@ -252,7 +210,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "## Paso 3: Regresión lineal de mínimos cuadrados\n", + "## Paso 3: Realizando una regresión lineal de mínimos cuadrados\n", "\n", "Para tener una idea del comportamiento general de nuestros datos, podemos buscar una curva suave que (de manera aproximada) se ajuste a los puntos. Generalmente buscamos una curva que sea simple (por ejemplo, un polinomio) y no reproduzca el ruido que siempre está presente en los datos experimentales.\n", "\n", @@ -274,7 +232,7 @@ "source": [ "### ¿Cuál es el \"mejor\" ajuste?\n", "\n", - "Cuando el ruido en los datos está limitado a la coordinada $y$, es común usar el método de **ajuste de mínimos cuadrados**, lo que minimiza la función\n", + "Cuando el ruido en los datos está limitado a la coordenada $y$, es común usar el método de **ajuste de mínimos cuadrados**, lo que minimiza la función\n", "\n", "$$\n", "\\begin{equation}\n", @@ -282,7 +240,9 @@ "\\end{equation}\n", "$$\n", "\n", - "con respecto a cada $ a_j $. Encontramos los valores de los parámetros que mejor se ajustan al resolver las siguientes ecuaciones:\n", + "con respecto a cada $ a_j $. \n", + "\n", + "Encontramos los valores de los parámetros que mejor se ajustan al resolver las siguientes ecuaciones:\n", "\n", "$$\n", "\\begin{equation}\n", @@ -292,7 +252,7 @@ "\n", "Aquí, los términos $ r_i = y_i - f (x_i) $ se llaman residuales: nos dicen la discrepancia entre los datos y la función de ajuste en $ x_i $.\n", "\n", - "Eche un vistazo a la función $ S $: lo que queremos minimizar es la suma de los cuadrados de los residuos. Las ecuaciones (2) son generalmente no lineales en $ a_j $ y pueden ser difíciles de resolver. Por lo tanto, la función de ajuste se elige comúnmente como una combinación lineal de funciones especificadas $ f_j (x) $,\n", + "Observa la función $ S $: lo que queremos minimizar es la suma de los cuadrados de los residuos. Las ecuaciones son generalmente no lineales en $ a_j $ y pueden ser difíciles de resolver. Por lo tanto, la función de ajuste se elige comúnmente como una combinación lineal de funciones específicas $ f_j (x) $,\n", "\n", "$$\n", "\\begin{equation*}\n", @@ -300,7 +260,9 @@ "\\end{equation*}\n", "$$\n", "\n", - "que da como resultado que las ecuaciones (2) sean lineales. En el caso de que la función de ajuste sea polinómica, tenemos $ f_0 (x) = 1, \\; f_1 (x) = x, \\; f_2 (x) = x ^ 2 $, y así sucesivamente." + "que da como resultado que las ecuaciones a resolver sean lineales. \n", + "\n", + "En el caso de que la función de ajuste sea polinómica, tenemos $ f_0 (x) = 1, \\; f_1 (x) = x, \\; f_2 (x) = x ^ 2 $, y así sucesivamente." ] }, { @@ -313,7 +275,7 @@ "\n", "$$\n", "\\begin{equation}\n", - "    f (x) = a_0 + a_1x\n", + "    f (x) = a_0 + a_1 x\n", "\\end{equation}\n", "$$\n", "\n", @@ -322,73 +284,81 @@ "$$\n", "\\begin{equation}\n", "    S (a_0, a_1) = \\sum_ {i = 0} ^ {n} [y_i - f (x_i)] ^ 2 = \\sum_ {i = 0} ^ {n} (y_i - a_0 - a_1x_i) ^ 2\n", - "\\end {ecuación}\n", + "\\end {equation}\n", "$$\n", "\n", - "Las ecuaciones (2) se convierten en:\n", + "Las ecuaciones a resolver se convierten en:\n", "\n", "$$\n", "\\begin{equation}\n", - "    \\frac {\\partial {S}} {\\partial {a_0}} = \\sum_ {i = 0} ^ {n} -2 (y_i - a_0 - a_1x_i) = 2 \\ left [a_0 (n + 1) + a_1 \\sum_ {i = 0} ^ {n} x_i - \\sum_ {i = 0} ^ {n} y_i \\ right] = 0\n", + "    \\frac {\\partial {S}} {\\partial {a_0}} \n", + " = \n", + " \\sum_ {i = 0} ^ {n} -2 (y_i - a_0 - a_1x_i) \n", + " = \n", + " - 2\\sum_ {i = 0} ^ {n} y_i + 2 a_0 (n + 1) + 2 a_1 \\sum_ {i = 0} ^ {n} x_i \n", + " = \n", + " 0\n", "\\end{equation}\n", "$$\n", "\n", "$$\n", "\\begin{equation}\n", - "    \\frac {\\partial {S}} {\\partial {a_1}} = \\sum_ {i = 0} ^ {n} -2 (y_i - a_0 - a_1x_i) x_i = 2 \\ left [a_0 \\sum_ {i = 0 } ^ {n} x_i + a_1 \\sum_ {i = 0} ^ {n} x_ {i} ^ 2 - \\sum_ {i = 0} ^ {n} x_iy_i \\ right] = 0\n", + "    \\frac {\\partial {S}} {\\partial {a_1}} \n", + " = \n", + " \\sum_ {i = 0} ^ {n} -2 (y_i - a_0 - a_1x_i) x_i \n", + " = \n", + " - 2 \\sum_ {i = 0} ^ {n} x_i y_i + 2 a_0 \\sum_ {i = 0 } ^ {n} x_i + 2 a_1 \\sum_ {i = 0} ^ {n} x_ {i} ^ 2 \n", + " = 0\n", "\\end{equation}\n", "$$\n", "\n", - "Dividamos ambas ecuaciones por $ 2 (n + 1) $ y reorganicemos los términos.\n", - "\n", - "Reordenamiento (6) y (7):\n", + "Dividamos la primera de las ecuaciones por $ 2 (n + 1) $ y reorganicemos los términos.\n", "\n", "$$\n", "\\begin{align}\n", - "    2 \\ left [a_0 (n + 1) + a_1 \\sum_ {i = 0} ^ {n} x_i - \\sum_ {i = 0} ^ {n} y_i \\ right] & = 0 \\ nonumber \\\\\n", - "    \\frac {a_0 (n + 1)} {n + 1} + a_1 \\frac {\\sum_ {i = 0} ^ {n} x_i} {n + 1} - \\frac {\\sum_ {i = 0} ^ {n} y_i} {n + 1} & = 0 \\\\\n", + "    \\frac {2 a_0 (n + 1)} {2 (n + 1)} + 2 a_1 \\frac {\\sum_ {i = 0} ^ {n} x_i} {2(n + 1)} - 2 \\frac {\\sum_ {i = 0} ^ {n} y_i} {2 (n + 1)} & = 0 \\\\\n", "\\end{align}\n", "$$\n", - "\n", + "Obtenemos\n", "$$\n", "\\begin{align}\n", - "    a_0 = \\ bar {y} - a_1 \\ bar {x}\n", + "    a_0 = \\bar {y} - a_1 \\bar {x}\n", "\\end{align}\n", "$$\n", "\n", - "donde $ \\ bar {x} = \\frac {\\sum_ {i = 0} ^ {n} x_i} {n + 1} $ y $ \\ bar {y} = \\frac {\\sum_ {i = 0} ^ { n} y_i} {n + 1} $.\n", + "donde $ \\bar {x} = \\frac {\\sum_ {i = 0} ^ {n} x_i} {n + 1} $ y $ \\bar {y} = \\frac {\\sum_ {i = 0} ^ { n} y_i} {n + 1} $.\n", "\n", - "Reordenamiento (7):\n", + "Reordenando la segunda ecuación:\n", "\n", "$$\n", "\\begin{align}\n", - "    2 \\ left [a_0 \\sum_ {i = 0} ^ {n} x_i + a_1 \\sum_ {i = 0} ^ {n} x_ {i} ^ 2 - \\sum_ {i = 0} ^ {n} x_iy_i \\ derecha] & = 0 \\\\\n", + "    2 \\left [a_0 \\sum_ {i = 0} ^ {n} x_i + a_1 \\sum_ {i = 0} ^ {n} x_ {i} ^ 2 - \\sum_ {i = 0} ^ {n} x_iy_i \\right] & = 0 \\\\\n", "    a_0 \\sum_ {i = 0} ^ {n} x_i + a_1 \\sum_ {i = 0} ^ {n} x_ {i} ^ 2 - \\sum_ {i = 0} ^ {n} x_iy_i & = 0 \\\\\n", "\\end{align}\n", "$$\n", "\n", - "Ahora, si reemplazamos $ a_0 $ de la ecuación (8) en (9) y reorganizamos los términos:\n", + "Ahora, si reemplazamos el valor obtenido para $ a_0 $ y reorganizamos los términos:\n", "\n", "$$\n", "\\begin{align*}\n", - "    (\\ bar {y} - a_1 \\ bar {x}) \\sum_ {i = 0} ^ {n} x_i + a_1 \\sum_ {i = 0} ^ {n} x_ {i} ^ 2 - \\sum_ {i = 0} ^ {n} x_iy_i & = 0 \\\\\n", + "    (\\bar {y} - a_1 \\bar {x}) \\sum_ {i = 0} ^ {n} x_i + a_1 \\sum_ {i = 0} ^ {n} x_ {i} ^ 2 - \\sum_ {i = 0} ^ {n} x_iy_i & = 0 \\\\\n", "\\end{align*}\n", "$$\n", "\n", - "Reemplazar las definiciones de los valores promedio en la ecuación,\n", + "Al reemplazar las definiciones de los valores promedio en la ecuación, obtenemos\n", "\n", "$$\n", "\\begin{align*}\n", - "    \\ left [\\frac {1} {n + 1} \\sum_ {i = 0} ^ {n} y_i - \\frac {a_1} {n + 1} \\sum_ {i = 0} ^ {n} x_i \\ right ] \\sum_ {i = 0} ^ {n} x_i + a_1 \\sum_ {i = 0} ^ {n} x_ {i} ^ 2 - \\sum_ {i = 0} ^ {n} x_iy_i & = 0 \\\\\n", + "    \\left [\\frac {1} {n + 1} \\sum_ {i = 0} ^ {n} y_i - \\frac {a_1} {n + 1} \\sum_ {i = 0} ^ {n} x_i \\right ] \\sum_ {i = 0} ^ {n} x_i + a_1 \\sum_ {i = 0} ^ {n} x_ {i} ^ 2 - \\sum_ {i = 0} ^ {n} x_iy_i & = 0 \\\\\n", "     \\frac {1} {n + 1} \\sum_ {i = 0} ^ {n} y_i \\sum_ {i = 0} ^ {n} x_i - \\frac {a_1} {n + 1} \\sum_ {i = 0} ^ {n} x_i \\sum_ {i = 0} ^ {n} x_i + a_1 \\sum_ {i = 0} ^ {n} x_ {i} ^ 2 - \\sum_ {i = 0} ^ {n} x_iy_i & = 0 \\\\\n", "\\end{align*}\n", "$$\n", "\n", - "Dejando todo en términos de $ \\ bar {x} $,\n", + "Dejando todo en términos de $ \\bar{x} $,\n", "\n", "$$\n", "\\begin{align*}\n", - "    \\sum_ {i = 0} ^ {n} y_i \\ bar {x} - a_1 \\sum_ {i = 0} ^ {n} x_i \\ bar {x} + a_1 \\sum_ {i = 0} ^ {n} x_ {i} ^ 2 - \\sum_ {i = 0} ^ {n} x_iy_i = 0\n", + "    \\sum_ {i = 0} ^ {n} y_i \\bar {x} - a_1 \\sum_ {i = 0} ^ {n} x_i \\bar {x} + a_1 \\sum_ {i = 0} ^ {n} x_ {i} ^ 2 - \\sum_ {i = 0} ^ {n} x_iy_i = 0\n", "\\end{align*}\n", "$$\n", "\n", @@ -396,9 +366,9 @@ "\n", "$$\n", "\\begin{align*}\n", - "    a_1 \\ left [\\sum_ {i = 0} ^ {n} x_ {i} ^ 2 - \\sum_ {i = 0} ^ {n} x_i \\ bar {x} \\ right] & = \\sum_ {i = 0 } ^ {n} x_iy_i - \\sum_ {i = 0} ^ {n} y_i \\ bar {x} \\\\\n", - "    a_1 \\sum_ {i = 0} ^ {n} (x_ {i} ^ 2 - x_i \\ bar {x}) & = \\sum_ {i = 0} ^ {n} (x_iy_i - y_i \\ bar {x}) \\\\\n", - "    a_1 \\sum_ {i = 0} ^ {n} x_ {i} (x_ {i} - \\ bar {x}) & = \\sum_ {i = 0} ^ {n} y_i (x_i - \\ bar {x} )\n", + "    a_1 \\left [\\sum_ {i = 0} ^ {n} x_ {i} ^ 2 - \\sum_ {i = 0} ^ {n} x_i \\bar {x} \\right] & = \\sum_ {i = 0 } ^ {n} x_iy_i - \\sum_ {i = 0} ^ {n} y_i \\bar {x} \\\\\n", + "    a_1 \\sum_ {i = 0} ^ {n} (x_ {i} ^ 2 - x_i \\bar {x}) & = \\sum_ {i = 0} ^ {n} (x_iy_i - y_i \\bar {x}) \\\\\n", + "    a_1 \\sum_ {i = 0} ^ {n} x_ {i} (x_ {i} - \\bar {x}) & = \\sum_ {i = 0} ^ {n} y_i (x_i - \\bar {x} )\n", "\\end{align*}\n", "$$\n", "\n", @@ -406,7 +376,7 @@ "\n", "$$\n", "\\begin{align}\n", - "    a_1 = \\frac {\\sum_ {i = 0} ^ {n} y_ {i} (x_i - \\ bar {x})} {\\sum_ {i = 0} ^ {n} x_i (x_i - \\ bar {x })}\n", + "    a_1 = \\frac {\\sum_ {i = 0} ^ {n} y_ {i} (x_i - \\bar {x})} {\\sum_ {i = 0} ^ {n} x_i (x_i - \\bar {x})}\n", "\\end{align}\n", "$$\n", "\n", @@ -423,7 +393,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "### ¡Vamos a ajustar (parámetros)!\n", + "### ¡Vamos a ajustar nuestros parámetros!\n", "\n", "Ahora ajustaremos una línea recta a través de los datos de anomalías de temperatura para ver la tendencia en el tiempo. Utilizaremos la regresión lineal de mínimos cuadrados para encontrar la pendiente y la intersección de una línea\n", "\n", @@ -431,13 +401,13 @@ "\n", "que se ajusta a nuestros datos.\n", "\n", - "En nuestro caso, el dato en `x` corresponde al año (`year`), y el dato en `y` es la anomalia en la temperatura (` temp_anomaly`). Para calcular nuestros coeficientes con la fórmula anterior, necesitamos los valores medios de nuestros datos. Sólo necesitaremos calcular la media para `x` e `y`, pero podría ser útil escribir una _función_ de Python personalizada que calcule la media de cualquier matriz, y así luego podemos reutilizarla.\n", + "En nuestro caso, el dato en `x` corresponde al año (`year`), y el dato en `y` es la anomalia en la temperatura (` temp_anomaly`). Para calcular nuestros coeficientes con la fórmula anterior, necesitamos los valores promedios de nuestros datos. Sólo necesitaremos calcular el promedio para `x` e `y`, pero podría ser útil escribir una _función_ de Python personalizada que calcule el promedio de cualquier array, y así luego podemos reutilizarla.\n", "\n", "Es una buena práctica de codificación *evitar la repetición*: queremos escribir código que sea reutilizable, no sólo porque lleva a menos tipeo sino también porque reduce los errores. Si te encuentras realizando el mismo cálculo varias veces, es mejor encapsularlo en una *función*.\n", "\n", - "Recuerde el _concepto clave_ de la [Lección 1](http://go.gwu.edu/engcomp1lesson1): Una función es una colección compacta de código que ejecuta alguna acción en sus argumentos.\n", + "Recuerde el _concepto clave_ de la [Lección 1](./1_Interactuando_con_Python.ipynb): Una función es una colección compacta de código que ejecuta alguna acción en sus argumentos.\n", "\n", - "Una vez *definida*, puedes *llamar* a una función tantas veces como desees. Cuando *llamamos* a una función, ejecutamos todo el código dentro de la función. El resultado de la ejecución depende de la *definición* de la función y de los valores *pasados* en ella como *argumentos*. Las funciones pueden o no *devolver* valores en su última operación.\n", + "Una vez *definida* la función, puedes *llamarla* tantas veces como desees. Cuando *llamamos* a una función, ejecutamos todo el código dentro de la función. El resultado de la ejecución depende de la *definición* de la función y de los valores *pasados* en ella como *argumentos*. Las funciones pueden o no *devolver* valores en su última operación.\n", "\n", "La sintaxis para definir funciones de Python personalizadas es:\n", "\n", @@ -449,14 +419,14 @@ "    \n", "```\n", "\n", - "El **docstring** (texto de documentación) de una función es un mensaje del programador que documenta lo que se construyó. Un docstrings debe ser descriptivo y conciso. Son importantes porque explican (o recuerdan) el uso previsto de la función para los usuarios. Más adelante puede acceder a la cadena de documentación de una función usando la función `help()` y pasando el nombre de la función. Si está en una libreta, también puede anteponer un signo de interrogación `?` antes del nombre de la función y ejecutar en una celda para mostrar la información de una función.\n", + "El **docstring** (documentación) de una función es un mensaje del programador que documenta lo que se construyó. Un docstrings debe ser descriptivo y conciso. Son importantes porque explican (o recuerdan) el uso previsto de la función para los usuarios. Más adelante puede acceder a la cadena de documentación de una función usando la función `help()` y pasando el nombre de la función. Si está en un notebook, también puedes anteponer un signo de interrogación `?` antes del nombre de la función y ejecutar en una celda para mostrar la información de una función.\n", "\n", "¡Intentalo!" ] }, { "cell_type": "code", - "execution_count": 10, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -472,28 +442,9 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Help on built-in function print in module builtins:\n", - "\n", - "print(...)\n", - " print(value, ..., sep=' ', end='\\n', file=sys.stdout, flush=False)\n", - " \n", - " Prints the values to a stream, or to sys.stdout by default.\n", - " Optional keyword arguments:\n", - " file: a file-like object (stream); defaults to the current sys.stdout.\n", - " sep: string inserted between values, default a space.\n", - " end: string appended after the last value, default a newline.\n", - " flush: whether to forcibly flush the stream.\n", - "\n" - ] - } - ], + "outputs": [], "source": [ "help(print)" ] @@ -502,29 +453,29 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Definamos una función personalizada que calcula el valor medio de cualquier matriz. Estudia el código a continuación con cuidado." + "Definamos una función personalizada que calcula el valor promedio de cualquier array. Estudia el código a continuación con cuidado." ] }, { "cell_type": "code", - "execution_count": 13, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ "def mean_value(array):\n", - " \"\"\" Calcular el valor peromedio de un array - Calculate the mean value of an array \n", + " \"\"\" Calcular el valor promedio de un array\n", " \n", - " Argumentos (Arguments)\n", + " Argumentos\n", " ---------\n", - " array: array de Numpy (Numpy array) \n", + " array: array de Numpy\n", " \n", - " Regresa (Returns)\n", + " Regresa\n", " ------- \n", - " mean: valor promedio de una array (mean value of the array)\n", + " mean: valor promedio de una array\n", " \"\"\"\n", " sum_elem = 0\n", " for element in array:\n", - " sum_elem += element # esto es equivalente a sum_elem = sum_elem + element\n", + " sum_elem += element # Esto es equivalente a sum_elem = sum_elem + element\n", " \n", " mean = sum_elem / len(array)\n", " \n", @@ -536,22 +487,14 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Una vez que se ejecuta la celda de arriba, la función `mean_value()` está disponible para usar en cualquier argumento del tipo correcto. Esta función funciona en arreglos de cualquier longitud. Podemos intentarlo ahora con nuestros datos." + "Una vez que se ejecuta la celda de arriba, la función `mean_value()` está disponible para usar en cualquier argumento del tipo correcto. Esta función funciona en arrays de cualquier longitud. Podemos intentarlo ahora con nuestros datos." ] }, { "cell_type": "code", - "execution_count": 14, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "1948.0\n" - ] - } - ], + "outputs": [], "source": [ "year_mean = mean_value(year)\n", "print(year_mean)" @@ -559,17 +502,9 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.0526277372263\n" - ] - } - ], + "outputs": [], "source": [ "temp_anomaly_mean = mean_value(temp_anomaly)\n", "print(temp_anomaly_mean)" @@ -579,7 +514,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "¡Genial! Aprendiste cómo escribir una función de Python, y creamos una función para calcular el valor medio de una matriz de números. No teníamos que hacerlo, porque NumPy tiene una función incorporada para hacer exactamente lo que necesitamos: [`numpy.mean()`](https://docs.scipy.org/doc/numpy-1.13.0/reference/generated/numpy.mean.html)." + "¡Genial! Aprendiste cómo escribir una función de Python, y creamos una función para calcular el valor promedio de un array de números. No teníamos que hacerlo, porque NumPy tiene una función incorporada para hacer exactamente lo que necesitamos: [`numpy.mean()`](https://docs.scipy.org/doc/numpy-1.13.0/reference/generated/numpy.mean.html). En general, resulta una práctica conveniente verificar que las funciones que necesitas no existan en las librerías que estás utilizando." ] }, { @@ -588,15 +523,13 @@ "source": [ "##### Ejercicio\n", "\n", - "Calcule la media de las matrices `year` y` temp_anomaly` utilizando la función incorporada de NumPy, y compare los resultados con los obtenidos utilizando nuestra función personalizada `mean_value`." + "Calcula el promedio de los arrays `year` y` temp_anomaly` utilizando la función incorporada de NumPy, y compara los resultados con los obtenidos utilizando nuestra función personalizada `mean_value`." ] }, { "cell_type": "code", "execution_count": null, - "metadata": { - "collapsed": true - }, + "metadata": {}, "outputs": [], "source": [] }, @@ -604,7 +537,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Ahora que tenemos valores medios, podemos calcular nuestros coeficientes siguiendo las ecuaciones (12). Primero calculamos $ a_1 $ y luego usamos ese valor para calcular $ a_0 $.\n", + "Ahora que tenemos valores medios, podemos calcular nuestros coeficientes siguiendo las ecuaciones. Primero calculamos $ a_1 $ y luego usamos ese valor para calcular $ a_0 $.\n", "\n", "Nuestros coeficientes son:\n", "\n", @@ -617,12 +550,12 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Ya calculamos los valores medios de las matrices de datos, pero la fórmula requiere dos sumas sobre nuevas matrices. Pero adivina, NumPy tiene una función incorporada para eso: [`numpy.sum()`](https://docs.scipy.org/doc/numpy/reference/generated/numpy.sum.html). Estudia el código a continuación." + "Ya calculamos los valores promedios de los arrays de datos, pero la fórmula requiere dos sumas sobre nuevos arrays. Pero adivina, NumPy tiene una función incorporada para eso: [`numpy.sum()`](https://docs.scipy.org/doc/numpy/reference/generated/numpy.sum.html). Estudia el código a continuación." ] }, { "cell_type": "code", - "execution_count": 16, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -631,24 +564,16 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.0103702839435\n" - ] - } - ], + "outputs": [], "source": [ "print(a_1)" ] }, { "cell_type": "code", - "execution_count": 18, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -657,17 +582,9 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "-20.1486853847\n" - ] - } - ], + "outputs": [], "source": [ "print(a_0)" ] @@ -681,7 +598,7 @@ "Escribe una función que calcule los coeficientes, llama a esta función para calcularlos y compara el resultado con los valores que obtuvimos antes. Como una pista, te damos la estructura que debes seguir:\n", "\n", "```python\n", - "de coeficients(x, y, x_mean, y_mean):\n", + "def coeficients(x, y, x_mean, y_mean):\n", "    \"\"\"\n", "    Escribir docstrings aquí\n", "    \"\"\"\n", @@ -698,12 +615,12 @@ "source": [ "Ahora tenemos los coeficientes de la función lineal que mejor se ajusta a nuestros datos. Con ellos, podemos calcular los valores predichos de anomalía de temperatura, de acuerdo con nuestro ajuste. Verifica nuevamente las ecuaciones anteriores: los valores que vamos a calcular son $f(x_i)$.\n", "\n", - "Llamemos a `reg` la matriz obtenida al evaluar $f(x_i)$ para todos los años." + "Llamemos a `reg` al array obtenido al evaluar $f(x_i)$ para todos los años." ] }, { "cell_type": "code", - "execution_count": 20, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -719,27 +636,16 @@ }, { "cell_type": "code", - "execution_count": 22, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "pyplot.figure(figsize=(10, 5))\n", "\n", "pyplot.plot(year, temp_anomaly, color='#2929a3', linestyle='-', linewidth=1, alpha=0.5) \n", "pyplot.plot(year, reg, 'k--', linewidth=2, label='Regresión lineal')\n", "pyplot.xlabel('Año')\n", - "pyplot.ylabel('Anomalía de temperatura en tierra [°C]')\n", + "pyplot.ylabel('Anomalía de temperatura[°C]')\n", "pyplot.legend(loc='best', fontsize=15)\n", "pyplot.grid();" ] @@ -748,14 +654,14 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "## Paso 4: aplicar la regresión usando NumPy" + "## Paso 4: aplicando la regresión usando NumPy" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "Anteriormente codificamos la regresión lineal desde cero. Pero, ya habrás adivinado: no tuvimos que hacerlo porque NumPy tiene funciones integradas que cubren muchas de nuestras necesidades.\n", + "Anteriormente codificamos la regresión lineal desde cero. Pero, como ya habrás supuesto, no era necesario hacerlo porque NumPy tiene funciones integradas que cubren muchas de nuestras necesidades.\n", "\n", "¡Sí! ¡Python y NumPy están aquí para ayudar! Con [`polyfit()`](https://docs.scipy.org/doc/numpy-1.10.0/reference/generated/numpy.polyfit.html), obtenemos la pendiente y el intercepto en $y$ de la línea que mejor se ajusta a los datos. Con [`poly1d()`](https://docs.scipy.org/doc/numpy/reference/generated/numpy.poly1d.html), podemos construir la función lineal desde su pendiente y su intercepto en $y$.\n", "\n", @@ -764,7 +670,7 @@ }, { "cell_type": "code", - "execution_count": 23, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -776,72 +682,36 @@ }, { "cell_type": "code", - "execution_count": 24, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.0103702839435\n" - ] - } - ], + "outputs": [], "source": [ "print(a_1n)" ] }, { "cell_type": "code", - "execution_count": 25, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "-20.1486853847\n" - ] - } - ], + "outputs": [], "source": [ "print(a_0n)" ] }, { "cell_type": "code", - "execution_count": 26, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - " \n", - "0.01037 x - 20.15\n" - ] - } - ], + "outputs": [], "source": [ "print(f_linear)" ] }, { "cell_type": "code", - "execution_count": 28, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "pyplot.figure(figsize=(10, 5))\n", "\n", @@ -868,25 +738,14 @@ "\n", "¿Qué pasa si dividimos los datos en dos (antes y después de 1970) y realizamos una regresión lineal en cada segmento?\n", "\n", - "Para hacer eso, necesitamos encontrar el puesto en nuestra matriz `year` donde se encuentra el año 1970. Afortunadamente, NumPy tiene una función llamada [`numpy.where()`](https://docs.scipy.org/doc/numpy/reference/generated/numpy.where.html) que nos puede ayudar. Pasamos una condición y `numpy.where()` nos dice en qué parte de la matriz la condición es `True`." + "Para hacer eso, necesitamos encontrar el lugar en nuestro aray `year` donde se encuentra el año 1970. Afortunadamente, NumPy tiene una función llamada [`numpy.where()`](https://docs.scipy.org/doc/numpy/reference/generated/numpy.where.html) que nos puede ayudar. Pasamos una condición y `numpy.where()` nos dice en qué parte del array la condición es `True`." ] }, { "cell_type": "code", - "execution_count": 29, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "(array([90]),)" - ] - }, - "execution_count": 29, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "numpy.where(year==1970)" ] @@ -895,25 +754,14 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Para dividir los datos, usamos el poderoso instrumento de _slicing_ con la notación de dos puntos. Recuerde que un punto entre dos índices indica un rango de valores desde un 'inicio' hasta un 'final'. La regla es que `[start: end]` incluye el elemento en el índice `start` pero excluye el del índice` end`. Por ejemplo, para obtener los primeros 3 años en nuestra matriz `year`, hacemos:" + "Para dividir los datos, usamos el poderoso instrumento de _slicing_ con la notación de dos puntos. Recuerde que un punto entre dos índices indica un rango de valores desde `start`(inicio) hasta `end` (fin). La regla es que `[start: end]` incluye el elemento en el índice `start` pero excluye el correspondiente al índice` end`. Por ejemplo, para obtener los primeros 3 años en nuestro array `year`, hacemos:" ] }, { "cell_type": "code", - "execution_count": 30, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array([ 1880., 1881., 1882.])" - ] - }, - "execution_count": 30, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "year[0:3]" ] @@ -922,12 +770,12 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Ahora sabemos cómo dividir nuestros datos en dos conjuntos, para obtener dos líneas de regresión. Necesitamos dos sectores de las matrices `year` y` temp_anomaly`, que guardaremos en los nuevos nombres de variables a continuación. Después de eso, completamos dos ajustes lineales utilizando las útiles funciones de NumPy que aprendimos anteriormente." + "Ahora sabemos cómo dividir nuestros datos en dos conjuntos, para obtener dos líneas de regresión. Necesitamos dos sectores de los arrays `year` y` temp_anomaly`, que guardaremos en los nuevos nombres de variables a continuación. Después de eso, completamos dos ajustes lineales utilizando las útiles funciones de NumPy que aprendimos anteriormente." ] }, { "cell_type": "code", - "execution_count": 31, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -943,20 +791,9 @@ }, { "cell_type": "code", - "execution_count": 33, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "pyplot.figure(figsize=(10, 5))\n", "\n", @@ -983,11 +820,11 @@ "source": [ "## Aprendimos:\n", "\n", - "* Hacer nuestros gráficos más bellos\n", + "* Hacer gráficos más bellos\n", "* Definir y llamar funciones de Python personalizadas\n", "* Aplicar regresión lineal a datos\n", "* Funciones nativas de NumPy para regresión lineal\n", - "* ¡¡La Tierra se está calentando !!!" + "* ¡La Tierra se está calentando!" ] }, { @@ -1002,169 +839,9 @@ }, { "cell_type": "code", - "execution_count": 28, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "\n", - "\n", - "\n", - "\n" - ], - "text/plain": [ - "" - ] - }, - "execution_count": 28, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "# Execute this cell to load the notebook's style sheet, then ignore it\n", "from IPython.core.display import HTML\n", From b8095642d01d04cf807a1d2922dd323d66f41311 Mon Sep 17 00:00:00 2001 From: Sebastian Flores Date: Mon, 9 Jul 2018 00:47:37 -0400 Subject: [PATCH 15/17] Fixing one link and using the provided jupyter template --- notebooks_es/1_Interactuando_con_Python.ipynb | 168 ++++++++++++++++- .../2_Strings_y_listas_en_accion.ipynb | 170 +++++++++++++++++- .../3_Jugando_con_archivo_de_cursos.ipynb | 168 ++++++++++++++++- .../4_Conociendo_arrays_y_graficos.ipynb | 166 ++++++++++++++++- .../5_Regresion_Lineal_con_datos_reales.ipynb | 166 ++++++++++++++++- 5 files changed, 824 insertions(+), 14 deletions(-) diff --git a/notebooks_es/1_Interactuando_con_Python.ipynb b/notebooks_es/1_Interactuando_con_Python.ipynb index 5c2f2b6..92315ff 100644 --- a/notebooks_es/1_Interactuando_con_Python.ipynb +++ b/notebooks_es/1_Interactuando_con_Python.ipynb @@ -848,9 +848,171 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + "\n", + "\n", + "\n", + "\n" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 1, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "# Execute this cell to load the notebook's style sheet, then ignore it\n", "from IPython.core.display import HTML\n", diff --git a/notebooks_es/2_Strings_y_listas_en_accion.ipynb b/notebooks_es/2_Strings_y_listas_en_accion.ipynb index 8549a6d..6c470df 100644 --- a/notebooks_es/2_Strings_y_listas_en_accion.ipynb +++ b/notebooks_es/2_Strings_y_listas_en_accion.ipynb @@ -13,7 +13,7 @@ "source": [ "# Jugando con datos en Jupyter\n", "\n", - "Esta es la segunda lección de nuestro curso en _\"Cálculos Computacionales en ingeniería\"_. En la primera lección, [_Interactuando con Python_](http://nbviewer.jupyter.org/github/engineersCode/EngComp1_offtheground/blob/master/notebooks_es/1_Interactuando_con_Python.ipynb), usamos **IPython**, el shell interactivo de Python. Es genial escribir expresiones de Python de una sola línea y obtener los resultados de forma interactiva. Sin embargo, aunque no lo creas, ¡hay cosas más increíbles!\n", + "Esta es la segunda lección de nuestro curso en _\"Cálculos Computacionales en ingeniería\"_. En la primera lección, [_Interactuando con Python_](./1_Interactuando_con_Python.ipynb), usamos **IPython**, el shell interactivo de Python. Es genial escribir expresiones de Python de una sola línea y obtener los resultados de forma interactiva. Sin embargo, aunque no lo creas, ¡hay cosas más increíbles!\n", "\n", "En esta lección, continuarás usando Python para jugar con datos, pero lo harás en un **Jupyter Notebook**. Esta misma lección está escrita en un Jupyter Notebook. ¿Listo? No te arrependirás." ] @@ -1601,9 +1601,171 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + "\n", + "\n", + "\n", + "\n" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 1, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "# Execute this cell to load the notebook's style sheet, then ignore it\n", "from IPython.core.display import HTML\n", diff --git a/notebooks_es/3_Jugando_con_archivo_de_cursos.ipynb b/notebooks_es/3_Jugando_con_archivo_de_cursos.ipynb index 9360eb1..b90ada9 100644 --- a/notebooks_es/3_Jugando_con_archivo_de_cursos.ipynb +++ b/notebooks_es/3_Jugando_con_archivo_de_cursos.ipynb @@ -520,9 +520,171 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + "\n", + "\n", + "\n", + "\n" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 1, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "# Execute this cell to load the notebook's style sheet, then ignore it\n", "from IPython.core.display import HTML\n", diff --git a/notebooks_es/4_Conociendo_arrays_y_graficos.ipynb b/notebooks_es/4_Conociendo_arrays_y_graficos.ipynb index 5d76349..a51cba7 100644 --- a/notebooks_es/4_Conociendo_arrays_y_graficos.ipynb +++ b/notebooks_es/4_Conociendo_arrays_y_graficos.ipynb @@ -1003,9 +1003,171 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 1, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/html": [ + "\n", + "\n", + "\n", + "\n", + "\n" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 1, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "# Execute this cell to load the notebook's style sheet, then ignore it\n", "from IPython.core.display import HTML\n", diff --git a/notebooks_es/5_Regresion_Lineal_con_datos_reales.ipynb b/notebooks_es/5_Regresion_Lineal_con_datos_reales.ipynb index d864947..5e63bb9 100644 --- a/notebooks_es/5_Regresion_Lineal_con_datos_reales.ipynb +++ b/notebooks_es/5_Regresion_Lineal_con_datos_reales.ipynb @@ -839,9 +839,171 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 1, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/html": [ + "\n", + "\n", + "\n", + "\n", + "\n" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 1, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "# Execute this cell to load the notebook's style sheet, then ignore it\n", "from IPython.core.display import HTML\n", From 7865d0fba5940ba103c9dd004a794b50d266e8c6 Mon Sep 17 00:00:00 2001 From: Sebastian Flores Date: Tue, 24 Jul 2018 21:22:38 -0400 Subject: [PATCH 16/17] Final corrections for notebook 2 --- .../2_Strings_y_listas_en_accion.ipynb | 151 ++++++++++-------- 1 file changed, 81 insertions(+), 70 deletions(-) diff --git a/notebooks_es/2_Strings_y_listas_en_accion.ipynb b/notebooks_es/2_Strings_y_listas_en_accion.ipynb index 6c470df..ddbbb5b 100644 --- a/notebooks_es/2_Strings_y_listas_en_accion.ipynb +++ b/notebooks_es/2_Strings_y_listas_en_accion.ipynb @@ -13,7 +13,7 @@ "source": [ "# Jugando con datos en Jupyter\n", "\n", - "Esta es la segunda lección de nuestro curso en _\"Cálculos Computacionales en ingeniería\"_. En la primera lección, [_Interactuando con Python_](./1_Interactuando_con_Python.ipynb), usamos **IPython**, el shell interactivo de Python. Es genial escribir expresiones de Python de una sola línea y obtener los resultados de forma interactiva. Sin embargo, aunque no lo creas, ¡hay cosas más increíbles!\n", + "Esta es la segunda lección de nuestro curso en _\"Cálculos Computacionales en Ingeniería\"_. En la primera lección, [_Interactuando con Python_](./1_Interactuando_con_Python.ipynb), usamos **IPython**, el shell interactivo de Python. Es genial escribir expresiones de Python de una sola línea y obtener los resultados de forma interactiva. Sin embargo, aunque no lo creas, ¡hay cosas más increíbles!\n", "\n", "En esta lección, continuarás usando Python para jugar con datos, pero lo harás en un **Jupyter Notebook**. Esta misma lección está escrita en un Jupyter Notebook. ¿Listo? No te arrependirás." ] @@ -24,9 +24,9 @@ "source": [ "## ¿Qué es Jupyter?\n", "\n", - "Jupyter es un conjunto de herramientas de código abierto para la informática interactiva y exploratoria. Trabajarás directamente en tu navegador web, que se convierte en la interfaz de usuario a través de la cual Jupyter te proporciona un explorador de archivos (el _dashboard_) y un formato de documento: el **notebook**.\n", + "Jupyter es un conjunto de herramientas de código abierto para la informática interactiva y exploratoria. Trabajarás directamente en tu navegador web, que se convierte en la interfaz de usuario a través de la cual Jupyter te proporciona un explorador de archivos (el _dashboard_) y un documento: el **notebook**.\n", "\n", - "Un Jupyter Notebook puede contener: entrada y salida de código, texto con formato, imágenes, videos, bonitas ecuaciones matemáticas y mucho más. El código de la computadora es completamente _ejecutable_, lo que significa que puede ejecutar el código, directamente en el documento, y obtener la salida de ese código directamente en el navegador. Esta forma interactiva de computación, mezclada con la narrativa multimedia, permite contar una historia (incluso de manera individual y personal) con súperpoderes computacionales." + "Un Jupyter Notebook puede contener: entrada y salida de código, texto con formato, imágenes, videos, bonitas ecuaciones matemáticas y mucho más. El código de la computadora es completamente _ejecutable_, lo que significa que puede ejecutar el código, directamente en el documento, y obtener la salida de ese código en el navegador. Esta forma interactiva de computación, mezclada con la narrativa multimedia, permite contar una historia (incluso de manera individual y personal) con súperpoderes computacionales." ] }, { @@ -55,23 +55,30 @@ "\n", "No cierres la ventana del terminal que lanzó Jupyter mientras todavía está trabajando en Jupyter. Si necesitas hacer otras tareas en la línea de comando, abre una nueva ventana de terminal.\n", "\n", - "#### Captura de pantalla del dashboard de Jupyter, abierto en el navegador.\n", + "---\n", "\n", "Para iniciar un nuevo Jupyter Notebook, haz clic en la esquina superior derecha, donde dice **Nuevo** o **New**, y selecciona `Python 3`. Deberías tener algo similar a la siguiente captura de pantalla:\n", "\n", "\n", "\n", - "#### Captura de pantalla que muestra cómo crear un nuevo cuaderno.\n", + "#### Captura de pantalla del dashboard de Jupyter, abierto en el navegador.\n", + "\n", + "---\n", "\n", "Aparecerá una nueva pestaña en tu navegador web y verás un notebook vacío, con una sola línea de entrada, esperando que ingreses algún código, como en la siguiente captura de pantalla:\n", "\n", "\n", "\n", - "#### Captura de pantalla que muestra un nuevo cuaderno vacío.\n", + "#### Captura de pantalla que muestra cómo crear un nuevo cuaderno.\n", + "\n", + "---\n", + "\n", "\n", "El notebook se abre de manera predeterminada con una sola celda de código vacía. Intenta escribir allí un código Python y ejecútalo presionando `[shift] + [enter]`.\n", "\n", - "\n" + "\n", + "\n", + "#### Captura de pantalla que muestra un nuevo cuaderno vacío.\n" ] }, { @@ -92,7 +99,7 @@ "\n", "El contenido de código ejecutable se ingresa en celdas de código. Usaremos el kernel de IPython (\"kernel\" es el nombre utilizado para el motor de computación), pero debes saber que Jupyter puede utilizarse con muchos lenguajes de computación diferentes. Es in-cre-í-ble.\n", "\n", - "Una celda de código le mostrará es espacio para ingresar código:\n", + "Una celda de código te mostrará un espacio para ingresar código:\n", "\n", "`In []:`\n", "\n", @@ -102,7 +109,7 @@ "\n", "##### Un poco de historia:\n", "\n", - "Markdown fue co-creado por el legendario pero trágico [Aaron Swartz](https://es.wikipedia.org/wiki/Aaron_Swartz). El documental biográfico sobre él se llama [\"The Own Boy de Internet\"](https://en.wikipedia.org/wiki/The_Internet%27s_Own_Boy) y puedes verlo en YouTube o Netflix. ¡Recomendado!" + "Markdown fue co-creado por el legendario pero trágico [Aaron Swartz](https://es.wikipedia.org/wiki/Aaron_Swartz). El documental biográfico sobre él se llama [The Internet's Own Boy\"](https://en.wikipedia.org/wiki/The_Internet%27s_Own_Boy) y puedes verlo en YouTube o Netflix. ¡Recomendado!" ] }, { @@ -250,7 +257,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "¿Qué ocurre si queremos agregar un espacio que separa `hello` from` world`? Añadimos directamente la cadena `' '` en el medio de las dos variables. Un espacio es un carácter de texto (NdlT: se llama character en inglés, abreviado char para los amigos)." + "¿Qué ocurre si queremos agregar un espacio que separa `hola` from `mundo`? Añadimos directamente la cadena `' '` en el medio de las dos variables. Un espacio es un carácter de texto (NdlT: se llama character en inglés, abreviado char para los amigos)." ] }, { @@ -269,7 +276,7 @@ "source": [ "##### Ejercicio:\n", "\n", - "Crea una nueva variable de cadena que agregua tres signos de admiración al final de `my_string`." + "Crea una nueva variable de cadena que agrega tres signos de admiración al final de `my_string`." ] }, { @@ -280,7 +287,7 @@ "source": [ "### Indexación\n", "\n", - "Podemos acceder a cada carácter de texto por separado en una cadena de texto (o incluso, un pedazo continuo de la misma) usando _índices_: enteros que denotan la posición del carácter en la cadena de texto. Los índices van entre corchetes, tocando el nombre de la variable a la derecha. Por ejemplo, para acceder al primer elemento de `new_string`, debemos ingresar` new_string[0]`. ¡Sí! en Python comenzamos a contar desde 0 (y hace mucho sentido)." + "Podemos acceder a cada carácter de texto por separado en una cadena de texto (o incluso, un trozo continuo de la misma) usando _índices_: enteros que denotan la posición del carácter en la cadena de texto. Los índices van entre corchetes, tocando el nombre de la variable a la derecha. Por ejemplo, para acceder al primer elemento de `new_string`, debemos ingresar` new_string[0]`. ¡Sí! en Python comenzamos a contar desde 0 (y hace mucho sentido)." ] }, { @@ -326,7 +333,7 @@ "source": [ "¿Cómo sabemos el índice del último elemento en la cadena?\n", "\n", - "Python tiene una función incorporada llamada `len()` (abreviación de length, que significa largo o extensión en inglés) que proporciona la información sobre la longitud de un objeto:" + "Python tiene una función incorporada llamada `len()` (abreviación de length, que significa largo o longitud en inglés) que proporciona la información sobre la longitud de un objeto:" ] }, { @@ -358,7 +365,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Oops. Tenemos un error: ¿por qué? La longitud de `my_string` es dies. Pero el número entero 10 no funciona como un índice. Si esperabas obtener el último elemento, es porque olvidaste que Python comienza a contar desde cero. No te preocupes: lleva un tiempo acostumbrarse.\n", + "Oops. Tenemos un error: ¿por qué? La longitud de `my_string` es diez. Pero el número entero 10 no funciona como un índice. Si esperabas obtener el último elemento, es porque olvidaste que Python comienza a contar desde cero. No te preocupes: lleva un tiempo acostumbrarse.\n", "\n", "El mensaje de error dice que el índice está fuera de rango: esto es porque el índice del _último elemento_ siempre será: `len (cadena) - 1`. En nuestro caso, ese número es 9. Probémoslo." ] @@ -485,7 +492,7 @@ "##### Ejercicios:\n", "\n", "1. Define una cadena de texto llamada `'banana'` e imprime la primera y última `'a'`.\n", - "2. Usando el mismo string, obtén las 2 combinaciones posibles que corresponden a la palabra \"ana\" e imprímalas.\n", + "2. Usando el mismo string, obtén las 2 combinaciones posibles que corresponden a la palabra \"ana\" e imprímelas.\n", "3. Crea tu propio ejercicio de slicing y pídales a sus compañeros que lo intenten (trabajar en grupos de 3)." ] }, @@ -493,7 +500,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Las siguientes líneas contienen las soluciones; para revelar la respuesta, seleccione las líneas con el mouse:\n", + "Las siguientes líneas contienen las soluciones; para revelar la respuesta, selecciona las líneas con el mouse:\n", " \n", "Ejercicio de solución 1:\n", "\n", @@ -517,9 +524,9 @@ "source": [ "### ¿Qué más podemos hacer con las cadenas?\n", "\n", - "Python tiene muchas funciones útiles para cadenas. Aprenderás algunas de ellos en esta sección. Un detalle técnico: en Python, algunas funciones están asociadas a una clase particular de objetos (por ejemplo, strings). La palabra **método** (method) se usa en este caso, y tenemos una nueva forma de llamarlos: el operador de punto. Es un poco contra-intuitivo que el nombre del método viene después del punto, mientras que el nombre del objeto en particular en el que actúa es lo primero. Así, por ejemplo, tendríamos: `mystring.method ()`.\n", + "Python tiene muchas funciones útiles para cadenas. Aprenderás algunas de ellos en esta sección. Un detalle técnico: en Python, algunas funciones están asociadas a una clase particular de objetos (por ejemplo, strings). La palabra **método** (method) se usa en este caso, y tenemos una nueva forma de llamarlos: el operador de punto. Es un poco contra-intuitivo que el nombre del método viene después del punto, mientras que el nombre del objeto en particular en el que actúa es lo primero. Así, por ejemplo, tendríamos: `mystring.method()`.\n", "\n", - "Si tiene curiosidad acerca de los muchos métodos disponibles para strings, vaya a la sección \"Métodos de strings incorporados\" en este [tutorial](https://www.tutorialspoint.com/python3/python_strings.htm).\n", + "Si tiene curiosidad acerca de los muchos métodos disponibles para strings, puedes ir a la sección \"Métodos de strings incorporados\" en este [tutorial](https://www.tutorialspoint.com/python3/python_strings.htm).\n", "\n", "Usaremos una cita de Albert Einstein como en un string y aplicaremos algunos métodos de cadena útiles para ejemplificar." ] @@ -587,7 +594,7 @@ "metadata": {}, "outputs": [], "source": [ - "AE_quote.count('Todas')" + "AE_quote.count('un')" ] }, { @@ -685,7 +692,7 @@ "\n", "*Sintaxis:*\n", "\n", - "`str.index (substr, start, end)`\n", + "`str.index(substr, start, end)`\n", "\n", "¡Por eso siempre es importante verificar la documentación!" ] @@ -809,7 +816,7 @@ "source": [ "Supongamos que quieres quitar el período al final; podrías hacer lo siguiente:\n", "\n", - "`ER_quote = ER_quote.strip ('.')`\n", + "`ER_quote = ER_quote.strip('.')`\n", "\n", "Pero si no queremos mantener los cambios en nuestra variable de cadena, no sobrescribimos la variable como hicimos anteriormente. Veamos cómo se ve:" ] @@ -853,7 +860,7 @@ "metadata": {}, "outputs": [], "source": [ - "ER_quote.startswith('great')" + "ER_quote.startswith('grandes')" ] }, { @@ -869,14 +876,14 @@ "metadata": {}, "outputs": [], "source": [ - "ER_quote.startswith('Great')" + "ER_quote.startswith('Grandes')" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "Es importante mencionar que no es necesario que coincidamos con el personaje hasta que lleguemos al espacio en blanco." + "Es importante mencionar que no es necesario que coincidamos con la primera palabra, sino con una combinación arbitraria de caracteres." ] }, { @@ -885,7 +892,7 @@ "metadata": {}, "outputs": [], "source": [ - "ER_quote.startswith('Gre')" + "ER_quote.startswith('Gra')" ] }, { @@ -896,7 +903,7 @@ "\n", "*Sintaxis:*\n", "\n", - "`str.split (separator, num)`" + "`str.split(separator, num)`" ] }, { @@ -971,7 +978,7 @@ "outputs": [], "source": [ "# A list of strings\n", - "['apple', 'banana', 'orange']" + "['manzana', 'banana', 'naranja']" ] }, { @@ -981,7 +988,7 @@ "outputs": [], "source": [ "# A list with different element types\n", - "[2, 'apple', 4.5, [5, 10]]" + "[2, 'manzana', 4.5, [5, 10]]" ] }, { @@ -1000,7 +1007,7 @@ "outputs": [], "source": [ "integers = [1, 2, 3, 4, 5]\n", - "fruits = ['apple', 'banana', 'orange']" + "fruits = ['manzana', 'banana', 'naranja']" ] }, { @@ -1097,7 +1104,7 @@ "source": [ "##### Ejercicios:\n", "\n", - "1. De la lista `enteros`, toma la sección `[2, 3, 4]` y luego `[4, 5]`.\n", + "1. De la lista `enteros`, toma la sub-lista `[2, 3, 4]` y luego `[4, 5]`.\n", "2. Crea tu propia lista y diseña un ejercicio para agarrar slices, trabajando con tus compañeros de clase." ] }, @@ -1123,7 +1130,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Comprobemos que la lista `entera 'ahora tiene un 6 al final:" + "Comprobemos que la lista ahora tiene un 6 al final:" ] }, { @@ -1160,7 +1167,7 @@ "metadata": {}, "outputs": [], "source": [ - "'strawberry' in fruits" + "'fresa' in fruits" ] }, { @@ -1169,7 +1176,7 @@ "metadata": {}, "outputs": [], "source": [ - "'strawberry' not in fruits" + "'fresa' not in fruits" ] }, { @@ -1180,13 +1187,13 @@ "\n", "1. Agrega dos frutas diferentes a la lista `fruits`.\n", "2. Comprueba si `'mango'` está en tu nueva lista` fruits`.\n", - "3. Dada la lista `lista = [1, 2, 3, '4', [5, 'six'], [7]]` ejecuta lo siguiente en celdas separadas y analiza el resultado con tus compañeros de clase:\n", + "3. Dada la lista `lista = [1, 2, 3, '4', [5, 'seis'], [7]]` ejecuta lo siguiente en celdas separadas y analiza el resultado con tus compañeros de clase:\n", "\n", "```Python\n", - "   4 in lista\n", - "   5 in lista\n", - "   7 in lista\n", - "   [7] in lista\n", + "4 in lista\n", + "5 in lista\n", + "7 in lista\n", + "[7] in lista\n", "```" ] }, @@ -1206,7 +1213,7 @@ "metadata": {}, "outputs": [], "source": [ - "lista = [1, 2, 3, '4', [5, 'six'], [7]]" + "lista = [1, 2, 3, '4', [5, 'seis'], [7]]" ] }, { @@ -1280,7 +1287,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Poder modificar elementos en una lista es una \"propiedad\" de las listas de Python; otros objetos Python que veremos más adelante en el curso también se comportan así, pero no todos los objetos Python. Por ejemplo, no puede modificar elementos en una cadena. Si lo intentamos, Python se quejará.\n", + "Poder modificar elementos en una lista es una \"propiedad\" de las listas de Python; otros objetos Python que veremos más adelante en el curso también se comportan así, pero no todos los objetos Python. Por ejemplo, no puede modificar elementos en un string. Si lo intentamos, Python se quejará.\n", "\n", "¡No importa! Vamos a intentarlo. Uno de los principios de computación es comprobar e intentar cosas, aunque no funcionen:" ] @@ -1291,7 +1298,7 @@ "metadata": {}, "outputs": [], "source": [ - "string = 'This is a string.'" + "string = 'Esto es un string.'" ] }, { @@ -1330,11 +1337,11 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "## Siguiente: cadenas y listas en acción\n", + "## Cadenas y listas en acción\n", "\n", - "Has aprendido muchas cosas sobre cadenas de texto y listas en esta lección, y probablemente estás ansioso por ver cómo aplicarlo a una situación realista. Creamos un [ejemplo completo](http://nbviewer.jupyter.org/github/engineersCode/EngComp1_offtheground/blob/master/notebooks_es/3_Ejemplo_con_MAEbulletin.ipynb) en un notebook separado para mostrar el poder de Python con los datos de texto.\n", + "Has aprendido muchas cosas sobre cadenas de texto y listas en esta lección, y probablemente estás ansioso por ver cómo aplicarlo a una situación realista. Creamos un [ejemplo completo](./3_Jugando_con_archivo_de_cursos.ipynb) en un notebook separado para mostrar el poder de Python con los datos de texto.\n", "\n", - "Pero antes de avanzar a eso, deberíamos presentarle las potentes ideas de **iteration** y **conditionals** en Python." + "Pero antes de avanzar a eso, deberíamos presentarle las potentes ideas de **iteración** y **condicionales** en Python." ] }, { @@ -1345,16 +1352,16 @@ "\n", "La idea de _iteración_ es básicamente repetir un proceso varias veces. Si tienes experiencia en programación con otro idioma (como C o Java, por ejemplo), puedes tener una idea de cómo crear iteraciones con sentencias `for`. Pero estos son un poco diferentes en Python, como puede leer en la [documentación](https://docs.python.org/3/tutorial/controlflow.html#for-statements).\n", "\n", - "En Python, la instrucción `for` itera sobre los elementos de una secuencia. Digamos que se tiene una lista llamada `frutas` que contiene cadenas de texto con nombres de fruta. Puedes escribir una ciclo for de la siguiente forma:\n", + "En Python, la instrucción `for` itera sobre los elementos de una secuencia. Digamos que se tiene una lista llamada `fruits` que contiene cadenas de texto con nombres de fruta. Puedes escribir una ciclo for de la siguiente forma:\n", "\n", "```Python\n", - "for fruta in frutas:\n", + "for fruit in fruits:\n", "```\n", "hacer algo con cada elemento de la lista.\n", "\n", - "Aquí, por primera vez, encontraremos una característica distintiva del lenguaje Python: agrupanción por **indentación**. Para delimitar _qué_ Python debe hacer con cada `fruta` en la lista de` frutas`, colocamos las siguientes declaraciones _indentadas_ desde la izquierda.\n", + "Aquí, por primera vez, encontraremos una característica distintiva del lenguaje Python: agrupanción por **indentación**. Para delimitar _qué_ Python debe hacer con cada `fruit` en la lista de` fruits`, colocamos las siguientes declaraciones _indentadas_ desde la izquierda.\n", "\n", - "¿Cuánto indentar? Esta es una pregunta de estilo, y todos tienen una preferencia: dos espacios, cuatro espacios, una sola tabulación... todos son válidos: ¡lo importante es elegir un estilo y ser consecuente!\n", + "¿Cuánto indentar? Esta es una pregunta de estilo, y todos tienen una preferencia: dos espacios, cuatro espacios, una sola tabulación... todos son válidos: ¡lo importante es elegir un estilo y ser consecuente! De la misma manera, el código resulta más legible si escribirmos los nombres de las variables en inglés.\n", "\n", "Usemos cuatro espacios:" ] @@ -1365,10 +1372,10 @@ "metadata": {}, "outputs": [], "source": [ - "fruits = ['apple', 'banana', 'orange', 'cherry', 'mandarin']\n", + "fruits = ['manzana', 'banana', 'naranja', 'cereza', 'mandarina']\n", "\n", "for fruit in fruits:\n", - " print(\"Eat your\", fruit)" + " print(\"Come tu\", fruit)" ] }, { @@ -1377,12 +1384,12 @@ "source": [ "##### Presta atención:\n", "\n", - "* la instrucción `for` termina con dos puntos,`: `\n", - "* la variable `fruit` está implícitamente definida en la declaración` for`\n", - "* `fruit` toma el valor (cadena) de cada elemento de la lista` fruits`, en orden\n", - "* la sentencia sangrienta `print()` se ejecuta para cada valor de `fruit`\n", - "* una vez que Python se queda sin frutas ('fruits'), se detiene\n", - "* ¡no necesitamos saber con anticipación cuántos elementos hay en la lista!" + "* La instrucción `for` termina con dos puntos,`: `\n", + "* La variable `fruit` está implícitamente definida en la declaración` for`\n", + "* `fruit` tomará el valor de cada elemento de la lista` fruits`, en orden\n", + "* La sentencia indentada `print()` se ejecuta para cada valor de `fruit`\n", + "* Una vez que Python se queda sin frutas ('fruits'), se detiene\n", + "* ¡No necesitamos saber con anticipación cuántos elementos hay en la lista!" ] }, { @@ -1433,8 +1440,12 @@ "\n", "Supongamos que tenemos una lista de listas (a.k.a., una _nested list_ o lista anidada), como se muestra a continuación:\n", "```Python\n", - "nombres completos = [['sam', 'jones'], ['zoe', 'smith'], ['joe', 'cheek'], ['tom', 'perez']]\n", + "fullnames = [['sam', 'jones'], \n", + " ['zoe', 'smith'], \n", + " ['joe', 'cheek'], \n", + " ['tom', 'perez']]\n", "```\n", + "\n", "Escriba un código que cree dos listas simples: una con los primeros nombres, otra con los apellidos de la lista anidada arriba, pero en mayúscula.\n", "\n", "Para comenzar, necesita crear dos listas _vacías_ utilizando los corchetes pero sin contenido. Hemos hecho eso para tí a continuación. _Pista_: ¡Usa el método de lista `append()`!" @@ -1459,7 +1470,7 @@ "source": [ "### Condicionales con declaraciones `if`\n", "\n", - "Algunas veces necesitamos la habilidad de verificar condiciones y cambiar el comportamiento de nuestro programa dependiendo de la condición. Lo logramos con una instrucción `if`, que puede tomar una de tres formas." + "Muchas veces necesitamos la habilidad de verificar condiciones y cambiar el comportamiento de nuestro programa dependiendo de la condición. Lo logramos con una instrucción `if`, que puede tomar una de tres formas." ] }, { @@ -1479,7 +1490,7 @@ "b = 3\n", "\n", "if a > b:\n", - " print('a is bigger than b')" + " print('a es mayor que b')" ] }, { @@ -1495,7 +1506,7 @@ "metadata": {}, "outputs": [], "source": [ - "# We pick a number, but you can change it\n", + "# Definimos un número\n", "x = 1547" ] }, @@ -1506,9 +1517,9 @@ "outputs": [], "source": [ "if x % 17 == 0: \n", - " print('Your number is a multiple of 17.')\n", + " print('Tu numero es multiplo de 17.')\n", "else:\n", - " print('Your number is not a multiple of 17.')" + " print('Tu numero no es multiplo de 17.')" ] }, { @@ -1522,7 +1533,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "* Sugerencia: * Puede descomentar esta siguiente celda y aprender un buen truco para pedirle al usuario que inserte un número. Puede usar esto en lugar de asignar un valor específico a `x` arriba." + "*Sugerencia:* Puedes descomentar la siguiente celda y aprender un buen truco para pedirle al usuario que inserte un número. Puedes usar esto en lugar de asignar un valor específico a `x`." ] }, { @@ -1551,18 +1562,18 @@ "b = 5\n", "\n", "if a > b:\n", - " print('a is bigger than b')\n", + " print('a es mayor a b')\n", "elif a < b:\n", - " print('a is smaller than b')\n", + " print('a es menor a b')\n", "else:\n", - " print('a is equal to b')" + " print('a es igual a b')" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "*Nota:* Podemos tener tantas líneas `elif` como queramos." + "*Nota:* Podemos tener tantos condicionales del tipo `elif` como sea necesario." ] }, { @@ -1593,7 +1604,7 @@ "source": [ "## Referencias\n", "\n", - "1. [Conceptos básicos del notebook: editor modal](http://jupyter-notebook.readthedocs.io/en/latest/examples/Notebook/Notebook%20Basics.html) (En inglés).\n", + "1. [Conceptos básicos del notebook: editor](http://jupyter-notebook.readthedocs.io/en/latest/examples/Notebook/Notebook%20Basics.html) (En inglés).\n", "2. [\"Índices de puntos entre los elementos\"](https://blog.nelhage.com/2015/08/indices-point-between-elements/) publicación de blog de Nelson Elhage (2015, en inglés).\n", "3. _Python para todos: explora datos usando Python 3_ (2016). Charles R. Severance. [PDF disponible](http://do1.dr-chuck.com/pythonlearn/EN_us/pythonlearn.pdf) (en inglés).\n", "4. _Piense en Python: cómo pensar como un científico de la computación_ (2012). Allen Downey. Green Tea Press. [PDF disponible](http://greenteapress.com/thinkpython/thinkpython.pdf) (en inglés)." @@ -1601,7 +1612,7 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 84, "metadata": {}, "outputs": [ { @@ -1761,7 +1772,7 @@ "" ] }, - "execution_count": 1, + "execution_count": 84, "metadata": {}, "output_type": "execute_result" } From bfb13ef2ce07561519a7a39e1e5c2fe372740182 Mon Sep 17 00:00:00 2001 From: Sebastian Flores Date: Wed, 25 Jul 2018 16:56:08 -0400 Subject: [PATCH 17/17] Cleaning notebook cells before PR --- notebooks_es/1_Interactuando_con_Python.ipynb | 3 ++- .../2_Strings_y_listas_en_accion.ipynb | 7 +++--- .../3_Jugando_con_archivo_de_cursos.ipynb | 7 +++--- .../4_Conociendo_arrays_y_graficos.ipynb | 22 +++++-------------- .../5_Regresion_Lineal_con_datos_reales.ipynb | 7 +++--- 5 files changed, 20 insertions(+), 26 deletions(-) diff --git a/notebooks_es/1_Interactuando_con_Python.ipynb b/notebooks_es/1_Interactuando_con_Python.ipynb index 92315ff..0a7509f 100644 --- a/notebooks_es/1_Interactuando_con_Python.ipynb +++ b/notebooks_es/1_Interactuando_con_Python.ipynb @@ -1014,7 +1014,8 @@ } ], "source": [ - "# Execute this cell to load the notebook's style sheet, then ignore it\n", + "# Ejecuta esta celda para cargar el notebook con estilo, \n", + "# pero puedes ignorar su contenido.\n", "from IPython.core.display import HTML\n", "css_file = '../style/custom.css'\n", "HTML(open(css_file, \"r\").read())" diff --git a/notebooks_es/2_Strings_y_listas_en_accion.ipynb b/notebooks_es/2_Strings_y_listas_en_accion.ipynb index ddbbb5b..600701a 100644 --- a/notebooks_es/2_Strings_y_listas_en_accion.ipynb +++ b/notebooks_es/2_Strings_y_listas_en_accion.ipynb @@ -1612,7 +1612,7 @@ }, { "cell_type": "code", - "execution_count": 84, + "execution_count": 1, "metadata": {}, "outputs": [ { @@ -1772,13 +1772,14 @@ "" ] }, - "execution_count": 84, + "execution_count": 1, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "# Execute this cell to load the notebook's style sheet, then ignore it\n", + "# Ejecuta esta celda para cargar el notebook con estilo, \n", + "# pero puedes ignorar su contenido.\n", "from IPython.core.display import HTML\n", "css_file = '../style/custom.css'\n", "HTML(open(css_file, \"r\").read())" diff --git a/notebooks_es/3_Jugando_con_archivo_de_cursos.ipynb b/notebooks_es/3_Jugando_con_archivo_de_cursos.ipynb index b90ada9..3cca43f 100644 --- a/notebooks_es/3_Jugando_con_archivo_de_cursos.ipynb +++ b/notebooks_es/3_Jugando_con_archivo_de_cursos.ipynb @@ -520,7 +520,7 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 34, "metadata": {}, "outputs": [ { @@ -680,13 +680,14 @@ "" ] }, - "execution_count": 1, + "execution_count": 34, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "# Execute this cell to load the notebook's style sheet, then ignore it\n", + "# Ejecuta esta celda para cargar el notebook con estilo, \n", + "# pero puedes ignorar su contenido.\n", "from IPython.core.display import HTML\n", "css_file = '../style/custom.css'\n", "HTML(open(css_file, \"r\").read())" diff --git a/notebooks_es/4_Conociendo_arrays_y_graficos.ipynb b/notebooks_es/4_Conociendo_arrays_y_graficos.ipynb index a51cba7..59b6ae4 100644 --- a/notebooks_es/4_Conociendo_arrays_y_graficos.ipynb +++ b/notebooks_es/4_Conociendo_arrays_y_graficos.ipynb @@ -518,20 +518,9 @@ }, { "cell_type": "code", - "execution_count": 88, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "2" - ] - }, - "execution_count": 88, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "# Tomar el elemento de la primera fila y segunda columna\n", "X[0, 1]" @@ -1003,7 +992,7 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 54, "metadata": {}, "outputs": [ { @@ -1163,13 +1152,14 @@ "" ] }, - "execution_count": 1, + "execution_count": 54, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "# Execute this cell to load the notebook's style sheet, then ignore it\n", + "# Ejecuta esta celda para cargar el notebook con estilo, \n", + "# pero puedes ignorar su contenido.\n", "from IPython.core.display import HTML\n", "css_file = '../style/custom.css'\n", "HTML(open(css_file, \"r\").read())" diff --git a/notebooks_es/5_Regresion_Lineal_con_datos_reales.ipynb b/notebooks_es/5_Regresion_Lineal_con_datos_reales.ipynb index 5e63bb9..5785b73 100644 --- a/notebooks_es/5_Regresion_Lineal_con_datos_reales.ipynb +++ b/notebooks_es/5_Regresion_Lineal_con_datos_reales.ipynb @@ -839,7 +839,7 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 30, "metadata": {}, "outputs": [ { @@ -999,13 +999,14 @@ "" ] }, - "execution_count": 1, + "execution_count": 30, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "# Execute this cell to load the notebook's style sheet, then ignore it\n", + "# Ejecuta esta celda para cargar el notebook con estilo, \n", + "# pero puedes ignorar su contenido.\n", "from IPython.core.display import HTML\n", "css_file = '../style/custom.css'\n", "HTML(open(css_file, \"r\").read())"