├── Módulo 0 - Preparación del entorno de trabajo ├── Modulo0Katas.ipynb └── Módulo 0 - Preparación del entorno de trabajo.md ├── Módulo 1 - Primeros pasos ├── Modulo1 - Primeros pasos.ipynb └── Modulo1Katas.ipynb ├── Módulo 10 - Manejo de errores └── Módulo 10 - Manejo de errores.md ├── Módulo 2 - Crear y administrar proyectos ├── Modulo2Katas.md └── Módulo 2 - Crear y administrar proyectos.md ├── Módulo 3 - Usar lógica booleana ├── Módulo 3 - Usar lógica booleana.md └── Módulo3Katas.ipynb ├── Módulo 4 - Cadenas ├── Módulo 4 - Cadenas.md └── Módulo4Katas.ipynb ├── Módulo 5 - Usar operaciones matemáticas ├── Módulo 5 - Operaciones matemáticas.md └── Módulo5Katas.ipynb ├── Módulo 6 - Introducción a las listas ├── Módulo 6- Introducción a las listas.md └── Módulo6Katas.ipynb ├── Módulo 7 - Estructuras de control ├── Módulo 7 - Estructuras de control.md └── Módulo7Katas.ipynb ├── Módulo 8 - Administrar datos con diccionarios ├── Módulo 8 - Administrar datos con diccionarios.md └── Módulo8Katas.ipynb ├── Módulo 9 - Funciones ├── Módulo 9 - Funciones.md └── Módulo9Katas.ipynb ├── README.md └── images ├── button.png ├── chart.png ├── choose-kernel.png ├── createn.gif ├── jupyter-extension.png ├── nivelesox.png ├── pip.png ├── planet.png ├── pythonv.png ├── restart.png ├── runmark.png └── vscode.jpeg /Módulo 0 - Preparación del entorno de trabajo/Modulo0Katas.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# Ejercicio: crea y ejecuta tu notebook\n", 8 | "\n", 9 | "Primero instalamos la biblioteca:" 10 | ] 11 | }, 12 | { 13 | "cell_type": "code", 14 | "execution_count": null, 15 | "metadata": {}, 16 | "outputs": [], 17 | "source": [ 18 | "pip install ipywidgets" 19 | ] 20 | }, 21 | { 22 | "cell_type": "code", 23 | "execution_count": null, 24 | "metadata": {}, 25 | "outputs": [], 26 | "source": [ 27 | "import ipywidgets as widgets\n", 28 | "\n", 29 | "ignition = widgets.ToggleButton(\n", 30 | " value=False,\n", 31 | " description='Iniciar Launch',\n", 32 | " button_style='success',\n", 33 | " tooltip='Engage your Launch',\n", 34 | " icon='rocket'\n", 35 | ")\n", 36 | "\n", 37 | "output = widgets.Output()\n", 38 | "\n", 39 | "display(ignition, output)\n", 40 | "\n", 41 | "def on_value_change(change):\n", 42 | " with output:\n", 43 | " if change['new'] == True:\n", 44 | " print(\"Nave Iniciada!\")\n", 45 | " else: \n", 46 | " print(\"Nave Detenida\")\n", 47 | "\n", 48 | "ignition.observe(on_value_change, names='value')" 49 | ] 50 | }, 51 | { 52 | "cell_type": "markdown", 53 | "metadata": {}, 54 | "source": [ 55 | "## Ejercicio 2: Usar comandos avanzados" 56 | ] 57 | }, 58 | { 59 | "cell_type": "code", 60 | "execution_count": null, 61 | "metadata": {}, 62 | "outputs": [], 63 | "source": [ 64 | "!pip install matplotlib\n", 65 | "!pip install numpy" 66 | ] 67 | }, 68 | { 69 | "cell_type": "markdown", 70 | "metadata": {}, 71 | "source": [ 72 | "## Niveles de Oxígeno\n", 73 | "Muestra diez minutos de niveles de oxígeno en tu nave." 74 | ] 75 | }, 76 | { 77 | "cell_type": "code", 78 | "execution_count": null, 79 | "metadata": {}, 80 | "outputs": [], 81 | "source": [ 82 | "import numpy as np\n", 83 | "import matplotlib.pyplot as plt\n", 84 | "data = np.random.default_rng(12345)\n", 85 | "oxy_nums = data.integers(low=0, high=10, size=10)\n", 86 | "\n", 87 | "plt.bar(range(len(oxy_nums)), oxy_nums)\n", 88 | "plt.show()" 89 | ] 90 | }, 91 | { 92 | "cell_type": "markdown", 93 | "metadata": {}, 94 | "source": [ 95 | "## Velocidad de la nave\n", 96 | "\n", 97 | "Muestra los segundos necesarios para pasar de 0 a 11200 metros por segundo, dada la aceleración de la nave en metros por segundo." 98 | ] 99 | }, 100 | { 101 | "cell_type": "code", 102 | "execution_count": null, 103 | "metadata": {}, 104 | "outputs": [], 105 | "source": [ 106 | "endVelocity = 11200\n", 107 | "startVelocity = 0\n", 108 | "acceleration = 9.8\n", 109 | "\n", 110 | "time = (endVelocity - startVelocity) / acceleration\n", 111 | "print(\"Tiempo para alcanzar la velocidad deseada = \", time)" 112 | ] 113 | }, 114 | { 115 | "cell_type": "markdown", 116 | "metadata": {}, 117 | "source": [ 118 | "Curso Propedútico de Python para Launch X - Innovacción Virtual.\n", 119 | "\n", 120 | "Material desarrollado con base en los contenidos de MSLearn y la metáfora de LaunchX, traducción e implementación por: Fernanda Ochoa - Learning Producer de LaunchX.\n", 121 | "\n", 122 | "Redes:\n", 123 | "* GitHub: [FernandaOchoa](https://github.com/FernandaOchoa)\n", 124 | "* Twitter: [@imonsh](https://twitter.com/imonsh)\n", 125 | "* Instagram: [fherz8a](https://www.instagram.com/fherz8a/)" 126 | ] 127 | } 128 | ], 129 | "metadata": { 130 | "interpreter": { 131 | "hash": "502cd6c3b6c9e666d195e1caff9d64ea12bf644e547a4c8fae84812082c54b6f" 132 | }, 133 | "kernelspec": { 134 | "display_name": "Python 3.9.5 64-bit", 135 | "language": "python", 136 | "name": "python3" 137 | }, 138 | "language_info": { 139 | "codemirror_mode": { 140 | "name": "ipython", 141 | "version": 3 142 | }, 143 | "file_extension": ".py", 144 | "mimetype": "text/x-python", 145 | "name": "python", 146 | "nbconvert_exporter": "python", 147 | "pygments_lexer": "ipython3", 148 | "version": "3.9.5" 149 | }, 150 | "orig_nbformat": 4 151 | }, 152 | "nbformat": 4, 153 | "nbformat_minor": 2 154 | } 155 | -------------------------------------------------------------------------------- /Módulo 0 - Preparación del entorno de trabajo/Módulo 0 - Preparación del entorno de trabajo.md: -------------------------------------------------------------------------------- 1 | # Introducción 2 | 3 | Aunque los desarrolladores web crean sus sitios web mediante el uso de herramientas como Node.js, ASP.NET o Java, y ejecutan su código localmente mediante el uso de herramientas en editores de código como Visual Studio Code, los desarrolladores de Python tienen algunas otras herramientas a su disposición. 4 | 5 | Una de esas herramientas útiles se llama ``notebook / notebook ``. Un notebook es un entorno interactivo que un desarrollador puede usar para ejecutar bloques de código y agregar áreas de documentación para explicar el código en sí. Aunque los desarrolladores de Python también pueden usar archivos .py para ejecutar programas de Python directamente, pueden usar notebooks para ejecutar y documentar su código, explicando su lógica en el camino. 6 | 7 | ## Escenario: Miembro de la tripulación en la ISS 8 | 9 | Supongamos que eres un miembro de la tripulación en una nave espacial. Su misión es entregar algunos equipos importantes a la Estación Espacial Internacional (ISS). Si no está familiarizado con algunos de los muchos botones de la consola de la nave espacial, ¡Es mejor no aprender por el método de prueba y error, en pleno vuelo! En su lugar, puede consultar el manual de viaje para saber qué botones presionar para realizar varias tareas. Pero, ¿Qué pasa si el manual está incompleto? 10 | 11 | Su trabajo es mejorar el registro de la nave mediante la creación de explicaciones interactivas de los controles de la nave. Al trabajar con un notebook, puede explicar más fácilmente los usos de las distintas partes de la consola. 12 | 13 | ## ¿Qué aprenderás? 14 | 15 | Al final de este módulo, podrás: 16 | 17 | * Crear un notebook de Jupyter localmente. 18 | * Ejecutar un notebook de Jupyter mediante Python en Visual Studio Code. 19 | * Describir algunas de las formas de crear un notebook. 20 | 21 | ## ¿Cuál es el objetivo principal? 22 | 23 | Aprovechar los notebooks como una herramienta para crear una experiencia de aprendizaje más interactiva. 24 | 25 | # Configurando el entorno de trabajo 26 | 27 | Hay muchas maneras de ejecutar notebooks. En varios de los módulos de este OnBoarding ejecutarás notebooks. En este módulo, sin embargo, aprenderás a configurar tu entorno de trabajo para ejecutar notebooks localmente a través de Visual Studio Code. 28 | 29 | Para comenzar a crear tu notebook, debes tener el siguiente software (programas) disponible en su computadora: 30 | 31 | * Python 32 | * Visual Studio Code 33 | * Extensión Jupyter de Visual Studio Code 34 | 35 | ## Instalando Python 36 | 37 | Si no tienes Python instalado en su computadora, debes descargarlo. Dirígete a la siguiente dirección [Python.org](https://www.python.org/downloads/) para instalar la última versión compatible con tu sistema operativo. 38 | 39 | Si ya tiene Python instalado, es posible que deba actualizar la instalación a la versión más reciente. Puedes verificarlo al abrir la terminal: 40 | 41 | * En windows: Presiona la tecla windows, posteriormente escribe 'cmd' y presiona enter. 42 | * En Mac: Finder - Terminal - Enter 43 | Posteriormente escribe el siguiente comando: 44 | 45 | ``python --version`` 46 | 47 | Es importante lo escribas exactamente igual, ya que al tratarse de un comando si no está escrito correctamente podría no saber la computadora a qué te refieres. 48 | 49 | Al ejecutar el comando te mostrará la versión que tienes actualmente instalada, para este entrenamiento, utilizaremos de la versión 3 para arriba. 50 | 51 | ![](../images/pythonv.png) 52 | 53 | ## Instalando Visual Studio Code 54 | 55 | A continuación, instala Visual Studio Code. Para ello dirígete a la siguiente dirección [Visual Studio Code](https://code.visualstudio.com/), selecciona el sistema operativo de tu preferencia. 56 | Si no ves la opción de tu sistema, selecciona la flecha para ver más sistemas disponibles. 57 | 58 | ![](../images/vscode.jpeg) 59 | 60 | Cuando se complete la instalación, configúrala a tu gusto. 61 | 62 | ## Instalando la extensión de Python 63 | 64 | Esta extensión permite ejecutar notebooks de Jupyter desde Visual Studio Code mediante un [Kernel](https://es.wikipedia.org/wiki/N%C3%BAcleo_(inform%C3%A1tica)). Un kernel en Visual Studio Code le ayuda a activar un entorno de Anaconda, por lo que puede ejecutar sus notebooks mediante la instalación de Python. 65 | 66 | En Visual Studio Code, en el panel de extensiones de la izquierda, busque Jupyter de Microsoft. Para instalar esta extensión, seleccione Instalar. 67 | 68 | ![](../images/jupyter-extension.png) 69 | 70 | Ahora que tienes configurados los tres elementos del área de trabajo, puedes empezar a trabajar con los notebooks de Jupyter en Visual Studio Code. 71 | 72 | # Ejercicio 1: Crea y ejecuta tu notebook 73 | 74 | Un notebook es un entorno interactivo en el que se puede escribir código y documentarlo. Los notebooks también pueden mostrar cálculos matemáticos y gráficos. 75 | 76 | Aquí, crearás un archivo .ipynb local y lo ejecutarás en Visual Studio Code. El sufijo ``.ipynb`` se utiliza para referirse a los notebooks de Jupyter, que anteriormente se llamaban: ``.iPython:`` ``notebooksipynb`` 77 | 78 | ## Crear un notebook 79 | 80 | Crea el archivo a través de la paleta de comandos en Visual Studio Code, abriendo la paleta y escribiendo el nombre del notebook: ``ship-manual.ipynb`` 81 | 82 | ![](../images/createn.gif) 83 | 84 | La extensión Jupyter debe mostrar el archivo en blanco, con la opción de agregar código (python) y bloques Markdown (Un lenguaje de etiquetas, similar a html que veremos más adelante). 85 | 86 | ### Crear un elemento de tipo Markdown 87 | 88 | En la parte superior del notebook, verás dos opciones para crear dos tipos diferentes de bloques de contenido en el notebook: **Markdown** y **código ejecutable**. 89 | 90 | La primera tarea es crear un título de documento. En la parte superior de la interfaz del notebook de Visual Studio Code, selecciona el botón más (+) situado junto a Markdown. Aparecerá un cuadro. Agregue el siguiente Markdown al cuadro: 91 | 92 | `` # Manual de la Nave`` 93 | 94 | Selecciona la palomita para ver el resultado. 95 | ![](../images/runmark.png) 96 | 97 | ¡Acabas de nombrar tu notebook! Para ver cómo se representa este archivo Markdown, elige ejecutar todo desde la parte superior del notebook o la flecha pequeña a la izquierda del cuadro Markdown.`

` 98 | 99 | ### Ejecutar el notebook 100 | 101 | Ahora necesitas ejecutar tu notebook. Elige un kernel de la lista desplegable en la parte superior derecha. Es posible que tengas uno o varios núcleos para elegir, así que asegúrese de elegir un kernel de Python 3. 102 | 103 | ![](../images/choose-kernel.png) 104 | 105 | ### Crear código ejecutable 106 | 107 | Ahora puedes agregar algo de código al notebook. Agreguemos una forma de mostrar un widget para iniciar el notebook. 108 | 109 | Primero, debes instalar una biblioteca llamada ``ipywidgets``. Instala la biblioteca agregando un nuevo bloque de código debajo del bloque de título del notebook. Utilizando el administrador de paquetes de Python ``pip``, para instalar la biblioteca. 110 | 111 | ``pip install ipywidgets`` 112 | 113 | ![](../images/pip.png) 114 | 115 | Después de instalarlo, te pedirá que reinicies el kernel. Basta con dar clic en la sección señalada de amarillo para reiniciar el kernel. 116 | 117 | ![](../images/restart.png) 118 | 119 | A continuación, crearemos un botón en el notebook que, cuando se presiona, muestra un mensaje. 120 | 121 | En un nuevo bloque de código, agrega el código siguiente: 122 | 123 | ``` 124 | import ipywidgets as widgets 125 | 126 | ignition = widgets.ToggleButton( 127 | value=False, 128 | description='Iniciar Launch', 129 | button_style='success', 130 | tooltip='Engage your Launch', 131 | icon='rocket' 132 | ) 133 | 134 | output = widgets.Output() 135 | 136 | display(ignition, output) 137 | 138 | def on_value_change(change): 139 | with output: 140 | if change['new'] == True: 141 | print("Nave Iniciada!") 142 | else: 143 | print("Nave Detenida") 144 | 145 | ignition.observe(on_value_change, names='value') 146 | ``` 147 | 148 | ![](../images/button.png) 149 | 150 | ¿Qué está pasando aquí? Utilizamos la biblioteca ``ipywidget`` para crear un botón y éste escucha cuando hacemos un clic provocando que su valor cambie, imprimiendo el mensaje observado. ¡Ahora tu manual está empezando a verse bien, y puedes arrancar la nave aún si se detiene! 151 | 152 | ## Ejercicio 2: Usar comandos avanzados 153 | 154 | Hemos creado un notebook básico con un poco de Markdown y un widget para arrancar la nave. Sin embargo, ¡Hay mucho más que puedes hacer con los notebooks! 155 | 156 | En el manual de su nave, le gustaría crear un gráfico de las estadísticas diarias de su nave. Puedes crear todo tipo de gráficos interesantes en un notebook, que también es útil para científicos de datos e ingenieros de aprendizaje automático (no solo astronautas). 157 | 158 | Crea un gráfico para mostrar los niveles de oxígeno de su nave utilizando ``Matplotlib y Numpy``, unas bibliotecas populares para crear tablas y gráficos en Python. 159 | 160 | Para ello en una celda de código vamos a ejecutar el siguiente comando: 161 | 162 | ``` 163 | !pip install matplotlib 164 | !pip install numpy 165 | ``` 166 | 167 | Enseguida, crea un bloque Markdown para anotar la descripción: 168 | 169 | ![](../images/nivelesox.png) 170 | 171 | ``` 172 | ## Niveles de Oxígeno 173 | 174 | Muestra diez minutos de niveles de oxígeno en tu nave. 175 | ``` 176 | 177 | Creamos un nuevo bloque de código e importamos dos bibliotecas ```numpy``` y ```matplotlib```, para crear un gráfico de barras. 178 | 179 | ``` 180 | import numpy as np 181 | import matplotlib.pyplot as plt 182 | data = np.random.default_rng(12345) 183 | oxy_nums = data.integers(low=0, high=10, size=10) 184 | 185 | plt.bar(range(len(oxy_nums)), oxy_nums) 186 | plt.show() 187 | ``` 188 | Por supuesto, estos datos son una maqueta de datos reales, que se utilizan para crear una matriz de 100 enteros entre 1 y 10. 189 | 190 | El gráfico de barras se ve así: 191 | ![](../images/chart.png) 192 | 193 | ### Realizar cálculos 194 | A continuación, deseas mostrar el tiempo que su barco necesita tomar para llegar a una buena velocidad. Anota y crea una ecuación que te permitirá ingresar la velocidad de inicio de tu nave, la velocidad final deseada y la aceleración en metros por segundo. 195 | 196 | Creamos un bloque markdown para explicar la ecuación: 197 | 198 | ``` 199 | ## Velocidad de la nave 200 | 201 | Muestra los segundos necesarios para pasar de 0 a 11200 metros por segundo, dada la aceleración de la nave en metros por segundo. 202 | ``` 203 | 204 | Agrega un bloque de código para la ecuación: 205 | 206 | ``` 207 | endVelocity = 11200 208 | startVelocity = 0 209 | acceleration = 9.8 210 | 211 | time = (endVelocity - startVelocity) / acceleration 212 | print("Tiempo para alcanzar la velocidad deseada = ", time) 213 | ``` 214 | 215 | Ejecuta el bloque de código para determinar cuánto tiempo tardará en alcanzar la velocidad deseada. 216 | 217 | Ajusta los valores de velocidad de inicio y fin, o la aceleración, para determinar cómo funcionará tu nave espacial. 218 | 219 | ¡Felicidades! Has creado con éxito el manual de una nave que muestra información útil sobre su nave espacial. Debido a que todo está contenido en un notebook de Jupyter, no tendrás ninguna dificultad para realizar un seguimiento de él, ya que está bien anotado y bien mostrado. ¡Incluso incluye un interruptor de encendido! Los notebooks Jupyter son una forma útil de mostrar todo tipo de datos e incluso pequeñas interfaces de usuario. 220 | 221 | 222 | Curso Propedútico de Python para Launch X - Innovacción Virtual. 223 | 224 | Material desarrollado con base en los contenidos de MSLearn y la metáfora de LaunchX, traducción e implementación por: Fernanda Ochoa - Learning Producer de LaunchX. 225 | 226 | Redes: 227 | * GitHub: [FernandaOchoa](https://github.com/FernandaOchoa) 228 | * Twitter: [@imonsh](https://twitter.com/imonsh) 229 | * Instagram: [fherz8a](https://www.instagram.com/fherz8a/) 230 | -------------------------------------------------------------------------------- /Módulo 1 - Primeros pasos/Modulo1 - Primeros pasos.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# Introducción\n", 8 | "\n", 9 | "Una tarea común es desarrollar programas que no solo puedan mostrar información en una pantalla o una consola, sino que también reciban información de los usuarios o incluso de otros programas. En este módulo, construirás tu primer programa en Python para aprender a manejar la entrada y la salida en la consola. También aprenderás conceptos de programación de Python como variables y conversión entre tipos de datos.\n", 10 | "\n", 11 | "### Escenario: Un programador junior creando sus primeras aplicaciones \n", 12 | "\n", 13 | "En este escenario, eres un joven cadete espacial en una nave espacial en algún momento en el futuro. Tu misión es encontrar y explorar nuevos sistemas solares. Estás capacitado como ingenierx y estás buscando desarrollar una serie de programas de servicios públicos para el personal más alto a bordo.\n", 14 | "\n", 15 | "### ¿Qué aprenderás?\n", 16 | "\n", 17 | "* Utilizar funciones para administrar la entrada y la salida a la consola.\n", 18 | "* Crear variables para almacenar datos.\n", 19 | "* Distinguir entre tipos de datos.\n", 20 | "* Utilizar la conversión de tipos para convertir entre tipos de datos.\n", 21 | "\n", 22 | "### ¿Cuál es el objetivo principal?\n", 23 | "Utiliza elementos básicos de programación para crear tus primeros programas Python." 24 | ] 25 | }, 26 | { 27 | "cell_type": "markdown", 28 | "metadata": {}, 29 | "source": [ 30 | "## Trabajar con salidas\n", 31 | "\n", 32 | "Cuando comienzas a aprender cualquier lenguaje de programación, primero pruebas algunas declaraciones de código en un bucle de lectura-evaluación-impresión (REPL). Sin embargo, pronto querrás pasar a un desarrollo serio. Eso significa aprender más sobre el idioma, cómo estructurar un programa y más.\n", 33 | "\n", 34 | "### Un programa Python\n", 35 | "\n", 36 | "Para crear un programa en Python, debes almacenarlo en un archivo. El archivo debe tener la extensión .py.\n", 37 | "\n", 38 | "La idea de un programa es hacer algo, llevar a cabo una tarea. Para que el programa haga algo, debe agregar instrucciones de código que realicen instrucciones. Una instrucción podría imprimir algún texto o calcular algo, por ejemplo. Un programa de ejemplo puede tener un aspecto similar al siguiente:\n", 39 | "\n", 40 | "```\n", 41 | " # program.py\n", 42 | " sum = 1 + 2\n", 43 | " print(sum)\n", 44 | "```\n", 45 | "\n", 46 | "### Ejecutar un programa\n", 47 | "Supongamos que has creado un programa que consta de instrucciones. Para ejecutarlo hay que invocar el programa ejecutable de Python, seguido del nombre del programa. Aquí hay un ejemplo de tal invocación:\n", 48 | "\n", 49 | "```\n", 50 | " python3 program.py\n", 51 | "```\n", 52 | "La ejecución de un programa de este tipo mostraría el siguiente resultado en la consola:\n", 53 | "\n", 54 | "```\n", 55 | " 3\n", 56 | "```\n", 57 | "### La función print()\n", 58 | "\n", 59 | "Una de las primeras cosas que es probable que hagas es imprimir en una consola. Una consola es una aplicación de línea de comandos que te permite interactuar con el sistema operativo. En la consola, puedes ejecutar comandos y programas. También puedes ingresar información y mostrar información como texto en la pantalla.\n", 60 | "\n", 61 | "Para escribir información en la consola, puedes utilizar la función e implementarla como función principal. Debido a que es una función central, tendrás acceso a ella si Python está instalado. Para usarla dale un argumento: ``` print()print() ```\n", 62 | "\n", 63 | "```\n", 64 | " print('Hola desde la consola')\n", 65 | "```" 66 | ] 67 | }, 68 | { 69 | "cell_type": "code", 70 | "execution_count": null, 71 | "metadata": {}, 72 | "outputs": [], 73 | "source": [ 74 | "# Impresión en pantalla print('Hola desde la consola')\n" 75 | ] 76 | }, 77 | { 78 | "cell_type": "markdown", 79 | "metadata": {}, 80 | "source": [ 81 | "Observa cómo el comando anterior invoca mediante paréntesis. Así es como invocas una función. Si usaras corchetes () en lugar de paréntesis, no funcionaría:print[] \n", 82 | "\n", 83 | "### Variables\n", 84 | "\n", 85 | "Para avanzar en la programación, debes comprender que estás operando con datos. Como tu programa está trabajando en datos, es posible que deba recordar un cierto valor a lo largo de la ejecución del programa. Para eso, se utilizan variables.\n", 86 | "\n", 87 | "En el ejemplo siguiente se realiza un cálculo y se almacena en variables:\n", 88 | "\n", 89 | "```\n", 90 | " sum = 1 + 2 # 3\n", 91 | " product = sum * 2\n", 92 | " print(product)\n", 93 | "```" 94 | ] 95 | }, 96 | { 97 | "cell_type": "code", 98 | "execution_count": null, 99 | "metadata": {}, 100 | "outputs": [], 101 | "source": [ 102 | "# Tu turno, prueba el fragmento de código anterior\n" 103 | ] 104 | }, 105 | { 106 | "cell_type": "markdown", 107 | "metadata": {}, 108 | "source": [ 109 | "### Tipos de datos\n", 110 | "Una variable asume un tipo de datos. En el programa anterior, obtiene el tipo . Pero hay muchos más tipos de datos. Aquí hay algunos que es probable que encuentre: ```sum``` ```int```\n", 111 | "\n", 112 | "Tipo | Descripción |Ejemplo \n", 113 | "-------- | -------- | -------- \n", 114 | "Tipo numérico | Número, con o sin decimales | ```int, float, complex, no = 3```\n", 115 | "Tipo de texto | Cadena de caracteres | ```str = \"a literal string\" ```\n", 116 | "Tipo booleano | Booleano | ```continue = True```\n", 117 | "\n", 118 | "Hay tipos más complejos, pero comencemos con estos.\n", 119 | "\n", 120 | "Aquí hay un fragmento de código que muestra algunos de los tipos anteriores:\n", 121 | "\n", 122 | "```\n", 123 | "planetas_en_el_sistema_solar = 8 # int, plutón era considerado un planeta pero ya es muy pequeño\n", 124 | "distancia_a_alfa_centauri = 4.367 # float, años luz\n", 125 | "puede_despegar = True\n", 126 | "transbordador_que_aterrizo_en_la_luna = \"Apollo 11\" #string \n", 127 | "```\n", 128 | "\n", 129 | "¿Cómo sabes qué tipo tiene algo? Si ve los datos asignados a la variable como se muestra en el código siguiente, puede detectarlos:\n", 130 | "\n", 131 | "```\n", 132 | "distancia_a_alfa_centauri = 4.367 # Parece un decimal flotante\n", 133 | "```\n", 134 | "\n", 135 | "La otra forma es usar la función:type()\n", 136 | "\n", 137 | "```\n", 138 | "type(distancia_a_alfa_centauri)\n", 139 | "```" 140 | ] 141 | }, 142 | { 143 | "cell_type": "code", 144 | "execution_count": 1, 145 | "metadata": {}, 146 | "outputs": [ 147 | { 148 | "data": { 149 | "text/plain": [ 150 | "float" 151 | ] 152 | }, 153 | "execution_count": 1, 154 | "metadata": {}, 155 | "output_type": "execute_result" 156 | } 157 | ], 158 | "source": [ 159 | "# Declaramos la variable\n", 160 | "distancia_a_alfa_centauri = 4.367\n", 161 | "\n", 162 | "# Descubrimos su tipo de dato\n", 163 | "type(distancia_a_alfa_centauri)" 164 | ] 165 | }, 166 | { 167 | "cell_type": "markdown", 168 | "metadata": {}, 169 | "source": [ 170 | "### Operadores\n", 171 | "\n", 172 | "Los operadores le permiten realizar cálculos sobre variables y sus valores. La idea general es que tienes un lado izquierdo y un lado derecho y un operador en el medio:\n", 173 | "\n", 174 | "```\n", 175 | " \n", 176 | "```\n", 177 | "\n", 178 | "Así es como se vería un ejemplo real del código de marcador de posición anterior:\n", 179 | "\n", 180 | "```\n", 181 | " left_side = 10\n", 182 | " right_side = 5\n", 183 | " left_side / right_side # 2\n", 184 | "```\n", 185 | "\n", 186 | "En este ejemplo se utiliza una barra diagonal (/) para dividir el valor por el valor. ```left_side``` ```right_side```\n", 187 | "\n", 188 | "Hay muchos más operadores. \n", 189 | "\n", 190 | "Python utiliza dos tipos de operadores: aritmética y asignación.\n", 191 | "\n", 192 | "### Operadores aritméticos\n", 193 | "\n", 194 | "Con los operadores aritméticos, se realizan cálculos como suma, resta, división y multiplicación. Aquí hay un subconjunto de operadores aritméticos que puede usar:\n", 195 | "\n", 196 | "| Tipo | Descripción | Ejemplo \n", 197 | "-------- | -------- | --------\n", 198 | "| + | Operador de adición que suma dos valores juntos | ``` 1 + 1 ```.\n", 199 | "| - | Operador de resta que quita el valor del lado derecho del lado izquierdo | ``` 1 - 2 ```.\n", 200 | "| / | Operador de división que divide el lado izquierdo tantas veces como especifique el lado derecho | ``` 10 / 2 ```.\n", 201 | "| * | Operador de multiplicación | ``` 2 * 2 ```.\n", 202 | "\n", 203 | "### Operadores de asignación\n", 204 | "\n", 205 | "Los operadores de asignación se utilizan para asignar valores a una variable a lo largo del ciclo de vida de la variable. Estos son algunos operadores de asignación que es probable que encuentres a medida que aprendes a crear programas:\n", 206 | "\n", 207 | "Operador | Ejemplo\n", 208 | "-------- | --------\n", 209 | "= | ```x = 2```
x ahora contiene 2.\n", 210 | "+= | ```x += 2```
x incrementado en 2. Si antes contenía 2, ahora tiene un valor de 4.\n", 211 | "-= | ```x -= 2```
x decrementado por 2. Si antes contenía 2, ahora tiene un valor de 0.\n", 212 | "/= | ```x /= 2```
x dividido por 2. Si antes contenía 2, ahora tiene un valor de 1.\n", 213 | "*= | ```x *= 2```
x multiplicado por 2. Si antes contenía 2, ahora tiene un valor de 4.\n", 214 | "\n", 215 | "### Fechas\n", 216 | "Cuando estás creando programas, es probable que interactúes con las fechas. Una fecha en un programa generalmente significa tanto la fecha del calendario como la hora.\n", 217 | "\n", 218 | "Una fecha se puede utilizar en varias aplicaciones, como estos ejemplos:\n", 219 | "\n", 220 | "* **Archivo de copia de seguridad.** Usar una fecha como parte del nombre de un archivo de copia de seguridad es una buena manera de indicar cuándo se realizó una copia de seguridad y cuándo debe realizarse nuevamente. \n", 221 | "* **Condición.** Es posible que desee llevar una lógica específica cuando hay una fecha determinada. \n", 222 | "* **Métrica.** Las fechas se utilizan para comprobar el rendimiento del código para, por ejemplo, medir el tiempo que se tarda en ejecutar una función. \n", 223 | "\n", 224 | "Para trabajar con una fecha, debe importar el módulo: ```date```\n", 225 | "\n", 226 | "```\n", 227 | "from datetime import date\n", 228 | "```\n", 229 | "\n", 230 | "A continuación, puede invocar las funciones con las que desea trabajar. Para obtener la fecha de hoy, puede llamar a la función: ```today()```\n", 231 | "\n", 232 | "```\n", 233 | "date.today()\n", 234 | "```\n", 235 | "\n", 236 | "Para mostrar la fecha en la consola, puede usar la función. La función toma muchos tipos de datos como entrada. Así es como puedes mostrar la fecha de hoy: ```print()```\n", 237 | "\n", 238 | "```\n", 239 | "print(date.today())\n", 240 | "```" 241 | ] 242 | }, 243 | { 244 | "cell_type": "code", 245 | "execution_count": 1, 246 | "metadata": {}, 247 | "outputs": [ 248 | { 249 | "name": "stdout", 250 | "output_type": "stream", 251 | "text": [ 252 | "2022-01-31\n" 253 | ] 254 | } 255 | ], 256 | "source": [ 257 | "# Importamos la biblioteca \n", 258 | "from datetime import date\n", 259 | "\n", 260 | "# Obtenemos la fecha de hoy\n", 261 | "date.today()\n", 262 | "\n", 263 | "# Mostramos la fecha en la consola\n", 264 | "print(date.today())" 265 | ] 266 | }, 267 | { 268 | "cell_type": "markdown", 269 | "metadata": {}, 270 | "source": [ 271 | "### Conversión de tipos de datos\n", 272 | "\n", 273 | "Quieres usar una fecha con un mensaje. Ese algo suele ser un problema. Si, por ejemplo, desea mostrar la fecha de hoy en la consola, es posible que tenga un problema:\n", 274 | "\n", 275 | "```\n", 276 | "print(\"Today's date is: \" + date.today())\n", 277 | "```\n", 278 | "\n", 279 | "Lo que obtienes es un error:\n", 280 | "\n", 281 | "```\n", 282 | "---------------------------------------------------------------------------\n", 283 | "TypeError Traceback (most recent call last)\n", 284 | " in \n", 285 | "----> 1 print(\"Today's date is: \" + date.today())\n", 286 | "\n", 287 | "TypeError: can only concatenate str (not \"datetime.date\") to str\n", 288 | "```\n", 289 | "La última fila del mensaje le indica cuál es el problema. Está intentando usar el operador ``` + ``` y combinar dos tipos de datos diferentes, una cadena y una fecha.\n", 290 | "\n", 291 | "Para que este código funcione, debe convertir la fecha en una cadena. Para lograr tal conversión mediante el uso de la función de utilidad: ```str()```\n", 292 | "\n", 293 | "```\n", 294 | "print(\"Today's date is: \" + str(date.today()))\n", 295 | "```" 296 | ] 297 | }, 298 | { 299 | "cell_type": "code", 300 | "execution_count": null, 301 | "metadata": {}, 302 | "outputs": [], 303 | "source": [ 304 | "# Tu turno ejecuta el siguiente comando: print(\"Today's date is: \" + str(date.today()))" 305 | ] 306 | }, 307 | { 308 | "cell_type": "markdown", 309 | "metadata": {}, 310 | "source": [ 311 | "## Recopilar información\n", 312 | "\n", 313 | "Hasta ahora, has aprendido varias construcciones del lenguaje de programación Python. También has escrito un par de programas. Sin embargo, los programas operan con datos, y esos datos provienen de alguna parte. En esta unidad, analizará más de cerca cómo puede recopilar la entrada tanto de la línea de comandos como de la entrada del usuario.\n", 314 | "\n", 315 | "### Entrada del usuario\n", 316 | "Puede codificarlo para que el programa le diga al usuario que ingrese información. Guarde los datos introducidos en el programa y, a continuación, actúe en consecuencia.\n", 317 | "\n", 318 | "Para capturar información del usuario, utilice la función. Aquí hay un ejemplo: ```input()```\n", 319 | "\n", 320 | "```\n", 321 | "print(\"Bienvenido al programa de bienvenida\")\n", 322 | "name = input(\"Introduzca su nombre \")\n", 323 | "print(\"Saludos: \" + name)\n", 324 | "```" 325 | ] 326 | }, 327 | { 328 | "cell_type": "code", 329 | "execution_count": null, 330 | "metadata": {}, 331 | "outputs": [], 332 | "source": [ 333 | "# Escribe tu código aquí" 334 | ] 335 | }, 336 | { 337 | "cell_type": "markdown", 338 | "metadata": {}, 339 | "source": [ 340 | "La ejecución del programa mediante el uso da el siguiente resultado ```python input.py (Si lo haces por consola)```:\n", 341 | "\n", 342 | "```\n", 343 | "Bienvenido al programa de bienvenida\n", 344 | "Enter your name Fernanda\n", 345 | "Saludos: Fernanda\n", 346 | "```\n", 347 | "\n", 348 | "#### Trabajar con números\n", 349 | "\n", 350 | "La función almacena un resultado como una cadena. Por lo tanto, es posible que el siguiente código no haga lo que desea que haga: ```input()```\n", 351 | "\n", 352 | "```\n", 353 | "print(\"Calculadora\")\n", 354 | "first_number = input(\"Primer número: \")\n", 355 | "second_number = input(\"Segundo número: \")\n", 356 | "print(first_number + second_number)\n", 357 | "```" 358 | ] 359 | }, 360 | { 361 | "cell_type": "code", 362 | "execution_count": null, 363 | "metadata": {}, 364 | "outputs": [], 365 | "source": [ 366 | "# Escribe tu código aquí" 367 | ] 368 | }, 369 | { 370 | "cell_type": "markdown", 371 | "metadata": {}, 372 | "source": [ 373 | "La ejecución de este programa mediante el uso da el siguiente resultado: ```python calc.py (Si lo haces por consola)```\n", 374 | "\n", 375 | "```\n", 376 | "Calculadora\n", 377 | "Primer número: 3\n", 378 | "Segundo número: 4\n", 379 | "34\n", 380 | "```\n", 381 | "\n", 382 | "Probablemente quieres que este programa te responda con 7 en lugar de 34. Entonces, ¿qué salió mal?\n", 383 | "\n", 384 | "La explicación es que el programa toma ambos números como si fuesen 'cadenas de texto'. Para que el cálculo funcione correctamente, debe cambiar esas cadenas a números mediante la función ```int()```. Modificando la última línea del programa a utilizar, puede resolver el problema:\n", 385 | "\n", 386 | "``` print(int(first_number) + int(second_number)) ```" 387 | ] 388 | }, 389 | { 390 | "cell_type": "code", 391 | "execution_count": null, 392 | "metadata": {}, 393 | "outputs": [], 394 | "source": [ 395 | "# Escribe tu código aquí" 396 | ] 397 | }, 398 | { 399 | "cell_type": "markdown", 400 | "metadata": {}, 401 | "source": [ 402 | "La repetición del programa ahora se produce 7 como respuesta." 403 | ] 404 | }, 405 | { 406 | "cell_type": "markdown", 407 | "metadata": {}, 408 | "source": [ 409 | "Curso Propedútico de Python para Launch X - Innovacción Virtual.\n", 410 | "\n", 411 | "Material desarrollado con base en los contenidos de MSLearn y la metáfora de LaunchX, traducción e implementación por: Fernanda Ochoa - Learning Producer de LaunchX.\n", 412 | "\n", 413 | "Redes:\n", 414 | "* GitHub: [FernandaOchoa](https://github.com/FernandaOchoa)\n", 415 | "* Twitter: [@imonsh](https://twitter.com/imonsh)\n", 416 | "* Instagram: [fherz8a](https://www.instagram.com/fherz8a/)" 417 | ] 418 | } 419 | ], 420 | "metadata": { 421 | "interpreter": { 422 | "hash": "502cd6c3b6c9e666d195e1caff9d64ea12bf644e547a4c8fae84812082c54b6f" 423 | }, 424 | "kernelspec": { 425 | "display_name": "Python 3.9.5 64-bit", 426 | "language": "python", 427 | "name": "python3" 428 | }, 429 | "language_info": { 430 | "codemirror_mode": { 431 | "name": "ipython", 432 | "version": 3 433 | }, 434 | "file_extension": ".py", 435 | "mimetype": "text/x-python", 436 | "name": "python", 437 | "nbconvert_exporter": "python", 438 | "pygments_lexer": "ipython3", 439 | "version": "3.9.5" 440 | }, 441 | "orig_nbformat": 4 442 | }, 443 | "nbformat": 4, 444 | "nbformat_minor": 2 445 | } 446 | -------------------------------------------------------------------------------- /Módulo 1 - Primeros pasos/Modulo1Katas.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "Oficial superior> \"¿Cadete?\"\n", 8 | "\n", 9 | "Usted > \"¿Sí, señora?\"\n", 10 | "\n", 11 | "Oficial superior> \"¿Puedes construir un programa que me muestre la fecha? La computadora del barco no venía con mucho en términos de programas de utilidad, por lo que necesitamos crear los que necesitamos. ¿Puedo confiar en ti con esto?\"\n", 12 | "\n", 13 | "Usted > \"Considéralo hecho\".\n", 14 | "\n", 15 | "Oficial superior> \"Excelente\".\n", 16 | "\n", 17 | "## Tu primer programa\n", 18 | "\n", 19 | "Para crear este programa, deberás utilizar los conceptos que aprendiste en el último módulo. Usarás Jupyter Notebook en este ejercicio, que es una combinación de texto y código con la que puede interactuar. Finaliza el código siguiente para que el resultado muestre la fecha de hoy." 20 | ] 21 | }, 22 | { 23 | "cell_type": "code", 24 | "execution_count": null, 25 | "metadata": {}, 26 | "outputs": [], 27 | "source": [ 28 | "from datetime import date\n", 29 | "\n", 30 | "print(\"Today's date is: \")" 31 | ] 32 | }, 33 | { 34 | "cell_type": "markdown", 35 | "metadata": {}, 36 | "source": [ 37 | "> **TIP**\n", 38 | "> Dedique unos minutos a tratar de encontrar una solución. Luego desplácese hacia abajo hasta la parte inferior para ver si ha logrado compilar el programa de acuerdo con las especificaciones.\n", 39 | "\n", 40 | "## Construir un convertidor de unidades\n", 41 | "\n", 42 | "El oficial superior> \"Necesito una cosa más: un programa de conversión entre parsecs y años luz. Tener un programa de este tipo podría ser realmente útil en el puente para trazar nuestro curso\".\n", 43 | "\n", 44 | "Tú> \"¡Lo haré!\"\n" 45 | ] 46 | }, 47 | { 48 | "cell_type": "code", 49 | "execution_count": null, 50 | "metadata": {}, 51 | "outputs": [], 52 | "source": [ 53 | "parsec = 11\n", 54 | "\n", 55 | "lightyears = 0\n", 56 | "\n", 57 | "print(str(parsec) + \" parsec, is \" + str(lightyears) + \" lightyears\")" 58 | ] 59 | }, 60 | { 61 | "cell_type": "markdown", 62 | "metadata": {}, 63 | "source": [ 64 | "> [!TIP]\n", 65 | "> 1 parsec es 3.26156 años luz. Utiliza el operador de multiplicación." 66 | ] 67 | }, 68 | { 69 | "cell_type": "markdown", 70 | "metadata": {}, 71 | "source": [ 72 | "## Soluciones\n", 73 | "\n", 74 | "Aquí está la solución para el primer programa:" 75 | ] 76 | }, 77 | { 78 | "cell_type": "code", 79 | "execution_count": null, 80 | "metadata": {}, 81 | "outputs": [], 82 | "source": [ 83 | "from datetime import date\n", 84 | "\n", 85 | "print(\"Today's date is: \" + str(date.today()))" 86 | ] 87 | }, 88 | { 89 | "cell_type": "code", 90 | "execution_count": null, 91 | "metadata": {}, 92 | "outputs": [], 93 | "source": [ 94 | "parsec = 11\n", 95 | "lightyears = 3.26156 * parsec\n", 96 | "\n", 97 | "print(str(parsec) + \" parsec, is \" + str(lightyears) + \" lightyears\")" 98 | ] 99 | }, 100 | { 101 | "cell_type": "markdown", 102 | "metadata": {}, 103 | "source": [ 104 | "Curso Propedútico de Python para Launch X - Innovacción Virtual.\n", 105 | "\n", 106 | "Material desarrollado con base en los contenidos de MSLearn y la metáfora de LaunchX, traducción e implementación por: Fernanda Ochoa - Learning Producer de LaunchX.\n", 107 | "\n", 108 | "Redes:\n", 109 | "* GitHub: [FernandaOchoa](https://github.com/FernandaOchoa)\n", 110 | "* Twitter: [@imonsh](https://twitter.com/imonsh)\n", 111 | "* Instagram: [fherz8a](https://www.instagram.com/fherz8a/)" 112 | ] 113 | } 114 | ], 115 | "metadata": { 116 | "kernel_info": { 117 | "name": "conda-env-py37_default-py" 118 | }, 119 | "kernelspec": { 120 | "display_name": "py37_default", 121 | "language": "python", 122 | "name": "conda-env-py37_default-py" 123 | }, 124 | "language_info": { 125 | "codemirror_mode": { 126 | "name": "ipython", 127 | "version": 3 128 | }, 129 | "file_extension": ".py", 130 | "mimetype": "text/x-python", 131 | "name": "python", 132 | "nbconvert_exporter": "python", 133 | "pygments_lexer": "ipython3", 134 | "version": "3.7.9" 135 | }, 136 | "nteract": { 137 | "version": "nteract-front-end@1.0.0" 138 | }, 139 | "orig_nbformat": 4 140 | }, 141 | "nbformat": 4, 142 | "nbformat_minor": 2 143 | } 144 | -------------------------------------------------------------------------------- /Módulo 2 - Crear y administrar proyectos/Modulo2Katas.md: -------------------------------------------------------------------------------- 1 | # Ejercicio - Crear un paquete 2 | 3 | En este ejercicio, aprenderás a utilizar entornos virtuales como una forma para no afectar a los paquetes instalados globalmente u otros programas que se ejecutan en tu máquina. 4 | 5 | *Para este ejercicio es necesario que lo ejecutes desde la terminal, línea de comandos, cmd, consola, cli, etc. de tu computadora, sé que es desafíante, pero no te preocupes ¡¡Sé que puedes lograrlo!!* 6 | 7 | ## Crear un entorno virtual 8 | 9 | Crea un entorno virtual mediante ``venv`` 10 | 11 | * Ejecutar en su terminal: ``python3 -m venv env`` o bien ``python -m venv env`` 12 | 13 | ``` 14 | python3 -m venv env 15 | ``` 16 | `` 17 | python -m venv env 18 | `` 19 | Ahora tienes un directorio (folder) ``env`` creado en tu terminal. 20 | 21 | * Ejecuta el comando para activar el entorno virtual: ``source env/bin/activate`` 22 | 23 | ``` 24 | source env/bin/activate 25 | # Windows 26 | env\bin\activate 27 | 28 | o bien: 29 | env\Scripts\activate 30 | 31 | # Linux, WSL or macOS 32 | source env/bin/activate 33 | ``` 34 | 35 | Ahora ves en tu terminal ``(env)``. Eso significa que has activado tu entorno virtual y se ha aislado del resto de tu máquina. 36 | 37 | ![image](https://user-images.githubusercontent.com/9124597/153076991-25e857c5-a910-4d54-80b9-47fce1b62147.png) 38 | 39 | ## Instalar una biblioteca 40 | 41 | Ahora que estás dentro de tu entorno virtual, puedes instalar una biblioteca y saber que la biblioteca solo existirá en el entorno virtual. 42 | 43 | * Ejecuta el comando ``pip freeze`` para ver las bibliotecas instaladas en tu entorno: 44 | 45 | ``` 46 | pip freeze 47 | ``` 48 | 49 | No deberías obtener respuesta. A continuación, veamos cómo cambia la salida de ``pip freeze`` cuando se agrega una biblioteca (un paquete). 50 | 51 | * Ejecuta el comando ``pip install`` para instalar una biblioteca: 52 | ``` 53 | pip install python-dateutil 54 | ``` 55 | * Un gran mensaje de salida de texto dice que está instalando tu biblioteca, y debe terminar con la siguiente oración: 56 | 57 | ``` 58 | Successfully installed python-dateutil-2.8.2 six-1.16.0 59 | ``` 60 | * Vuelve a ejecutar ```pip freeze``` para ver cómo ha cambiado tu lista de bibliotecas: 61 | ``` 62 | pip freeze 63 | ``` 64 | * Ahora deberías ver la siguiente lista: 65 | ``` 66 | python-dateutil==2.8.2 67 | six==1.16.0 68 | ``` 69 | 70 | ### Desactivar un entorno virtual 71 | 72 | Hasta ahora, has creado un entorno virtual y le has agregado un paquete. Sin embargo, es posible que estés trabajando en varios proyectos de Python y necesites cambiar entre ellos. Para hacer eso, debes salir (desactivar) tu entorno virtual. 73 | 74 | Ejecuta el comando ``deactivate``: 75 | ``` 76 | deactivate 77 | ``` 78 | 79 | Observa cómo cambia el mensaje de tu terminal ``(env)`` a cómo se veía antes. 80 | 81 | ¡Felicidades! Has logrado crear y usar correctamente un entorno virtual. 82 | 83 | 84 | Curso Propedútico de Python para Launch X - Innovacción Virtual. 85 | 86 | Material desarrollado con base en los contenidos de MSLearn y la metáfora de LaunchX, traducción e implementación por: Fernanda Ochoa - Learning Producer de LaunchX. 87 | 88 | Redes: 89 | * GitHub: [FernandaOchoa](https://github.com/FernandaOchoa) 90 | * Twitter: [@imonsh](https://twitter.com/imonsh) 91 | * Instagram: [fherz8a](https://www.instagram.com/fherz8a/) 92 | -------------------------------------------------------------------------------- /Módulo 2 - Crear y administrar proyectos/Módulo 2 - Crear y administrar proyectos.md: -------------------------------------------------------------------------------- 1 | # Introducción 2 | 3 | En este punto, has creado pequeños programas que utilizan las bibliotecas que vienen con la instalación de Python. Funcionan bien. Pero a medida que construyes programas más avanzados, debes hacerte una pregunta: ¿Cuánto de esta nueva funcionalidad escribo y cuánto ya está escrito que puedo usar en mis propios programas? 4 | 5 | Como desarrollador, es probable que crees muchos programas en una sola máquina. Esos programas también se pueden usar en otras máquinas. Sin embargo, algunas de estas máquinas pueden tener versiones de Python instaladas que no son lo que espera. O bien, pueden tener bibliotecas instaladas que son de versión inferior o superior a las que necesita su programa. 6 | 7 | Entonces, ¿Qué hacer? Debes encontrar una manera de que tu programa funcione de forma aislada, para que no moleste lo que está instalado en la máquina de destino. También debes asegurarte de que una máquina no deshabilite tu programa porque tiene instalada la versión incorrecta de Python o la versión de la biblioteca. 8 | 9 | ## Escenario: Construyamos un programa 10 | 11 | A medida que tus habilidades crecen y comienzas a construir programas más avanzados, siempre deseas comenzar con un buen enfoque. Deseas pensar en el programa que compila como un proyecto, con el código distribuido en muchos archivos. Si es posible, también deseas utilizar bibliotecas que otros han escrito, para acelerar el tiempo de desarrollo. 12 | 13 | ## ¿Qué aprenderás? 14 | Al final de este módulo, podrás: 15 | 16 | * Crear un proyecto de Python. 17 | * Desarrollar y ejecutar tu código de forma aislada en una máquina. 18 | * Usar bibliotecas que otra persona haya escrito. 19 | * Restaurar un proyecto a partir de una lista de dependencias. 20 | 21 | ## ¿Cuál es el objetivo principal? 22 | Utilizar bibliotecas y planificar tu proyecto para crear programas Python que sean más avanzados. 23 | 24 | ### Trabajar con paquetes 25 | 26 | La mayoría de los programas que escribas se basarán en código escrito por otros. Este código a menudo viene en forma de paquetes, que son módulos externos o bibliotecas que se incluyen en el proyecto. Al igual que con cualquier proyecto que requiera un conjunto de recursos, es importante considerar cómo te asegurarás de que los recursos adecuados estén disponibles para tu programa. 27 | 28 | Un buen comienzo es aprender a administrar tu programa. Una forma de hacerlo es pensar en el programa como un proyecto. Python aborda esto mediante el uso de algo llamado entornos virtuales. 29 | 30 | ### ¿Qué es un entorno virtual? 31 | 32 | Tienes una máquina de desarrollo. En esa máquina, es posible que tengas una versión de Python instalada o una versión de una biblioteca que quieras usar. ¿Qué sucede cuando mueves tu programa a una máquina que tiene una versión diferente de Python instalada o diferentes versiones de las bibliotecas de las que depende? 33 | 34 | Una cosa que no deseas hacer es asumir que tu programa funcionará y que puede instalar la última versión de las bibliotecas de las que depende. Si haces eso, podrías terminar destruyendo la capacidad de los otros programas para funcionar en la máquina de destino. La solución es encontrar una manera de que tu aplicación funcione de forma aislada. 35 | 36 | La solución de Python para estos problemas es un entorno virtual. Un entorno virtual es una copia autónoma de todo lo necesario para ejecutar el programa. Esto incluye el intérprete de Python y cualquier biblioteca que su programa necesite. Mediante el uso de un entorno virtual, puedes asegurarte de que tu programa tendrá acceso a las versiones y recursos correctos para ejecutarse correctamente. 37 | 38 | El flujo de trabajo básico se ve así: 39 | 40 | * Crear un entorno virtual que no afecte al resto de la máquina. 41 | * Ingresar al entorno virtual, donde especifique la versión de Python y las bibliotecas que necesita. 42 | * Desarrolla tu programa. 43 | 44 | ### Crear un entorno virtual 45 | 46 | Para crear un entorno virtual, llama al módulo. El módulo espera un nombre como argumento venv. 47 | 48 | Sigue estos pasos: 49 | 50 | Desde tu terminal ve al directorio donde deseas guardar tu proyecto. (Documentos/TuFolderPreferido) 51 | Ejemplo en windows: ``cd Documents/TuFolderPreferido`` 52 | 53 | Utiliza el siguiente comando para llamar al módulo ``venv``. El comando difiere ligeramente dependiendo de tu sistema operativo. 54 | 55 | En consola: 56 | ``python3 -m venv env `` 57 | 58 | Donde: 59 | * python3: La versión de python a utilizar. 60 | * venv: Llamada al módulo ``venv`` conocido como virtual environment. 61 | * env: Nombre de nuestro entorno virtual. 62 | 63 | En este punto, se crean algunos directorios: 64 | ``` 65 | /env 66 | /bin 67 | /include 68 | lib 69 | ``` 70 | Tu entorno necesita el directorio ``venv`` para realizar un seguimiento de detalles como qué versión de Python y qué bibliotecas está utilizando. No coloque los archivos de programa en el directorio ``venv``. Te sugerimos que coloques tus archivos en el directorio ``src``o algo similar. La estructura del proyecto podría verse así: 71 | ``` 72 | /env 73 | /src 74 | program.py 75 | ``` 76 | 77 | ### Activar el entorno virtual 78 | 79 | En este punto, tienes un entorno virtual, pero no has comenzado a usarlo. Para usarlo, debes activarlo llamando ``activate`` a un script en tu directorio ``env``. 80 | 81 | Así es como puede verse la activación en distintos sistemas operativos. 82 | 83 | ``` 84 | # Bash | Consola 85 | # Windows 86 | env\bin\activate 87 | 88 | # Linux, WSL o macOS 89 | source env/bin/activate 90 | ``` 91 | Llamar al comando ``activate`` cambia el mensaje de salida de la consola. Ahora está precedido con ``(env)`` y se parece a este ejemplo: 92 | 93 | ``` 94 | # Bash | Consola 95 | (env) -> path/to/project 96 | ``` 97 | 98 | Ahora, ya estás dentro de tu entorno virtual. Cualquier cosa que hagas sucede de forma aislada. 99 | 100 | ### ¿Qué es un paquete? 101 | Una de las principales ventajas de utilizar bibliotecas externas es acelerar el tiempo de desarrollo de tu programa. Puedes obtener una biblioteca de este tipo en Internet. Pero al buscar e instalar estas bibliotecas a través de un entorno virtual, te aseguras de instalar estas bibliotecas solo para el entorno virtual y no globalmente para toda la máquina. 102 | 103 | ### Instalar un paquete 104 | Instalar un paquete mediante ``pip``. El comando ``pip`` utiliza el Python Package Index, o PyPi para abreviar, para saber dónde obtener los paquetes. Puedes visitar el sitio web de [PyPi](https://pypi.org/) para conocer qué paquetes están disponibles. 105 | 106 | Para instalar un paquete, ejecute , como en este ejemplo: pip install 107 | 108 | *Dato curioso: Si estás desde un notebook se ejecuta así: ``!pip install python-dateutil ``* Con signo de admiración al inicio. Sin embargo, no estamos trabajando con notebooks ahorita, estamos ejecutando todo por terminal (consola, bash, cli, cmd, como sea que le digas). 109 | 110 | ``` 111 | # Bash | Consola 112 | pip install python-dateutil 113 | ``` 114 | 115 | Si ejecutas el comando anterior, descargará e instalará ``dateutil``, un paquete para analizar el formato de archivo .yml. Después de instalar el paquete, puedes verlo en la lista si expande el directorio lib en env, así: 116 | 117 | ``` 118 | # Mensaje de salida en consola 119 | /env 120 | /lib 121 | /dateutil 122 | ``` 123 | Para ver qué paquetes están ahora instalados en tu entorno virtual, puedes ejecutar ``pip freeze``. Este comando produce una lista de paquetes instalados en el terminal: 124 | 125 | *Recuerda: Si deseas instalar un paquete desde un notebook se ejecuta con signo de admiración al inicio. ``!pip freeze``* Sin embargo, no estamos trabajando con notebooks ahorita, estamos ejecutando todo por terminal (consola, bash, cli, cmd, como sea que le digas). 126 | 127 | ``` 128 | # Mensaje de salida en consola 129 | python-dateutil==2.8.2 130 | six==1.16.0 131 | ``` 132 | 133 | Contiene algo más que sólo pipdate por que en sí misma se basan otras bibliotecas. 134 | 135 | Para asegurarte de que estos paquetes solo existen en tu entorno virtual, intenta salir de ese entorno llamando al comando ``deactivate``: 136 | 137 | ``` 138 | # Bash | Consola 139 | deactivate 140 | ``` 141 | 142 | Observa cómo cambia el mensaje de la terminal. Ya no está precedido por ``(env)`` y ha regresado a su estado anterior: 143 | 144 | ``` 145 | # Bash | Consola 146 | path/to/project 147 | ``` 148 | Si ejecutas el comando ``pip freeze``, verás una lista mucho más larga de dependencias. Esta lista indica que verás todos los paquetes instalados en tu máquina en lugar de solo lo que está instalado en tu entorno virtual. 149 | 150 | 151 | ### Más formas de instalar un paquete 152 | 153 | También puedes utilizar los siguientes comandos para instalar un paquete: 154 | 155 | * Teniendo un conjunto de archivos en tu máquina e instalándolos desde esa fuente: 156 | ``` 157 | # Bash | Consola 158 | cd 159 | python3 -m pip install . 160 | ``` 161 | * Instalar desde un repositorio de GitHub que nos proporciona el control de versiones: 162 | 163 | ``` 164 | git+https://github.com/your-repo.git 165 | ``` 166 | * Instalar desde un archivo comprimido: 167 | 168 | ``` 169 | python3 -m pip install package.tar.gz 170 | ``` 171 | 172 | ### Usar un paquete instalado 173 | Ahora tienes un paquete instalado. ¿Cómo se usa en el código? 174 | 175 | Asegúrate de tener un directorio para tus archivos. Te sugerimos que llames al directorio (folder) src y agregues un archivo Python llamado app.py. Ahora agrega un poco de código para llamar al comando ``pipdate``: 176 | 177 | ``` 178 | from datetime import * 179 | from dateutil.relativedelta import * 180 | now = datetime.now() 181 | print(now) 182 | 183 | now = now + relativedelta(months=1, weeks=1, hour=10) 184 | 185 | print(now) 186 | ``` 187 | 188 | Curso Propedútico de Python para Launch X - Innovacción Virtual. 189 | 190 | Material desarrollado con base en los contenidos de MSLearn y la metáfora de LaunchX, traducción e implementación por: Fernanda Ochoa - Learning Producer de LaunchX. 191 | 192 | Redes: 193 | * GitHub: [FernandaOchoa](https://github.com/FernandaOchoa) 194 | * Twitter: [@imonsh](https://twitter.com/imonsh) 195 | * Instagram: [fherz8a](https://www.instagram.com/fherz8a/) -------------------------------------------------------------------------------- /Módulo 3 - Usar lógica booleana/Módulo 3 - Usar lógica booleana.md: -------------------------------------------------------------------------------- 1 | # Introducción 2 | 3 | Los booleanos son un tipo común en Python. Su valor solo puede ser una de dos cosas: verdadero o falso. Comprender cómo usar los valores booleanos es fundamental, ya que los necesitarás para escribir *lógica condicional*. 4 | 5 | ## Escenario: Imprimir mensajes de advertencia 6 | Supongamos que estás creando un programa que alertará a las personas de todo el mundo de que un asteroide grande y rápido se está acercando a la Tierra. Si el asteroide está lo suficientemente cerca de la Tierra como para representar un peligro, debe imprimir un mensaje de advertencia en los dispositivos de las personas. Si no hay peligro, debes hacer que todos lo sepan, para que puedan continuar con su día. Para poder proporcionar estos mensajes, tendrías que encontrar una manera de razonar si una condición es verdadera o falsa. 7 | 8 | En este módulo, usarás palabras clave y operadores booleanos para escribir varios tipos de expresiones condicionales. 9 | 10 | ## ¿Qué aprenderás? 11 | 12 | Al final de este módulo, podrás: 13 | 14 | * Ejecutar código en una variedad de condiciones mediante sentencias ```if, else```, y ```elif ```. 15 | * Combinar la lógica condicional y crear condiciones más complejas mediante el uso de operadores``` and ``` y operadores ``` or ```. 16 | 17 | ## ¿Cuál es el objetivo principal? 18 | Este módulo te enseña cómo usar la lógica condicional para crear programas basados en decisiones. 19 | 20 | --- 21 | ## Lógica Booleana 22 | 23 | ### Escribir declaraciones 'if' 24 | 25 | Para expresar la lógica condicional en Python, se utilizan instrucciones ```if ```. Cuando escribes una declaración ```if```, confías en otro concepto que cubrimos en este módulo, los operadores matemáticos. Python admite los operadores lógicos comunes de las matemáticas: igual, no igual, menor que, menor que o igual a, mayor que y mayor que o igual a. Probablemente estés acostumbrado a ver estos operadores mostrados usando símbolos, que es la forma en que también se representan en Python. 26 | 27 | * Iguales: ``a == b`` 28 | * No es igual: ``a != b`` 29 | * Menos que: ``a < b`` 30 | * Menor o igual que: ``a <= b`` 31 | * Mayor que: ``a > b`` 32 | * Mayor o igual que: ``a >= b`` 33 | 34 | ### Expresiones de prueba 35 | 36 | Debes usar una instrucción ``if`` para ejecutar código solo si se cumple una determinada condición. Lo primero que se hace cuando se escribe una instrucción ``if`` es comprobar la condición mediante una *expresión de prueba*. A continuación, determins si la instrucción evalúa a ``True (Verdadero)`` o ``False (Falso)`` . Si es ``True (Verdadero)``, se ejecuta el siguiente bloque de código con sangría: 37 | 38 | ``` 39 | # Tip de práctica 1: Intenta ejecutarlo en un notebook. 40 | a = 97 41 | b = 55 42 | # test expression / expresión de prueba 43 | if a < b: 44 | # statement to be run / instrucción a ejecutar 45 | print(b) 46 | ``` 47 | 48 | En este ejemplo, ``a < b`` es la expresión de prueba. El programa evalúa la expresión de prueba y, a continuación, ejecuta el código dentro de la instrucción ``if`` sólo si la expresión de prueba es ``True (Verdadera)``. Si evalúa la expresión, sabe que es ``False (Falso)``, no se ejecutará ningún código que escriba en la instrucción ``if``. 49 | 50 | 51 | ### Escribir declaraciones ``if`` 52 | 53 | Utiliza una instrucción ``if`` si deseas ejecutar código sólo si se cumple una determinada condición. La sintaxis de una instrucción ``if`` es siempre: 54 | 55 | ``` 56 | if expresion_prueba: 57 | # intrucción(es) a ejecutar 58 | ``` 59 | 60 | Por ejemplo: 61 | 62 | *Tip de práctica 2: Antes de ejecutarlo en un notebook, intenta deducir cuál será el resultado y compruébalo.* 63 | 64 | ``` 65 | # Aplica el tip de práctica 1. 66 | a = 93 67 | b = 27 68 | if a >= b: 69 | print(a) 70 | ``` 71 | El fragmento anterior se lee de la siguiente manera (Línea por línea): 72 | 73 | ``` 74 | A la letra 'a' le asigno el valor de 93. 75 | A la letra 'b' le asigno el valor de 27. 76 | SI a(93) es mayor o igual a b(27) entonces: 77 | Muestra (print) el valor de a(93) 78 | ``` 79 | 🤯 Estamos aprendiendo a leer el código de una forma más sencilla. 80 | 81 | En Python, el cuerpo de una instrucción ``if`` debe tener [sangría](https://es.wikipedia.org/wiki/Sangr%C3%ADa_(tipograf%C3%ADa)) . Siempre se ejecutará cualquier código que siga a una expresión de prueba que no tenga sangría: 82 | 83 | *Tips de práctica 1 y 2* 84 | ``` 85 | a = 24 86 | b = 44 87 | if a <= 0: 88 | print(a) 89 | print(b) 90 | ``` 91 | En este ejemplo, el ``44`` como resultado se debe a que la expresión de prueba es ``False`` y la instrucción ``print(b)`` no tiene sangría en el mismo nivel que la instrucción ``if``. 92 | 93 | ### ¿Qué son las declaraciones "else" y "elif"? 94 | 95 | ¿Qué sucede si también deseas que tu programa ejecute una pieza de código cuando tu expresión de prueba es ``False``? ¿O qué pasa si deseas incluir otra expresión de prueba?. 96 | 97 | Python tiene otras palabras clave que puedes usar para hacer declaraciones ``if`` más complejas, ``else`` y ``elif`` . Cuando se utiliza ``if``, ``else``, y ``elif`` en combinación, se pueden escribir programas complejos con varias expresiones de prueba y sentencias para ejecutar. 98 | 99 | ### Trabajando con else 100 | Cuando utilizas una instrucción, el cuerpo del programa sólo se ejecutará si la expresión de prueba es ``True``. Para agregar más código que se ejecutará cuando la expresión de prueba sea ``False``, debes agregar una instrucción ``else``. 101 | 102 | Volvamos al ejemplo de la sección anterior: 103 | ``` 104 | a = 93 105 | b = 27 106 | if a >= b: 107 | print(a) 108 | ``` 109 | En este ejemplo, si ``a`` no es mayor o igual que ``b``, no pasa nada. Supongamos que desea imprimir ``b`` si la expresión de prueba es ``False``: 110 | 111 | ``` 112 | a = 93 113 | b = 27 114 | if a >= b: 115 | print(a) 116 | else: 117 | print(b) 118 | ``` 119 | Si la expresión de prueba es ``False``, se omite el código del cuerpo de la instrucción ``if`` y el programa continúa ejecutándose desde la instrucción ``else``. La sintaxis de una instrucción ``if/else`` es siempre: 120 | 121 | ``` 122 | if expresion_prueba: 123 | # instrucción(es) a ejecutar 124 | else: 125 | # instrucción(es) a ejecutar 126 | ``` 127 | 128 | ### Trabajando con elif 129 | En Python, la palabra clave ``elif`` es la abreviatura de *else if*. El uso de instrucciones ``elif`` te permite agregar varias expresiones de prueba al programa. Estas instrucciones se ejecutan en el orden en que están escritas, por lo que el programa ingresará una instrucción ``elif`` solo si la primera instrucción ``if`` es ``False`` . Por ejemplo: 130 | 131 | ``` 132 | a = 93 133 | b = 27 134 | if a >= b: 135 | print("a es mayor o igual que b") 136 | elif a == b: 137 | print("a es igual que b") 138 | ``` 139 | La instrucción ``elif`` de este bloque de código no se ejecutará, porque la instrucción ``if`` es ``True``. 140 | 141 | La sintaxis de una instrucción ``if/elif`` es: 142 | 143 | ``` 144 | if expresion_prueba: 145 | # instrucción(es) a ejecutar 146 | elif expresion_prueba: 147 | # instrucción(es) a ejecutar 148 | ``` 149 | 150 | ### Combinar declaraciones ``if ``, ``elif``, y ``else`` 151 | 152 | Puedes combinar sentencias ``if ``, ``elif``, y ``else`` para crear programas con lógica condicional compleja. Recuerda que una instrucción ``elif`` sólo se ejecuta cuando la condición ``if `` es ``False``. También ten en cuenta que un bloque ``if `` puede tener solo un bloque ``else``, pero puede tener varios bloques ``elif``. 153 | 154 | Veamos el ejemplo de nuevo con una declaración ``elif`` añadida: 155 | 156 | ``` 157 | a = 93 158 | b = 27 159 | if a > b: 160 | print("a es mayor que b") 161 | elif a < b: 162 | print("a es menor que b") 163 | else: 164 | print ("a es igual que b") 165 | ``` 166 | Un bloque de código que utiliza los tres tipos de instrucciones tiene la sintaxis siguiente: 167 | 168 | ``` 169 | if expresion_prueba: 170 | # instrucción(es) a ejecutar 171 | elif expresion_prueba: 172 | # instrucción(es) a ejecutar 173 | elif expresion_prueba: 174 | # instrucción(es) a ejecutar 175 | else: 176 | # instrucción(es) a ejecutar 177 | ``` 178 | 179 | ### Trabajar con lógica condicional anidada 180 | 181 | Python también admite lógica condicional anidada, lo que significa que puedes anidar sentencias ``if ``, ``elif``, y ``else``, para crear programas aún más complejos. Para anidar condiciones, indenta las condiciones internas y todo lo que esté en el mismo nivel de sangría se ejecutará en el mismo bloque de código: 182 | 183 | ``` 184 | a = 16 185 | b = 25 186 | c = 27 187 | if a > b: 188 | if b > c: 189 | print ("a es mayor que b y b es mayor que c") 190 | else: 191 | print ("a es mayor que b y menor que c") 192 | elif a == b: 193 | print ("a es igual que b") 194 | else: 195 | print ("a es menor que b") 196 | ``` 197 | 198 | Este fragmento de código produce la salida ```"a es menor que b"```. 199 | 200 | La lógica condicional anidada sigue las mismas reglas que la lógica condicional normal dentro de cada bloque de código. Aquí hay un ejemplo de la sintaxis: 201 | 202 | ``` 203 | if expresion_prueba: 204 | # instrucción(es) a ejecutar 205 | if expresion_prueba: 206 | # instrucción(es) a ejecutar 207 | else: 208 | # instrucción(es) a ejecutar 209 | elif expresion_prueba: 210 | # instrucción(es) a ejecutar 211 | if expresion_prueba: 212 | # instrucción(es) a ejecutar 213 | else: 214 | # instrucción(es) a ejecutar 215 | else: 216 | # instrucción(es) a ejecutar 217 | ``` 218 | 219 | ### ¿Qué son los operadores 'and' y 'or'? 220 | 221 | Es posible que ocasionalmente desees combinar expresiones de prueba para evaluar varias condiciones ``if ``, ``elif``, y ``else`` en una instrucción. Para ello, utilizaremos los operadores booleanos ``and`` y ``or``. 222 | 223 | #### El operador ``or`` 224 | 225 | Puede conectar dos expresiones booleanas o de prueba mediante el operador booleano ``or``. Para que toda la expresión se evalúe en ``True``, al menos una de las subexpresiones debe ser verdadera. Si ninguna de las subexpresiones es verdadera, toda la expresión se evalúa en ``False``. Por ejemplo, en la siguiente expresión, toda la expresión de prueba se evalúa en ``True``, porque se ha cumplido una de las condiciones de las subexpresiones: 226 | 227 | ``` 228 | a = 23 229 | b = 34 230 | if a == 34 or b == 34: 231 | print(a + b) 232 | ``` 233 | 234 | Si ambas subexpresiones son verdaderas, toda la expresión de prueba también evalúa a ``True``. 235 | 236 | Una expresión booleana que utiliza ``or`` tiene la sintaxis siguiente: 237 | ``` 238 | subexpresión1 or subexpresión2 239 | ``` 240 | 241 | #### El operador ``and`` 242 | 243 | También puedes conectar dos expresiones de prueba mediante el operador booleano ``and``. 244 | 245 | Ambas condiciones de la expresión de prueba deben ser verdaderas para que toda la expresión de prueba se evalúe en ``True``. En cualquier otro caso, la expresión de prueba es ``False``. En el ejemplo siguiente, toda la expresión de prueba se evalúa en ``False``, porque sólo una de las condiciones de las subexpresiones es ``True``: 246 | 247 | ``` 248 | a = 23 249 | b = 34 250 | if a == 34 and b == 34: 251 | print (a + b) 252 | ``` 253 | 254 | Una expresión booleana que utiliza ``and`` tiene la sintaxis siguiente: 255 | 256 | ``` 257 | subexpresión1 and subexpresión2 258 | ``` 259 | 260 | #### La diferencia entre ``and`` y ``or`` 261 | 262 | Para resaltar la diferencia entre los dos operadores booleanos, puedes utilizar una tabla de verdad. Una tabla de verdad muestra a qué se evalúa toda la expresión de prueba en función de las dos subexpresiones. 263 | 264 | Aquí está la tabla de la verdad para: ``and`` 265 | 266 | subexpresión1 | Operador | subexpresión2 | Resultado 267 | -------- | -------- | -------- | -------- 268 | ``True`` | ``and`` | ``True`` | ``True`` 269 | ``True`` | ``and`` | ``False`` | ``False`` 270 | ``False`` | ``and`` | ``True`` | ``False`` 271 | ``False`` | ``and`` | ``False`` | ``False`` 272 | 273 | Aquí está la tabla de la verdad para: ``or`` 274 | 275 | subexpresión1 | Operador | subexpresión2 | Resultado 276 | -------- | -------- | -------- | -------- 277 | ``True`` | ``or`` | ``True`` | ``True`` 278 | ``True`` | ``or`` | ``False`` | ``True`` 279 | ``False`` | ``or`` | ``True`` | ``True`` 280 | ``False`` | ``or`` | ``False`` | ``False`` 281 | 282 | Curso Propedútico de Python para Launch X - Innovacción Virtual. 283 | 284 | Material desarrollado con base en los contenidos de MSLearn y la metáfora de LaunchX, traducción e implementación por: Fernanda Ochoa - Learning Producer de LaunchX. 285 | 286 | Redes: 287 | * GitHub: [FernandaOchoa](https://github.com/FernandaOchoa) 288 | * Twitter: [@imonsh](https://twitter.com/imonsh) 289 | * Instagram: [fherz8a](https://www.instagram.com/fherz8a/) 290 | -------------------------------------------------------------------------------- /Módulo 3 - Usar lógica booleana/Módulo3Katas.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# Ejercicio - Escribir declaraciones `if`, `else`, y `elif`\n", 8 | "\n", 9 | "Las instrucciones `If` te permiten ejecutar condicionalmente código Python. Se usan comúnmente en Python para \"tomar decisiones\" sobre lo que debería suceder a continuación mientras se ejecuta un programa.\n", 10 | "\n", 11 | "Para crear una instrucción `if` en Python, define una expresión de prueba que pueda tener un valor `True` o `False`, seguido de un bloque de código con sangría que se ejecutará si se cumple la condición. \n", 12 | "\n", 13 | "```python\n", 14 | "if expresion_prueba:\n", 15 | " # intrucción(es) a ejecutar\n", 16 | "```\n", 17 | "\n", 18 | "Para escribir un programa con una lógica condicional más compleja, puedes agregar instrucciones `else` y `elif` al bloque de código. También puedes anidar instrucciones condicionales. \n", 19 | "\n", 20 | "\n", 21 | "```python\n", 22 | "if expresion_prueba:\n", 23 | " # intrucción(es) a ejecutar\n", 24 | " if expresion_prueba:\n", 25 | " # intrucción(es) a ejecutar\n", 26 | " else: \n", 27 | " # intrucción(es) a ejecutar\n", 28 | "elif expresion_prueba:\n", 29 | " # intrucción(es) a ejecutar\n", 30 | "else:\n", 31 | " # intrucción(es) a ejecutar\n", 32 | "```\n", 33 | "\n", 34 | "> **TIP**\n", 35 | "> Dedica unos minutos a tratar de encontrar una solución. Luego desplázate hacia abajo hasta la parte inferior para ver si has logrado compilar el programa de acuerdo con las especificaciones.\n", 36 | "\n", 37 | "Para este ejercicio, escribirás una lógica condicional que imprima una advertencia si un asteroide se acerca a la Tierra demasiado rápido. La velocidad del asteroide varía dependiendo de lo cerca que esté del sol, y cualquier velocidad superior a 25 kilómetros por segundo (km/s) merece una advertencia.\n", 38 | "\n", 39 | "Un asteroide se acerca, y viaja a una velocidad de 49 km/s." 40 | ] 41 | }, 42 | { 43 | "cell_type": "code", 44 | "execution_count": null, 45 | "metadata": {}, 46 | "outputs": [], 47 | "source": [ 48 | "# Añadir el código necesario para crear una variable que guarde la velocidad del asteroide.\n", 49 | "# Escribe una expresión de prueba para calcular si necesita una advertencia.\n", 50 | "# Agregue las instrucciones que se ejecutarán si la expresión de prueba es true o false." 51 | ] 52 | }, 53 | { 54 | "cell_type": "markdown", 55 | "metadata": {}, 56 | "source": [ 57 | "Si un asteroide entra en la atmósfera de la Tierra a una velocidad mayor o igual a 20 km/s, a veces produce un rayo de luz que se puede ver desde la Tierra. Escribe la lógica condicional que usa declaraciones `if`, `else`, y `elif` para alertar a las personas de todo el mundo que deben buscar un asteroide en el cielo. ¡Hay uno que se dirige a la tierra ahora a una velocidad de 19 km/s!" 58 | ] 59 | }, 60 | { 61 | "cell_type": "code", 62 | "execution_count": null, 63 | "metadata": {}, 64 | "outputs": [], 65 | "source": [ 66 | "# Agrega el código para crear una variable para un asteroide que viaja a 19 km/s\n", 67 | "# Escribe varias expresiones de prueba para determinar si puedes ver el rayo de luz desde la tierra\n", 68 | "# Agrega las instrucciones que se ejecutarán si las expresiones de prueba son True o False" 69 | ] 70 | }, 71 | { 72 | "cell_type": "markdown", 73 | "metadata": {}, 74 | "source": [ 75 | "# Ejercicio: Uso de operadores `and` y `or` \n", 76 | "\n", 77 | "En el ejercicio anterior, trabajó con sentencias `if`, `else`, y `elif` para escribir programas con lógica condicional compleja. Para crear expresiones booleanas aún más interesantes, puede usar los operadores `and` y `or` en Python.\n", 78 | "\n", 79 | "Las expresiones `and` son sólo si ambas subexpresiones son verdaderas.\n", 80 | "\n", 81 | "`expresión1 and expresión2`\n", 82 | "\n", 83 | "Las expresiones `or` son `True` si *al menos una* subexpresión es verdadera.\n", 84 | "\n", 85 | "`expresión1 or expresión2`\n", 86 | "\n", 87 | "En este ejercicio, aprenderás información más matizada sobre cuándo los asteroides representan un peligro para la Tierra, y utilizarás esa información para mejorar nuestro sistema de advertencia. Aquí está la nueva información que necesitas saber:\n", 88 | "\n", 89 | "*Los asteroides de menos de 25 metros en su dimensión más grande probablemente se quemarán a medida que entren en la atmósfera de la Tierra.\n", 90 | "* Si una pieza de un asteroide que es más grande que 25 metros pero más pequeña que 1000 metros golpeara la Tierra, causaría mucho daño.\n", 91 | "\n", 92 | "También discutimos en el ejercicio anterior que:\n", 93 | "\n", 94 | "* La velocidad del asteroide varía en función de lo cerca que esté del sol, y cualquier velocidad superior a 25 kilómetros por segundo (km/s) merece una advertencia.\n", 95 | "* Si un asteroide entra en la atmósfera de la Tierra a una velocidad mayor o igual a 20 km/s, a veces produce un rayo de luz que se puede ver desde la Tierra.\n", 96 | "\n", 97 | "Usando toda esta información, escribe un programa que emita la advertencia o información correcta a la gente de la Tierra, según la velocidad y el tamaño de un asteroide. Utiliza instrucciones `if`, `else`, y `elif`, así como los operadores `and` y `or`." 98 | ] 99 | }, 100 | { 101 | "cell_type": "code", 102 | "execution_count": null, 103 | "metadata": {}, 104 | "outputs": [], 105 | "source": [ 106 | "# Agrega el código para crear nuevas variables para la velocidad y el tamaño del asteroide\n", 107 | "# Para probar el código, prueba con varias velocidades y tamaños\n", 108 | "# Escribe varias expresiones de prueba o combinaciones de expresiones de prueba para determinar qué mensaje se debe enviar a Tierra." 109 | ] 110 | }, 111 | { 112 | "cell_type": "markdown", 113 | "metadata": {}, 114 | "source": [ 115 | "## Soluciones" 116 | ] 117 | }, 118 | { 119 | "cell_type": "markdown", 120 | "metadata": {}, 121 | "source": [ 122 | "#### Problema No. 1" 123 | ] 124 | }, 125 | { 126 | "cell_type": "code", 127 | "execution_count": null, 128 | "metadata": {}, 129 | "outputs": [], 130 | "source": [ 131 | "# Añadir el código necesario para crear una variable que guarde la velocidad del asteroide.\n", 132 | "# Escribe una expresión de prueba para calcular si necesita una advertencia.\n", 133 | "# Agregue las instrucciones que se ejecutarán si la expresión de prueba es true o false.\n", 134 | "\n", 135 | "asteroide = 49\n", 136 | "if asteroide > 25:\n", 137 | " print('¡Alerta! ¡Un asteroide se acerca a velocidades peligrosas!')\n", 138 | "else:\n", 139 | " print('¡Sigue con tu día!')" 140 | ] 141 | }, 142 | { 143 | "cell_type": "markdown", 144 | "metadata": {}, 145 | "source": [ 146 | "#### Problema No. 2" 147 | ] 148 | }, 149 | { 150 | "cell_type": "code", 151 | "execution_count": null, 152 | "metadata": {}, 153 | "outputs": [], 154 | "source": [ 155 | "# Agrega el código para crear una variable para un asteroide que viaja a 19 km/s\n", 156 | "# Escribe varias expresiones de prueba para determinar si puedes ver el rayo de luz desde la tierra\n", 157 | "# Agrega las instrucciones que se ejecutarán si las expresiones de prueba son True o False\n", 158 | "\n", 159 | "asteroide = 19\n", 160 | "if asteroide > 20:\n", 161 | " print('Look up! ¡Hay una luz mágica en el cielo!')\n", 162 | "elif asteroide == 20:\n", 163 | " print('Look up! ¡Hay una luz mágica en el cielo!')\n", 164 | "else:\n", 165 | " print('¡Nada que ver aquí!')" 166 | ] 167 | }, 168 | { 169 | "cell_type": "markdown", 170 | "metadata": {}, 171 | "source": [ 172 | "#### Problema No. 3" 173 | ] 174 | }, 175 | { 176 | "cell_type": "code", 177 | "execution_count": null, 178 | "metadata": {}, 179 | "outputs": [], 180 | "source": [ 181 | "# Agrega el código para crear nuevas variables para la velocidad y el tamaño del asteroide\n", 182 | "# Para probar el código, prueba con varias velocidades y tamaños\n", 183 | "# Escribe varias expresiones de prueba o combinaciones de expresiones de prueba para determinar qué mensaje se debe enviar a Tierra.\n", 184 | "\n", 185 | "velocidad_asteroide = 25\n", 186 | "tamano_asteroide = 40\n", 187 | "if velocidad_asteroide > 25 and tamano_asteroide > 25:\n", 188 | " print('¡Alerta, Un asteroide muy peligroso viene hacia la Tierra!')\n", 189 | "elif velocidad_asteroide >= 20:\n", 190 | " print('Look up! ¡Hay una luz mágica en el cielo!')\n", 191 | "elif tamano_asteroide < 25:\n", 192 | " print('Nada que ver aquí :)')\n", 193 | "else:\n", 194 | " print('Nada que ver aquí :)')" 195 | ] 196 | }, 197 | { 198 | "cell_type": "markdown", 199 | "metadata": {}, 200 | "source": [ 201 | "Curso Propedútico de Python para Launch X - Innovacción Virtual.\n", 202 | "\n", 203 | "Material desarrollado con base en los contenidos de MSLearn y la metáfora de LaunchX, traducción e implementación por: Fernanda Ochoa - Learning Producer de LaunchX.\n", 204 | "\n", 205 | "Redes:\n", 206 | "* GitHub: [FernandaOchoa](https://github.com/FernandaOchoa)\n", 207 | "* Twitter: [@imonsh](https://twitter.com/imonsh)\n", 208 | "* Instagram: [fherz8a](https://www.instagram.com/fherz8a/)" 209 | ] 210 | } 211 | ], 212 | "metadata": { 213 | "interpreter": { 214 | "hash": "916dbcbb3f70747c44a77c7bcd40155683ae19c65e1c03b4aa3499c5328201f1" 215 | }, 216 | "kernel_info": { 217 | "name": "conda-env-py37_default-py" 218 | }, 219 | "kernelspec": { 220 | "display_name": "py37_default", 221 | "language": "python", 222 | "name": "python3" 223 | }, 224 | "language_info": { 225 | "codemirror_mode": { 226 | "name": "ipython", 227 | "version": 3 228 | }, 229 | "file_extension": ".py", 230 | "mimetype": "text/x-python", 231 | "name": "python", 232 | "nbconvert_exporter": "python", 233 | "pygments_lexer": "ipython3", 234 | "version": "3.8.10" 235 | }, 236 | "nteract": { 237 | "version": "nteract-front-end@1.0.0" 238 | }, 239 | "orig_nbformat": 4 240 | }, 241 | "nbformat": 4, 242 | "nbformat_minor": 2 243 | } 244 | -------------------------------------------------------------------------------- /Módulo 4 - Cadenas/Módulo4Katas.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# Ejercicio 1: Transformar cadenas\n", 8 | "Hay varias operaciones que puedes realizar en las cadenas cuando las manipulamos. En este ejercicio, usarás métodos de cadena para modificar el texto con hechos sobre la Luna y luego extraerás información para crear un breve resumen.\n", 9 | "\n", 10 | "> **Nota**\n", 11 | "> Dedica unos minutos a tratar de encontrar una solución. Luego desplázate hacia abajo hasta la parte inferior para ver si has logrado compilar el programa de acuerdo con las especificaciones." 12 | ] 13 | }, 14 | { 15 | "cell_type": "markdown", 16 | "metadata": {}, 17 | "source": [ 18 | "El texto con el que trabajarás es el siguiente: " 19 | ] 20 | }, 21 | { 22 | "cell_type": "code", 23 | "execution_count": null, 24 | "metadata": {}, 25 | "outputs": [], 26 | "source": [ 27 | "text = \"\"\"Interesting facts about the Moon. The Moon is Earth's only satellite. There are several interesting facts about the Moon and how it affects life here on Earth. \n", 28 | "On average, the Moon moves 4cm away from the Earth every year. This yearly drift is not significant enough to cause immediate effects on Earth. The highest daylight temperature of the Moon is 127 C.\"\"\"" 29 | ] 30 | }, 31 | { 32 | "cell_type": "markdown", 33 | "metadata": {}, 34 | "source": [ 35 | "Primero, divide el texto en cada oración para trabajar con su contenido:" 36 | ] 37 | }, 38 | { 39 | "cell_type": "code", 40 | "execution_count": null, 41 | "metadata": {}, 42 | "outputs": [], 43 | "source": [ 44 | "# Añade el código necesario" 45 | ] 46 | }, 47 | { 48 | "cell_type": "markdown", 49 | "metadata": {}, 50 | "source": [ 51 | "Ahora, define algunas palabras clave para búsqueda que te ayudarán a determinar si una oración contiene un hecho." 52 | ] 53 | }, 54 | { 55 | "cell_type": "code", 56 | "execution_count": null, 57 | "metadata": {}, 58 | "outputs": [], 59 | "source": [ 60 | "# Define las palabras pista: average, temperature y distance suenan bien" 61 | ] 62 | }, 63 | { 64 | "cell_type": "markdown", 65 | "metadata": {}, 66 | "source": [ 67 | "Cre un bucle para imprimir solo datos sobre la Luna que estén relacionados con las palabras clave definidas anteriormente:" 68 | ] 69 | }, 70 | { 71 | "cell_type": "code", 72 | "execution_count": null, 73 | "metadata": {}, 74 | "outputs": [], 75 | "source": [ 76 | "# Ciclo for para recorrer la cadena" 77 | ] 78 | }, 79 | { 80 | "cell_type": "markdown", 81 | "metadata": {}, 82 | "source": [ 83 | "Finalmente, actualiza el bucle(ciclo) para cambiar _C_ a _Celsius_:" 84 | ] 85 | }, 86 | { 87 | "cell_type": "code", 88 | "execution_count": null, 89 | "metadata": {}, 90 | "outputs": [], 91 | "source": [ 92 | "# Ciclo para cambiar C a Celsius" 93 | ] 94 | }, 95 | { 96 | "cell_type": "markdown", 97 | "metadata": {}, 98 | "source": [ 99 | "> Recuerda: Lo importante es intentarlo, puedes auxiliarte de internet, libros, etc. El objetivo de una kata es la comprobación de la comprensión de la lección y su aplicación inmediata a la resolución de problemas. Go for it!" 100 | ] 101 | }, 102 | { 103 | "cell_type": "markdown", 104 | "metadata": {}, 105 | "source": [ 106 | "# Ejercicio 2: Formateando Cadenas\n", 107 | "\n", 108 | "Saber cómo dar formato a las cadenas es esencial cuando se presenta información de un programa. Hay algunas maneras diferentes de lograr esto en Python. En este ejercicio, se utilizan variables que contienen datos clave sobre la gravedad en varias lunas y luego se utilizan para dar formato e imprimir la información.\n", 109 | "\n", 110 | "El formato tiene que acomodar información sobre otras lunas, por lo que debe ser genérico.\n", 111 | "\n", 112 | "En lugar de reemplazar las variables en una cadena larga como parte de un párrafo, utiliza la información para presentarla en un formato tabular. El resultado debería verse así:\n", 113 | "\n", 114 | "```\n", 115 | "Gravity Facts about Ganymede\n", 116 | "-------------------------------------------------------------------------------\n", 117 | "Planet Name: Mars\n", 118 | "Gravity on Ganymede: 1.4300000000000002 m/s2\n", 119 | "```" 120 | ] 121 | }, 122 | { 123 | "cell_type": "code", 124 | "execution_count": null, 125 | "metadata": {}, 126 | "outputs": [], 127 | "source": [ 128 | "# Datos con los que vas a trabajar\n", 129 | "name = \"Moon\"\n", 130 | "gravity = 0.00162 # in kms\n", 131 | "planet = \"Earth\"" 132 | ] 133 | }, 134 | { 135 | "cell_type": "markdown", 136 | "metadata": {}, 137 | "source": [ 138 | "Primero, crea un título para el texto. Debido a que este texto trata sobre la gravedad en la Tierra y la Luna, úsalo para crear un título significativo. Utiliza las variables en lugar de escribir." 139 | ] 140 | }, 141 | { 142 | "cell_type": "code", 143 | "execution_count": null, 144 | "metadata": {}, 145 | "outputs": [], 146 | "source": [ 147 | "# Creamos el título" 148 | ] 149 | }, 150 | { 151 | "cell_type": "markdown", 152 | "metadata": {}, 153 | "source": [ 154 | "Ahora crea una plantilla de cadena multilínea para contener el resto de la información. En lugar de usar kilómetros, debes convertir la distancia a metros multiplicando por 1,000." 155 | ] 156 | }, 157 | { 158 | "cell_type": "code", 159 | "execution_count": null, 160 | "metadata": {}, 161 | "outputs": [], 162 | "source": [ 163 | "# Creamos la plantilla" 164 | ] 165 | }, 166 | { 167 | "cell_type": "markdown", 168 | "metadata": {}, 169 | "source": [ 170 | "Finalmente, usa ambas variables para unir el título y los hechos." 171 | ] 172 | }, 173 | { 174 | "cell_type": "code", 175 | "execution_count": null, 176 | "metadata": {}, 177 | "outputs": [], 178 | "source": [ 179 | "# Unión de ambas cadenas" 180 | ] 181 | }, 182 | { 183 | "cell_type": "markdown", 184 | "metadata": {}, 185 | "source": [ 186 | "Ahora usa información de una luna diferente para ver si la plantilla todavía funciona.\n", 187 | "\n", 188 | "Datos muestra: \n", 189 | "```\n", 190 | "planeta = 'Marte '\n", 191 | "gravedad = 0.00143\n", 192 | "nombre = 'Ganímedes'\n", 193 | "```" 194 | ] 195 | }, 196 | { 197 | "cell_type": "code", 198 | "execution_count": null, 199 | "metadata": {}, 200 | "outputs": [], 201 | "source": [ 202 | "# Comprueba la plantilla\n", 203 | "# print(nombre_plantilla)" 204 | ] 205 | }, 206 | { 207 | "cell_type": "markdown", 208 | "metadata": {}, 209 | "source": [ 210 | "La salida no muestra información sobre Marte. Todavía muestra información sobre la Luna. Esto sucede porque las cadenas f están ansiosas en su evaluación, por lo que las variables una vez asignadas no se pueden reasignar. Para evitar este problema, vuelva a hacer la plantilla para utilizar .format():" 211 | ] 212 | }, 213 | { 214 | "cell_type": "code", 215 | "execution_count": null, 216 | "metadata": {}, 217 | "outputs": [], 218 | "source": [ 219 | "# Nueva plantilla" 220 | ] 221 | }, 222 | { 223 | "cell_type": "markdown", 224 | "metadata": {}, 225 | "source": [ 226 | "Debido a que .format() no permite expresiones, la gravedad en Ganímedes es incorrecta. Asegúrese de que la operación se realiza fuera de la plantilla de formato e imprima de nuevo para ver el resultado de trabajo." 227 | ] 228 | }, 229 | { 230 | "cell_type": "code", 231 | "execution_count": null, 232 | "metadata": {}, 233 | "outputs": [], 234 | "source": [ 235 | "# Pista: print(nueva_plantilla.format(variables))" 236 | ] 237 | }, 238 | { 239 | "cell_type": "markdown", 240 | "metadata": {}, 241 | "source": [ 242 | "## Soluciones" 243 | ] 244 | }, 245 | { 246 | "cell_type": "markdown", 247 | "metadata": {}, 248 | "source": [ 249 | "## Ejercicio 1" 250 | ] 251 | }, 252 | { 253 | "cell_type": "code", 254 | "execution_count": null, 255 | "metadata": {}, 256 | "outputs": [], 257 | "source": [ 258 | "# Divide el texto\n", 259 | "text_parts = text.split('. ')\n", 260 | "text_parts" 261 | ] 262 | }, 263 | { 264 | "cell_type": "code", 265 | "execution_count": null, 266 | "metadata": {}, 267 | "outputs": [], 268 | "source": [ 269 | "# Palabras clave\n", 270 | "key_words = [\"average\", \"temperature\", \"distance\"]" 271 | ] 272 | }, 273 | { 274 | "cell_type": "code", 275 | "execution_count": null, 276 | "metadata": {}, 277 | "outputs": [], 278 | "source": [ 279 | "# Ciclo for para recorrer la cadena\n", 280 | "for sentence in text_parts:\n", 281 | " for key_word in key_words:\n", 282 | " if key_word in sentence:\n", 283 | " print(sentence)\n", 284 | " break" 285 | ] 286 | }, 287 | { 288 | "cell_type": "code", 289 | "execution_count": null, 290 | "metadata": {}, 291 | "outputs": [], 292 | "source": [ 293 | "# Ciclo para cambiar C a Celsius\n", 294 | "for sentence in text_parts:\n", 295 | " for key_word in key_words:\n", 296 | " if key_word in sentence:\n", 297 | " print(sentence.replace(' C', ' Celsius'))\n", 298 | " break" 299 | ] 300 | }, 301 | { 302 | "cell_type": "markdown", 303 | "metadata": {}, 304 | "source": [ 305 | "## Ejercicio 2" 306 | ] 307 | }, 308 | { 309 | "cell_type": "code", 310 | "execution_count": null, 311 | "metadata": {}, 312 | "outputs": [], 313 | "source": [ 314 | "# Datos con los que vamos a trabajar\n", 315 | "\n", 316 | "planeta = 'Marte '\n", 317 | "gravedad = 0.00143\n", 318 | "nombre = 'Ganímedes'" 319 | ] 320 | }, 321 | { 322 | "cell_type": "code", 323 | "execution_count": null, 324 | "metadata": {}, 325 | "outputs": [], 326 | "source": [ 327 | "# Creamos el título\n", 328 | "title = f'datos de gravedad sobre {nombre}'" 329 | ] 330 | }, 331 | { 332 | "cell_type": "code", 333 | "execution_count": null, 334 | "metadata": {}, 335 | "outputs": [], 336 | "source": [ 337 | "# Creamos la plantilla\n", 338 | "hechos = f\"\"\"{'-'*80} \n", 339 | "Nombre del planeta: {planeta} \n", 340 | "Gravedad en {nombre}: {gravedad * 1000} m/s2 \n", 341 | "\"\"\"" 342 | ] 343 | }, 344 | { 345 | "cell_type": "code", 346 | "execution_count": null, 347 | "metadata": {}, 348 | "outputs": [], 349 | "source": [ 350 | "# Unión de ambas cadenas\n", 351 | "template = f\"\"\"{title.title()} \n", 352 | "{hechos} \n", 353 | "\"\"\" \n", 354 | "print(hechos)" 355 | ] 356 | }, 357 | { 358 | "cell_type": "code", 359 | "execution_count": null, 360 | "metadata": {}, 361 | "outputs": [], 362 | "source": [ 363 | "# Nuevos datos muestra\n", 364 | "planeta = 'Marte '\n", 365 | "gravedad = 0.00143\n", 366 | "nombre = 'Ganímedes'" 367 | ] 368 | }, 369 | { 370 | "cell_type": "code", 371 | "execution_count": null, 372 | "metadata": {}, 373 | "outputs": [], 374 | "source": [ 375 | "# Comprobamos la plantilla\n", 376 | "print(hechos)" 377 | ] 378 | }, 379 | { 380 | "cell_type": "code", 381 | "execution_count": null, 382 | "metadata": {}, 383 | "outputs": [], 384 | "source": [ 385 | "new_template = \"\"\"\n", 386 | "Datos de Gravedad sobre: {nombre}\n", 387 | "-------------------------------------------------------------------------------\n", 388 | "Nombre del planeta: {planeta}\n", 389 | "Gravedad en {nombre}: {gravedad} m/s2\n", 390 | "\"\"\"\n", 391 | "print(new_template.format(nombre=nombre, planeta=planeta, gravedad=gravedad))" 392 | ] 393 | }, 394 | { 395 | "cell_type": "code", 396 | "execution_count": null, 397 | "metadata": {}, 398 | "outputs": [], 399 | "source": [ 400 | "# Pista: print(nueva_plantilla.format(variables))\n", 401 | "print(new_template.format(nombre=nombre, planeta=planeta, gravedad=gravedad*1000))" 402 | ] 403 | }, 404 | { 405 | "cell_type": "markdown", 406 | "metadata": {}, 407 | "source": [ 408 | "Curso Propedútico de Python para Launch X - Innovacción Virtual.\n", 409 | "\n", 410 | "Material desarrollado con base en los contenidos de MSLearn y la metáfora de LaunchX, traducción e implementación por: Fernanda Ochoa - Learning Producer de LaunchX.\n", 411 | "\n", 412 | "Redes:\n", 413 | "* GitHub: [FernandaOchoa](https://github.com/FernandaOchoa)\n", 414 | "* Twitter: [@imonsh](https://twitter.com/imonsh)\n", 415 | "* Instagram: [fherz8a](https://www.instagram.com/fherz8a/)" 416 | ] 417 | } 418 | ], 419 | "metadata": { 420 | "interpreter": { 421 | "hash": "502cd6c3b6c9e666d195e1caff9d64ea12bf644e547a4c8fae84812082c54b6f" 422 | }, 423 | "kernel_info": { 424 | "name": "conda-env-py37_default-py" 425 | }, 426 | "kernelspec": { 427 | "display_name": "py37_default", 428 | "language": "python", 429 | "name": "python3" 430 | }, 431 | "language_info": { 432 | "codemirror_mode": { 433 | "name": "ipython", 434 | "version": 3 435 | }, 436 | "file_extension": ".py", 437 | "mimetype": "text/x-python", 438 | "name": "python", 439 | "nbconvert_exporter": "python", 440 | "pygments_lexer": "ipython3", 441 | "version": "3.9.5" 442 | }, 443 | "nteract": { 444 | "version": "nteract-front-end@1.0.0" 445 | }, 446 | "orig_nbformat": 4 447 | }, 448 | "nbformat": 4, 449 | "nbformat_minor": 2 450 | } 451 | -------------------------------------------------------------------------------- /Módulo 5 - Usar operaciones matemáticas/Módulo 5 - Operaciones matemáticas.md: -------------------------------------------------------------------------------- 1 | # Introducción 2 | Las matemáticas serán parte de casi todos los proyectos que crees a lo largo de tu viaje como desarrollador. Si eres un científico de datos, es posible que estés haciendo cálculos bastante complejos. Si estás creando sitios web, es posible que estés determinando los precios o los artículos en un carrito de compras. Python, como cualquier otro lenguaje de programación, proporciona numerosos operadores y bibliotecas para realizar operaciones matemáticas. 3 | 4 | ## Escenario: Crear un programa para calcular la distancia entre planetas 5 | 6 | Imagina que estás creando un programa para calcular la distancia entre planetas. El programa permite a un usuario ingresar las distancias de dos planetas desde el sol, y calcula la distancia entre esos dos planetas. Además, deseas proporcionar la distancia tanto en millas como en kilómetros. 7 | 8 | ## ¿Qué aprenderás? 9 | 10 | En este módulo, explorarás las capacidades matemáticas básicas de Python. 11 | 12 | Aprenderás sobre: 13 | 14 | * Los operadores matemáticos disponibles en Python. 15 | * El orden de las operaciones. 16 | * Cómo convertir cadenas en números. 17 | 18 | ## ¿Cuál es el objetivo principal? 19 | Aprovechar el poder de los operadores matemáticos cuando creamos un programa Python. 20 | 21 | --- 22 | 23 | ## ¿Qué son los operadores en Python? 24 | 25 | Por lo general, las matemáticas implican alrededor de cuatro operaciones principales: suma, resta, multiplicación y división. Python es compatible con estos cuatro operadores y algunos otros. Exploremos los operadores más comunes que usarás en tus programas. 26 | 27 | ### Adición (Suma) 28 | 29 | En python usamos ``+`` para indicar la adición. Usando ``+`` entre dos números los suma y proporciona el total. 30 | 31 | ``` 32 | answer = 30 + 12 33 | print(answer) 34 | ``` 35 | *Salida: 42* 36 | 37 | Los operadores se comportan igual cuando usan números literales (como ``42``) o variables. 38 | 39 | ### Sustracción (Resta) 40 | 41 | Del mismo modo, Python utiliza ``-`` para la resta. El uso de ``-`` entre dos números resta los dos números y proporciona la diferencia. 42 | 43 | ``` 44 | difference = 30 - 12 45 | print(difference) 46 | ``` 47 | *Salida: 18* 48 | 49 | ### Multiplicación 50 | 51 | En Python ``*``, es el operador de multiplicación. Proporciona el producto de dos números: 52 | 53 | ``` 54 | product = 30 * 12 55 | print(product) 56 | ``` 57 | 58 | *Salida: 360* 59 | 60 | ### División 61 | 62 | Por último, se utiliza ``/`` para la división. Proporciona el cociente de dos números: 63 | 64 | ``` 65 | quotient = 30 / 12 66 | print(quotient) 67 | ``` 68 | 69 | *Salida: 2.5* 70 | 71 | ### Trabajar con la división 72 | 73 | Imagina que necesitas convertir un número de segundos en minutos y segundos para la visualización. 74 | 75 | ``` 76 | seconds = 1042 77 | ``` 78 | 79 | El primer paso es determinar el número de minutos que hay en ``1042`` segundos. Con ``60`` segundos en un minuto, puedes dividir y obtener una respuesta de ``17.3666667`` . El número que te interesa es simplemente ``17``. Siempre que desees redondear hacia abajo, utilizando lo que se conoce como *división de piso*. Para realizar la división de piso en Python, utilizamos ``//``. 80 | 81 | ``` 82 | seconds = 1042 83 | display_minutes = 1042 // 60 84 | print(display_minutes) 85 | ``` 86 | *Salida: 17* 87 | 88 | El siguiente paso es determinar el número de segundos. Este es el resto de si se divide por ``1042``. Puedes encontrar el resto utilizando el operador ``módulo``, que es ``%`` en Python. El resto de ``1042 / 60`` es ``22``, que es lo que proporcionará el operador del módulo. 89 | 90 | ``` 91 | seconds = 1042 92 | display_minutes = 1042 // 60 93 | display_seconds = 1042 % 60 94 | 95 | print(display_minutes) 96 | print(display_seconds) 97 | ``` 98 | 99 | *Salida: 17, 22* 100 | 101 | ### Orden de funcionamiento (Jerarquía de Operaciones) 102 | 103 | Python respeta el orden de operación para las matemáticas. El orden de operación dicta que las expresiones deben evaluarse en el siguiente orden: 104 | 105 | * 1.- Paréntesis 106 | * 2.- Exponentes 107 | * 3.- Multiplicación y división 108 | * 4.- Suma y resta 109 | 110 | Observa cómo se evalúan los paréntesis antes de cualquier otra operación. Esto permite asegurarte de que el código se ejecuta de manera predecible y que su código sea más fácil de leer y mantener. 111 | 112 | Como resultado, es una buena práctica usar paréntesis incluso si el orden de operación se evaluaría de la misma manera sin ellos. En las siguientes dos líneas de código, la segunda es más comprensible porque el paréntesis es una indicación clara de qué operación se realizará primero. 113 | 114 | ``` 115 | result_1 = 1032 + 26 * 2 116 | result_2 = 1032 + (26 * 2) 117 | ``` 118 | 119 | *El resultado es el mismo en ambos casos - 1084* 120 | 121 | --- 122 | 123 | ## Trabajar con números en Python 124 | 125 | Más allá de la aritmética central, puedes hacer uso de otras operaciones con números. Es posible que debas realizar el redondeo o convertir cadenas en números. 126 | 127 | En el escenario de este módulo, deseas aceptar la entrada de un usuario. La entrada será una cadena en lugar de un número, por lo que deberás convertirla en un número. Además, el usuario puede introducir valores que le den una respuesta negativa, que no querrás mostrar. Es posible que debas convertir la respuesta a su valor absoluto (Recordemos que el valor absoluto hace refencia al valor sin signos, es decir sin negativo). 128 | 129 | Afortunadamente, Python proporciona utilidades para estas operaciones. 130 | 131 | ### Convertir cadenas en números 132 | Python admite dos tipos principales de números: enteros (o ``int``) y coma flotante (o ``float``). La diferencia clave entre los dos es la existencia de un punto decimal; los enteros son números enteros, mientras que los floats contienen un valor decimal. 133 | 134 | Cuando conviertes cadenas en números, indicamos el tipo de número que deseamos crear. Debemos decidir si necesitamos un punto decimal. Se utiliza ``int`` para convertir a un número entero y ``float`` para convertir a un número de coma flotante. 135 | 136 | ``` 137 | demo_int = int('215') 138 | print(demo_int) 139 | ``` 140 | *Salida: 215* 141 | 142 | ``` 143 | demo_float = float('215.3') 144 | print(demo_float) 145 | ``` 146 | *Salida: 215.3* 147 | 148 | Si utilizas un valor no válido para cualquiera de los dos ``int`` o ``float``, obtendrás un error. 149 | 150 | ### Valores absolutos 151 | 152 | Un valor absoluto en matemáticas es el número no negativo sin su signo. El uso de un valor absoluto puede ser útil en diferentes situaciones, incluido nuestro ejemplo de buscar determinar la distancia entre dos planetas. Considera las siguientes matemáticas: 153 | 154 | ``` 155 | a = 39 - 16 156 | b = 16 - 39 157 | ``` 158 | Observa que la diferencia entre las dos ecuaciones es que los números se invierten. Las respuestas son ``23`` y ``-23``, respectivamente. Cuando estás determinando la distancia entre dos planetas, el orden en el que ingresas los números no importa, porque la respuesta absoluta es la misma. 159 | 160 | Convertimos el valor negativo en su valor absoluto utilizando ``abs``. Si realiza la misma operación utilizando ``abs`` (e imprimes las respuestas), notarás que se muestra ``23`` para ambas ecuaciones. 161 | 162 | ``` 163 | print(abs(39 - 16)) 164 | print(abs(16 - 39)) 165 | ``` 166 | *Salida: 23, 23* 167 | 168 | ### Redondeo 169 | La función de python incorporada llamada ``round`` también es útil. Usada para redondear al entero más cercano si el valor decimal ``.5`` es mayor o mayor, o hacia abajo si es menor que ``.5``. 170 | 171 | ``` 172 | print(round(14.5)) 173 | ``` 174 | *Salida: 15* 175 | 176 | ### Biblioteca Math 177 | Python tiene bibliotecas para proporcionar operaciones y cálculos más avanzados. Una de las más comunes es la biblioteca ``math``. ``math`` te permite realizar el redondeo con ``floor`` y ``ceil``, proporcionar el valor de pi, y muchas otras operaciones. Veamos cómo usar esta biblioteca para redondear hacia arriba o hacia abajo. 178 | 179 | El redondeo de números permite quitar la parte decimal de un flotador. Puedes elegir redondear siempre hacia arriba al número entero más cercano usando ``ceil``, o hacia abajo usando ``floor``. 180 | 181 | ``` 182 | from math import ceil, floor 183 | 184 | round_up = ceil(12.5) 185 | print(round_up) 186 | 187 | round_down = floor(12.5) 188 | print(round_down) 189 | ``` 190 | *Salida: 13, 12* 191 | 192 | 193 | --- 194 | ## Resumen 195 | 196 | Se te encomendó la tarea de crear una aplicación que solicita al usuario las distancias del sol para dos planetas, así como calcular la diferencia entre las dos distancias. Utilizaste los operadores aritméticos en Python y funciones como ``abs`` e ``int`` para convertir valores. 197 | 198 | Aprendiste sobre: 199 | 200 | * Los operadores matemáticos disponibles en Python. 201 | * El orden de las operaciones. 202 | * Cómo convertir cadenas en números. 203 | 204 | 205 | --- 206 | 207 | Curso Propedútico de Python para Launch X - Innovacción Virtual. 208 | 209 | Material desarrollado con base en los contenidos de MSLearn y la metáfora de LaunchX, traducción e implementación por: Fernanda Ochoa - Learning Producer de LaunchX. 210 | 211 | Redes: 212 | * GitHub: [FernandaOchoa](https://github.com/FernandaOchoa) 213 | * Twitter: [@imonsh](https://twitter.com/imonsh) 214 | * Instagram: [fherz8a](https://www.instagram.com/fherz8a/) -------------------------------------------------------------------------------- /Módulo 5 - Usar operaciones matemáticas/Módulo5Katas.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# Ejercicio1 - Utilizar operadores aritméticos" 8 | ] 9 | }, 10 | { 11 | "cell_type": "markdown", 12 | "metadata": {}, 13 | "source": [ 14 | "### Operadores aritméticos en Python\n", 15 | "Python proporciona operadores aritméticos comunes para que puedas realizar operaciones matemáticas en tu código. Estos incluyen las cuatro operaciones principales de suma, resta, multiplicación y división.\n", 16 | "\n", 17 | "Exploremos cómo podemos crear un programa que pueda calcular la distancia entre dos planetas. Comenzaremos usando dos distancias de planetas: Tierra (149.597.870 km) y Júpiter (778.547.200 km).\n", 18 | "\n", 19 | "> **TIP**\n", 20 | "> Dedica unos minutos a tratar de encontrar una solución. Luego desplázate hacia abajo hasta la parte inferior para ver si has logrado compilar el programa de acuerdo con las especificaciones.\n", 21 | "\n", 22 | "**Nota:** Quita las comas cuando uses los valores." 23 | ] 24 | }, 25 | { 26 | "cell_type": "code", 27 | "execution_count": null, 28 | "metadata": {}, 29 | "outputs": [], 30 | "source": [ 31 | "# Crear variables para almacenar las dos distancias\n", 32 | "# ¡Asegúrate de quitar las comas!" 33 | ] 34 | }, 35 | { 36 | "cell_type": "markdown", 37 | "metadata": {}, 38 | "source": [ 39 | "### Realizar la operación\n", 40 | "\n", 41 | "Con los valores obtenidos, es el momento de añadir el código para realizar la operación. Restarás el primer planeta del segundo para determinar la distancia en kilómetros. A continuación, puedes convertir la distancia del kilómetro en millas multiplicándola por `0.621`." 42 | ] 43 | }, 44 | { 45 | "cell_type": "code", 46 | "execution_count": null, 47 | "metadata": {}, 48 | "outputs": [], 49 | "source": [ 50 | "# Calcular la distancia entre planetas" 51 | ] 52 | }, 53 | { 54 | "cell_type": "markdown", 55 | "metadata": {}, 56 | "source": [ 57 | "### Prueba tu proyecto\n", 58 | "\n", 59 | "Con el código creado, ejecuta el notebook para obtener el resultado. Deberías recibir lo siguiente:\n", 60 | "\n", 61 | "```\n", 62 | "628949330\n", 63 | "390577534\n", 64 | "```\n", 65 | "\n", 66 | "> Recuerda: Lo importante es intentarlo, puedes auxiliarte de internet, libros, etc. El objetivo de una kata es la comprobación de la comprensión de la lección y su aplicación inmediata a la resolución de problemas. Go for it!\n", 67 | "\n", 68 | "---" 69 | ] 70 | }, 71 | { 72 | "cell_type": "markdown", 73 | "metadata": {}, 74 | "source": [ 75 | "## Ejercicio 2: convierte cadenas en números y usa valores absolutos\n", 76 | "\n", 77 | "### Crear una aplicación para trabajar con números y entrada de usuario\n", 78 | "Con frecuencia, deberás convertir los valores de cadena en números para realizar correctamente diferentes operaciones o determinar el valor absoluto de un número.\n", 79 | "\n", 80 | "Para crear nuestra aplicación, queremos leer la distancia del sol para dos planetas, y luego mostrar la distancia entre los planetas. Haremos esto usando `input` para leer los valores, `int` para convertir a entero y luego `abs` para convertir el resultado en su valor absoluto." 81 | ] 82 | }, 83 | { 84 | "cell_type": "markdown", 85 | "metadata": {}, 86 | "source": [ 87 | "### Lee los valores\n", 88 | "Usando `input`, agrega el código para leer la distancia del sol para cada planeta, considerando 2 planetas." 89 | ] 90 | }, 91 | { 92 | "cell_type": "code", 93 | "execution_count": null, 94 | "metadata": {}, 95 | "outputs": [], 96 | "source": [ 97 | "# Almacenar las entradas del usuario\n", 98 | "#Pista: variable = input(\"¿Cuál es tu nombre?\")" 99 | ] 100 | }, 101 | { 102 | "cell_type": "markdown", 103 | "metadata": {}, 104 | "source": [ 105 | "### Convertir a número\n", 106 | "Debido a que `input` devuelve valores de cadena, necesitamos convertirlos en números. Para nuestro ejemplo, usaremos `int`" 107 | ] 108 | }, 109 | { 110 | "cell_type": "code", 111 | "execution_count": null, 112 | "metadata": {}, 113 | "outputs": [], 114 | "source": [ 115 | "# Convierte las cadenas de ambos planetas a números enteros" 116 | ] 117 | }, 118 | { 119 | "cell_type": "markdown", 120 | "metadata": {}, 121 | "source": [ 122 | "### Realizar el cálculo y convertir a valor absoluto\n", 123 | "\n", 124 | "Con los valores almacenados como números, ahora puedes agregar el código para realizar el cálculo, restando el primer planeta del segundo. Debido a que el segundo planeta podría ser un número mayor, usarás `abs` para convertirlo a un valor absoluto. También agregarás el código para mostrar el resultado en millas multiplicando la distancia del kilómetro por 0.621" 125 | ] 126 | }, 127 | { 128 | "cell_type": "code", 129 | "execution_count": null, 130 | "metadata": {}, 131 | "outputs": [], 132 | "source": [ 133 | "# Realizar el cálculo y determinar el valor absoluto\n", 134 | "\n", 135 | "\n", 136 | "# Convertir de KM a Millas" 137 | ] 138 | }, 139 | { 140 | "cell_type": "markdown", 141 | "metadata": {}, 142 | "source": [ 143 | "### Prueba tu aplicación\n", 144 | "Para probar el proyecto, ejecuta tu notebook. En la parte superior de vscode surgirá un cuadro de diálogo para que proporciones las distancias. Puede utilizar los datos de la tabla siguiente:\n", 145 | "\n", 146 | "| Planeta | Distancia al sol |\n", 147 | "| ------- | ----------------- |\n", 148 | "| Mercurio | 57900000 |\n", 149 | "| Venus | 108200000 |\n", 150 | "| Tierra | 149600000 |\n", 151 | "| Marte | 227900000 |\n", 152 | "| Júpiter | 778600000 |\n", 153 | "| Saturno | 1433500000 |\n", 154 | "| Urano | 2872500000 |\n", 155 | "| Neptuno | 4495100000 |" 156 | ] 157 | }, 158 | { 159 | "cell_type": "markdown", 160 | "metadata": {}, 161 | "source": [ 162 | "## Soluciones" 163 | ] 164 | }, 165 | { 166 | "cell_type": "markdown", 167 | "metadata": {}, 168 | "source": [ 169 | "### Ejercicio 1" 170 | ] 171 | }, 172 | { 173 | "cell_type": "code", 174 | "execution_count": null, 175 | "metadata": {}, 176 | "outputs": [], 177 | "source": [ 178 | "# Crear variables para almacenar las dos distancias\n", 179 | "# ¡Asegúrate de quitar las comas!\n", 180 | "\n", 181 | "first_planet = 149597870\n", 182 | "second_planet = 778547200" 183 | ] 184 | }, 185 | { 186 | "cell_type": "code", 187 | "execution_count": null, 188 | "metadata": {}, 189 | "outputs": [], 190 | "source": [ 191 | "# Calcular la distancia entre planetas\n", 192 | "\n", 193 | "distance_km = second_planet - first_planet\n", 194 | "print(distance_km)\n", 195 | "\n", 196 | "distance_mi = distance_km * 0.621\n", 197 | "print(distance_mi)" 198 | ] 199 | }, 200 | { 201 | "cell_type": "markdown", 202 | "metadata": {}, 203 | "source": [ 204 | "### Ejercicio 2" 205 | ] 206 | }, 207 | { 208 | "cell_type": "code", 209 | "execution_count": null, 210 | "metadata": {}, 211 | "outputs": [], 212 | "source": [ 213 | "# Almacenar las entradas del usuario\n", 214 | "first_planet = input('Introduzca la distancia del sol para el primer planeta en KM')\n", 215 | "second_planet = input('Introduzca la distancia desde el sol para el segundo planeta en KM')" 216 | ] 217 | }, 218 | { 219 | "cell_type": "code", 220 | "execution_count": null, 221 | "metadata": {}, 222 | "outputs": [], 223 | "source": [ 224 | "# Convierte las cadenas de ambos planetas a números enteros\n", 225 | "first_planet = int(first_planet)\n", 226 | "second_planet = int(second_planet)" 227 | ] 228 | }, 229 | { 230 | "cell_type": "code", 231 | "execution_count": null, 232 | "metadata": {}, 233 | "outputs": [], 234 | "source": [ 235 | "# Realizar el cálculo y determinar el valor absoluto\n", 236 | "distance_km = second_planet - first_planet\n", 237 | "print(distance_km)\n", 238 | "\n", 239 | "# Convertir de KM a Millas\n", 240 | "distance_mi = distance_km * 0.621\n", 241 | "print(abs(distance_mi))" 242 | ] 243 | }, 244 | { 245 | "cell_type": "markdown", 246 | "metadata": {}, 247 | "source": [ 248 | "---\n", 249 | "\n", 250 | "Curso Propedútico de Python para Launch X - Innovacción Virtual.\n", 251 | "\n", 252 | "Material desarrollado con base en los contenidos de MSLearn y la metáfora de LaunchX, traducción e implementación por: Fernanda Ochoa - Learning Producer de LaunchX.\n", 253 | "\n", 254 | "Redes:\n", 255 | "* GitHub: [FernandaOchoa](https://github.com/FernandaOchoa)\n", 256 | "* Twitter: [@imonsh](https://twitter.com/imonsh)\n", 257 | "* Instagram: [fherz8a](https://www.instagram.com/fherz8a/)" 258 | ] 259 | } 260 | ], 261 | "metadata": { 262 | "interpreter": { 263 | "hash": "502cd6c3b6c9e666d195e1caff9d64ea12bf644e547a4c8fae84812082c54b6f" 264 | }, 265 | "kernel_info": { 266 | "name": "conda-env-py37_default-py" 267 | }, 268 | "kernelspec": { 269 | "display_name": "py37_default", 270 | "language": "python", 271 | "name": "python3" 272 | }, 273 | "language_info": { 274 | "codemirror_mode": { 275 | "name": "ipython", 276 | "version": 3 277 | }, 278 | "file_extension": ".py", 279 | "mimetype": "text/x-python", 280 | "name": "python", 281 | "nbconvert_exporter": "python", 282 | "pygments_lexer": "ipython3", 283 | "version": "3.9.7" 284 | }, 285 | "nteract": { 286 | "version": "nteract-front-end@1.0.0" 287 | }, 288 | "orig_nbformat": 4 289 | }, 290 | "nbformat": 4, 291 | "nbformat_minor": 2 292 | } 293 | -------------------------------------------------------------------------------- /Módulo 6 - Introducción a las listas/Módulo 6- Introducción a las listas.md: -------------------------------------------------------------------------------- 1 | # Introducción 2 | 3 | Como desarrollador, con frecuencia trabajarás con conjuntos de datos. Es posible que debas administrar varios nombres, edades o direcciones. Almacenar cada valor en una variable individual hace que el código sea más difícil de leer y escribir. Para almacenar varios valores, puedes usar una lista de Python. 4 | 5 | ## Escenario: Trabajar en una aplicación planetaria 6 | 7 | Imagina que eres un desarrollador que quiere crear una aplicación para trabajar con una lista de planetas. Deseas pedirle al usuario el nombre de un planeta y mostrar los planetas más cerca y más lejos del sol. 8 | 9 | En este módulo, aprenderás a trabajar con listas de Python y algunas de las operaciones más comunes. 10 | 11 | ## ¿Qué aprenderás? 12 | Después de completar este módulo, podrás: 13 | 14 | * Identificar cuándo usar una lista. 15 | * Crea una lista. 16 | * Obtener acceso a un elemento determinado de una lista mediante índices. 17 | * Insertar elementos al final de una lista. 18 | Ordenar y dividir una lista. 19 | 20 | ## ¿Cuál es el objetivo principal? 21 | Al final de este módulo, comprenderás cuándo usar una estructura de lista y cómo puede ayudar a organizar tus datos. 22 | 23 | --- 24 | 25 | ## Introducción a las listas 26 | Python tiene muchos tipos integrados, como cadenas y enteros. Python tiene un tipo para almacenar una colección de valores: la lista. 27 | 28 | ### Crear una lista 29 | Para crear una lista, asigne una secuencia de valores a una variable. Cada valor está separado por una coma y rodeado por corchetes (``[]``). En el ejemplo siguiente se almacena la lista de todos los planetas de la variable ``planets``: 30 | ``` 31 | planets = ['Mercury', 'Venus', 'Earth', 'Mars', 'Jupiter', 'Saturn', 'Uranus', 'Neptune'] 32 | ``` 33 | 34 | ### Acceder a elementos de lista por índice 35 | 36 | Puedes acceder a cualquier elemento de una lista poniendo el *index/índice* entre ``[]`` después del nombre de la variable de lista. Los índices comienzan desde 0, por lo que en el siguiente código ``planets[0]``, es el primer elemento de la lista ``planets``: 37 | 38 | ``` 39 | print('The first planet is', planets[0]) 40 | print('The second planet is', planets[1]) 41 | print('The third planet is', planets[2]) 42 | ``` 43 | *Salida: 'The first planet is Mercury', 'The second planet is Venus', 'The third planet is Earth'* 44 | 45 | **Nota: Todos los índices inician en 0, es decir en la posición 0 de la lista planets, es Mercury, en la posición 1 el elemento es Venus y así sucesivamente** 46 | 47 | También puedes modificar los valores de una lista mediante un índice. Lo hacemos asignando un nuevo valor, de la misma manera que asignaría un valor a una variable. Por ejemplo, podrías cambiar el nombre de Marte en la lista para usar su apodo: 48 | 49 | ``` 50 | planets[3] = 'Red Planet' 51 | print('Mars is also known as', planets[3]) 52 | ``` 53 | 54 | *Salida: Mars is also known as Red Planet* 55 | 56 | ### Determinar la longitud de una lista 57 | Para obtener la longitud de una lista, utilice la función integrada ``len``. El código siguiente crea una nueva variable,``number_of_planetsplanets`` . El código asigna a esa variable el número de elementos de la lista ``planets`` (8 planetas). 58 | 59 | ``` 60 | number_of_planets = len(planets) 61 | print('There are', number_of_planets, 'planets in the solar system.') 62 | ``` 63 | *Salida: There are 8 planets in the solar system* 64 | 65 | ### Agregar valores a listas 66 | Las listas en Python son dinámicas: Es decir, puedes agregar y eliminar elementos después de crearlos. Para agregar un elemento a una lista, utilice el método ``.append(value)``. 67 | 68 | Por ejemplo, el código siguiente agrega la cadena ``'Pluto`` al final de la lista ``planets``: 69 | 70 | ``` 71 | planets.append('Pluto') 72 | number_of_planets = len(planets) 73 | print('There are actually', number_of_planets, 'planets in the solar system.') 74 | ``` 75 | *Salida: There are actually 9 planets in the solar system.* 76 | 77 | ### Eliminar valores de una lista 78 | Puedes eliminar el último elemento de una lista llamando al método ``.pop()`` de la variable de lista: 79 | 80 | ``` 81 | planets.pop() # Goodbye, Pluto 82 | number_of_planets = len(planets) 83 | print('No, there are definitely', number_of_planets, 'planets in the solar system.') 84 | ``` 85 | 86 | ### Índices negativos 87 | 88 | Hasta ahora hemos visto cómo usar índices para obtener un elemento individual de una lista: 89 | 90 | ``` 91 | print("The first planet is", planets[0]) 92 | ``` 93 | *Salida: The first planet is Mercury* 94 | 95 | Los índices comienzan en cero y aumentan. Los índices negativos comienzan al final de la lista y trabajan hacia atrás. 96 | 97 | En el ejemplo siguiente, un índice de ``-1`` devuelve el último elemento de una lista. Un índice de ``-2`` retorna del penúltimo al último. 98 | 99 | ``` 100 | print('The last planet is', planets[-1]) 101 | print('The penultimate planet is', planets[-2]) 102 | ``` 103 | *Salida: The last planet is Neptune* 104 | *Salida: The penultimate planet is Uranus* 105 | 106 | Si quisieras devolver del tercero al último, usarías un índice de ``-3``(y así sucesivamente). 107 | 108 | ### Buscar un valor en una lista 109 | Para determinar en qué parte de una lista se almacena un valor, utilizamos el método ``index()`` de la lista. Este método busca el valor y devuelve el índice de ese elemento en la lista. Si no encuentra una coincidencia, devuelve ``-1``. 110 | 111 | En el ejemplo siguiente se muestra el uso de ``'Jupiter`` como valor de índice: 112 | 113 | ``` 114 | jupiter_index = planets.index('Jupiter') 115 | print('Jupiter is the', jupiter_index + 1, 'planet from the sun') 116 | ``` 117 | *Salida: Jupiter is the 5 planet from the sun* 118 | 119 | ## Trabajar con números en listas 120 | Hasta ahora, has estado usando nombres de planetas en una lista. Es posible que te preguntes acerca de trabajar con otros tipos de datos, como números. 121 | 122 | ¿Sabías que la gravedad en otros planetas es más fuerte o más débil dependiendo de la masa o el tamaño del planeta? La gravedad a menudo se mide en G, donde la gravedad en la Tierra es 1 y otros planetas se miden en [relación con la Tierra](https://nssdc.gsfc.nasa.gov/planetary/factsheet/planet_table_ratio.html). 123 | 124 | La gravedad en la luna es de 0,166 G, por lo que los astronautas pueden saltar tan alto en la luna. La gravedad en Neptuno es de 1,12 G, por lo que saltar es más difícil. Incluso los atletas olímpicos tendrían dificultades para saltar más de 2 metros sobre Neptuno. 125 | 126 | ![Planeta](https://raw.githubusercontent.com/FernandaOchoa/CursoIntroPython/main/images/planet.png) 127 | 128 | ### Almacenar números en listas 129 | Para almacenar números con decimales en Python, utilizamos el tipo ``float``. Para crear un float, introduzca el número con el decimal y asígnelo a una variable: 130 | 131 | ``` 132 | gravity_on_earth = 1.0 133 | gravity_on_the_moon = 0.166 134 | ``` 135 | 136 | En el siguiente código creamos una lista que muestra las fuerzas gravitacionales de los ocho planetas del sistema solar, en G: 137 | 138 | ``` 139 | gravity_on_planets = [0.378, 0.907, 1, 0.379, 2.36, 0.916, 0.889, 1.12] 140 | ``` 141 | 142 | En esta lista, ``gravity_on_planets[0]`` está la gravedad en Mercurio (0.378 G), ``gravity_on_planets[1]`` es la gravedad en Venus (0.907 G), y así sucesivamente. 143 | 144 | En la Tierra, un autobús de dos pisos pesa 12,650 kilogramos (kg), que es 12.65 toneladas. En Mercurio, donde la gravedad es de 0,378 G, el mismo autobús pesa 12.65 toneladas multiplicadas por 0.378. En Python, para multiplicar dos valores, se utiliza el símbolo ``*``. 145 | 146 | En el siguiente ejemplo, puedes calcular el peso de un bus de dos pisos en diferentes planetas obteniendo el valor de la lista: 147 | 148 | ``` 149 | bus_weight = 12650 # in kilograms, on Earth 150 | 151 | print('On Earth, a double-decker bus weighs', bus_weight, 'kg') 152 | print('On Mercury, a double-decker bus weighs', bus_weight * gravity_on_planets[0], 'kg') 153 | ``` 154 | 155 | *Salida: On Earth, a double-decker bus weighs 12650 kg* 156 | *Salida: On Mercury, a double-decker bus weighs 4781.7 kg* 157 | 158 | ### min() y max () con listas 159 | Python tiene funciones integradas para calcular los números más grandes y más pequeños de una lista. La función ``max()`` devuelve el número más grande y la función ``min()`` devuelve el más pequeño. Así que ``min(gravity_on_planets)``devuelve el número más pequeño de la lista, ``gravity_on_planets`` que es 0.378 (Mercurio). 160 | 161 | El siguiente código calcula los pesos mínimos y máximos en el sistema solar mediante el uso de esas funciones: 162 | 163 | ``` 164 | bus_weight = 12650 # in kilograms, on Earth 165 | 166 | print('On Earth, a double-decker bus weighs', bus_weight, 'kg') 167 | print('The lightest a bus would be in the solar system is', bus_weight * min(gravity_on_planets), 'kg') 168 | print('The heaviest a bus would be in the solar system is', bus_weight * max(gravity_on_planets), 'kg') 169 | ``` 170 | ``` 171 | Salida: 172 | * On Earth, a double-decker bus weighs 12650 kg 173 | * The lightest a bus would be in the solar system is 4781.7 kg 174 | * The heaviest a bus would be in the solar system is 29854 kg 175 | ``` 176 | ## Manipular datos de lista 177 | 178 | Es posible que debas trabajar con diferentes partes de una lista. Por ejemplo, supongamos que tiene una lista con cantidades de lluvia para varios meses. Para analizar adecuadamente este tipo de datos, es posible que debas buscar precipitaciones en otoño o en un período de tres meses. O puede ser que desees ordenar la lista de mayor cantidad de lluvia a menor. 179 | 180 | Python proporciona un soporte sólido para trabajar con los datos en las listas. Este soporte incluye el ``slicing`` (examinando solo una parte) y el ``sorting``. 181 | 182 | ### Slice list 183 | 184 | Puedes recuperar una parte de una lista mediante un ``slice`` (Entendamos slice como una porción, un pedacito, un fragmento, segmento.). ``Slice`` utiliza corchetes, pero en lugar de un solo elemento, tiene los índices inicial y final de los elementos que queremos recuperar. Cuando se utiliza ``slice``, se crea una nueva lista que comienza en el índice inicial y que termina antes (y no incluye) el índice final. 185 | 186 | La lista de planetas tiene ocho elementos. La Tierra es la tercera en la lista. Para obtener los planetas antes que la Tierra, use un ``slice`` para obtener elementos que comienzan en 0 y terminan en 2: 187 | 188 | ``` 189 | planets = ['Mercury', 'Venus', 'Earth', 'Mars', 'Jupiter', 'Saturn', 'Uranus', 'Neptune'] 190 | planets_before_earth = planets[0:2] 191 | print(planets_before_earth) 192 | ``` 193 | 194 | *Salida: ['Mercury', 'Venus']* 195 | 196 | Observa cómo la Tierra no está incluida en la lista. La razón es que el índice termina antes que el índice final. 197 | 198 | Para obtener todos los planetas después de la Tierra, comenzamos en el tercero y vamos al octavo: 199 | 200 | ``` 201 | planets_after_earth = planets[3:8] 202 | print(planets_after_earth) 203 | ``` 204 | *Salida: ['Mars', 'Jupiter', 'Saturn', 'Uranus', 'Neptune']* 205 | 206 | En este ejemplo, se muestra Neptuno. La razón es que el índice para Neptuno es `7`, porque la indexación comienza en `0`. Debido a que el índice final era `8`, incluye el último valor. Si no coloca el índice de detención en el ``slice``, Python asume que deseas ir al final de la lista: 207 | 208 | ``` 209 | planets_after_earth = planets[3:] 210 | print(planets_after_earth) 211 | ``` 212 | 213 | *Salida: ['Mars', 'Jupiter', 'Saturn', 'Uranus', 'Neptune']* 214 | 215 | Un ``slice`` crea una nueva lista. No modifica la lista actual. 216 | 217 | ### Uniendo listas 218 | 219 | Has visto cómo puedes usar slices para dividir listas, pero ¿Qué hay de unirlas de nuevo? 220 | 221 | Para unir dos listas, utilice el operador (`+`) con dos listas para devolver una nueva lista. 222 | 223 | Hay 79 lunas conocidas de Júpiter. Las cuatro más grandes son Io, Europa, Ganímedes y Calisto. Estas se llaman las lunas galileanas, porque Galileo Galilei las descubrió usando su telescopio en 1610. Más cerca de Júpiter que del grupo galileo está el grupo de Amaltea. Consiste en las lunas Metis, Adrastea, Amaltea y Teba. 224 | 225 | Crea dos listas. Llene la primera lista con las cuatro lunas de Amaltea y la segunda lista con las cuatro lunas galileanas. Únelos para crear una nueva lista: 226 | 227 | ``` 228 | amalthea_group = ['Metis', 'Adrastea', 'Amalthea', 'Thebe'] 229 | galilean_moons = ['Io', 'Europa', 'Ganymede', 'Callisto'] 230 | 231 | regular_satellite_moons = amalthea_group + galilean_moons 232 | print('The regular satellite moons of Jupiter are', regular_satellite_moons) 233 | 234 | ``` 235 | *Salida: The regular satellite moons of Jupiter are ['Metis', 'Adrastea', 'Amalthea', 'Thebe', 'Io', 'Europa', 'Ganymede', 'Callisto']* 236 | 237 | Al unir las listas, se crea una nueva lista. No se modifica la lista actual. 238 | 239 | ### Ordenar listas 240 | 241 | Para ordenar una lista, utilizamos el método ``sort()`` de la lista. Python ordenará una lista de cadenas en orden alfabético y una lista de números en orden numérico: 242 | 243 | ``` 244 | regular_satellite_moons.sort() 245 | print("The regular satellite moons of Jupiter are", regular_satellite_moons) 246 | ``` 247 | *Salida: The regular satellite moons of Jupiter are ['Adrastea', 'Amalthea', 'Callisto', 'Europa', 'Ganymede', 'Io', 'Metis', 'Thebe']* 248 | 249 | Para ordenar una lista en forma inversa, llamamos al método ``.sort(reverse=True)`` de la lista: 250 | 251 | ``` 252 | regular_satellite_moons.sort(reverse=True) 253 | print("The regular satellite moons of Jupiter are", regular_satellite_moons) 254 | ``` 255 | *Salida: The regular satellite moons of Jupiter are ['Thebe', 'Metis', 'Io', 'Ganymede', 'Europa', 'Callisto', 'Amalthea', 'Adrastea']* 256 | 257 | Al usar el método ``.sort`` modificas la lista actual. 258 | 259 | --- 260 | 261 | ## Resumen 262 | 263 | Queríamos trabajar con una colección de datos sobre planetas. Nuestra aplicación necesitaba la capacidad de determinar dónde estaban los elementos en relación con otros y mostrar los resultados. Hicimos esto usando una lista. 264 | 265 | Las listas de Python son una herramienta importante cuando se trabaja con datos. Has visto cómo crear, dividir, unir y ordenar listas. Usará estas habilidades en casi todas las aplicaciones de Python que cree. 266 | 267 | En este módulo, aprendiste a: 268 | 269 | * Identificar cuándo usar una lista. 270 | * Crear una lista. 271 | * Obtener acceso a un elemento determinado de una lista mediante índices. 272 | * Insertar elementos al final de una lista. 273 | * Ordenar y dividir una lista. 274 | 275 | 276 | --- 277 | 278 | Curso Propedútico de Python para Launch X - Innovacción Virtual. 279 | 280 | Material desarrollado con base en los contenidos de MSLearn y la metáfora de LaunchX, traducción e implementación por: Fernanda Ochoa - Learning Producer de LaunchX. 281 | 282 | Redes: 283 | * GitHub: [FernandaOchoa](https://github.com/FernandaOchoa) 284 | * Twitter: [@imonsh](https://twitter.com/imonsh) 285 | * Instagram: [fherz8a](https://www.instagram.com/fherz8a/) -------------------------------------------------------------------------------- /Módulo 6 - Introducción a las listas/Módulo6Katas.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# Ejercicio1: Crear y usar listas de Python\n" 8 | ] 9 | }, 10 | { 11 | "cell_type": "markdown", 12 | "metadata": {}, 13 | "source": [ 14 | "### Ejercicio: Usar listas para almacenar nombres de planetas\n", 15 | "Las listas permiten almacenar varios valores en una sola variable. Comenzarás un proyecto sobre información planetaria creando una lista de planetas.\n", 16 | "\n", 17 | "> **TIP**\n", 18 | "> Dedica unos minutos para tratar de encontrar una solución. Luego desplázate hacia abajo hasta la parte inferior para ver si has logrado compilar el programa de acuerdo con las especificaciones" 19 | ] 20 | }, 21 | { 22 | "cell_type": "markdown", 23 | "metadata": {}, 24 | "source": [ 25 | "En primer lugar, crea una variable denominada `planets`. Agrega los ocho planetas (sin Plutón) a la lista. A continuación, muestra el número de planetas." 26 | ] 27 | }, 28 | { 29 | "cell_type": "code", 30 | "execution_count": null, 31 | "metadata": {}, 32 | "outputs": [], 33 | "source": [ 34 | "# Creamos la lista planets y la mostramos" 35 | ] 36 | }, 37 | { 38 | "cell_type": "markdown", 39 | "metadata": {}, 40 | "source": [ 41 | "Agrega a Plutón a la lista que creaste. Luego muestra tanto el número de planetas como el último planeta de la lista." 42 | ] 43 | }, 44 | { 45 | "cell_type": "code", 46 | "execution_count": null, 47 | "metadata": {}, 48 | "outputs": [], 49 | "source": [ 50 | "# Agregamos a plutón y mostramos el último elemento" 51 | ] 52 | }, 53 | { 54 | "cell_type": "markdown", 55 | "metadata": {}, 56 | "source": [ 57 | "> Recuerda: Lo importante es intentarlo, puedes auxiliarte de internet, libros, etc. El objetivo de una kata es la comprobación de la comprensión de la lección y su aplicación inmediata a la resolución de problemas. Go for it!" 58 | ] 59 | }, 60 | { 61 | "cell_type": "markdown", 62 | "metadata": {}, 63 | "source": [ 64 | "## Ejercicio 2: Trabajando con datos de una lista\n", 65 | "\n", 66 | "### Usar slices para recuperar partes de una lista" 67 | ] 68 | }, 69 | { 70 | "cell_type": "markdown", 71 | "metadata": {}, 72 | "source": [ 73 | "Es posible que debas trabajar con diferentes secciones de una lista. En nuestro ejemplo, queremos mostrar planetas más cerca y más lejos del sol de un planeta que el usuario ingresa por teclado.\n", 74 | "\n", 75 | "Comienza agregando el código para crear una lista con los planetas." 76 | ] 77 | }, 78 | { 79 | "cell_type": "code", 80 | "execution_count": null, 81 | "metadata": {}, 82 | "outputs": [], 83 | "source": [ 84 | "# Lista de planetas\n", 85 | "planets = ['Mercury', 'Venus', 'Earth', 'Mars', 'Jupiter', 'Saturn', 'Neptune']" 86 | ] 87 | }, 88 | { 89 | "cell_type": "markdown", 90 | "metadata": {}, 91 | "source": [ 92 | "### Solicita al usuario el nombre de un planeta\n", 93 | "\n", 94 | "A continuación, agrega el código para solicitar al usuario un nombre. Debido a que las cadenas distinguen entre mayúsculas y minúsculas en Python, pídale al usuario que use una letra mayúscula para comenzar el nombre del planeta." 95 | ] 96 | }, 97 | { 98 | "cell_type": "code", 99 | "execution_count": null, 100 | "metadata": {}, 101 | "outputs": [], 102 | "source": [ 103 | "# Solicitamos el nombre de un planeta *Pista: input()*" 104 | ] 105 | }, 106 | { 107 | "cell_type": "markdown", 108 | "metadata": {}, 109 | "source": [ 110 | "### Encuentra el planeta en la lista\n", 111 | "Para determinar qué planetas están más cerca que el que ingresó el usuario, debes encontrar dónde está el planeta en la lista. Puedes utilizar `index` para realizar esta operación. Agrega el código para encontrar el índice del planeta." 112 | ] 113 | }, 114 | { 115 | "cell_type": "code", 116 | "execution_count": null, 117 | "metadata": {}, 118 | "outputs": [], 119 | "source": [ 120 | "# Busca el planeta en la lista" 121 | ] 122 | }, 123 | { 124 | "cell_type": "markdown", 125 | "metadata": {}, 126 | "source": [ 127 | "### Mostrar planetas más cercanos al sol que el que el usuario ingresó\n", 128 | "\n", 129 | "Con el índice determinado, ahora puedes agregar el código para mostrar los planetas más cercanos al sol." 130 | ] 131 | }, 132 | { 133 | "cell_type": "code", 134 | "execution_count": null, 135 | "metadata": {}, 136 | "outputs": [], 137 | "source": [ 138 | "# Muestra los planetas más cercanos al sol" 139 | ] 140 | }, 141 | { 142 | "cell_type": "markdown", 143 | "metadata": {}, 144 | "source": [ 145 | "# Mostrar planetas más alejados del sol que el que el usuario ingresó\n", 146 | "\n", 147 | "Puedes usar el mismo índice para mostrar planetas más alejados del sol. Sin embargo, recuerda que el índice inicial se incluye cuando usas un slice. Como resultado, tendrás que agregar 1 al valor. Agrega el código para mostrar los planetas más alejados del sol." 148 | ] 149 | }, 150 | { 151 | "cell_type": "code", 152 | "execution_count": null, 153 | "metadata": {}, 154 | "outputs": [], 155 | "source": [ 156 | "# Muestra los planetas más lejanos al sol" 157 | ] 158 | }, 159 | { 160 | "cell_type": "markdown", 161 | "metadata": {}, 162 | "source": [ 163 | "## Soluciones" 164 | ] 165 | }, 166 | { 167 | "cell_type": "markdown", 168 | "metadata": {}, 169 | "source": [ 170 | "### Ejercicio 1" 171 | ] 172 | }, 173 | { 174 | "cell_type": "code", 175 | "execution_count": null, 176 | "metadata": {}, 177 | "outputs": [], 178 | "source": [ 179 | "# Creamos la lista planets y la mostramos\n", 180 | "\n", 181 | "planets = ['Mercury', 'Venus', 'Earth', 'Mars', 'Jupiter', 'Saturn', 'Uranus', 'Neptune']\n", 182 | "\n", 183 | "print('There are', len(planets), 'planets')" 184 | ] 185 | }, 186 | { 187 | "cell_type": "code", 188 | "execution_count": null, 189 | "metadata": {}, 190 | "outputs": [], 191 | "source": [ 192 | "# Agregamos a plutón y mostramos el último elemento\n", 193 | "\n", 194 | "planets.append('Pluto')\n", 195 | "\n", 196 | "print(planets[-1], 'is the last planet')" 197 | ] 198 | }, 199 | { 200 | "cell_type": "markdown", 201 | "metadata": {}, 202 | "source": [ 203 | "## Ejercicio 2" 204 | ] 205 | }, 206 | { 207 | "cell_type": "code", 208 | "execution_count": null, 209 | "metadata": {}, 210 | "outputs": [], 211 | "source": [ 212 | "# Lista de planetas\n", 213 | "\n", 214 | "planets = ['Mercury', 'Venus', 'Earth', 'Mars', 'Jupiter', 'Saturn', 'Neptune']" 215 | ] 216 | }, 217 | { 218 | "cell_type": "code", 219 | "execution_count": null, 220 | "metadata": {}, 221 | "outputs": [], 222 | "source": [ 223 | "# Solicitamos el nombre de un planeta *Pista: input()*\n", 224 | "user_planet = input('Please enter the name of the planet (with a capital letter to start)')" 225 | ] 226 | }, 227 | { 228 | "cell_type": "code", 229 | "execution_count": null, 230 | "metadata": {}, 231 | "outputs": [], 232 | "source": [ 233 | "# Busca el planeta en la lista\n", 234 | "\n", 235 | "planet_index = planets.index(user_planet)" 236 | ] 237 | }, 238 | { 239 | "cell_type": "code", 240 | "execution_count": null, 241 | "metadata": {}, 242 | "outputs": [], 243 | "source": [ 244 | "# Muestra los planetas más cercanos al sol\n", 245 | "\n", 246 | "print('Here are the planets closer than ' + user_planet)\n", 247 | "print(planets[0:planet_index])" 248 | ] 249 | }, 250 | { 251 | "cell_type": "code", 252 | "execution_count": null, 253 | "metadata": {}, 254 | "outputs": [], 255 | "source": [ 256 | "# Muestra los planetas más lejanos al sol\n", 257 | "\n", 258 | "print('Here are the planets further than ' + user_planet)\n", 259 | "print(planets[planet_index + 1:])" 260 | ] 261 | }, 262 | { 263 | "cell_type": "markdown", 264 | "metadata": {}, 265 | "source": [ 266 | "Curso Propedútico de Python para Launch X - Innovacción Virtual.\n", 267 | "\n", 268 | "Material desarrollado con base en los contenidos de MSLearn y la metáfora de LaunchX, traducción e implementación por: Fernanda Ochoa - Learning Producer de LaunchX.\n", 269 | "\n", 270 | "Redes:\n", 271 | "* GitHub: [FernandaOchoa](https://github.com/FernandaOchoa)\n", 272 | "* Twitter: [@imonsh](https://twitter.com/imonsh)\n", 273 | "* Instagram: [fherz8a](https://www.instagram.com/fherz8a/)" 274 | ] 275 | } 276 | ], 277 | "metadata": { 278 | "interpreter": { 279 | "hash": "b8bdd4e700647ba2b08c59e5df8b7da1dcf50a218bcd4c1bcd9b3dc92e8788e5" 280 | }, 281 | "kernelspec": { 282 | "display_name": "Python 3.9.1 64-bit", 283 | "name": "python3" 284 | }, 285 | "language_info": { 286 | "codemirror_mode": { 287 | "name": "ipython", 288 | "version": 3 289 | }, 290 | "file_extension": ".py", 291 | "mimetype": "text/x-python", 292 | "name": "python", 293 | "nbconvert_exporter": "python", 294 | "pygments_lexer": "ipython3", 295 | "version": "3.9.5" 296 | }, 297 | "nteract": { 298 | "version": "nteract-front-end@1.0.0" 299 | } 300 | }, 301 | "nbformat": 4, 302 | "nbformat_minor": 4 303 | } 304 | -------------------------------------------------------------------------------- /Módulo 7 - Estructuras de control/Módulo 7 - Estructuras de control.md: -------------------------------------------------------------------------------- 1 | # Introducción 2 | 3 | Los programas informáticos son excelentes para trabajar con tareas repetitivas. Como desarrollador, a menudo tendrás que recorrer en ciclo secuencias de valores, como cadenas, números y objetos. Python proporciona dos mecanismos para realizar estas tareas: ciclos ````while```` y ``for``. 4 | 5 | ## Escenario: Trabajo con el control de flujo en una aplicación de planetario 6 | 7 | Imagina que vas a crear una aplicación en la que los usuarios escribirán una lista de nombres de planetas. Después de que los usuarios escriban los nombres, volverás a mostrarles los resultados. Esto requerirá que se les pidas varias veces que escriban valores y, cuando terminen, el código imprimirá todos los datos de la lista. En este módulo, exploraremos cómo puedes usar los ciclos ````while```` y ``for`` para crear esta aplicación. 8 | 9 | Al final del módulo, sabrás utilizar los ciclos ````while```` y ``for``. 10 | 11 | ## ¿Qué aprenderás? 12 | Cuando hayas finalizado este módulo, podrás: 13 | 14 | * Identificar cuándo se deben usar los ciclos ````while```` y ``for``. 15 | * Ejecutar una tarea varias veces mediante ciclos ``while``. 16 | * Recorrer en ciclo los datos de la lista mediante ciclos ``for``. 17 | 18 | ## ¿Cuál es el objetivo principal? 19 | En este módulo, descubrirás cómo aplicar el control de flujo a tu aplicación para repetir instrucciones y trabajar con estructuras de lista. 20 | 21 | --- 22 | 23 | ## Acerca de los ciclos ``while`` 24 | 25 | Al escribir código, un desafío común es que realices una tarea un número desconocido de veces. En esta unidad, quieres permitir que un usuario escriba una lista de nombres de planetas. Desafortunadamente, no sabes cuántos nombres escribirá el usuario. Para admitir una entrada de usuario o ejecutar una tarea, un número desconocido de veces, puedes usar un ciclo ````while````. 26 | 27 | Un ciclo ````while```` realiza una operación *mientras* (``while``, en inglés) *una determinada condición es True*. Funcionan para evaluar si hay otra línea en un archivo, si se ha establecido una marca, si un usuario ha terminado de escribir valores o bien ha cambiado algo más para indicar que el código puede dejar de realizar la operación. 28 | 29 | > Lo más importante que se debe recordar al crear ciclos ````while```` es asegurarse de que cambia la condición. Si la condición siempre es True, Python seguirá ejecutando el código hasta que el programa se bloquee. 30 | 31 | La sintaxis de un ciclo ``while`` es similar a la de una instrucción ``if``. Proporciona una condición, así como el código que quieres ejecutar mientras la condición sea ``True`` (Oséa, mientras la condición se cumpla o sea verdadera). 32 | 33 | Un ciclo ``while`` tiene tres partes importantes: 34 | 35 | * La palabra ``while``, seguida de un espacio. 36 | 37 | * La condición que se va a probar. Si la condición es True, se ejecutará el código dentro del ciclo ``while``. 38 | 39 | * El código que quiere ejecutar para cada elemento del objeto iterable, seguido de espacios en blanco anidados. Por ejemplo: 40 | 41 | ``` 42 | while condition: 43 | # lo que quieres que se ejecute 44 | ``` 45 | *Se lee de la siguiente manera: Mientras la condición se cumpla: ejecuta el código* 46 | 47 | Veamos cómo puedes crear código para pedir a los usuarios que escriban valores y, después, permitirles usar ``done`` cuando terminen de escribir los valores. En nuestro ejemplo, usaremos la entrada de usuario como condición y, después, la probaremos al principio del ciclo ``while``. 48 | 49 | 50 | ``` 51 | user_input = '' 52 | 53 | while user_input.lower() != 'done': 54 | user_input = input('Enter a new value, or done when done') 55 | ``` 56 | 57 | **Leamos el código línea por línea, el texto entre paréntesis hace referencia al fragmento del código que describimos.** 58 | 59 | ``` 60 | Definimos la variable user_input (Para guardar lo que el usuario va a escribir) 61 | 62 | mientras(while) lo que el usuario escriba(user_input), convertido a minúsculas(.lower()) sea diferente de(!=) la palabra 'done' quiero que: 63 | 64 | Guardes en la variable user_input(user_input =), lo que el usuario escriba (input), muestra un texto de ejemplo para el usuario('Enter a new value, or done when done'). 65 | 66 | ``` 67 | 68 | Tengamos en cuenta que se usa input para preguntar a los usuarios. Cada vez que los usuarios escriben un nuevo valor, cambian la condición, lo que significa que el ciclo while se finalizará una vez que se haya escrito la palabra done, si escribes cualquier otra palabra el ciclo continuará. 69 | 70 | Puedes usar la cadena recién escrita como lo haríamos con cualquier otra cadena capturada con input. Si quieres agregarla a una lista, puedes usar código similar al ejemplo siguiente: 71 | 72 | ``` 73 | # Creamos la variable que almacena el texto 74 | user_input = '' 75 | # Creamos la lista que almacena cada uno de los textos que el usuario ingresa 76 | inputs = [] 77 | 78 | # Ciclo while 79 | while user_input.lower() != 'done': 80 | # Verificamos si hay un valor en user_input 81 | if user_input: 82 | # Almacenamos ese valor en la lista 83 | inputs.append(user_input) 84 | # Capturamos un nuevo valor 85 | user_input = input('Enter a new value, or done when done') 86 | ``` 87 | 88 | Observa la instrucción ``if`` dentro del ciclo ``while``. Esta instrucción prueba si hay un valor de cadena dentro de ``user_input``. Si el ciclo ``while`` se ejecuta por primera vez, no hay ningún valor, por lo que no hay nada que almacenar en ``inputs``. Después de que se ejecute por primera vez, ``user_input`` siempre conserva el valor que el usuario acaba de escribir. Dado que ``while`` está probando para asegurarse de que el valor no es igual a done (la palabra que el usuario escribirá para salir de la aplicación), sabe que el valor actual es uno que puede agregar a la lista. 89 | 90 | > Es posible que en otros lenguajes de programación hayas visto el uso del ciclo 'do', lo que permite realizar una verificación al final del ciclo. En python no existe un ciclo 'do'. 91 | 92 | ### Uso de ciclos ``for`` con listas 93 | 94 | En Python, las listas pueden almacenar cualquier tipo de valor, como cadenas o números: 95 | 96 | ``` 97 | planets = ["Mercury", "Venus", "Earth", "Mars", "Jupiter", "Saturn", "Uranus", "Neptune"] 98 | ``` 99 | 100 | Puedes acceder a cualquier elemento de una lista poniendo el índice entre corchetes ([]) después del nombre de la variable. Los índices comienzan a partir de 0: 101 | 102 | ``` 103 | print("The first planet is ", planets[0]) 104 | print("The second planet is ", planets[1]) 105 | print("The third planet is ", planets[2]) 106 | ``` 107 | 108 | También puede determinar el número de elementos de una lista mediante ``len``. Por lo tanto, podría usar un ciclo ``while`` y un contador para recorrer en ciclo o en iteración cada elemento de la lista. Dado que se trata de una operación tan común, Python proporciona ciclos ``for``, que puedes usar para recorrer en iteración las listas. 109 | 110 | > Python tiene muchos tipos que se pueden recorrer en ciclo. Estos tipos se conocen como iterables. 111 | 112 | Las listas de Python son iterables y se pueden usar con un ciclo ``for``. Se usa un ciclo ``for`` con objetos iterables que va a recorrer en ciclo un número conocido de veces, una vez para cada elemento del objeto iterable. 113 | 114 | ### Acerca de los ciclos ``for`` 115 | Este es un ciclo ``for`` de ejemplo que hace una cuenta atrás, de 4 a 0: 116 | 117 | ``` 118 | countdown = [4, 3, 2, 1, 0] 119 | for number in countdown: 120 | print(number) 121 | print("Blast off!! 🚀") 122 | ``` 123 | 124 | El ciclo ``for`` es una instrucción con cinco partes importantes: 125 | 126 | * La palabra ``for``, seguida de un espacio. 127 | * El nombre de la variable que quieres crear para cada valor de la secuencia (*number*). 128 | * La palabra ``in``, entre espacios. 129 | * El nombre de la lista (*countdown*, en el ejemplo anterior) u objeto iterable que quieres recorrer en ciclo, seguido de dos puntos (``:``). 130 | * El código que quieres ejecutar para cada elemento del objeto iterable, separado por espacios en blanco anidados. 131 | 132 | Vamos a cambiar el código anterior para que espere un segundo entre cada número mediante la función ``sleep()``: 133 | 134 | ``` 135 | # De la biblioteca time, importamos (traemos) la clase sleep 136 | 137 | from time import sleep 138 | 139 | # Creamos una lista de 5 números llamada countdown 140 | countdown = [4, 3, 2, 1, 0] 141 | 142 | # Para cada número en countdown 143 | for number in countdown: 144 | #Muestra el número 145 | print(number) 146 | 147 | # Espera (1segundo) 148 | sleep(1) 149 | 150 | # Muestra el mensaje Blast off 151 | print("Blast off!! 🚀") 152 | ``` 153 | 154 | > La mayoría del código de Python usa cuatro espacios como la unidad del espacio en blanco (sangría). Para ahorrar tener que presionar la barra espaciadora cuatro veces, la mayoría de los editores tienen una función rápida de teclado con la tecla ``Tab``, que inserta cuatro espacios. 155 | 156 | --- 157 | ## Resumen 158 | 159 | En este módulo, hemos creado una aplicación que solicita a los usuarios que escriban una lista de nombres de planetas, los almacenan y, después, los muestran. 160 | 161 | Dado que no sabíamos cuántos planetas escribirían los usuarios, usamos un ciclo ``while``. Los ciclos ``while`` se usan para ejecutar un bloque de código mientras una condición es ``True``. 162 | 163 | Hemos almacenado cada nombre del planeta en una lista. 164 | 165 | Después de crear la lista de planetas, usamos un ciclo ``for`` para recorrerla en iteración. Los ciclos ``for`` se usan con listas y otros objetos iterables para ejecutar código un número conocido de veces, una por cada elemento de la lista de nombres de planetas. 166 | 167 | En este módulo, has aprendido a: 168 | 169 | * Identificar cuándo usar un ciclo ``while`` o uno ``for``. 170 | * Usar un ciclo ``while`` para ejecutar una tarea varias veces, siempre y cuando una condición determinada siga siendo True. 171 | * Usar un ciclo ``for`` para recorrer en ciclo los datos de la lista. 172 | 173 | 174 | --- 175 | 176 | Curso Propedútico de Python para Launch X - Innovacción Virtual. 177 | 178 | Material desarrollado con base en los contenidos de MSLearn y la metáfora de LaunchX, traducción e implementación por: Fernanda Ochoa - Learning Producer de LaunchX. 179 | 180 | Redes: 181 | * GitHub: [FernandaOchoa](https://github.com/FernandaOchoa) 182 | * Twitter: [@imonsh](https://twitter.com/imonsh) 183 | * Instagram: [fherz8a](https://www.instagram.com/fherz8a/) -------------------------------------------------------------------------------- /Módulo 7 - Estructuras de control/Módulo7Katas.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# Ejercicio 1: Creación de un bucle \"while\"" 8 | ] 9 | }, 10 | { 11 | "cell_type": "markdown", 12 | "metadata": {}, 13 | "source": [ 14 | "### Ejercicio 1: Uso de ciclos `while` en Python\n", 15 | "\n", 16 | "En Python, los ciclos `while` te permiten ejecutar código un número desconocido de veces. Los ciclos examinan una condición booleana y, siempre que la condición sea verdadera, se ejecutará el código dentro del ciclo. Esto es muy útil para situaciones como solicitar valores a un usuario.\n", 17 | "\n", 18 | "En este ejercicio, estás creando una aplicación que solicita a un usuario que ingrese una lista de planetas. En un ejercicio posterior, agregarás código que muestre la lista. Por ahora, crearás solo el código que solicita al usuario la lista de planetas.\n", 19 | "\n", 20 | "> **TIP**\n", 21 | "> Dedica unos minutos para tratar de encontrar una solución. Luego desplázate hacia abajo hasta la parte inferior para ver si has logrado compilar el programa de acuerdo con las especificaciones\n", 22 | "\n", 23 | "Comienza agregando dos variables, una para la entrada del usuario, con el nombre `new_planet`, y otra variable para la lista de planetas, denominada `planets`." 24 | ] 25 | }, 26 | { 27 | "cell_type": "code", 28 | "execution_count": null, 29 | "metadata": {}, 30 | "outputs": [], 31 | "source": [ 32 | "# Declara dos variables" 33 | ] 34 | }, 35 | { 36 | "cell_type": "markdown", 37 | "metadata": {}, 38 | "source": [ 39 | "### Crea un ciclo `while`\n", 40 | "\n", 41 | "Comenzando con las variables que acabas de crear, crearás un ciclo `while`. El ciclo `while` se ejecutará *mientras* el `new_planet` **no** sea igual a la palabra 'done'.\n", 42 | "\n", 43 | "Dentro del ciclo, comprobarás si la variable `new_planet` contiene un valor, que debería ser el nombre de un planeta. Esta es una forma rápida de ver si el usuario ha introducido un valor. Si lo han hecho, tu código agregará (`append`) ese valor a la variable `planets`.\n", 44 | "\n", 45 | "Finalmente, usarás `input` para solicitar al usuario que ingrese un nuevo nombre de planeta o que escriba *done* si ha terminado de ingresar nombres de planeta. Almacenará el valor de `input` en la variable `new_planet`." 46 | ] 47 | }, 48 | { 49 | "cell_type": "code", 50 | "execution_count": 2, 51 | "metadata": {}, 52 | "outputs": [], 53 | "source": [ 54 | "# Escribe el ciclo while solicitado" 55 | ] 56 | }, 57 | { 58 | "cell_type": "markdown", 59 | "metadata": {}, 60 | "source": [ 61 | "> Recuerda: Lo importante es intentarlo, puedes auxiliarte de internet, libros, etc. El objetivo de una kata es la comprobación de la comprensión de la lección y su aplicación inmediata a la resolución de problemas. Go for it!" 62 | ] 63 | }, 64 | { 65 | "cell_type": "markdown", 66 | "metadata": {}, 67 | "source": [ 68 | "## Ejercicio 2: Creación de un ciclo \"for\"" 69 | ] 70 | }, 71 | { 72 | "cell_type": "markdown", 73 | "metadata": {}, 74 | "source": [ 75 | "### Ejercicio: - Ciclo para una lista\n", 76 | "\n", 77 | "En el ejercicio anterior, creaste código para solicitar a los usuarios que introduzcan una lista de nombres de planetas. En este ejercicio, completarás la aplicación escribiendo código que muestre los nombres de esos planetas.\n", 78 | "\n", 79 | "### Mostrar la lista de los planetas\n", 80 | "\n", 81 | "La variable `planets` almacena los nombres de planeta que ha introducido un usuario. Ahora usarás un ciclo para mostrar esas entradas.\n", 82 | "\n", 83 | "Crea un ciclo `for` para iterar sobre la lista `planets`. Puedes usar como nombre de la variable `planet` para cada planeta. Dentro del ciclo `for`, recuerda utilizar `print` para mostrar cada `planet`." 84 | ] 85 | }, 86 | { 87 | "cell_type": "code", 88 | "execution_count": null, 89 | "metadata": {}, 90 | "outputs": [], 91 | "source": [ 92 | "# Escribe tu ciclo for para iterar en una lista de planetas" 93 | ] 94 | }, 95 | { 96 | "cell_type": "markdown", 97 | "metadata": {}, 98 | "source": [ 99 | "## Soluciones" 100 | ] 101 | }, 102 | { 103 | "cell_type": "markdown", 104 | "metadata": {}, 105 | "source": [ 106 | "### Ejercicio 1" 107 | ] 108 | }, 109 | { 110 | "cell_type": "code", 111 | "execution_count": null, 112 | "metadata": {}, 113 | "outputs": [], 114 | "source": [ 115 | "# Declaramos 2 variables\n", 116 | "\n", 117 | "new_planet = ''\n", 118 | "planets = []" 119 | ] 120 | }, 121 | { 122 | "cell_type": "code", 123 | "execution_count": null, 124 | "metadata": {}, 125 | "outputs": [], 126 | "source": [ 127 | "# Escribe el ciclo while solicitado\n", 128 | "\n", 129 | "while new_planet.lower() != 'done':\n", 130 | " if new_planet:\n", 131 | " planets.append(new_planet)\n", 132 | " new_planet = input('Enter a new planet ')" 133 | ] 134 | }, 135 | { 136 | "cell_type": "markdown", 137 | "metadata": {}, 138 | "source": [ 139 | "### Ejercicio 2" 140 | ] 141 | }, 142 | { 143 | "cell_type": "code", 144 | "execution_count": null, 145 | "metadata": {}, 146 | "outputs": [], 147 | "source": [ 148 | "# Escribe tu ciclo for para iterar en una lista de planetas\n", 149 | "\n", 150 | "for planet in planets:\n", 151 | " print(planet)" 152 | ] 153 | }, 154 | { 155 | "cell_type": "markdown", 156 | "metadata": {}, 157 | "source": [ 158 | "---\n", 159 | "\n", 160 | "Curso Propedútico de Python para Launch X - Innovacción Virtual.\n", 161 | "\n", 162 | "Material desarrollado con base en los contenidos de MSLearn y la metáfora de LaunchX, traducción e implementación por: Fernanda Ochoa - Learning Producer de LaunchX.\n", 163 | "\n", 164 | "Redes:\n", 165 | "* GitHub: [FernandaOchoa](https://github.com/FernandaOchoa)\n", 166 | "* Twitter: [@imonsh](https://twitter.com/imonsh)\n", 167 | "* Instagram: [fherz8a](https://www.instagram.com/fherz8a/)" 168 | ] 169 | } 170 | ], 171 | "metadata": { 172 | "interpreter": { 173 | "hash": "916dbcbb3f70747c44a77c7bcd40155683ae19c65e1c03b4aa3499c5328201f1" 174 | }, 175 | "kernelspec": { 176 | "display_name": "Python 3.8.10 64-bit", 177 | "language": "python", 178 | "name": "python3" 179 | }, 180 | "language_info": { 181 | "codemirror_mode": { 182 | "name": "ipython", 183 | "version": 3 184 | }, 185 | "file_extension": ".py", 186 | "mimetype": "text/x-python", 187 | "name": "python", 188 | "nbconvert_exporter": "python", 189 | "pygments_lexer": "ipython3", 190 | "version": "3.8.10" 191 | }, 192 | "nteract": { 193 | "version": "nteract-front-end@1.0.0" 194 | }, 195 | "orig_nbformat": 4 196 | }, 197 | "nbformat": 4, 198 | "nbformat_minor": 2 199 | } 200 | -------------------------------------------------------------------------------- /Módulo 8 - Administrar datos con diccionarios/Módulo 8 - Administrar datos con diccionarios.md: -------------------------------------------------------------------------------- 1 | # Introducción 2 | 3 | Con frecuencia tendrás que trabajar con datos más complejos que cadenas y valores booleanos. En este módulo se te proporcionan las herramientas para hacerlo. Ahora se acotará el tema mediante el análisis de un escenario. 4 | 5 | ## Escenario: Análisis de un sistema solar 6 | 7 | Imagina que vas a crear un programa para analizar el número de lunas en diferentes planetas del sistema solar. Quieres mostrar información al usuario y poder calcular valores diferentes, como el número total de lunas en el sistema solar. Sería tedioso hacerlo con variables, que solo pueden almacenar una cadena o un número. 8 | 9 | En este módulo, crearás un programa que puede realizar estos tipos de operaciones. Utilizaremos diccionarios de Python para modelar los datos. Al final del módulo, podrás trabajar con diccionarios de Python para almacenar datos complejos. 10 | 11 | ## ¿Qué aprenderás? 12 | En este módulo, podrás hacer lo siguiente: 13 | 14 | * Identificar cuándo se debe usar un diccionario. 15 | * Crear y modificar datos dentro de un diccionario. 16 | * Trabajar con métodos de diccionario para acceder a los datos del diccionario. 17 | 18 | ## ¿Cuál es el objetivo principal? 19 | 20 | Usar una estructura de diccionario dentro de la aplicación para almacenar datos en un formato que facilite la búsqueda de valores. 21 | 22 | --- 23 | 24 | ## Introducción a los diccionarios de Python 25 | 26 | Las variables de Python pueden almacenar varios tipos de datos. Anteriormente, hemos aprendido que puedes almacenar cadenas y números: 27 | 28 | ``` 29 | name = 'Earth' 30 | moons = 1 31 | ``` 32 | 33 | Aunque esto funciona para cantidades más pequeñas de datos, puede ser cada vez más complejo cuando se trabaja con datos relacionados. Imagina que quieres almacenar información sobre las lunas de la Tierra y la Luna. 34 | 35 | ``` 36 | earth_name = 'Earth' 37 | earth_moons = 1 38 | 39 | jupiter_name = 'Jupiter' 40 | jupiter_moons = 79 41 | ``` 42 | 43 | Observa cómo se duplican las variables con prefijos diferentes. Esto puede resultar difícil de manejar. Con frecuencia tendrás que trabajar con conjuntos de datos relacionados, como por ejemplo: el promedio de precipitaciones durante varios meses en distintas ciudades, almacenarlos como valores individuales no es una opción viable. Aquí es donde los diccionarios de Python pueden ayudarnos. 44 | 45 | Los diccionarios de Python permiten trabajar con conjuntos de datos relacionados. Un diccionario es una colección de pares clave-valor. Piensa que es como un grupo de variables dentro de una cajita, donde la clave es el nombre de la variable y el valor es el valor almacenado en su interior. 46 | 47 | ### Creación de un diccionario 48 | 49 | Python usa llaves (``{ }``) y dos puntos (``:``) para indicar un diccionario. Puedes crear un diccionario vacío y agregar valores más adelante, o bien rellenarlo en el momento de la creación. Cada clave o valor está separado por dos puntos y el nombre de cada clave se incluye entre comillas como un literal de cadena. Como la clave es un literal de cadena, puede usar el nombre que sea adecuado para describir el valor(Sí el que tu quieras). 50 | 51 | Ahora crearemos un diccionario para almacenar el nombre del planeta Tierra y el número de lunas que tiene: 52 | 53 | ``` 54 | planet = { 55 | 'name': 'Earth', 56 | 'moons': 1 57 | } 58 | ``` 59 | 60 | Tiene dos claves, `'name'` y `'moons'`. Cada una se comporta igual que una variable: tienen un nombre único y almacenan un valor. Pero se incluyen dentro de una única variable más grande, denominada `planet`. 61 | 62 | Como sucede con las variables convencionales, debes asegurarte de que usas los tipos de datos correctos. En el valor `moons` de `1` en el ejemplo anterior, no se han incluido comillas alrededor del número, porque se quiere usar un entero. Si hubieras usado `'1'`, Python lo vería como una cadena, lo que afectaría a la capacidad de realizar cálculos. 63 | 64 | A diferencia de las variables convencionales, los nombres de clave *no* necesitan seguir las reglas de nomenclatura estándar para Python. Por lo que te recomendamos ser más descriptivo en el código. 65 | 66 | ### Lectura de los valores de un diccionario 67 | 68 | Podemos leer valores dentro de un diccionario. Los objetos de diccionario tienen un método llamado `get` que puedes usar para acceder a un valor mediante su clave. Si queremos imprimir `name`, funcionaría de la siguiente manera: 69 | 70 | ``` 71 | print(planet.get('name')) 72 | 73 | # Muestra Earth 74 | ``` 75 | 76 | Como podrías sospechar, el acceso a los valores de un diccionario es una operación común. Afortunadamente, hay un acceso directo. También puedes pasar la clave entre corchetes (`[ ]`). Utilizando menos código que `get` y la mayoría de los programadores utilizan esta sintaxis en su lugar. Podemos reescribir el ejemplo anterior de la siguiente forma: 77 | 78 | ``` 79 | # planet['name'] es idéntico a usar planet.get('name') 80 | print(planet['name']) 81 | 82 | # Muestra Earth 83 | ``` 84 | Aunque el comportamiento de `get` y los corchetes (`[ ]`) suele ser el mismo para recuperar elementos, hay una diferencia principal. Si una clave no está disponible, `get` devuelve `None` y `[ ]` genera un error `KeyError`. 85 | 86 | ``` 87 | wibble = planet.get('wibble') # Regresa None 88 | wibble = planet['wibble'] # Arroja un KeyError 89 | ``` 90 | 91 | *Cómo te podrás dar cuenta, funcionan con una estructura similar a las listas. Ya que en el caso de las listas accedemos a cada uno de sus elementos a través de su índice (posición iniciando en 0) y en el caso de un diccionario, accedemos a sus elementos mediante la 'clave'* 92 | 93 | ### Modificación de valores de un diccionario 94 | 95 | También puedes modificar valores dentro de un objeto de diccionario, con el método `update`. Este método acepta un diccionario como parámetro (sí, parámetro por que un diccionario es un rango de valores) y actualiza los valores existentes con los nuevos que proporciones. Si quieres cambiar `name` para el diccionario `planet`, puedes usar lo siguiente, por ejemplo: 96 | 97 | ``` 98 | planet.update({'name': 'Makemake'}) 99 | 100 | # name ahora es Makemake 101 | ``` 102 | 103 | Al igual que se usa el acceso directo de corchetes (`[ ]`) para leer valores, se puede utilizar para modificar valores. La principal diferencia en la sintaxis es que se usa `=` (a veces denominado operador de asignación) para proporcionar un nuevo valor. Para modificar el ejemplo anterior y cambiar el nombre, puedes usar lo siguiente: 104 | 105 | ``` 106 | planet['name'] = 'Makemake' 107 | 108 | # name is now set to Makemake 109 | ``` 110 | 111 | La principal ventaja de usar `update` es la capacidad de modificar varios valores en una operación. Los dos ejemplos siguientes son lógicamente los mismos, pero la sintaxis es diferente. Puedes usar la sintaxis que creas más adecuada. Para actualizar valores individuales, la mayoría de los desarrolladores eligen corchetes. 112 | 113 | En el ejemplo siguiente se hacen las mismas modificaciones en la variable `planet` y se actualizan el nombre y las lunas. Ten en cuenta que al usar `update` realizas una sola llamada a la función, mientras que el uso de corchetes implica dos llamadas. 114 | 115 | ``` 116 | # Usando update 117 | planet.update({ 118 | 'name': 'Jupiter', 119 | 'moons': 79 120 | }) 121 | 122 | # Usando corchetes 123 | planet['name'] = 'Jupiter' 124 | planet['moons'] = 79 125 | ``` 126 | 127 | ### Adición y eliminación de claves 128 | 129 | No es necesario crear todas las claves al inicializar un diccionario. De hecho, no es necesario crear ninguna. Siempre que quieras crear una clave, asígnala como harías con una existente. 130 | 131 | Imagina que quieres actualizar `planet` para incluir el período orbital en días: 132 | 133 | ``` 134 | planet['orbital period'] = 4333 135 | 136 | # el diccionario planet ahora contiene: { 137 | # name: 'jupiter' 138 | # moons: 79 139 | # orbital period: 4333 140 | # } 141 | ``` 142 | 143 | > Los nombres de una clave, como todo lo demás en Python, distinguen mayúsculas de minúsculas. Como resultado, 'name' y 'Name' se consideran dos claves independientes en un diccionario de Python. 144 | 145 | Para quitar una clave, usa `pop`. `pop` devuelve el valor y quita la clave del diccionario. Para eliminar `orbital period`, puedes usar el código siguiente: 146 | 147 | ``` 148 | planet.pop('orbital period') 149 | 150 | # el diccionario planet ahora contiene: { 151 | # name: 'jupiter' 152 | # moons: 79 153 | # } 154 | ``` 155 | 156 | ### Tipos de data complejos 157 | Los diccionarios pueden almacenar cualquier tipo de valor, incluidos otros diccionarios. Esto te permite modelar datos complejos según sea necesario. Imagina que debes que almacenar el diámetro de `planet`, que se podría medir alrededor de su ecuador o de los polos. Puedes crear otro diccionario dentro de `planet` para almacenar esta información: 158 | 159 | ``` 160 | # Añadimos los datos 161 | planet['diameter (km)'] = { 162 | 'polar': 133709, 163 | 'equatorial': 142984 164 | } 165 | 166 | # el diccionario planet ahora contiene: { 167 | # name: 'Jupiter' 168 | # moons: 79 169 | # diameter (km): { 170 | # polar: 133709 171 | # equatorial: 142984 172 | # } 173 | # } 174 | ``` 175 | Para recuperar valores en un diccionario anidado, debe puedes utilizar corchetes `[ ]` o llamar a `get`. 176 | 177 | ``` 178 | print(f'{planet['name']} polar diameter: {planet['diameter (km)']['polar']}') 179 | 180 | # Salida: Jupiter polar diameter: 133709 181 | ``` 182 | 183 | ## Programación dinámica con diccionarios 184 | 185 | En el programa, quieres realizar varios cálculos, como el del número total de lunas. Además, a medida que progreses en programación, es posible que necesites cargar este tipo de información desde archivos o una base de datos, en lugar de programarlos directamente en Python. 186 | 187 | Para ayudar a admitir estos escenarios, Python te permite tratar las claves y los valores dentro de un diccionario como una lista. Puedes determinar de manera dinámica las claves y los valores, y realizar varios cálculos. 188 | 189 | Imagina un diccionario en el que se almacenan cantidades mensuales de precipitaciones. Es probable que tengas claves para cada mes y sus precipitaciones asociadas. Quieres sumar el total de precipitaciones, y escribir el código para realizar la operación mediante cada clave individual sería bastante tedioso. 190 | 191 | ### Recuperación de todas las claves y valores 192 | El método `keys()` devuelve un objeto de lista que contiene todas las claves. Puedes usar este método para iterar por todos los elementos del diccionario. 193 | 194 | Imagina que tiene el siguiente diccionario, en el que se almacenan los últimos tres meses de precipitaciones (rainfall). 195 | 196 | ``` 197 | rainfall = { 198 | 'october': 3.5, 199 | 'november': 4.2, 200 | 'december': 2.1 201 | } 202 | ``` 203 | 204 | Imagina que quiere mostrar la lista de todas las precipitaciones. Puedes escribir el nombre de cada mes, pero sería tedioso, en este caso hacemos uso del método `keys()`. 205 | 206 | ``` 207 | for key in rainfall.keys(): 208 | print(f'{key}: {rainfall[key]}cm') 209 | 210 | # Salida: 211 | # october: 3.5cm 212 | # november: 4.2cm 213 | # december: 2.1cm 214 | ``` 215 | *Para cada clave en las claves(keys()) contenidas en `rainfalls`: muestra la clave que estás iterando (meses): así como el valor (número) de la clave que estamos iterando (clave-mes : valor-número) en cm* 216 | 217 | ### Determinando la existencia de una clave en un diccionario 218 | 219 | Al actualizar un valor en un diccionario, Python sobrescribirá el valor existente o creará uno en su defecto, si la clave no existe. Si quieres agregar un valor en lugar de sobrescribirlo, puedes comprobar si la clave existe mediante `in`. Por ejemplo, si quieres agregar un valor a diciembre o crear uno si no existe, puedes usar lo siguiente: 220 | 221 | ``` 222 | # El valor de december: 2.1cm 223 | 224 | # Si, 'december' existe en rainfall 225 | if 'december' in rainfall: 226 | # rainfall [en la posición december] es igual a 227 | # rainfall [en la posición december] + 1 (2.1+1) 228 | rainfall['december'] = rainfall['december'] + 1 229 | 230 | # Si no: 231 | else: 232 | 233 | # rainfall [en la posición december] es igual a 1 234 | rainfall['december'] = 1 235 | 236 | # Como december si existe, el valor será 3.1 237 | ``` 238 | ### Recuper todos los valores de un diccionario 239 | 240 | De forma similar a `keys()`, `values()` devuelve la lista de todos los valores de un diccionario sin sus claves correspondientes. Esto puede resultar útil cuando se usa la clave con fines de etiquetado, como en el ejemplo anterior, en el que las claves son el nombre del mes. Puedes usar `values()` para determinar el importe total de las precipitaciones: 241 | 242 | ``` 243 | #Total de precipitaciones 0 244 | total_rainfall = 0 245 | 246 | # Para cada valor en los valores de rainfall 247 | for value in rainfall.values(): 248 | 249 | # El total de las precipitaciones será igual a ese mismo + el valor que se está iterando 250 | 251 | total_rainfall = total_rainfall + value 252 | 253 | # Muestra 'Hay un total de precipitaciones (el valor total) en centímetros en el último cuarto (haciendo referencia al cuarto del año) 254 | 255 | print(f'There was {total_rainfall}cm in the last quarter') 256 | 257 | # Salida: 258 | # There was 10.8cm in the last quarter 259 | ``` 260 | 261 | ## Resumen 262 | 263 | La mayoría de los programas necesitan datos más complejos que los valores de cadena y número. En el escenario de este módulo, has intentado trabajar con información sobre los planetas del sistema solar. Esta información incluía propiedades como el número de lunas y la circunferencia. 264 | 265 | Mediante los diccionarios, has podido crear una variable para almacenar todos los datos relacionados. Después, has usado `keys` y `values` para interactuar directamente con los datos, sin utilizar nombres de clave para realizar cálculos. 266 | 267 | Los diccionarios de Python son objetos flexibles, lo que permite modelar datos complejos y relacionados. 268 | 269 | En este módulo, has aprendido a: 270 | 271 | * Identificar cuándo se debe usar un diccionario. 272 | * Crear y modificar datos dentro de un diccionario. 273 | * Usar métodos de diccionario para acceder a los datos del diccionario. 274 | 275 | --- 276 | 277 | Curso Propedútico de Python para Launch X - Innovacción Virtual. 278 | 279 | Material desarrollado con base en los contenidos de MSLearn y la metáfora de LaunchX, traducción e implementación por: Fernanda Ochoa - Learning Producer de LaunchX. 280 | 281 | Redes: 282 | * GitHub: [FernandaOchoa](https://github.com/FernandaOchoa) 283 | * Twitter: [@imonsh](https://twitter.com/imonsh) 284 | * Instagram: [fherz8a](https://www.instagram.com/fherz8a/) -------------------------------------------------------------------------------- /Módulo 8 - Administrar datos con diccionarios/Módulo8Katas.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# Ejercicio 1: Creación de diccionarios de Python" 8 | ] 9 | }, 10 | { 11 | "cell_type": "markdown", 12 | "metadata": {}, 13 | "source": [ 14 | "### Ejercicio: Crear y modificar un diccionario de Python\n", 15 | "\n", 16 | "Los diccionarios python te permiten modelar datos más complejos. Los diccionarios son una colección de pares clave/valor, y son muy comunes en los programas Python. Su flexibilidad le permite trabajar dinámicamente con valores relacionados sin tener que crear clases u objetos.\n", 17 | "\n", 18 | "Un diccionario se indica en Python mediante el uso de llaves (`{ }`), con pares clave/valor separados por dos puntos (`:`). Las claves son literales de cadena y los valores pueden ser de cualquier tipo de datos.{ }:\n", 19 | "\n", 20 | "```python\n", 21 | "demo = {\n", 22 | " 'key': 'value',\n", 23 | " 'number': 42\n", 24 | "}\n", 25 | "```\n", 26 | "\n", 27 | "Para este ejercicio, crearás un diccionario que almacene información sobre el planeta Marte.\n", 28 | "\n", 29 | "\n", 30 | "> **TIP**\n", 31 | "> Dedica unos minutos para tratar de encontrar una solución. Luego desplázate hacia abajo hasta la parte inferior para ver si has logrado compilar el programa de acuerdo con las especificaciones\n", 32 | "\n", 33 | "Agrega el código para crear un nuevo diccionario denominado 'planet'. Rellena con la siguiente información:\n", 34 | "\n", 35 | "```\n", 36 | "name: Mars\n", 37 | "moons: 2\n", 38 | "```" 39 | ] 40 | }, 41 | { 42 | "cell_type": "code", 43 | "execution_count": null, 44 | "metadata": {}, 45 | "outputs": [], 46 | "source": [ 47 | "# Crea un diccionario llamado planet con los datos propuestos" 48 | ] 49 | }, 50 | { 51 | "cell_type": "markdown", 52 | "metadata": {}, 53 | "source": [ 54 | "Para recuperar valores, puede utilizar el método `get` o corchetes (`[ ]`) con el nombre de la clave que desea recuperar." 55 | ] 56 | }, 57 | { 58 | "cell_type": "code", 59 | "execution_count": null, 60 | "metadata": {}, 61 | "outputs": [], 62 | "source": [ 63 | "# Muestra el nombre del planeta y el número de lunas que tiene." 64 | ] 65 | }, 66 | { 67 | "cell_type": "markdown", 68 | "metadata": {}, 69 | "source": [ 70 | "Puedes actualizar las claves existentes o crear otras nuevas utilizando el método `update` o entre corchetes (`[ ]`). Cuando se usa `update`, se pasa un nuevo objeto de diccionario con los valores actualizados o nuevos. Cuando se usan corchetes, se especifica el nombre de la clave y se asigna un nuevo valor.\n", 71 | "\n", 72 | "\n", 73 | "```python\n", 74 | "demo['new_key'] = 'New value'\n", 75 | "```\n", 76 | "\n", 77 | "Agrega un nuevo valor con una clave de 'circunferencia (km)'. Este nuevo valor debería almacenar un diccionario con las dos circunferencias del planeta:\n", 78 | "\n", 79 | "```\n", 80 | "polar: 6752\n", 81 | "equatorial: 6792\n", 82 | "```\n" 83 | ] 84 | }, 85 | { 86 | "cell_type": "code", 87 | "execution_count": null, 88 | "metadata": {}, 89 | "outputs": [], 90 | "source": [ 91 | "# Agrega la clave circunferencia con los datos proporcionados previamente" 92 | ] 93 | }, 94 | { 95 | "cell_type": "markdown", 96 | "metadata": {}, 97 | "source": [ 98 | "Imprime el nombre del planeta con su circunferencia polar." 99 | ] 100 | }, 101 | { 102 | "cell_type": "code", 103 | "execution_count": null, 104 | "metadata": {}, 105 | "outputs": [], 106 | "source": [ 107 | "# Imprime el nombre del planeta con su circunferencia polar." 108 | ] 109 | }, 110 | { 111 | "cell_type": "markdown", 112 | "metadata": {}, 113 | "source": [ 114 | "> Recuerda: Lo importante es intentarlo, puedes auxiliarte de internet, libros, etc. El objetivo de una kata es la comprobación de la comprensión de la lección y su aplicación inmediata a la resolución de problemas. Go for it!" 115 | ] 116 | }, 117 | { 118 | "cell_type": "markdown", 119 | "metadata": {}, 120 | "source": [ 121 | "## Ejercicio 2: Programación dinámica con diccionarios" 122 | ] 123 | }, 124 | { 125 | "cell_type": "markdown", 126 | "metadata": {}, 127 | "source": [ 128 | "### Ejercicio: Cálculo de valores\n", 129 | "En este escenario, calcularás tanto el número total de lunas en el sistema solar como el número promedio de lunas que tiene un planeta." 130 | ] 131 | }, 132 | { 133 | "cell_type": "code", 134 | "execution_count": null, 135 | "metadata": {}, 136 | "outputs": [], 137 | "source": [ 138 | "# Planets and moons\n", 139 | "\n", 140 | "planet_moons = {\n", 141 | " 'mercury': 0,\n", 142 | " 'venus': 0,\n", 143 | " 'earth': 1,\n", 144 | " 'mars': 2,\n", 145 | " 'jupiter': 79,\n", 146 | " 'saturn': 82,\n", 147 | " 'uranus': 27,\n", 148 | " 'neptune': 14,\n", 149 | " 'pluto': 5,\n", 150 | " 'haumea': 2,\n", 151 | " 'makemake': 1,\n", 152 | " 'eris': 1\n", 153 | "}" 154 | ] 155 | }, 156 | { 157 | "cell_type": "markdown", 158 | "metadata": {}, 159 | "source": [ 160 | "Los diccionarios de Python te permiten recuperar todos los valores y claves utilizando los métodos `values` y `keys`, respectivamente. Cada método devuelve una lista que contiene los datos, que luego se puede usar como una lista normal de Python. Puedes determinar el número de elementos mediante `len`, e iterar a través de él mediante un ciclo `for`.\n", 161 | "\n", 162 | "Agrega el código a continuación para determinar el número de lunas. Comienza almacenando el valor `values` de `planet_moons` en una variable denominada `moons`. A continuación, almacena el número de planetas en una variable denominada `planets`.\n" 163 | ] 164 | }, 165 | { 166 | "cell_type": "code", 167 | "execution_count": null, 168 | "metadata": {}, 169 | "outputs": [], 170 | "source": [ 171 | "# Añade el código para determinar el número de lunas." 172 | ] 173 | }, 174 | { 175 | "cell_type": "markdown", 176 | "metadata": {}, 177 | "source": [ 178 | "Agrega el código para contar el número de lunas. Puedes hacerlo creando un ciclo `for` para iterar a través de las lunas `moons` y agregándolos a una variable denominada `total_moons`. Finalmente calcule el promedio dividiendo `total_moons` por `planets` e imprimiendo los resultados." 179 | ] 180 | }, 181 | { 182 | "cell_type": "code", 183 | "execution_count": null, 184 | "metadata": {}, 185 | "outputs": [], 186 | "source": [ 187 | "# Agrega el código para contar el número de lunas. " 188 | ] 189 | }, 190 | { 191 | "cell_type": "markdown", 192 | "metadata": {}, 193 | "source": [ 194 | "## Soluciones" 195 | ] 196 | }, 197 | { 198 | "cell_type": "markdown", 199 | "metadata": {}, 200 | "source": [ 201 | "### Ejercicio 1:" 202 | ] 203 | }, 204 | { 205 | "cell_type": "code", 206 | "execution_count": null, 207 | "metadata": {}, 208 | "outputs": [], 209 | "source": [ 210 | "# Crea un diccionario llamado planet con los datos propuestos\n", 211 | "\n", 212 | "planet = {\n", 213 | " 'name': 'Mars',\n", 214 | " 'moons': 2\n", 215 | "}" 216 | ] 217 | }, 218 | { 219 | "cell_type": "code", 220 | "execution_count": null, 221 | "metadata": {}, 222 | "outputs": [], 223 | "source": [ 224 | "# Muestra el nombre del planeta y el número de lunas que tiene.\n", 225 | "\n", 226 | "print(f'{planet[\"name\"]} has {planet[\"moons\"]} moons')" 227 | ] 228 | }, 229 | { 230 | "cell_type": "code", 231 | "execution_count": null, 232 | "metadata": {}, 233 | "outputs": [], 234 | "source": [ 235 | "# Agrega la clave circunferencia con los datos proporcionados previamente\n", 236 | "\n", 237 | "planet['circumference (km)'] = {\n", 238 | " 'polar': 6752,\n", 239 | " 'equatorial': 6792\n", 240 | "}" 241 | ] 242 | }, 243 | { 244 | "cell_type": "code", 245 | "execution_count": null, 246 | "metadata": {}, 247 | "outputs": [], 248 | "source": [ 249 | "# Imprime el nombre del planeta con su circunferencia polar.\n", 250 | "\n", 251 | "print(f'{planet[\"name\"]} has a polar circumference of {planet[\"circumference (km)\"][\"polar\"]}')" 252 | ] 253 | }, 254 | { 255 | "cell_type": "markdown", 256 | "metadata": {}, 257 | "source": [ 258 | "### Ejercicio 2" 259 | ] 260 | }, 261 | { 262 | "cell_type": "code", 263 | "execution_count": null, 264 | "metadata": {}, 265 | "outputs": [], 266 | "source": [ 267 | "# Añade el código para determinar el número de lunas.\n", 268 | "\n", 269 | "# Obtenemos la lista de las lunas\n", 270 | "# Almacenamos los resultados en una variable moons\n", 271 | "moons = planet_moons.values()\n", 272 | "\n", 273 | "# Obtenemos el total de planetas\n", 274 | "# Almacenamos los resultados en una variable llamada years\n", 275 | "planets = len(planet_moons.keys())" 276 | ] 277 | }, 278 | { 279 | "cell_type": "code", 280 | "execution_count": null, 281 | "metadata": {}, 282 | "outputs": [], 283 | "source": [ 284 | "# Calcula el total_moons agregando todas las lunas\n", 285 | "# Almacena su valor en una variable llamada total_moons\n", 286 | "\n", 287 | "total_moons = 0\n", 288 | "for moon in moons:\n", 289 | " total_moons = total_moons + moon\n", 290 | "\n", 291 | "# Calcula el promedio dividiendo el total_moons por el número de planetas\n", 292 | "average = total_moons / planets\n", 293 | "\n", 294 | "# Muestra el promedio\n", 295 | "print(average)" 296 | ] 297 | }, 298 | { 299 | "cell_type": "markdown", 300 | "metadata": {}, 301 | "source": [ 302 | "---\n", 303 | "\n", 304 | "Curso Propedútico de Python para Launch X - Innovacción Virtual.\n", 305 | "\n", 306 | "Material desarrollado con base en los contenidos de MSLearn y la metáfora de LaunchX, traducción e implementación por: Fernanda Ochoa - Learning Producer de LaunchX.\n", 307 | "\n", 308 | "Redes:\n", 309 | "* GitHub: [FernandaOchoa](https://github.com/FernandaOchoa)\n", 310 | "* Twitter: [@imonsh](https://twitter.com/imonsh)\n", 311 | "* Instagram: [fherz8a](https://www.instagram.com/fherz8a/)" 312 | ] 313 | } 314 | ], 315 | "metadata": { 316 | "interpreter": { 317 | "hash": "916dbcbb3f70747c44a77c7bcd40155683ae19c65e1c03b4aa3499c5328201f1" 318 | }, 319 | "kernelspec": { 320 | "display_name": "Python 3.8.10 64-bit", 321 | "name": "python3" 322 | }, 323 | "language_info": { 324 | "codemirror_mode": { 325 | "name": "ipython", 326 | "version": 3 327 | }, 328 | "file_extension": ".py", 329 | "mimetype": "text/x-python", 330 | "name": "python", 331 | "nbconvert_exporter": "python", 332 | "pygments_lexer": "ipython3", 333 | "version": "3.9.5" 334 | }, 335 | "nteract": { 336 | "version": "nteract-front-end@1.0.0" 337 | }, 338 | "orig_nbformat": 4 339 | }, 340 | "nbformat": 4, 341 | "nbformat_minor": 2 342 | } 343 | -------------------------------------------------------------------------------- /Módulo 9 - Funciones/Módulo 9 - Funciones.md: -------------------------------------------------------------------------------- 1 | # Introducción 2 | 3 | El uso de una función de Python es el primer paso para codificar después de las estructuras de datos y los condicionales básicos. Las funciones permiten la reutilización, lo que evita la duplicación de código. Cuando los proyectos reutilizan código con funciones, se vuelven más legibles y fáciles de mantener. 4 | 5 | ## Escenario: Organización de datos sobre un cohete 6 | 7 | Imagina que vas a crear un programa para construir información precisa sobre un cohete espacial. Las funciones reutilizables te permitirán no solo calcular información, sino también crear valores combinando entradas y salidas de otras funciones. 8 | 9 | ## ¿Qué descubrirás? 10 | En este módulo, aprenderás a: 11 | 12 | * Trabajar con entradas predeterminadas, obligatorias y de carácter comodín. 13 | * Hacer que el código sea reutilizable extrayendo patrones comunes en funciones independientes. 14 | * Devolver valores, estructuras de datos o resultados calculados. 15 | 16 | ## ¿Cuál es el objetivo principal? 17 | Al final de este módulo, comprenderás algunas de las reglas y el comportamiento asociado a las funciones, incluida la forma de controlar las entradas y salidas. 18 | 19 | --- 20 | 21 | ## Aspectos básicos de las funciones de Python 22 | 23 | Las funciones son el siguiente paso después de haber aprendido los conceptos básicos de programación de Python. En su forma más sencilla, una función contiene código que siempre devuelve un valor (o valores). En algunos casos, una función también tiene entradas opcionales u obligatorias. 24 | 25 | Al empezar a escribir código que duplica otras partes del programa, se convierte en una oportunidad perfecta para extraer el código en una función. Aunque compartir código común mediante funciones es útil, también se puede limitar el tamaño del código extrayendo partes en funciones más pequeñas (y legibles). 26 | 27 | Los programas que evitan la duplicación y evitan funciones de gran tamaño mediante funciones más pequeñas son más legibles y fáciles de mantener. También son más fáciles de depurar cuando las cosas no funcionan correctamente. 28 | 29 | Hay varias reglas sobre las entradas de funciones que son fundamentales para aprovechar al máximo todo lo que las funciones tienen que ofrecer. 30 | 31 | *Aunque se usa el término entrada para describir las funciones que se aceptan, estos elementos normalmente se denominan argumentos y/o parámetros. Para mantener la coherencia en este módulo, a las entradas las denominaremos argumentos.* 32 | 33 | ### Funciones sin argumentos 34 | Para crear una función, utilizamos la palabra clave `def`, seguida de un nombre, paréntesis y, después, del cuerpo con el código de función: 35 | 36 | ``` 37 | # Defino mi función 38 | def rocket_parts(): 39 | print('payload, propellant, structure') 40 | ``` 41 | 42 | En este caso, rocket_parts es el nombre de la función. Ese nombre va seguido de paréntesis vacíos, que indican que no se necesitan argumentos. El último es el código, con sangría de cuatro espacios. Para trabajar con la función, debes llamarla por su nombre usando paréntesis: 43 | 44 | ``` 45 | # Llamo a mi función 46 | 47 | >>> rocket_parts() 48 | 'payload, propellant, structure' 49 | ``` 50 | 51 | La función rocket_parts() no toma ningún argumento e imprime una instrucción sobre la gravedad. Si necesitas usar un valor que devuelve una función, puedes asignar la salida de la función a una variable: 52 | 53 | ``` 54 | >>> output = rocket_parts() 55 | payload, propellant, structure 56 | 57 | >>> output is None 58 | True 59 | ``` 60 | 61 | Puede parecer sorprendente que el valor de la variable output sea None. Esto se debe a que la función rocket_parts() no ha devuelto explícitamente un valor. En Python, si una función no devuelve explícitamente un valor, devuelve implícitamente None. Actualizar la función para devolver la cadena en lugar de imprimirla hace que la variable output tenga un valor distinto: 62 | 63 | ``` 64 | >>> def rocket_parts(): 65 | ... return 'payload, propellant, structure' 66 | ... 67 | >>> output = rocket_parts() 68 | >>> output 69 | 'payload, propellant, structure' 70 | ``` 71 | Si necesitas usar el valor de una función, esa función debe devolver el valor explícitamente. De lo contrario; se devolverá `None`. 72 | 73 | *No es necesario asignar siempre la devolución de una función. En la mayoría de los casos en los que una función no devuelve un valor (o valores) explícitamente, significa que no es necesario asignar ni usar el valor implícito `None` que se devuelve.* 74 | 75 | ### Argumentos opcionales y requeridos 76 | En Python, varias funciones integradas requieren argumentos. Algunas funciones integradas hacen que los argumentos sean opcionales. Las funciones integradas están disponibles de inmediato, por lo que no es necesario importarlas explícitamente. 77 | 78 | Un ejemplo de una función integrada que requiere un argumento es `any()`. Esta función toma un objeto iterable (por ejemplo, una lista) y devuelve `True` si algún elemento del objeto iterable es `True`. De lo contrario, devuelve `False`. 79 | 80 | ``` 81 | >>> any([True, False, False]) 82 | True 83 | >>> any([False, False, False]) 84 | False 85 | ``` 86 | 87 | Si llamamos a `any()` sin ningún argumento, se genera una excepción útil. El mensaje de error explica que necesita al menos un argumento: 88 | 89 | ``` 90 | >>> any() 91 | Traceback (most recent call last): 92 | File '', line 1, in 93 | TypeError: any() takes exactly one argument (0 given) 94 | ``` 95 | 96 | Puedes comprobar que algunas funciones permiten el uso de argumentos opcionales mediante otra función integrada denominada `str()`. Esta función crea una cadena a partir de un argumento. Si no se pasa ningún argumento, devuelve una cadena vacía: 97 | 98 | ``` 99 | >>> str() 100 | '' 101 | >>> str(15) 102 | '15' 103 | ``` 104 | 105 | ## Uso de argumentos en una función de Python 106 | 107 | Ahora que sabes cómo crear una función sin entradas, el paso siguiente es crear funciones que requieran un argumento. El uso de argumentos hace que las funciones sean más flexibles, ya que pueden hacer más y condicionalizar lo que hacen. 108 | 109 | ### Exigencia de un argumento 110 | Si vas a pilotar un cohete, una función sin entradas obligatorias es como un equipo con un botón que le indique la hora. Si presionas el botón, una voz computarizada le indicará la hora. Pero una entrada necesaria puede ser un destino para calcular la distancia del viaje. Las entradas obligatorias se denominan *argumentos* para la función. 111 | 112 | Para requerir un argumento, agrégalo entre paréntesis: 113 | 114 | ``` 115 | def distance_from_earth(destination): 116 | if destination == 'Moon': 117 | return '238,855' 118 | else: 119 | return 'Unable to compute to that destination' 120 | ``` 121 | Intenta llamar a la función distance_from_earth() sin argumento alguno: 122 | 123 | ``` 124 | >>> distance_from_earth() 125 | Traceback (most recent call last): 126 | File '', line 1, in 127 | TypeError: distance_from_earth() missing 1 required positional argument: 'destination' 128 | ``` 129 | 130 | Python genera `TypeError` con un mensaje de error que indica que la función requiere un argumento denominado destination. Si se pide al equipo del cohete que calcule la distancia del viaje con un destino, debes solicitar que un destino es un requisito. El código de ejemplo tiene dos rutas de acceso para una respuesta, una para la Luna y la otra para cualquier otra cosa. Use la Luna como entrada para obtener una respuesta: 131 | 132 | ``` 133 | >>> distance_from_earth('Moon') 134 | '238,855' 135 | ``` 136 | 137 | Dado que hay una condición catch-all, intenta usar cualquier otra cadena como destino para comprobar ese comportamiento: 138 | 139 | ``` 140 | >>> distance_from_earth('Saturn') 141 | 'Unable to compute to that destination' 142 | ``` 143 | 144 | ### Varios argumentos necesarios 145 | Para usar varios argumentos, debes separarlos con una coma. Vamos a crear una función que pueda calcular cuántos días se tardarán en llegar a un destino, dadas la distancia y una velocidad constante: 146 | 147 | ``` 148 | def days_to_complete(distance, speed): 149 | hours = distance/speed 150 | return hours/24 151 | ``` 152 | 153 | Ahora usa la distancia entre la Tierra y la Luna para calcular cuántos días tardaría en llegar a la Luna con un límite de velocidad común de 120 kilómetros por hora: 154 | 155 | ``` 156 | >>> days_to_complete(238855, 75) 157 | 132.69722222222222 158 | ``` 159 | ### Funciones como argumentos 160 | Puedes usar el valor de la función days_to_complete() y asignarlo a una variable y, después, pasarlo a round() (una función integrada que redondea al número entero más cercano) para obtener un número entero: 161 | 162 | ``` 163 | >>> total_days = days_to_complete(238855, 75) 164 | >>> round(total_days) 165 | 133 166 | ``` 167 | Pero un patrón útil es pasar funciones a otras funciones en lugar de asignar el valor devuelto: 168 | 169 | ``` 170 | >>> round(days_to_complete(238855, 75)) 171 | 133 172 | ``` 173 | 174 | **Sugerencia** 175 | 176 | Aunque pasar funciones directamente a otras funciones como entrada es útil, existe la posibilidad de que se reduzca la legibilidad. Este patrón es especialmente problemático cuando las funciones requieren muchos argumentos. 177 | 178 | ## Uso de argumentos de palabra clave en Python 179 | 180 | Los argumentos opcionales requieren un valor predeterminado asignado a ellos. Estos argumentos con nombre se denominan *argumentos de palabra clave*. Los valores del argumento de palabra clave deben definirse en las propias funciones. Cuando se llama a una función definida con argumentos de palabra clave, no es necesario usarlos en absoluto. 181 | 182 | La misión Apolo 11 tardó unas 51 horas en llegar a la Luna. Vamos a crear una función que devuelva la hora estimada de llegada usando el mismo valor que la misión Apolo 11 como valor predeterminado: 183 | 184 | ``` 185 | from datetime import timedelta, datetime 186 | 187 | def arrival_time(hours=51): 188 | now = datetime.now() 189 | arrival = now + timedelta(hours=hours) 190 | return arrival.strftime('Arrival: %A %H:%M') 191 | ``` 192 | 193 | La función usa el módulo `datetime` para definir la hora actual. Usa `timedelta` para permitir la operación de suma que da como resultado un objeto de hora nuevo. Después de calcular ese resultado, devuelve la estimación `arrival` con formato de cadena. Intentando llamarla sin algún argumento: 194 | 195 | ``` 196 | >>> arrival_time() 197 | 'Arrival: Saturday 16:42' 198 | ``` 199 | 200 | Aunque la función define un argumento de palabra clave, no permite pasar uno cuando se llama a una función. En este caso, la variable `hours` tiene como valor predeterminado `51`. Para comprobar que la fecha actual es correcta, usamos `0` como valor para `hours`: 201 | 202 | ``` 203 | >>> arrival_time(hours=0) 204 | 'Arrival: Thursday 13:42' 205 | ``` 206 | 207 | ### Combinación de argumentos y argumentos de palabra clave 208 | 209 | A veces, una función necesita una combinación de argumentos de palabra clave y argumentos. En Python, esta combinación sigue un orden específico. Los argumentos siempre se declaran primero, seguidos de argumentos de palabra clave. 210 | 211 | Actualizando la función `arrival_time()` para que tome un argumento necesario, que es el nombre del destino: 212 | 213 | ``` 214 | from datetime import timedelta, datetime 215 | 216 | def arrival_time(destination, hours=51): 217 | now = datetime.now() 218 | arrival = now + timedelta(hours=hours) 219 | return arrival.strftime(f'{destination} Arrival: %A %H:%M') 220 | ``` 221 | 222 | Dado que hemos agregado un argumento necesario, ya no es posible llamar a la función sin ningún argumento: 223 | 224 | 225 | ``` 226 | >>> arrival_time() 227 | Traceback (most recent call last): 228 | File '', line 1, in 229 | TypeError: arrival_time() missing 1 required positional argument: 'destination' 230 | ``` 231 | Usamos 'Moon' como valor para destination a fin de evitar el error: 232 | 233 | ``` 234 | >>> arrival_time('Moon') 235 | 'Moon Arrival: Saturday 16:54' 236 | ``` 237 | También podemos pasar más de dos valores, pero debemos separarlos con una coma. Se tarda aproximadamente 8 minutos (0,13 horas) en entrar en órbita, así que utilizaremos eso como argumento: 238 | 239 | ``` 240 | >>> arrival_time('Orbit', hours=0.13) 241 | 'Orbit Arrival: Thursday 14:11' 242 | ``` 243 | 244 | ## Uso de argumentos de variable en Python 245 | 246 | En Python, puedes usar cualquier número de argumentos de palabra clave y argumentos sin necesidad de declarar cada uno de ellos. Esta capacidad es útil cuando una función puede obtener un número desconocido de entradas. 247 | 248 | ### Argumentos de variable 249 | Los argumentos en las funciones son necesarios. Pero cuando se usan argumentos de variable, la función permite pasar cualquier número de argumentos (incluido `0`). La sintaxis para usar argumentos de variable es agregar un asterisco único como prefijo (`*`) antes del nombre del argumento. 250 | 251 | La función siguiente imprime los argumentos recibidos: 252 | 253 | ``` 254 | def variable_length(*args): 255 | print(args) 256 | ``` 257 | *No es necesario denominar a los argumentos de variable `args`. Puedes usar cualquier nombre de variable válido. Aunque es habitual ver *args o *a, debe intentar usar la misma convención en un proyecto.* 258 | 259 | En este caso, `*args` indica a la función que acepta cualquier número de argumentos (incluido `0`). En la función, `args` ahora está disponible como la variable que contiene todos los argumentos como una tupla. Pruebe la función pasando cualquier número o tipo de argumentos: 260 | 261 | ``` 262 | >>> variable_length() 263 | () 264 | >>> variable_length('one', 'two') 265 | ('one', 'two') 266 | >>> variable_length(None) 267 | (None,) 268 | ``` 269 | Como puedes ver, no hay ninguna restricción en el número o tipo de argumentos que se pasan. 270 | 271 | Un cohete realiza varios pasos antes de un lanzamiento. En función de las tareas o retrasos, estos pasos pueden tardar más de lo previsto. Vamos a crear una función de longitud variable que pueda calcular cuántos minutos quedan hasta el inicio, dado el tiempo que va a tardar cada paso: 272 | 273 | ``` 274 | def sequence_time(*args): 275 | total_minutes = sum(args) 276 | if total_minutes < 60: 277 | return f'Total time to launch is {total_minutes} minutes' 278 | else: 279 | return f'Total time to launch is {total_minutes/60} hours' 280 | ``` 281 | Probamos la función pasando cualquier número de minutos: 282 | 283 | ``` 284 | >>> sequence_time(4, 14, 18) 285 | 'Total time to launch is 36 minutes' 286 | >>> sequence_time(4, 14, 48) 287 | 'Total time to launch is 1.1 hours' 288 | ``` 289 | *Cuando se utilizan argumentos de variable, a cada valor ya no se le asigna un nombre de variable. Todos los valores ahora forman parte del nombre de variable catch-all que usa el asterisco (en estos ejemplos, args).* 290 | 291 | ### Argumentos de palabra clave variable 292 | Para que una función acepte cualquier número de argumentos de palabra clave, debe usar una sintaxis similar. En este caso, se requiere un asterisco doble: 293 | 294 | ``` 295 | def variable_length(**kwargs): 296 | print(kwargs) 297 | ``` 298 | 299 | Prueba la función de ejemplo, que imprime los nombres y valores pasados como `kwargs`: 300 | ``` 301 | >>> variable_length(tanks=1, day='Wednesday', pilots=3) 302 | {'tanks': 1, 'day': 'Wednesday', 'pilots': 3} 303 | ``` 304 | 305 | Si ya conoces bien los diccionarios de Python, observarás que los argumentos de palabra clave de longitud variable se asignan como un diccionario. Para interactuar con las variables y los valores, usamos las mismas operaciones que un diccionario. 306 | 307 | *Al igual que con los argumentos de variable, no es necesario usar kwargs cuando se usan argumentos de palabra clave variable. Puede usar cualquier nombre de variable válido. Aunque es habitual ver **kwargs o **kw, debe intentar usar la misma convención en un proyecto.* 308 | 309 | En esta función, vamos a usar argumentos de palabra clave variable para notificar los astronautas asignados a la misión. Dado que esta función permite cualquier número de argumentos de palabra clave, se puede reutilizar independientemente del número de astronautas asignados: 310 | 311 | ``` 312 | def crew_members(**kwargs): 313 | print(f'{len(kwargs)} astronauts assigned for this mission:') 314 | for title, name in kwargs.items(): 315 | print(f'{title}: {name}') 316 | ``` 317 | 318 | Probando con la tripulación del Apolo 11: 319 | ``` 320 | >>> crew_members(captain='Neil Armstrong', pilot='Buzz Aldrin', command_pilot='Michael Collins') 321 | 3 astronauts assigned for this mission: 322 | captain: Neil Armstrong 323 | pilot: Buzz Aldrin 324 | command_pilot: Michael Collins 325 | ``` 326 | 327 | Dado que puede pasar cualquier combinación de argumentos de palabra clave, nos aseguramos de evitar palabras clave repetidas. Las palabras clave repetidas producirán un error: 328 | 329 | ``` 330 | >>> crew_members(captain='Neil Armstrong', pilot='Buzz Aldrin', pilot='Michael Collins') 331 | File '', line 1 332 | SyntaxError: keyword argument repeated: pilot 333 | ``` 334 | 335 | --- 336 | ## Resumen 337 | 338 | Las funciones de Python permiten escribir código modular y reutilizable, calcular valores y realizar acciones basadas en el contexto. En este módulo, ha obtenido información sobre algunas de las reglas y el comportamiento asociados a las funciones. Estas reglas incluían enfrentarse a entradas y salidas. Por último, ha tenido la oportunidad de extraer y mejorar el código para que sea más legible y fácil de mantener. 339 | 340 | Ahora conoces aspectos esenciales como estos sobre las funciones: 341 | 342 | * Las funciones pueden requerir argumentos o convertirlos en opcionales. 343 | * Puedes extraer código reutilizable y reutilizarlo en una función. 344 | * Los argumentos de variable y los argumentos de palabra clave de variable son útiles cuando no se conocen las entradas exactas. 345 | * Con estas técnicas y el conocimiento de las funciones, deberías sentirse más cómodo abordando problemas más grandes al escribir código de Python. 346 | 347 | --- 348 | 349 | Curso Propedútico de Python para Launch X - Innovacción Virtual. 350 | 351 | Material desarrollado con base en los contenidos de MSLearn y la metáfora de LaunchX, traducción e implementación por: Fernanda Ochoa - Learning Producer de LaunchX. 352 | 353 | Redes: 354 | * GitHub: [FernandaOchoa](https://github.com/FernandaOchoa) 355 | * Twitter: [@imonsh](https://twitter.com/imonsh) 356 | * Instagram: [fherz8a](https://www.instagram.com/fherz8a/) -------------------------------------------------------------------------------- /Módulo 9 - Funciones/Módulo9Katas.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# Ejercicio: Uso de funciones en Python" 8 | ] 9 | }, 10 | { 11 | "cell_type": "markdown", 12 | "metadata": {}, 13 | "source": [ 14 | "### Ejercicio 1: Trabajar con argumentos en funciones\n", 15 | "\n", 16 | "Los argumentos requeridos en las funciones se utilizan cuando las funciones necesitan que esos argumentos funcionen correctamente. En este ejercicio, construirás un informe de combustible que requiere información de varias ubicaciones de combustible en todo el cohete.\n", 17 | "\n" 18 | ] 19 | }, 20 | { 21 | "cell_type": "markdown", 22 | "metadata": {}, 23 | "source": [ 24 | "> **TIP**\n", 25 | "> Dedica unos minutos para tratar de encontrar una solución. Luego desplázate hacia abajo hasta la parte inferior para ver si has logrado compilar el programa de acuerdo con las especificaciones\n", 26 | "\n", 27 | "Comienza por crear una función que necesite tres lecturas de combustible y devuelva un informe:" 28 | ] 29 | }, 30 | { 31 | "cell_type": "code", 32 | "execution_count": null, 33 | "metadata": {}, 34 | "outputs": [], 35 | "source": [ 36 | "# Función para leer 3 tanques de combustible y muestre el promedio\n" 37 | ] 38 | }, 39 | { 40 | "cell_type": "markdown", 41 | "metadata": {}, 42 | "source": [ 43 | "Ahora que hemos definido la función de informes, vamos a comprobarlo. Para esta misión, los tanques no están llenos:" 44 | ] 45 | }, 46 | { 47 | "cell_type": "code", 48 | "execution_count": null, 49 | "metadata": {}, 50 | "outputs": [], 51 | "source": [ 52 | "\n", 53 | "# Llamamos a la función que genera el reporte print(funcion(tanque1, tanque2, tanque3))" 54 | ] 55 | }, 56 | { 57 | "cell_type": "markdown", 58 | "metadata": {}, 59 | "source": [ 60 | "En lugar de simplemente crear el informe, la función también está calculando el promedio. Mejora la legibilidad extrayendo el cálculo promedio de la función en una nueva función para que el promedio se pueda hacer de forma independiente:" 61 | ] 62 | }, 63 | { 64 | "cell_type": "code", 65 | "execution_count": null, 66 | "metadata": {}, 67 | "outputs": [], 68 | "source": [ 69 | "# Función promedio " 70 | ] 71 | }, 72 | { 73 | "cell_type": "markdown", 74 | "metadata": {}, 75 | "source": [ 76 | "Ahora actualiza la función de informes para llamando a la nueva función del promedio:\n" 77 | ] 78 | }, 79 | { 80 | "cell_type": "code", 81 | "execution_count": null, 82 | "metadata": {}, 83 | "outputs": [], 84 | "source": [ 85 | "# Actualiza la función" 86 | ] 87 | }, 88 | { 89 | "cell_type": "markdown", 90 | "metadata": {}, 91 | "source": [ 92 | "> Recuerda: Lo importante es intentarlo, puedes auxiliarte de internet, libros, etc. El objetivo de una kata es la comprobación de la comprensión de la lección y su aplicación inmediata a la resolución de problemas. Go for it!" 93 | ] 94 | }, 95 | { 96 | "cell_type": "markdown", 97 | "metadata": {}, 98 | "source": [ 99 | "## Ejercicio 2: Trabajo con argumentos de palabra clave" 100 | ] 101 | }, 102 | { 103 | "cell_type": "markdown", 104 | "metadata": {}, 105 | "source": [ 106 | "### Ejercicio : Trabajar con argumentos de palabras clave en funciones\n", 107 | "En este ejercicio, construirás un informe de cohete que requiere varias piezas de información, como el tiempo hasta el destino, el combustible a la izquierda y el nombre del destino. Comienza por crear una función que creará un informe preciso de la misión:" 108 | ] 109 | }, 110 | { 111 | "cell_type": "code", 112 | "execution_count": null, 113 | "metadata": {}, 114 | "outputs": [], 115 | "source": [ 116 | "# Función con un informe preciso de la misión. Considera hora de prelanzamiento, tiempo de vuelo, destino, tanque externo y tanque interno" 117 | ] 118 | }, 119 | { 120 | "cell_type": "markdown", 121 | "metadata": {}, 122 | "source": [ 123 | "La función es problemática porque no se puede adaptar para minutos adicionales o tanques adicionales de combustible. Hazlo más flexible permitiendo cualquier número de pasos basados en el tiempo y cualquier número de tanques. En lugar de usar `*args` y `**kwargs`, aprovecha el hecho de que puedes usar cualquier nombre que desees. Asegurate que la función sea más legible mediante el uso de nombres de variables que están asociados con las entradas, como `*minutes` y `**fuel_reservoirs`:" 124 | ] 125 | }, 126 | { 127 | "cell_type": "code", 128 | "execution_count": null, 129 | "metadata": {}, 130 | "outputs": [], 131 | "source": [ 132 | "# Escribe tu nueva función de reporte considerando lo anterior" 133 | ] 134 | }, 135 | { 136 | "cell_type": "markdown", 137 | "metadata": {}, 138 | "source": [ 139 | "Debido a que el combustible que queda en los tanques es específico de cada tanque, actualiza la función para usar el nombre de cada tanque en el informe:" 140 | ] 141 | }, 142 | { 143 | "cell_type": "code", 144 | "execution_count": null, 145 | "metadata": {}, 146 | "outputs": [], 147 | "source": [ 148 | "# Escribe tu nueva función" 149 | ] 150 | }, 151 | { 152 | "cell_type": "markdown", 153 | "metadata": {}, 154 | "source": [ 155 | "## Soluciones" 156 | ] 157 | }, 158 | { 159 | "cell_type": "markdown", 160 | "metadata": {}, 161 | "source": [ 162 | "## Ejercicio 1" 163 | ] 164 | }, 165 | { 166 | "cell_type": "code", 167 | "execution_count": null, 168 | "metadata": {}, 169 | "outputs": [], 170 | "source": [ 171 | "# Función para leer 3 tanques de combustible y muestre el promedio\n", 172 | "\n", 173 | "def generate_report(main_tank, external_tank, hydrogen_tank):\n", 174 | " total_average = (main_tank + external_tank + hydrogen_tank) / 3\n", 175 | " return f\"\"\"Fuel Report:\n", 176 | " Total Average: {total_average}%\n", 177 | " Main tank: {main_tank}%\n", 178 | " External tank: {external_tank}%\n", 179 | " Hydrogen tank: {hydrogen_tank}% \n", 180 | " \"\"\"\n" 181 | ] 182 | }, 183 | { 184 | "cell_type": "code", 185 | "execution_count": null, 186 | "metadata": {}, 187 | "outputs": [], 188 | "source": [ 189 | "# Llamamos a la función que genera el reporte print(funcion(tanque1, tanque2, tanque3))\n", 190 | "print(generate_report(80, 70, 85))" 191 | ] 192 | }, 193 | { 194 | "cell_type": "code", 195 | "execution_count": null, 196 | "metadata": {}, 197 | "outputs": [], 198 | "source": [ 199 | "# Función promedio \n", 200 | "def average(values):\n", 201 | " total = sum(values)\n", 202 | " number_of_items = len(values)\n", 203 | " return total / number_of_items\n", 204 | "\n", 205 | "# Test the averaging function with a list of integers:\n", 206 | "average([80, 85, 81]) " 207 | ] 208 | }, 209 | { 210 | "cell_type": "code", 211 | "execution_count": null, 212 | "metadata": {}, 213 | "outputs": [], 214 | "source": [ 215 | "# Actualiza la función\n", 216 | "def generate_report(main_tank, external_tank, hydrogen_tank):\n", 217 | " return f\"\"\"Fuel Report:\n", 218 | " Total Average: {average([main_tank, external_tank, hydrogen_tank])}%\n", 219 | " Main tank: {main_tank}%\n", 220 | " External tank: {external_tank}%\n", 221 | " Hydrogen tank: {hydrogen_tank}% \n", 222 | " \"\"\"\n", 223 | "\n", 224 | "# Call the updated function again with different values\n", 225 | "print(generate_report(88, 76, 70))" 226 | ] 227 | }, 228 | { 229 | "cell_type": "markdown", 230 | "metadata": {}, 231 | "source": [ 232 | "### Ejercicio 2:" 233 | ] 234 | }, 235 | { 236 | "cell_type": "code", 237 | "execution_count": null, 238 | "metadata": {}, 239 | "outputs": [], 240 | "source": [ 241 | "# Función con un informe preciso de la misión. Considera hora de prelanzamiento, tiempo de vuelo, destino, tanque externo y tanque interno\n", 242 | "\n", 243 | "def mission_report(pre_launch_time, flight_time, destination, external_tank, main_tank):\n", 244 | " return f\"\"\"\n", 245 | " Mission to {destination}\n", 246 | " Total travel time: {pre_launch_time + flight_time} minutes\n", 247 | " Total fuel left: {external_tank + main_tank} gallons\n", 248 | " \"\"\"\n", 249 | "\n", 250 | "print(mission_report(14, 51, \"Moon\", 200000, 300000))" 251 | ] 252 | }, 253 | { 254 | "cell_type": "code", 255 | "execution_count": null, 256 | "metadata": {}, 257 | "outputs": [], 258 | "source": [ 259 | "# Escribe tu nueva función de reporte considerando lo anterior\n", 260 | "\n", 261 | "def mission_report(destination, *minutes, **fuel_reservoirs):\n", 262 | " return f\"\"\"\n", 263 | " Mission to {destination}\n", 264 | " Total travel time: {sum(minutes)} minutes\n", 265 | " Total fuel left: {sum(fuel_reservoirs.values())}\n", 266 | " \"\"\"\n", 267 | "\n", 268 | "print(mission_report(\"Moon\", 10, 15, 51, main=300000, external=200000))" 269 | ] 270 | }, 271 | { 272 | "cell_type": "code", 273 | "execution_count": null, 274 | "metadata": {}, 275 | "outputs": [], 276 | "source": [ 277 | "# Escribe tu nueva función\n", 278 | "\n", 279 | "def mission_report(destination, *minutes, **fuel_reservoirs):\n", 280 | " main_report = f\"\"\"\n", 281 | " Mission to {destination}\n", 282 | " Total travel time: {sum(minutes)} minutes\n", 283 | " Total fuel left: {sum(fuel_reservoirs.values())}\n", 284 | " \"\"\"\n", 285 | " for tank_name, gallons in fuel_reservoirs.items():\n", 286 | " main_report += f\"{tank_name} tank --> {gallons} gallons left\\n\"\n", 287 | " return main_report\n", 288 | "\n", 289 | "print(mission_report(\"Moon\", 8, 11, 55, main=300000, external=200000))" 290 | ] 291 | }, 292 | { 293 | "cell_type": "markdown", 294 | "metadata": {}, 295 | "source": [ 296 | "---\n", 297 | "\n", 298 | "Curso Propedútico de Python para Launch X - Innovacción Virtual.\n", 299 | "\n", 300 | "Material desarrollado con base en los contenidos de MSLearn y la metáfora de LaunchX, traducción e implementación por: Fernanda Ochoa - Learning Producer de LaunchX.\n", 301 | "\n", 302 | "Redes:\n", 303 | "* GitHub: [FernandaOchoa](https://github.com/FernandaOchoa)\n", 304 | "* Twitter: [@imonsh](https://twitter.com/imonsh)\n", 305 | "* Instagram: [fherz8a](https://www.instagram.com/fherz8a/)" 306 | ] 307 | } 308 | ], 309 | "metadata": { 310 | "interpreter": { 311 | "hash": "205095b8b86ea82a021a8fc2ffba2b3bc9f8d0be25999901963b225939f75778" 312 | }, 313 | "kernelspec": { 314 | "display_name": "Python 3.8.10 64-bit ('tmp': conda)", 315 | "name": "python3" 316 | }, 317 | "language_info": { 318 | "codemirror_mode": { 319 | "name": "ipython", 320 | "version": 3 321 | }, 322 | "file_extension": ".py", 323 | "mimetype": "text/x-python", 324 | "name": "python", 325 | "nbconvert_exporter": "python", 326 | "pygments_lexer": "ipython3", 327 | "version": "3.8.10" 328 | }, 329 | "nteract": { 330 | "version": "nteract-front-end@1.0.0" 331 | }, 332 | "orig_nbformat": 4 333 | }, 334 | "nbformat": 4, 335 | "nbformat_minor": 2 336 | } 337 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # Curso Introductorio de Python 2 | Curso Propedútico de Python 3 | 4 | Material desarrollado con base en los contenidos de MSLearn traducción e implementación por: Fernanda Ochoa - Productora. 5 | 6 | Redes: 7 | * GitHub: [FernandaOchoa](https://github.com/FernandaOchoa) 8 | * Twitter: [@imonsh](https://twitter.com/imonsh) 9 | * Instagram: [fherz8a](https://www.instagram.com/fherz8a/) 10 | 11 | --- 12 | 13 | ![LatinXperts Banners](https://user-images.githubusercontent.com/9124597/190833811-e8b1328c-657d-4474-93f2-d8d1300fbc55.png) 14 | 15 | # LatinXperts Regresa en modo Híbrido 16 | 17 | ### Hola @LaunchX-InnovaccionVirtual ❤️‍🔥 18 | 19 | LatinXperts inició en el 2021 como un show de Twitch por parte del GitHub Stream Team, transmitido durante 14 episodios en el canal de **GitHub Education**. Con el objetivo de empoderar e inspirar a las juventudes de América Latina a través de entrevistas con personalidades increíbles de la industria tech. 20 | 21 | Ahora, somos una comunidad híbrida, con el mismo objetivo y con el interés de conocer, conectar, colaborar y aprender juntos de lo mucho que tiene por ofrecer el mundo de la tecnología. 22 | 23 | ## ¿Por qué ser parte de la comunidad? 24 | 25 | ¡Acelera tu carrera, tus habilidades y haz crecer tu red de contactos, mientras te diviertes! 26 | 27 | Únete a la comunidad para mantenerte al día. 28 | 29 | ### Beneficios de la comunidad de **LatinXperts** 30 | 31 | * **Discussions:** Convive en un entorno inclusivo, seguro y de apoyo en discusiones que van desde Git y GitHub desde cero, hasta hablar en público y hackatones. 32 | 33 | * **HacktoberFest:** Colabora en proyectos interesantes, aumenta tu capacidad de descubrimiento. 34 | 35 | * **Organización de GitHub:** Conoce los logros de los miembros de la comunidad, el contenido exclusivo y los próximos eventos híbridos. 36 | 37 | * **LinkedIn:** Haz crecer tu red profesional en LinkedIn añadiendo LatinXperts a tu perfil en la sección de voluntariado. 38 | 39 | 40 | ## ¿Cómo unirme a la comunidad? 41 | 42 | Sigue estos pasos: 43 | 44 | - [ ] Ingresa al siguiente link [Soy el LINK](https://latinxperts.herokuapp.com) 45 | - [ ] Escribe tu **Usuario de GitHub** sin el @ 46 | - Captura de Pantalla 2022-09-16 a la(s) 20 02 16 47 | - Te enviaremos un email para que te unas a la organización 48 | - [ ] Acepta la invitación 49 | - [ ] Ingresa al foro de la comunidad para ver nuestros próximos eventos y contenido exclusivo [Soy el enlace al foro](https://github.com/LatinXperts/CommunityFolks/discussions) 50 | 51 | ### ¡Listo, ahora eres un@ LatinXpert! 52 | 53 | **Al ingresar a la organización, foros, cursos, eventos y actividades derivadas de la comunidad, estás aceptando el código de conducta. El cuál puedes consultar [aquí](https://github.com/LatinXperts/.github/blob/main/CodeOfConduct.md)** 54 | -------------------------------------------------------------------------------- /images/button.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/LaunchX-InnovaccionVirtual/CursoIntroPython/01d63a4b3ba251998cae4edd66970ccff05f9619/images/button.png -------------------------------------------------------------------------------- /images/chart.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/LaunchX-InnovaccionVirtual/CursoIntroPython/01d63a4b3ba251998cae4edd66970ccff05f9619/images/chart.png -------------------------------------------------------------------------------- /images/choose-kernel.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/LaunchX-InnovaccionVirtual/CursoIntroPython/01d63a4b3ba251998cae4edd66970ccff05f9619/images/choose-kernel.png -------------------------------------------------------------------------------- /images/createn.gif: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/LaunchX-InnovaccionVirtual/CursoIntroPython/01d63a4b3ba251998cae4edd66970ccff05f9619/images/createn.gif -------------------------------------------------------------------------------- /images/jupyter-extension.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/LaunchX-InnovaccionVirtual/CursoIntroPython/01d63a4b3ba251998cae4edd66970ccff05f9619/images/jupyter-extension.png -------------------------------------------------------------------------------- /images/nivelesox.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/LaunchX-InnovaccionVirtual/CursoIntroPython/01d63a4b3ba251998cae4edd66970ccff05f9619/images/nivelesox.png -------------------------------------------------------------------------------- /images/pip.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/LaunchX-InnovaccionVirtual/CursoIntroPython/01d63a4b3ba251998cae4edd66970ccff05f9619/images/pip.png -------------------------------------------------------------------------------- /images/planet.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/LaunchX-InnovaccionVirtual/CursoIntroPython/01d63a4b3ba251998cae4edd66970ccff05f9619/images/planet.png -------------------------------------------------------------------------------- /images/pythonv.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/LaunchX-InnovaccionVirtual/CursoIntroPython/01d63a4b3ba251998cae4edd66970ccff05f9619/images/pythonv.png -------------------------------------------------------------------------------- /images/restart.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/LaunchX-InnovaccionVirtual/CursoIntroPython/01d63a4b3ba251998cae4edd66970ccff05f9619/images/restart.png -------------------------------------------------------------------------------- /images/runmark.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/LaunchX-InnovaccionVirtual/CursoIntroPython/01d63a4b3ba251998cae4edd66970ccff05f9619/images/runmark.png -------------------------------------------------------------------------------- /images/vscode.jpeg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/LaunchX-InnovaccionVirtual/CursoIntroPython/01d63a4b3ba251998cae4edd66970ccff05f9619/images/vscode.jpeg --------------------------------------------------------------------------------