├── .gitignore ├── .vscode └── settings.json ├── GitHubPrimerosPasos.md ├── Módulo 0 - Preparación del entorno de trabajo ├── .ipynb_checkpoints │ ├── Modulo0Katas-checkpoint.ipynb │ └── Módulo 0 - Preparación del entorno de trabajo-checkpoint.md ├── Modulo0Katas.ipynb └── Módulo 0 - Preparación del entorno de trabajo.md ├── Módulo 1 - Primeros pasos ├── .ipynb_checkpoints │ ├── Modulo1 - Primeros pasos-checkpoint.ipynb │ └── Modulo1Katas-checkpoint.ipynb ├── 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 ├── .ipynb_checkpoints │ └── Módulo3Katas-checkpoint.ipynb ├── Módulo 3 - Usar lógica booleana.md └── Módulo3Katas.ipynb ├── Módulo 4 - Cadenas ├── .ipynb_checkpoints │ └── Módulo4Katas-checkpoint.ipynb ├── Módulo 4 - Cadenas.md └── Módulo4Katas.ipynb ├── Módulo 5 - Usar operaciones matemáticas ├── .ipynb_checkpoints │ └── Módulo5Katas-checkpoint.ipynb ├── Módulo 5 - Operaciones matemáticas.md └── Módulo5Katas.ipynb ├── Módulo 6 - Introducción a las listas ├── .ipynb_checkpoints │ └── Módulo6Katas-checkpoint.ipynb ├── Módulo 6- Introducción a las listas.md └── Módulo6Katas.ipynb ├── Módulo 7 - Estructuras de control ├── .ipynb_checkpoints │ └── Módulo7Katas-checkpoint.ipynb ├── Módulo 7 - Estructuras de control.md └── Módulo7Katas.ipynb ├── Módulo 8 - Administrar datos con diccionarios ├── .ipynb_checkpoints │ └── Módulo8Katas-checkpoint.ipynb ├── Módulo 8 - Administrar datos con diccionarios.md └── Módulo8Katas.ipynb ├── Módulo 9 - Funciones ├── .ipynb_checkpoints │ └── Módulo9Katas-checkpoint.ipynb ├── Módulo 9 - Funciones.md └── Módulo9Katas.ipynb ├── README.md ├── Repaso_Python_3_IA_Center_Verano_2023.ipynb └── 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 /.gitignore: -------------------------------------------------------------------------------- 1 | .env 2 | .env/ 3 | ``` 4 | I have tried to add the following to my .gitignore file: 5 | ``` 6 | .env 7 | .env/ 8 | .env/* 9 | ``` 10 | But none of these seem to work. I have also tried to remove the file from the repo using: 11 | ``` -------------------------------------------------------------------------------- /.vscode/settings.json: -------------------------------------------------------------------------------- 1 | { 2 | "window.zoomLevel": 1.7 3 | } -------------------------------------------------------------------------------- /GitHubPrimerosPasos.md: -------------------------------------------------------------------------------- 1 | # Primeros pasos github 2 | Paso 1: Configurar Git en tu computadora 3 | 1. Descarga e instala Git en tu computadora desde el sitio web oficial (https://git-scm.com). 4 | 2. Abre la terminal o línea de comandos y configura tu nombre de usuario y dirección de correo electrónico usando los siguientes comandos: 5 | ``` 6 | git config --global user.name "Tu nombre" 7 | git config --global user.email "tu@email.com" 8 | ``` 9 | 10 | Paso 2: Crear un repositorio en GitHub 11 | 1. Ve a la página principal de GitHub (https://github.com) y crea una cuenta si aún no tienes una. 12 | 2. Haz clic en el botón "New" (Nuevo) en la esquina superior derecha para crear un nuevo repositorio. 13 | 3. Asigna un nombre al repositorio y proporciona una descripción opcional. 14 | 4. Puedes elegir hacer el repositorio público o privado (requiere una cuenta de pago). 15 | 5. Haz clic en "Create repository" (Crear repositorio) para finalizar la creación. 16 | 17 | Paso 3: Clonar el repositorio en tu computadora 18 | 1. Copia la URL del repositorio que has creado en GitHub. 19 | 2. Abre la terminal o línea de comandos y navega hasta la ubicación donde deseas clonar el repositorio. 20 | 3. Ejecuta el siguiente comando para clonar el repositorio en tu computadora: 21 | ``` 22 | git clone 23 | ``` 24 | (reemplaza `` con la URL que copiaste anteriormente) 25 | 26 | Paso 4: Realizar cambios y subirlos al repositorio 27 | 1. Haz cambios en los archivos dentro de la carpeta del repositorio clonado en tu computadora. 28 | 2. Una vez que hayas realizado los cambios, abre la terminal o línea de comandos en la carpeta del repositorio. 29 | 3. Usa el siguiente comando para ver el estado de los archivos modificados: 30 | ``` 31 | git status 32 | ``` 33 | 4. Utiliza el comando `git add ` para agregar los cambios al área de preparación. Si deseas agregar todos los cambios, puedes usar `git add .`. 34 | 5. Luego, utiliza el comando `git commit -m "Mensaje del commit"` para confirmar los cambios con un mensaje descriptivo. 35 | 6. Finalmente, utiliza el comando `git push` para subir los cambios al repositorio en GitHub. 36 | 37 | ¡Y eso es todo! Has completado los primeros pasos de Git en GitHub. Ahora podrás realizar cambios, confirmarlos y subirlos a tu repositorio en GitHub. Te recomiendo explorar más sobre Git y GitHub para aprovechar al máximo estas herramientas. 38 | 39 | 40 | 41 | 42 | # sRamas (Opcional) 43 | Paso 1: Crear una rama 44 | 1. Abre la terminal o línea de comandos en la carpeta de tu repositorio clonado. 45 | 2. Para crear una nueva rama, utiliza el siguiente comando: 46 | ``` 47 | git branch 48 | ``` 49 | (reemplaza `` con el nombre que deseas darle a tu rama). 50 | 51 | Paso 2: Cambiar a la rama creada 52 | 1. Utiliza el siguiente comando para cambiar a la nueva rama: 53 | ``` 54 | git checkout 55 | ``` 56 | (reemplaza `` con el nombre de la rama que creaste). 57 | 2. Ahora estarás trabajando en la nueva rama y podrás hacer cambios sin afectar la rama principal (normalmente llamada "main" o "master"). 58 | 59 | Paso 3: Realizar cambios en la rama 60 | 1. Haz los cambios necesarios en los archivos de tu proyecto. 61 | 2. Utiliza los comandos `git add` y `git commit` para agregar y confirmar los cambios en la rama actual, de la misma manera que lo harías en la rama principal. 62 | 63 | Paso 4: Fusionar la rama con la rama principal 64 | 1. Una vez que hayas completado los cambios y estés listo para fusionar la rama con la rama principal, primero cambia a la rama principal utilizando el comando `git checkout main` (o `git checkout master` si es la rama principal). 65 | 2. Luego, utiliza el siguiente comando para fusionar la rama creada con la rama principal: 66 | ``` 67 | git merge 68 | ``` 69 | (reemplaza `` con el nombre de la rama que creaste). 70 | 71 | Paso 5: Eliminar una rama 72 | 1. Después de fusionar exitosamente la rama con la rama principal, puedes eliminar la rama si ya no la necesitas. 73 | 2. Utiliza el siguiente comando para eliminar una rama: 74 | ``` 75 | git branch -d 76 | ``` 77 | (reemplaza `` con el nombre de la rama que deseas eliminar). 78 | 79 | ¡Eso es todo! Ahora sabes cómo crear ramas, cambiar entre ellas, hacer cambios y fusionar ramas en Git. Recuerda que trabajar con ramas te permite desarrollar nuevas funcionalidades, experimentar y colaborar de manera segura sin afectar la rama principal de tu proyecto. -------------------------------------------------------------------------------- /Módulo 0 - Preparación del entorno de trabajo/.ipynb_checkpoints/Módulo 0 - Preparación del entorno de trabajo-checkpoint.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 ddde MSLearn y la metáfora de LaunchX, traducción e implementación por: Fernanda Ochoa - Learning Producer de LaunchX. 225 | 226 | Redes: 227 | * GitHub: [javierIA](https://github.com/javierIA) 228 | * Twitter: [@Xavi_Error](https://twitter.com/Xavi_Error) 229 | * Instagram: [xavierfloresx2](https://www.instagram.com/xavierfloresx2/) 230 | -------------------------------------------------------------------------------- /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 ddde MSLearn y la metáfora de LaunchX, traducción e implementación por: Fernanda Ochoa - Learning Producer de LaunchX. 225 | 226 | Redes: 227 | * GitHub: [javierIA](https://github.com/javierIA) 228 | * Twitter: [@Xavi_Error](https://twitter.com/Xavi_Error) 229 | * Instagram: [xavierfloresx2](https://www.instagram.com/xavierfloresx2/) 230 | -------------------------------------------------------------------------------- /Módulo 1 - Primeros pasos/.ipynb_checkpoints/Modulo1Katas-checkpoint.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": { 6 | "slideshow": { 7 | "slide_type": "slide" 8 | } 9 | }, 10 | "source": [ 11 | "Oficial superior> \"¿Cadete?\"\n", 12 | "\n", 13 | "Usted > \"¿Sí, señora?\"\n", 14 | "\n", 15 | "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", 16 | "\n", 17 | "Usted > \"Considéralo hecho\".\n", 18 | "\n", 19 | "Oficial superior> \"Excelente\".\n", 20 | "\n", 21 | "## Tu primer programa\n", 22 | "\n", 23 | "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." 24 | ] 25 | }, 26 | { 27 | "cell_type": "code", 28 | "execution_count": null, 29 | "metadata": { 30 | "slideshow": { 31 | "slide_type": "subslide" 32 | } 33 | }, 34 | "outputs": [], 35 | "source": [ 36 | "from datetime import date\n", 37 | "\n", 38 | "print(\"Today's date is: \")" 39 | ] 40 | }, 41 | { 42 | "cell_type": "markdown", 43 | "metadata": { 44 | "slideshow": { 45 | "slide_type": "subslide" 46 | } 47 | }, 48 | "source": [ 49 | "> **TIP**\n", 50 | "> 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", 51 | "\n", 52 | "## Construir un convertidor de unidades\n", 53 | "\n", 54 | "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", 55 | "\n", 56 | "Tú> \"¡Lo haré!\"\n" 57 | ] 58 | }, 59 | { 60 | "cell_type": "code", 61 | "execution_count": null, 62 | "metadata": { 63 | "slideshow": { 64 | "slide_type": "slide" 65 | } 66 | }, 67 | "outputs": [ 68 | { 69 | "ename": "", 70 | "evalue": "", 71 | "output_type": "error", 72 | "traceback": [ 73 | "\u001b[1;31mRunning cells with '/bin/python3' requires the ipykernel package.\n", 74 | "\u001b[1;31mRun the following command to install 'ipykernel' into the Python environment. \n", 75 | "\u001b[1;31mCommand: '/bin/python3 -m pip install ipykernel -U --user --force-reinstall'" 76 | ] 77 | } 78 | ], 79 | "source": [ 80 | "parsec = 11\n", 81 | "\n", 82 | "lightyears = 0\n", 83 | "\n", 84 | "print(str(parsec) + \" parsec, is \" + str(lightyears) + \" lightyears\")" 85 | ] 86 | }, 87 | { 88 | "cell_type": "markdown", 89 | "metadata": { 90 | "slideshow": { 91 | "slide_type": "slide" 92 | } 93 | }, 94 | "source": [ 95 | "> [!TIP]\n", 96 | "> 1 parsec es 3.26156 años luz. Utiliza el operador de multiplicación." 97 | ] 98 | }, 99 | { 100 | "cell_type": "markdown", 101 | "metadata": { 102 | "slideshow": { 103 | "slide_type": "slide" 104 | } 105 | }, 106 | "source": [ 107 | "## Soluciones\n", 108 | "\n", 109 | "Aquí está la solución para el primer programa:" 110 | ] 111 | }, 112 | { 113 | "cell_type": "code", 114 | "execution_count": null, 115 | "metadata": { 116 | "slideshow": { 117 | "slide_type": "slide" 118 | } 119 | }, 120 | "outputs": [ 121 | { 122 | "ename": "", 123 | "evalue": "", 124 | "output_type": "error", 125 | "traceback": [ 126 | "\u001b[1;31mRunning cells with '/bin/python3' requires the ipykernel package.\n", 127 | "\u001b[1;31mRun the following command to install 'ipykernel' into the Python environment. \n", 128 | "\u001b[1;31mCommand: '/bin/python3 -m pip install ipykernel -U --user --force-reinstall'" 129 | ] 130 | } 131 | ], 132 | "source": [ 133 | "from datetime import date\n", 134 | "\n", 135 | "print(\"Today's date is: \" + str(date.today()))" 136 | ] 137 | }, 138 | { 139 | "cell_type": "code", 140 | "execution_count": null, 141 | "metadata": { 142 | "slideshow": { 143 | "slide_type": "slide" 144 | } 145 | }, 146 | "outputs": [], 147 | "source": [ 148 | "parsec = 11\n", 149 | "lightyears = 3.26156 * parsec\n", 150 | "\n", 151 | "print(str(parsec) + \" parsec, is \" + str(lightyears) + \" lightyears\")" 152 | ] 153 | } 154 | ], 155 | "metadata": { 156 | "celltoolbar": "Slideshow", 157 | "kernel_info": { 158 | "name": "conda-env-py37_default-py" 159 | }, 160 | "kernelspec": { 161 | "display_name": "Python 3 (ipykernel)", 162 | "language": "python", 163 | "name": "python3" 164 | }, 165 | "language_info": { 166 | "codemirror_mode": { 167 | "name": "ipython", 168 | "version": 3 169 | }, 170 | "file_extension": ".py", 171 | "mimetype": "text/x-python", 172 | "name": "python", 173 | "nbconvert_exporter": "python", 174 | "pygments_lexer": "ipython3", 175 | "version": "3.11.2" 176 | }, 177 | "nteract": { 178 | "version": "nteract-front-end@1.0.0" 179 | } 180 | }, 181 | "nbformat": 4, 182 | "nbformat_minor": 4 183 | } 184 | -------------------------------------------------------------------------------- /Módulo 1 - Primeros pasos/Modulo1Katas.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": { 6 | "slideshow": { 7 | "slide_type": "slide" 8 | } 9 | }, 10 | "source": [ 11 | "Oficial superior> \"¿Cadete?\"\n", 12 | "\n", 13 | "Usted > \"¿Sí, señora?\"\n", 14 | "\n", 15 | "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", 16 | "\n", 17 | "Usted > \"Considéralo hecho\".\n", 18 | "\n", 19 | "Oficial superior> \"Excelente\".\n", 20 | "\n", 21 | "## Tu primer programa\n", 22 | "\n", 23 | "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." 24 | ] 25 | }, 26 | { 27 | "cell_type": "code", 28 | "execution_count": null, 29 | "metadata": { 30 | "slideshow": { 31 | "slide_type": "subslide" 32 | } 33 | }, 34 | "outputs": [], 35 | "source": [ 36 | "from datetime import date\n", 37 | "\n", 38 | "print(\"Today's date is: \")" 39 | ] 40 | }, 41 | { 42 | "cell_type": "markdown", 43 | "metadata": { 44 | "slideshow": { 45 | "slide_type": "subslide" 46 | } 47 | }, 48 | "source": [ 49 | "> **TIP**\n", 50 | "> 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", 51 | "\n", 52 | "## Construir un convertidor de unidades\n", 53 | "\n", 54 | "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", 55 | "\n", 56 | "Tú> \"¡Lo haré!\"\n" 57 | ] 58 | }, 59 | { 60 | "cell_type": "code", 61 | "execution_count": null, 62 | "metadata": { 63 | "slideshow": { 64 | "slide_type": "slide" 65 | } 66 | }, 67 | "outputs": [ 68 | { 69 | "ename": "", 70 | "evalue": "", 71 | "output_type": "error", 72 | "traceback": [ 73 | "\u001b[1;31mRunning cells with '/bin/python3' requires the ipykernel package.\n", 74 | "\u001b[1;31mRun the following command to install 'ipykernel' into the Python environment. \n", 75 | "\u001b[1;31mCommand: '/bin/python3 -m pip install ipykernel -U --user --force-reinstall'" 76 | ] 77 | } 78 | ], 79 | "source": [ 80 | "parsec = 11\n", 81 | "\n", 82 | "lightyears = 0\n", 83 | "\n", 84 | "print(str(parsec) + \" parsec, is \" + str(lightyears) + \" lightyears\")" 85 | ] 86 | }, 87 | { 88 | "cell_type": "markdown", 89 | "metadata": { 90 | "slideshow": { 91 | "slide_type": "slide" 92 | } 93 | }, 94 | "source": [ 95 | "> [!TIP]\n", 96 | "> 1 parsec es 3.26156 años luz. Utiliza el operador de multiplicación." 97 | ] 98 | }, 99 | { 100 | "cell_type": "markdown", 101 | "metadata": { 102 | "slideshow": { 103 | "slide_type": "slide" 104 | } 105 | }, 106 | "source": [ 107 | "## Soluciones\n", 108 | "\n", 109 | "Aquí está la solución para el primer programa:" 110 | ] 111 | }, 112 | { 113 | "cell_type": "code", 114 | "execution_count": null, 115 | "metadata": { 116 | "slideshow": { 117 | "slide_type": "slide" 118 | } 119 | }, 120 | "outputs": [ 121 | { 122 | "ename": "", 123 | "evalue": "", 124 | "output_type": "error", 125 | "traceback": [ 126 | "\u001b[1;31mRunning cells with '/bin/python3' requires the ipykernel package.\n", 127 | "\u001b[1;31mRun the following command to install 'ipykernel' into the Python environment. \n", 128 | "\u001b[1;31mCommand: '/bin/python3 -m pip install ipykernel -U --user --force-reinstall'" 129 | ] 130 | } 131 | ], 132 | "source": [ 133 | "from datetime import date\n", 134 | "\n", 135 | "print(\"Today's date is: \" + str(date.today()))" 136 | ] 137 | }, 138 | { 139 | "cell_type": "code", 140 | "execution_count": null, 141 | "metadata": { 142 | "slideshow": { 143 | "slide_type": "slide" 144 | } 145 | }, 146 | "outputs": [], 147 | "source": [ 148 | "parsec = 11\n", 149 | "lightyears = 3.26156 * parsec\n", 150 | "\n", 151 | "print(str(parsec) + \" parsec, is \" + str(lightyears) + \" lightyears\")" 152 | ] 153 | } 154 | ], 155 | "metadata": { 156 | "celltoolbar": "Slideshow", 157 | "kernel_info": { 158 | "name": "conda-env-py37_default-py" 159 | }, 160 | "kernelspec": { 161 | "display_name": "Python 3 (ipykernel)", 162 | "language": "python", 163 | "name": "python3" 164 | }, 165 | "language_info": { 166 | "codemirror_mode": { 167 | "name": "ipython", 168 | "version": 3 169 | }, 170 | "file_extension": ".py", 171 | "mimetype": "text/x-python", 172 | "name": "python", 173 | "nbconvert_exporter": "python", 174 | "pygments_lexer": "ipython3", 175 | "version": "3.11.4" 176 | }, 177 | "nteract": { 178 | "version": "nteract-front-end@1.0.0" 179 | } 180 | }, 181 | "nbformat": 4, 182 | "nbformat_minor": 4 183 | } 184 | -------------------------------------------------------------------------------- /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 fastrack de python 85 | 86 | Material desarrollado con base en los contenidos de MSLearn - 87 | 88 | Redes: 89 | * GitHub: [javierIA](https://github.com/javierIA) 90 | * Twitter: [@Xavi_Error](https://twitter.com/Xavi_Error) 91 | * Instagram: [xavierfloresx2](https://www.instagram.com/xavierfloresx2/) 92 | 93 | 94 | -------------------------------------------------------------------------------- /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 fastrack de python 189 | 190 | Material desarrollado con base en los contenidos de MSLearn - 191 | 192 | Redes: 193 | * GitHub: [javierIA](https://github.com/javierIA) 194 | * Twitter: [@Xavi_Error](https://twitter.com/Xavi_Error) 195 | * Instagram: [xavierfloresx2](https://www.instagram.com/xavierfloresx2/) 196 | 197 | -------------------------------------------------------------------------------- /Módulo 3 - Usar lógica booleana/.ipynb_checkpoints/Módulo3Katas-checkpoint.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": { 6 | "slideshow": { 7 | "slide_type": "slide" 8 | } 9 | }, 10 | "source": [ 11 | "# Ejercicio - Escribir declaraciones `if`, `else`, y `elif`\n", 12 | "\n", 13 | "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", 14 | "\n", 15 | "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", 16 | "\n", 17 | "```python\n", 18 | "if expresion_prueba:\n", 19 | " # intrucción(es) a ejecutar\n", 20 | "```\n", 21 | "\n", 22 | "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", 23 | "\n", 24 | "\n", 25 | "```python\n", 26 | "if expresion_prueba:\n", 27 | " # intrucción(es) a ejecutar\n", 28 | " if expresion_prueba:\n", 29 | " # intrucción(es) a ejecutar\n", 30 | " else: \n", 31 | " # intrucción(es) a ejecutar\n", 32 | "elif expresion_prueba:\n", 33 | " # intrucción(es) a ejecutar\n", 34 | "else:\n", 35 | " # intrucción(es) a ejecutar\n", 36 | "```\n", 37 | "\n", 38 | "> **TIP**\n", 39 | "> 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", 40 | "\n", 41 | "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", 42 | "\n", 43 | "Un asteroide se acerca, y viaja a una velocidad de 49 km/s." 44 | ] 45 | }, 46 | { 47 | "cell_type": "code", 48 | "execution_count": null, 49 | "metadata": {}, 50 | "outputs": [], 51 | "source": [] 52 | }, 53 | { 54 | "cell_type": "code", 55 | "execution_count": null, 56 | "metadata": {}, 57 | "outputs": [], 58 | "source": [] 59 | }, 60 | { 61 | "cell_type": "code", 62 | "execution_count": null, 63 | "metadata": {}, 64 | "outputs": [], 65 | "source": [] 66 | }, 67 | { 68 | "cell_type": "code", 69 | "execution_count": null, 70 | "metadata": {}, 71 | "outputs": [], 72 | "source": [] 73 | }, 74 | { 75 | "cell_type": "code", 76 | "execution_count": null, 77 | "metadata": {}, 78 | "outputs": [], 79 | "source": [] 80 | }, 81 | { 82 | "cell_type": "code", 83 | "execution_count": null, 84 | "metadata": {}, 85 | "outputs": [], 86 | "source": [] 87 | }, 88 | { 89 | "cell_type": "code", 90 | "execution_count": null, 91 | "metadata": {}, 92 | "outputs": [], 93 | "source": [] 94 | }, 95 | { 96 | "cell_type": "code", 97 | "execution_count": null, 98 | "metadata": { 99 | "slideshow": { 100 | "slide_type": "-" 101 | } 102 | }, 103 | "outputs": [], 104 | "source": [ 105 | "# Añadir el código necesario para crear una variable que guarde la velocidad del asteroide.\n", 106 | "# Escribe una expresión de prueba para calcular si necesita una advertencia.\n", 107 | "# Agregue las instrucciones que se ejecutarán si la expresión de prueba es true o false." 108 | ] 109 | }, 110 | { 111 | "cell_type": "markdown", 112 | "metadata": { 113 | "slideshow": { 114 | "slide_type": "-" 115 | } 116 | }, 117 | "source": [ 118 | "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!" 119 | ] 120 | }, 121 | { 122 | "cell_type": "code", 123 | "execution_count": null, 124 | "metadata": { 125 | "slideshow": { 126 | "slide_type": "-" 127 | } 128 | }, 129 | "outputs": [], 130 | "source": [ 131 | "# Agrega el código para crear una variable para un asteroide que viaja a 19 km/s\n", 132 | "# Escribe varias expresiones de prueba para determinar si puedes ver el rayo de luz desde la tierra\n", 133 | "# Agrega las instrucciones que se ejecutarán si las expresiones de prueba son True o False" 134 | ] 135 | }, 136 | { 137 | "cell_type": "markdown", 138 | "metadata": { 139 | "slideshow": { 140 | "slide_type": "slide" 141 | } 142 | }, 143 | "source": [ 144 | "# Ejercicio: Uso de operadores `and` y `or` \n", 145 | "\n", 146 | "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", 147 | "\n", 148 | "Las expresiones `and` son sólo si ambas subexpresiones son verdaderas.\n", 149 | "\n", 150 | "`expresión1 and expresión2`\n", 151 | "\n", 152 | "Las expresiones `or` son `True` si *al menos una* subexpresión es verdadera.\n", 153 | "\n", 154 | "`expresión1 or expresión2`\n", 155 | "\n", 156 | "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", 157 | "\n", 158 | "*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", 159 | "* 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", 160 | "\n", 161 | "También discutimos en el ejercicio anterior que:\n", 162 | "\n", 163 | "* 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", 164 | "* 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", 165 | "\n", 166 | "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`." 167 | ] 168 | }, 169 | { 170 | "cell_type": "code", 171 | "execution_count": null, 172 | "metadata": { 173 | "slideshow": { 174 | "slide_type": "-" 175 | } 176 | }, 177 | "outputs": [], 178 | "source": [ 179 | "# Agrega el código para crear nuevas variables para la velocidad y el tamaño del asteroide\n", 180 | "# Para probar el código, prueba con varias velocidades y tamaños\n", 181 | "# Escribe varias expresiones de prueba o combinaciones de expresiones de prueba para determinar qué mensaje se debe enviar a Tierra." 182 | ] 183 | }, 184 | { 185 | "cell_type": "markdown", 186 | "metadata": { 187 | "slideshow": { 188 | "slide_type": "slide" 189 | } 190 | }, 191 | "source": [ 192 | "## Soluciones" 193 | ] 194 | }, 195 | { 196 | "cell_type": "markdown", 197 | "metadata": { 198 | "slideshow": { 199 | "slide_type": "slide" 200 | } 201 | }, 202 | "source": [ 203 | "#### Problema No. 1" 204 | ] 205 | }, 206 | { 207 | "cell_type": "code", 208 | "execution_count": null, 209 | "metadata": { 210 | "slideshow": { 211 | "slide_type": "subslide" 212 | } 213 | }, 214 | "outputs": [], 215 | "source": [ 216 | "# Añadir el código necesario para crear una variable que guarde la velocidad del asteroide.\n", 217 | "# Escribe una expresión de prueba para calcular si necesita una advertencia.\n", 218 | "# Agregue las instrucciones que se ejecutarán si la expresión de prueba es true o false.\n", 219 | "\n", 220 | "asteroide = 49\n", 221 | "if asteroide > 25:\n", 222 | " print('¡Alerta! ¡Un asteroide se acerca a velocidades peligrosas!')\n", 223 | "else:\n", 224 | " print('¡Sigue con tu día!')" 225 | ] 226 | }, 227 | { 228 | "cell_type": "markdown", 229 | "metadata": { 230 | "slideshow": { 231 | "slide_type": "slide" 232 | } 233 | }, 234 | "source": [ 235 | "#### Problema No. 2" 236 | ] 237 | }, 238 | { 239 | "cell_type": "code", 240 | "execution_count": null, 241 | "metadata": { 242 | "slideshow": { 243 | "slide_type": "subslide" 244 | } 245 | }, 246 | "outputs": [], 247 | "source": [ 248 | "# Agrega el código para crear una variable para un asteroide que viaja a 19 km/s\n", 249 | "# Escribe varias expresiones de prueba para determinar si puedes ver el rayo de luz desde la tierra\n", 250 | "# Agrega las instrucciones que se ejecutarán si las expresiones de prueba son True o False\n", 251 | "\n", 252 | "asteroide = 19\n", 253 | "if asteroide > 20:\n", 254 | " print('Look up! ¡Hay una luz mágica en el cielo!')\n", 255 | "elif asteroide == 20:\n", 256 | " print('Look up! ¡Hay una luz mágica en el cielo!')\n", 257 | "else:\n", 258 | " print('¡Nada que ver aquí!')" 259 | ] 260 | }, 261 | { 262 | "cell_type": "markdown", 263 | "metadata": { 264 | "slideshow": { 265 | "slide_type": "slide" 266 | } 267 | }, 268 | "source": [ 269 | "#### Problema No. 3" 270 | ] 271 | }, 272 | { 273 | "cell_type": "code", 274 | "execution_count": null, 275 | "metadata": { 276 | "slideshow": { 277 | "slide_type": "subslide" 278 | } 279 | }, 280 | "outputs": [], 281 | "source": [ 282 | "# Agrega el código para crear nuevas variables para la velocidad y el tamaño del asteroide\n", 283 | "# Para probar el código, prueba con varias velocidades y tamaños\n", 284 | "# Escribe varias expresiones de prueba o combinaciones de expresiones de prueba para determinar qué mensaje se debe enviar a Tierra.\n", 285 | "\n", 286 | "velocidad_asteroide = 25\n", 287 | "tamano_asteroide = 40\n", 288 | "if velocidad_asteroide > 25 and tamano_asteroide > 25:\n", 289 | " print('¡Alerta, Un asteroide muy peligroso viene hacia la Tierra!')\n", 290 | "elif velocidad_asteroide >= 20:\n", 291 | " print('Look up! ¡Hay una luz mágica en el cielo!')\n", 292 | "elif tamano_asteroide < 25:\n", 293 | " print('Nada que ver aquí :)')\n", 294 | "else:\n", 295 | " print('Nada que ver aquí :)')" 296 | ] 297 | }, 298 | { 299 | "cell_type": "code", 300 | "execution_count": null, 301 | "metadata": {}, 302 | "outputs": [], 303 | "source": [] 304 | } 305 | ], 306 | "metadata": { 307 | "celltoolbar": "Slideshow", 308 | "interpreter": { 309 | "hash": "916dbcbb3f70747c44a77c7bcd40155683ae19c65e1c03b4aa3499c5328201f1" 310 | }, 311 | "kernel_info": { 312 | "name": "conda-env-py37_default-py" 313 | }, 314 | "kernelspec": { 315 | "display_name": "Python 3 (ipykernel)", 316 | "language": "python", 317 | "name": "python3" 318 | }, 319 | "language_info": { 320 | "codemirror_mode": { 321 | "name": "ipython", 322 | "version": 3 323 | }, 324 | "file_extension": ".py", 325 | "mimetype": "text/x-python", 326 | "name": "python", 327 | "nbconvert_exporter": "python", 328 | "pygments_lexer": "ipython3", 329 | "version": "3.11.4" 330 | }, 331 | "nteract": { 332 | "version": "nteract-front-end@1.0.0" 333 | } 334 | }, 335 | "nbformat": 4, 336 | "nbformat_minor": 2 337 | } 338 | -------------------------------------------------------------------------------- /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 fastrack de python 283 | 284 | Material desarrollado con base en los contenidos de MSLearn - 285 | 286 | Redes: 287 | * GitHub: [javierIA](https://github.com/javierIA) 288 | * Twitter: [@Xavi_Error](https://twitter.com/Xavi_Error) 289 | * Instagram: [xavierfloresx2](https://www.instagram.com/xavierfloresx2/) -------------------------------------------------------------------------------- /Módulo 3 - Usar lógica booleana/Módulo3Katas.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": { 6 | "slideshow": { 7 | "slide_type": "slide" 8 | } 9 | }, 10 | "source": [ 11 | "# Ejercicio - Escribir declaraciones `if`, `else`, y `elif`\n", 12 | "\n", 13 | "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", 14 | "\n", 15 | "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", 16 | "\n", 17 | "```python\n", 18 | "if expresion_prueba:\n", 19 | " # intrucción(es) a ejecutar\n", 20 | "```\n", 21 | "\n", 22 | "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", 23 | "\n", 24 | "\n", 25 | "```python\n", 26 | "if expresion_prueba:\n", 27 | " # intrucción(es) a ejecutar\n", 28 | " if expresion_prueba:\n", 29 | " # intrucción(es) a ejecutar\n", 30 | " else: \n", 31 | " # intrucción(es) a ejecutar\n", 32 | "elif expresion_prueba:\n", 33 | " # intrucción(es) a ejecutar\n", 34 | "else:\n", 35 | " # intrucción(es) a ejecutar\n", 36 | "```\n", 37 | "\n", 38 | "> **TIP**\n", 39 | "> 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", 40 | "\n", 41 | "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", 42 | "\n", 43 | "Un asteroide se acerca, y viaja a una velocidad de 49 km/s." 44 | ] 45 | }, 46 | { 47 | "cell_type": "code", 48 | "execution_count": null, 49 | "metadata": {}, 50 | "outputs": [], 51 | "source": [] 52 | }, 53 | { 54 | "cell_type": "code", 55 | "execution_count": null, 56 | "metadata": {}, 57 | "outputs": [], 58 | "source": [] 59 | }, 60 | { 61 | "cell_type": "code", 62 | "execution_count": null, 63 | "metadata": {}, 64 | "outputs": [], 65 | "source": [] 66 | }, 67 | { 68 | "cell_type": "code", 69 | "execution_count": null, 70 | "metadata": {}, 71 | "outputs": [], 72 | "source": [] 73 | }, 74 | { 75 | "cell_type": "code", 76 | "execution_count": null, 77 | "metadata": {}, 78 | "outputs": [], 79 | "source": [] 80 | }, 81 | { 82 | "cell_type": "code", 83 | "execution_count": null, 84 | "metadata": {}, 85 | "outputs": [], 86 | "source": [] 87 | }, 88 | { 89 | "cell_type": "code", 90 | "execution_count": null, 91 | "metadata": {}, 92 | "outputs": [], 93 | "source": [] 94 | }, 95 | { 96 | "cell_type": "code", 97 | "execution_count": null, 98 | "metadata": { 99 | "slideshow": { 100 | "slide_type": "-" 101 | } 102 | }, 103 | "outputs": [], 104 | "source": [ 105 | "# Añadir el código necesario para crear una variable que guarde la velocidad del asteroide.\n", 106 | "# Escribe una expresión de prueba para calcular si necesita una advertencia.\n", 107 | "# Agregue las instrucciones que se ejecutarán si la expresión de prueba es true o false." 108 | ] 109 | }, 110 | { 111 | "cell_type": "markdown", 112 | "metadata": { 113 | "slideshow": { 114 | "slide_type": "-" 115 | } 116 | }, 117 | "source": [ 118 | "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!" 119 | ] 120 | }, 121 | { 122 | "cell_type": "code", 123 | "execution_count": null, 124 | "metadata": { 125 | "slideshow": { 126 | "slide_type": "-" 127 | } 128 | }, 129 | "outputs": [], 130 | "source": [ 131 | "# Agrega el código para crear una variable para un asteroide que viaja a 19 km/s\n", 132 | "# Escribe varias expresiones de prueba para determinar si puedes ver el rayo de luz desde la tierra\n", 133 | "# Agrega las instrucciones que se ejecutarán si las expresiones de prueba son True o False" 134 | ] 135 | }, 136 | { 137 | "cell_type": "markdown", 138 | "metadata": { 139 | "slideshow": { 140 | "slide_type": "slide" 141 | } 142 | }, 143 | "source": [ 144 | "# Ejercicio: Uso de operadores `and` y `or` \n", 145 | "\n", 146 | "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", 147 | "\n", 148 | "Las expresiones `and` son sólo si ambas subexpresiones son verdaderas.\n", 149 | "\n", 150 | "`expresión1 and expresión2`\n", 151 | "\n", 152 | "Las expresiones `or` son `True` si *al menos una* subexpresión es verdadera.\n", 153 | "\n", 154 | "`expresión1 or expresión2`\n", 155 | "\n", 156 | "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", 157 | "\n", 158 | "*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", 159 | "* 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", 160 | "\n", 161 | "También discutimos en el ejercicio anterior que:\n", 162 | "\n", 163 | "* 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", 164 | "* 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", 165 | "\n", 166 | "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`." 167 | ] 168 | }, 169 | { 170 | "cell_type": "code", 171 | "execution_count": null, 172 | "metadata": { 173 | "slideshow": { 174 | "slide_type": "-" 175 | } 176 | }, 177 | "outputs": [], 178 | "source": [ 179 | "# Agrega el código para crear nuevas variables para la velocidad y el tamaño del asteroide\n", 180 | "# Para probar el código, prueba con varias velocidades y tamaños\n", 181 | "# Escribe varias expresiones de prueba o combinaciones de expresiones de prueba para determinar qué mensaje se debe enviar a Tierra." 182 | ] 183 | }, 184 | { 185 | "cell_type": "markdown", 186 | "metadata": { 187 | "slideshow": { 188 | "slide_type": "slide" 189 | } 190 | }, 191 | "source": [ 192 | "## Soluciones" 193 | ] 194 | }, 195 | { 196 | "cell_type": "markdown", 197 | "metadata": { 198 | "slideshow": { 199 | "slide_type": "slide" 200 | } 201 | }, 202 | "source": [ 203 | "#### Problema No. 1" 204 | ] 205 | }, 206 | { 207 | "cell_type": "code", 208 | "execution_count": null, 209 | "metadata": { 210 | "slideshow": { 211 | "slide_type": "subslide" 212 | } 213 | }, 214 | "outputs": [], 215 | "source": [ 216 | "# Añadir el código necesario para crear una variable que guarde la velocidad del asteroide.\n", 217 | "# Escribe una expresión de prueba para calcular si necesita una advertencia.\n", 218 | "# Agregue las instrucciones que se ejecutarán si la expresión de prueba es true o false.\n", 219 | "\n", 220 | "asteroide = 49\n", 221 | "if asteroide > 25:\n", 222 | " print('¡Alerta! ¡Un asteroide se acerca a velocidades peligrosas!')\n", 223 | "else:\n", 224 | " print('¡Sigue con tu día!')" 225 | ] 226 | }, 227 | { 228 | "cell_type": "markdown", 229 | "metadata": { 230 | "slideshow": { 231 | "slide_type": "slide" 232 | } 233 | }, 234 | "source": [ 235 | "#### Problema No. 2" 236 | ] 237 | }, 238 | { 239 | "cell_type": "code", 240 | "execution_count": null, 241 | "metadata": { 242 | "slideshow": { 243 | "slide_type": "subslide" 244 | } 245 | }, 246 | "outputs": [], 247 | "source": [ 248 | "# Agrega el código para crear una variable para un asteroide que viaja a 19 km/s\n", 249 | "# Escribe varias expresiones de prueba para determinar si puedes ver el rayo de luz desde la tierra\n", 250 | "# Agrega las instrucciones que se ejecutarán si las expresiones de prueba son True o False\n", 251 | "\n", 252 | "asteroide = 19\n", 253 | "if asteroide > 20:\n", 254 | " print('Look up! ¡Hay una luz mágica en el cielo!')\n", 255 | "elif asteroide == 20:\n", 256 | " print('Look up! ¡Hay una luz mágica en el cielo!')\n", 257 | "else:\n", 258 | " print('¡Nada que ver aquí!')" 259 | ] 260 | }, 261 | { 262 | "cell_type": "markdown", 263 | "metadata": { 264 | "slideshow": { 265 | "slide_type": "slide" 266 | } 267 | }, 268 | "source": [ 269 | "#### Problema No. 3" 270 | ] 271 | }, 272 | { 273 | "cell_type": "code", 274 | "execution_count": null, 275 | "metadata": { 276 | "slideshow": { 277 | "slide_type": "subslide" 278 | } 279 | }, 280 | "outputs": [], 281 | "source": [ 282 | "# Agrega el código para crear nuevas variables para la velocidad y el tamaño del asteroide\n", 283 | "# Para probar el código, prueba con varias velocidades y tamaños\n", 284 | "# Escribe varias expresiones de prueba o combinaciones de expresiones de prueba para determinar qué mensaje se debe enviar a Tierra.\n", 285 | "\n", 286 | "velocidad_asteroide = 25\n", 287 | "tamano_asteroide = 40\n", 288 | "if velocidad_asteroide > 25 and tamano_asteroide > 25:\n", 289 | " print('¡Alerta, Un asteroide muy peligroso viene hacia la Tierra!')\n", 290 | "elif velocidad_asteroide >= 20:\n", 291 | " print('Look up! ¡Hay una luz mágica en el cielo!')\n", 292 | "elif tamano_asteroide < 25:\n", 293 | " print('Nada que ver aquí :)')\n", 294 | "else:\n", 295 | " print('Nada que ver aquí :)')" 296 | ] 297 | }, 298 | { 299 | "cell_type": "code", 300 | "execution_count": null, 301 | "metadata": {}, 302 | "outputs": [], 303 | "source": [] 304 | } 305 | ], 306 | "metadata": { 307 | "celltoolbar": "Slideshow", 308 | "interpreter": { 309 | "hash": "916dbcbb3f70747c44a77c7bcd40155683ae19c65e1c03b4aa3499c5328201f1" 310 | }, 311 | "kernel_info": { 312 | "name": "conda-env-py37_default-py" 313 | }, 314 | "kernelspec": { 315 | "display_name": "Python 3 (ipykernel)", 316 | "language": "python", 317 | "name": "python3" 318 | }, 319 | "language_info": { 320 | "codemirror_mode": { 321 | "name": "ipython", 322 | "version": 3 323 | }, 324 | "file_extension": ".py", 325 | "mimetype": "text/x-python", 326 | "name": "python", 327 | "nbconvert_exporter": "python", 328 | "pygments_lexer": "ipython3", 329 | "version": "3.11.4" 330 | }, 331 | "nteract": { 332 | "version": "nteract-front-end@1.0.0" 333 | } 334 | }, 335 | "nbformat": 4, 336 | "nbformat_minor": 2 337 | } 338 | -------------------------------------------------------------------------------- /Módulo 5 - Usar operaciones matemáticas/.ipynb_checkpoints/Módulo5Katas-checkpoint.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": { 6 | "slideshow": { 7 | "slide_type": "slide" 8 | } 9 | }, 10 | "source": [ 11 | "# Ejercicio1 - Utilizar operadores aritméticos" 12 | ] 13 | }, 14 | { 15 | "cell_type": "markdown", 16 | "metadata": { 17 | "slideshow": { 18 | "slide_type": "subslide" 19 | } 20 | }, 21 | "source": [ 22 | "### Operadores aritméticos en Python\n", 23 | "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", 24 | "\n", 25 | "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", 26 | "\n", 27 | "> **TIP**\n", 28 | "> 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", 29 | "\n", 30 | "**Nota:** Quita las comas cuando uses los valores." 31 | ] 32 | }, 33 | { 34 | "cell_type": "code", 35 | "execution_count": null, 36 | "metadata": {}, 37 | "outputs": [], 38 | "source": [ 39 | "# Crear variables para almacenar las dos distancias\n", 40 | "# ¡Asegúrate de quitar las comas!" 41 | ] 42 | }, 43 | { 44 | "cell_type": "markdown", 45 | "metadata": {}, 46 | "source": [ 47 | "### Realizar la operación\n", 48 | "\n", 49 | "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`." 50 | ] 51 | }, 52 | { 53 | "cell_type": "code", 54 | "execution_count": null, 55 | "metadata": {}, 56 | "outputs": [], 57 | "source": [ 58 | "# Calcular la distancia entre planetas" 59 | ] 60 | }, 61 | { 62 | "cell_type": "markdown", 63 | "metadata": { 64 | "slideshow": { 65 | "slide_type": "slide" 66 | } 67 | }, 68 | "source": [ 69 | "### Prueba tu proyecto\n", 70 | "\n", 71 | "Con el código creado, ejecuta el notebook para obtener el resultado. Deberías recibir lo siguiente:\n", 72 | "\n", 73 | "```\n", 74 | "628949330\n", 75 | "390577534\n", 76 | "```\n", 77 | "\n", 78 | "> 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", 79 | "\n", 80 | "---" 81 | ] 82 | }, 83 | { 84 | "cell_type": "markdown", 85 | "metadata": { 86 | "slideshow": { 87 | "slide_type": "slide" 88 | } 89 | }, 90 | "source": [ 91 | "## Ejercicio 2: convierte cadenas en números y usa valores absolutos\n", 92 | "\n", 93 | "### Crear una aplicación para trabajar con números y entrada de usuario\n", 94 | "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", 95 | "\n", 96 | "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." 97 | ] 98 | }, 99 | { 100 | "cell_type": "markdown", 101 | "metadata": { 102 | "slideshow": { 103 | "slide_type": "slide" 104 | } 105 | }, 106 | "source": [ 107 | "### Lee los valores\n", 108 | "Usando `input`, agrega el código para leer la distancia del sol para cada planeta, considerando 2 planetas." 109 | ] 110 | }, 111 | { 112 | "cell_type": "code", 113 | "execution_count": null, 114 | "metadata": {}, 115 | "outputs": [], 116 | "source": [ 117 | "# Almacenar las entradas del usuario\n", 118 | "#Pista: variable = input(\"¿Cuál es tu nombre?\")" 119 | ] 120 | }, 121 | { 122 | "cell_type": "markdown", 123 | "metadata": { 124 | "slideshow": { 125 | "slide_type": "subslide" 126 | } 127 | }, 128 | "source": [ 129 | "### Convertir a número\n", 130 | "Debido a que `input` devuelve valores de cadena, necesitamos convertirlos en números. Para nuestro ejemplo, usaremos `int`" 131 | ] 132 | }, 133 | { 134 | "cell_type": "code", 135 | "execution_count": null, 136 | "metadata": {}, 137 | "outputs": [], 138 | "source": [ 139 | "# Convierte las cadenas de ambos planetas a números enteros" 140 | ] 141 | }, 142 | { 143 | "cell_type": "markdown", 144 | "metadata": {}, 145 | "source": [ 146 | "### Realizar el cálculo y convertir a valor absoluto\n", 147 | "\n", 148 | "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" 149 | ] 150 | }, 151 | { 152 | "cell_type": "code", 153 | "execution_count": null, 154 | "metadata": {}, 155 | "outputs": [], 156 | "source": [ 157 | "# Realizar el cálculo y determinar el valor absoluto\n", 158 | "\n", 159 | "\n", 160 | "# Convertir de KM a Millas" 161 | ] 162 | }, 163 | { 164 | "cell_type": "markdown", 165 | "metadata": {}, 166 | "source": [ 167 | "### Prueba tu aplicación\n", 168 | "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", 169 | "\n", 170 | "| Planeta | Distancia al sol |\n", 171 | "| ------- | ----------------- |\n", 172 | "| Mercurio | 57900000 |\n", 173 | "| Venus | 108200000 |\n", 174 | "| Tierra | 149600000 |\n", 175 | "| Marte | 227900000 |\n", 176 | "| Júpiter | 778600000 |\n", 177 | "| Saturno | 1433500000 |\n", 178 | "| Urano | 2872500000 |\n", 179 | "| Neptuno | 4495100000 |" 180 | ] 181 | }, 182 | { 183 | "cell_type": "markdown", 184 | "metadata": { 185 | "slideshow": { 186 | "slide_type": "slide" 187 | } 188 | }, 189 | "source": [ 190 | "## Soluciones" 191 | ] 192 | }, 193 | { 194 | "cell_type": "markdown", 195 | "metadata": { 196 | "slideshow": { 197 | "slide_type": "slide" 198 | } 199 | }, 200 | "source": [ 201 | "### Ejercicio 1" 202 | ] 203 | }, 204 | { 205 | "cell_type": "code", 206 | "execution_count": null, 207 | "metadata": { 208 | "slideshow": { 209 | "slide_type": "slide" 210 | } 211 | }, 212 | "outputs": [], 213 | "source": [ 214 | "# Crear variables para almacenar las dos distancias\n", 215 | "# ¡Asegúrate de quitar las comas!\n", 216 | "\n", 217 | "first_planet = 149597870\n", 218 | "second_planet = 778547200" 219 | ] 220 | }, 221 | { 222 | "cell_type": "code", 223 | "execution_count": null, 224 | "metadata": { 225 | "slideshow": { 226 | "slide_type": "subslide" 227 | } 228 | }, 229 | "outputs": [], 230 | "source": [ 231 | "# Calcular la distancia entre planetas\n", 232 | "\n", 233 | "distance_km = second_planet - first_planet\n", 234 | "print(distance_km)\n", 235 | "\n", 236 | "distance_mi = distance_km * 0.621\n", 237 | "print(distance_mi)" 238 | ] 239 | }, 240 | { 241 | "cell_type": "markdown", 242 | "metadata": { 243 | "slideshow": { 244 | "slide_type": "slide" 245 | } 246 | }, 247 | "source": [ 248 | "### Ejercicio 2" 249 | ] 250 | }, 251 | { 252 | "cell_type": "code", 253 | "execution_count": null, 254 | "metadata": { 255 | "slideshow": { 256 | "slide_type": "subslide" 257 | } 258 | }, 259 | "outputs": [], 260 | "source": [ 261 | "# Almacenar las entradas del usuario\n", 262 | "first_planet = input('Introduzca la distancia del sol para el primer planeta en KM')\n", 263 | "second_planet = input('Introduzca la distancia desde el sol para el segundo planeta en KM')" 264 | ] 265 | }, 266 | { 267 | "cell_type": "code", 268 | "execution_count": null, 269 | "metadata": { 270 | "slideshow": { 271 | "slide_type": "subslide" 272 | } 273 | }, 274 | "outputs": [], 275 | "source": [ 276 | "# Convierte las cadenas de ambos planetas a números enteros\n", 277 | "first_planet = int(first_planet)\n", 278 | "second_planet = int(second_planet)" 279 | ] 280 | }, 281 | { 282 | "cell_type": "code", 283 | "execution_count": null, 284 | "metadata": { 285 | "slideshow": { 286 | "slide_type": "subslide" 287 | } 288 | }, 289 | "outputs": [], 290 | "source": [ 291 | "# Realizar el cálculo y determinar el valor absoluto\n", 292 | "distance_km = second_planet - first_planet\n", 293 | "print(distance_km)\n", 294 | "\n", 295 | "# Convertir de KM a Millas\n", 296 | "distance_mi = distance_km * 0.621\n", 297 | "print(abs(distance_mi))" 298 | ] 299 | } 300 | ], 301 | "metadata": { 302 | "celltoolbar": "Slideshow", 303 | "interpreter": { 304 | "hash": "502cd6c3b6c9e666d195e1caff9d64ea12bf644e547a4c8fae84812082c54b6f" 305 | }, 306 | "kernel_info": { 307 | "name": "conda-env-py37_default-py" 308 | }, 309 | "kernelspec": { 310 | "display_name": "Python 3 (ipykernel)", 311 | "language": "python", 312 | "name": "python3" 313 | }, 314 | "language_info": { 315 | "codemirror_mode": { 316 | "name": "ipython", 317 | "version": 3 318 | }, 319 | "file_extension": ".py", 320 | "mimetype": "text/x-python", 321 | "name": "python", 322 | "nbconvert_exporter": "python", 323 | "pygments_lexer": "ipython3", 324 | "version": "3.11.2" 325 | }, 326 | "nteract": { 327 | "version": "nteract-front-end@1.0.0" 328 | } 329 | }, 330 | "nbformat": 4, 331 | "nbformat_minor": 2 332 | } 333 | -------------------------------------------------------------------------------- /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 | "slideshow": { 7 | "slide_type": "slide" 8 | } 9 | }, 10 | "source": [ 11 | "# Ejercicio1 - Utilizar operadores aritméticos" 12 | ] 13 | }, 14 | { 15 | "cell_type": "markdown", 16 | "metadata": { 17 | "slideshow": { 18 | "slide_type": "subslide" 19 | } 20 | }, 21 | "source": [ 22 | "### Operadores aritméticos en Python\n", 23 | "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", 24 | "\n", 25 | "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", 26 | "\n", 27 | "> **TIP**\n", 28 | "> 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", 29 | "\n", 30 | "**Nota:** Quita las comas cuando uses los valores." 31 | ] 32 | }, 33 | { 34 | "cell_type": "code", 35 | "execution_count": null, 36 | "metadata": {}, 37 | "outputs": [], 38 | "source": [ 39 | "# Crear variables para almacenar las dos distancias\n", 40 | "# ¡Asegúrate de quitar las comas!" 41 | ] 42 | }, 43 | { 44 | "cell_type": "markdown", 45 | "metadata": {}, 46 | "source": [ 47 | "### Realizar la operación\n", 48 | "\n", 49 | "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`." 50 | ] 51 | }, 52 | { 53 | "cell_type": "code", 54 | "execution_count": null, 55 | "metadata": {}, 56 | "outputs": [], 57 | "source": [ 58 | "# Calcular la distancia entre planetas" 59 | ] 60 | }, 61 | { 62 | "cell_type": "markdown", 63 | "metadata": { 64 | "slideshow": { 65 | "slide_type": "slide" 66 | } 67 | }, 68 | "source": [ 69 | "### Prueba tu proyecto\n", 70 | "\n", 71 | "Con el código creado, ejecuta el notebook para obtener el resultado. Deberías recibir lo siguiente:\n", 72 | "\n", 73 | "```\n", 74 | "628949330\n", 75 | "390577534\n", 76 | "```\n", 77 | "\n", 78 | "> 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", 79 | "\n", 80 | "---" 81 | ] 82 | }, 83 | { 84 | "cell_type": "markdown", 85 | "metadata": { 86 | "slideshow": { 87 | "slide_type": "slide" 88 | } 89 | }, 90 | "source": [ 91 | "## Ejercicio 2: convierte cadenas en números y usa valores absolutos\n", 92 | "\n", 93 | "### Crear una aplicación para trabajar con números y entrada de usuario\n", 94 | "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", 95 | "\n", 96 | "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." 97 | ] 98 | }, 99 | { 100 | "cell_type": "markdown", 101 | "metadata": { 102 | "slideshow": { 103 | "slide_type": "slide" 104 | } 105 | }, 106 | "source": [ 107 | "### Lee los valores\n", 108 | "Usando `input`, agrega el código para leer la distancia del sol para cada planeta, considerando 2 planetas." 109 | ] 110 | }, 111 | { 112 | "cell_type": "code", 113 | "execution_count": null, 114 | "metadata": {}, 115 | "outputs": [], 116 | "source": [ 117 | "# Almacenar las entradas del usuario\n", 118 | "#Pista: variable = input(\"¿Cuál es tu nombre?\")" 119 | ] 120 | }, 121 | { 122 | "cell_type": "markdown", 123 | "metadata": { 124 | "slideshow": { 125 | "slide_type": "subslide" 126 | } 127 | }, 128 | "source": [ 129 | "### Convertir a número\n", 130 | "Debido a que `input` devuelve valores de cadena, necesitamos convertirlos en números. Para nuestro ejemplo, usaremos `int`" 131 | ] 132 | }, 133 | { 134 | "cell_type": "code", 135 | "execution_count": null, 136 | "metadata": {}, 137 | "outputs": [], 138 | "source": [ 139 | "# Convierte las cadenas de ambos planetas a números enteros" 140 | ] 141 | }, 142 | { 143 | "cell_type": "markdown", 144 | "metadata": {}, 145 | "source": [ 146 | "### Realizar el cálculo y convertir a valor absoluto\n", 147 | "\n", 148 | "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" 149 | ] 150 | }, 151 | { 152 | "cell_type": "code", 153 | "execution_count": null, 154 | "metadata": {}, 155 | "outputs": [], 156 | "source": [ 157 | "# Realizar el cálculo y determinar el valor absoluto\n", 158 | "\n", 159 | "\n", 160 | "# Convertir de KM a Millas" 161 | ] 162 | }, 163 | { 164 | "cell_type": "markdown", 165 | "metadata": {}, 166 | "source": [ 167 | "### Prueba tu aplicación\n", 168 | "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", 169 | "\n", 170 | "| Planeta | Distancia al sol |\n", 171 | "| ------- | ----------------- |\n", 172 | "| Mercurio | 57900000 |\n", 173 | "| Venus | 108200000 |\n", 174 | "| Tierra | 149600000 |\n", 175 | "| Marte | 227900000 |\n", 176 | "| Júpiter | 778600000 |\n", 177 | "| Saturno | 1433500000 |\n", 178 | "| Urano | 2872500000 |\n", 179 | "| Neptuno | 4495100000 |" 180 | ] 181 | }, 182 | { 183 | "cell_type": "markdown", 184 | "metadata": { 185 | "slideshow": { 186 | "slide_type": "slide" 187 | } 188 | }, 189 | "source": [ 190 | "## Soluciones" 191 | ] 192 | }, 193 | { 194 | "cell_type": "markdown", 195 | "metadata": { 196 | "slideshow": { 197 | "slide_type": "slide" 198 | } 199 | }, 200 | "source": [ 201 | "### Ejercicio 1" 202 | ] 203 | }, 204 | { 205 | "cell_type": "code", 206 | "execution_count": null, 207 | "metadata": { 208 | "slideshow": { 209 | "slide_type": "slide" 210 | } 211 | }, 212 | "outputs": [], 213 | "source": [ 214 | "# Crear variables para almacenar las dos distancias\n", 215 | "# ¡Asegúrate de quitar las comas!\n", 216 | "\n", 217 | "first_planet = 149597870\n", 218 | "second_planet = 778547200" 219 | ] 220 | }, 221 | { 222 | "cell_type": "code", 223 | "execution_count": null, 224 | "metadata": { 225 | "slideshow": { 226 | "slide_type": "subslide" 227 | } 228 | }, 229 | "outputs": [], 230 | "source": [ 231 | "# Calcular la distancia entre planetas\n", 232 | "\n", 233 | "distance_km = second_planet - first_planet\n", 234 | "print(distance_km)\n", 235 | "\n", 236 | "distance_mi = distance_km * 0.621\n", 237 | "print(distance_mi)" 238 | ] 239 | }, 240 | { 241 | "cell_type": "markdown", 242 | "metadata": { 243 | "slideshow": { 244 | "slide_type": "slide" 245 | } 246 | }, 247 | "source": [ 248 | "### Ejercicio 2" 249 | ] 250 | }, 251 | { 252 | "cell_type": "code", 253 | "execution_count": null, 254 | "metadata": { 255 | "slideshow": { 256 | "slide_type": "subslide" 257 | } 258 | }, 259 | "outputs": [], 260 | "source": [ 261 | "# Almacenar las entradas del usuario\n", 262 | "first_planet = input('Introduzca la distancia del sol para el primer planeta en KM')\n", 263 | "second_planet = input('Introduzca la distancia desde el sol para el segundo planeta en KM')" 264 | ] 265 | }, 266 | { 267 | "cell_type": "code", 268 | "execution_count": null, 269 | "metadata": { 270 | "slideshow": { 271 | "slide_type": "subslide" 272 | } 273 | }, 274 | "outputs": [], 275 | "source": [ 276 | "# Convierte las cadenas de ambos planetas a números enteros\n", 277 | "first_planet = int(first_planet)\n", 278 | "second_planet = int(second_planet)" 279 | ] 280 | }, 281 | { 282 | "cell_type": "code", 283 | "execution_count": null, 284 | "metadata": { 285 | "slideshow": { 286 | "slide_type": "subslide" 287 | } 288 | }, 289 | "outputs": [], 290 | "source": [ 291 | "# Realizar el cálculo y determinar el valor absoluto\n", 292 | "distance_km = second_planet - first_planet\n", 293 | "print(distance_km)\n", 294 | "\n", 295 | "# Convertir de KM a Millas\n", 296 | "distance_mi = distance_km * 0.621\n", 297 | "print(abs(distance_mi))" 298 | ] 299 | } 300 | ], 301 | "metadata": { 302 | "celltoolbar": "Slideshow", 303 | "interpreter": { 304 | "hash": "502cd6c3b6c9e666d195e1caff9d64ea12bf644e547a4c8fae84812082c54b6f" 305 | }, 306 | "kernel_info": { 307 | "name": "conda-env-py37_default-py" 308 | }, 309 | "kernelspec": { 310 | "display_name": "Python 3 (ipykernel)", 311 | "language": "python", 312 | "name": "python3" 313 | }, 314 | "language_info": { 315 | "codemirror_mode": { 316 | "name": "ipython", 317 | "version": 3 318 | }, 319 | "file_extension": ".py", 320 | "mimetype": "text/x-python", 321 | "name": "python", 322 | "nbconvert_exporter": "python", 323 | "pygments_lexer": "ipython3", 324 | "version": "3.11.4" 325 | }, 326 | "nteract": { 327 | "version": "nteract-front-end@1.0.0" 328 | } 329 | }, 330 | "nbformat": 4, 331 | "nbformat_minor": 2 332 | } 333 | -------------------------------------------------------------------------------- /Módulo 6 - Introducción a las listas/.ipynb_checkpoints/Módulo6Katas-checkpoint.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": { 6 | "slideshow": { 7 | "slide_type": "slide" 8 | } 9 | }, 10 | "source": [ 11 | "# Ejercicio1: Crear y usar listas de Python\n" 12 | ] 13 | }, 14 | { 15 | "cell_type": "markdown", 16 | "metadata": { 17 | "slideshow": { 18 | "slide_type": "slide" 19 | } 20 | }, 21 | "source": [ 22 | "### Ejercicio: Usar listas para almacenar nombres de planetas\n", 23 | "Las listas permiten almacenar varios valores en una sola variable. Comenzarás un proyecto sobre información planetaria creando una lista de planetas.\n", 24 | "\n", 25 | "> **TIP**\n", 26 | "> 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" 27 | ] 28 | }, 29 | { 30 | "cell_type": "markdown", 31 | "metadata": {}, 32 | "source": [ 33 | "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." 34 | ] 35 | }, 36 | { 37 | "cell_type": "code", 38 | "execution_count": null, 39 | "metadata": {}, 40 | "outputs": [], 41 | "source": [ 42 | "# Creamos la lista planets y la mostramos" 43 | ] 44 | }, 45 | { 46 | "cell_type": "markdown", 47 | "metadata": {}, 48 | "source": [ 49 | "Agrega a Plutón a la lista que creaste. Luego muestra tanto el número de planetas como el último planeta de la lista." 50 | ] 51 | }, 52 | { 53 | "cell_type": "code", 54 | "execution_count": null, 55 | "metadata": {}, 56 | "outputs": [], 57 | "source": [ 58 | "# Agregamos a plutón y mostramos el último elemento" 59 | ] 60 | }, 61 | { 62 | "cell_type": "markdown", 63 | "metadata": {}, 64 | "source": [ 65 | "> 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!" 66 | ] 67 | }, 68 | { 69 | "cell_type": "markdown", 70 | "metadata": { 71 | "slideshow": { 72 | "slide_type": "slide" 73 | } 74 | }, 75 | "source": [ 76 | "## Ejercicio 2: Trabajando con datos de una lista\n", 77 | "\n", 78 | "### Usar slices para recuperar partes de una lista" 79 | ] 80 | }, 81 | { 82 | "cell_type": "markdown", 83 | "metadata": { 84 | "slideshow": { 85 | "slide_type": "subslide" 86 | } 87 | }, 88 | "source": [ 89 | "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", 90 | "\n", 91 | "Comienza agregando el código para crear una lista con los planetas." 92 | ] 93 | }, 94 | { 95 | "cell_type": "code", 96 | "execution_count": null, 97 | "metadata": {}, 98 | "outputs": [], 99 | "source": [ 100 | "# Lista de planetas\n", 101 | "planets = ['Mercury', 'Venus', 'Earth', 'Mars', 'Jupiter', 'Saturn', 'Neptune']" 102 | ] 103 | }, 104 | { 105 | "cell_type": "markdown", 106 | "metadata": {}, 107 | "source": [ 108 | "### Solicita al usuario el nombre de un planeta\n", 109 | "\n", 110 | "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." 111 | ] 112 | }, 113 | { 114 | "cell_type": "code", 115 | "execution_count": null, 116 | "metadata": {}, 117 | "outputs": [], 118 | "source": [ 119 | "# Solicitamos el nombre de un planeta *Pista: input()*" 120 | ] 121 | }, 122 | { 123 | "cell_type": "markdown", 124 | "metadata": {}, 125 | "source": [ 126 | "### Encuentra el planeta en la lista\n", 127 | "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." 128 | ] 129 | }, 130 | { 131 | "cell_type": "code", 132 | "execution_count": null, 133 | "metadata": {}, 134 | "outputs": [], 135 | "source": [ 136 | "# Busca el planeta en la lista" 137 | ] 138 | }, 139 | { 140 | "cell_type": "markdown", 141 | "metadata": {}, 142 | "source": [ 143 | "### Mostrar planetas más cercanos al sol que el que el usuario ingresó\n", 144 | "\n", 145 | "Con el índice determinado, ahora puedes agregar el código para mostrar los planetas más cercanos al sol." 146 | ] 147 | }, 148 | { 149 | "cell_type": "code", 150 | "execution_count": null, 151 | "metadata": {}, 152 | "outputs": [], 153 | "source": [ 154 | "# Muestra los planetas más cercanos al sol" 155 | ] 156 | }, 157 | { 158 | "cell_type": "markdown", 159 | "metadata": {}, 160 | "source": [ 161 | "# Mostrar planetas más alejados del sol que el que el usuario ingresó\n", 162 | "\n", 163 | "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." 164 | ] 165 | }, 166 | { 167 | "cell_type": "code", 168 | "execution_count": null, 169 | "metadata": {}, 170 | "outputs": [], 171 | "source": [ 172 | "# Muestra los planetas más lejanos al sol" 173 | ] 174 | }, 175 | { 176 | "cell_type": "markdown", 177 | "metadata": {}, 178 | "source": [ 179 | "## Soluciones" 180 | ] 181 | }, 182 | { 183 | "cell_type": "markdown", 184 | "metadata": { 185 | "slideshow": { 186 | "slide_type": "slide" 187 | } 188 | }, 189 | "source": [ 190 | "### Ejercicio 1" 191 | ] 192 | }, 193 | { 194 | "cell_type": "code", 195 | "execution_count": null, 196 | "metadata": { 197 | "slideshow": { 198 | "slide_type": "subslide" 199 | } 200 | }, 201 | "outputs": [], 202 | "source": [ 203 | "# Creamos la lista planets y la mostramos\n", 204 | "\n", 205 | "planets = ['Mercury', 'Venus', 'Earth', 'Mars', 'Jupiter', 'Saturn', 'Uranus', 'Neptune']\n", 206 | "\n", 207 | "print('There are', len(planets), 'planets')" 208 | ] 209 | }, 210 | { 211 | "cell_type": "code", 212 | "execution_count": null, 213 | "metadata": { 214 | "slideshow": { 215 | "slide_type": "subslide" 216 | } 217 | }, 218 | "outputs": [], 219 | "source": [ 220 | "# Agregamos a plutón y mostramos el último elemento\n", 221 | "\n", 222 | "planets.append('Pluto')\n", 223 | "\n", 224 | "print(planets[-1], 'is the last planet')" 225 | ] 226 | }, 227 | { 228 | "cell_type": "markdown", 229 | "metadata": { 230 | "slideshow": { 231 | "slide_type": "slide" 232 | } 233 | }, 234 | "source": [ 235 | "## Ejercicio 2" 236 | ] 237 | }, 238 | { 239 | "cell_type": "code", 240 | "execution_count": null, 241 | "metadata": { 242 | "slideshow": { 243 | "slide_type": "subslide" 244 | } 245 | }, 246 | "outputs": [], 247 | "source": [ 248 | "# Lista de planetas\n", 249 | "\n", 250 | "planets = ['Mercury', 'Venus', 'Earth', 'Mars', 'Jupiter', 'Saturn', 'Neptune']" 251 | ] 252 | }, 253 | { 254 | "cell_type": "code", 255 | "execution_count": null, 256 | "metadata": { 257 | "slideshow": { 258 | "slide_type": "subslide" 259 | } 260 | }, 261 | "outputs": [], 262 | "source": [ 263 | "# Solicitamos el nombre de un planeta *Pista: input()*\n", 264 | "user_planet = input('Please enter the name of the planet (with a capital letter to start)')" 265 | ] 266 | }, 267 | { 268 | "cell_type": "code", 269 | "execution_count": null, 270 | "metadata": { 271 | "slideshow": { 272 | "slide_type": "subslide" 273 | } 274 | }, 275 | "outputs": [], 276 | "source": [ 277 | "# Busca el planeta en la lista\n", 278 | "\n", 279 | "planet_index = planets.index(user_planet)" 280 | ] 281 | }, 282 | { 283 | "cell_type": "code", 284 | "execution_count": null, 285 | "metadata": { 286 | "slideshow": { 287 | "slide_type": "subslide" 288 | } 289 | }, 290 | "outputs": [], 291 | "source": [ 292 | "# Muestra los planetas más cercanos al sol\n", 293 | "\n", 294 | "print('Here are the planets closer than ' + user_planet)\n", 295 | "print(planets[0:planet_index])" 296 | ] 297 | }, 298 | { 299 | "cell_type": "code", 300 | "execution_count": null, 301 | "metadata": { 302 | "slideshow": { 303 | "slide_type": "subslide" 304 | } 305 | }, 306 | "outputs": [], 307 | "source": [ 308 | "# Muestra los planetas más lejanos al sol\n", 309 | "\n", 310 | "print('Here are the planets further than ' + user_planet)\n", 311 | "print(planets[planet_index + 1:])" 312 | ] 313 | } 314 | ], 315 | "metadata": { 316 | "celltoolbar": "Slideshow", 317 | "interpreter": { 318 | "hash": "b8bdd4e700647ba2b08c59e5df8b7da1dcf50a218bcd4c1bcd9b3dc92e8788e5" 319 | }, 320 | "kernelspec": { 321 | "display_name": "Python 3 (ipykernel)", 322 | "language": "python", 323 | "name": "python3" 324 | }, 325 | "language_info": { 326 | "codemirror_mode": { 327 | "name": "ipython", 328 | "version": 3 329 | }, 330 | "file_extension": ".py", 331 | "mimetype": "text/x-python", 332 | "name": "python", 333 | "nbconvert_exporter": "python", 334 | "pygments_lexer": "ipython3", 335 | "version": "3.11.2" 336 | }, 337 | "nteract": { 338 | "version": "nteract-front-end@1.0.0" 339 | } 340 | }, 341 | "nbformat": 4, 342 | "nbformat_minor": 4 343 | } 344 | -------------------------------------------------------------------------------- /Módulo 6 - Introducción a las listas/Módulo6Katas.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": { 6 | "slideshow": { 7 | "slide_type": "slide" 8 | } 9 | }, 10 | "source": [ 11 | "# Ejercicio1: Crear y usar listas de Python\n" 12 | ] 13 | }, 14 | { 15 | "cell_type": "markdown", 16 | "metadata": { 17 | "slideshow": { 18 | "slide_type": "slide" 19 | } 20 | }, 21 | "source": [ 22 | "### Ejercicio: Usar listas para almacenar nombres de planetas\n", 23 | "Las listas permiten almacenar varios valores en una sola variable. Comenzarás un proyecto sobre información planetaria creando una lista de planetas.\n", 24 | "\n", 25 | "> **TIP**\n", 26 | "> 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" 27 | ] 28 | }, 29 | { 30 | "cell_type": "markdown", 31 | "metadata": {}, 32 | "source": [ 33 | "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." 34 | ] 35 | }, 36 | { 37 | "cell_type": "code", 38 | "execution_count": null, 39 | "metadata": {}, 40 | "outputs": [], 41 | "source": [ 42 | "# Creamos la lista planets y la mostramos" 43 | ] 44 | }, 45 | { 46 | "cell_type": "markdown", 47 | "metadata": {}, 48 | "source": [ 49 | "Agrega a Plutón a la lista que creaste. Luego muestra tanto el número de planetas como el último planeta de la lista." 50 | ] 51 | }, 52 | { 53 | "cell_type": "code", 54 | "execution_count": null, 55 | "metadata": {}, 56 | "outputs": [], 57 | "source": [ 58 | "# Agregamos a plutón y mostramos el último elemento" 59 | ] 60 | }, 61 | { 62 | "cell_type": "markdown", 63 | "metadata": {}, 64 | "source": [ 65 | "> 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!" 66 | ] 67 | }, 68 | { 69 | "cell_type": "markdown", 70 | "metadata": { 71 | "slideshow": { 72 | "slide_type": "slide" 73 | } 74 | }, 75 | "source": [ 76 | "## Ejercicio 2: Trabajando con datos de una lista\n", 77 | "\n", 78 | "### Usar slices para recuperar partes de una lista" 79 | ] 80 | }, 81 | { 82 | "cell_type": "markdown", 83 | "metadata": { 84 | "slideshow": { 85 | "slide_type": "subslide" 86 | } 87 | }, 88 | "source": [ 89 | "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", 90 | "\n", 91 | "Comienza agregando el código para crear una lista con los planetas." 92 | ] 93 | }, 94 | { 95 | "cell_type": "code", 96 | "execution_count": null, 97 | "metadata": {}, 98 | "outputs": [], 99 | "source": [ 100 | "# Lista de planetas\n", 101 | "planets = ['Mercury', 'Venus', 'Earth', 'Mars', 'Jupiter', 'Saturn', 'Neptune']" 102 | ] 103 | }, 104 | { 105 | "cell_type": "markdown", 106 | "metadata": {}, 107 | "source": [ 108 | "### Solicita al usuario el nombre de un planeta\n", 109 | "\n", 110 | "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." 111 | ] 112 | }, 113 | { 114 | "cell_type": "code", 115 | "execution_count": null, 116 | "metadata": {}, 117 | "outputs": [], 118 | "source": [ 119 | "# Solicitamos el nombre de un planeta *Pista: input()*" 120 | ] 121 | }, 122 | { 123 | "cell_type": "markdown", 124 | "metadata": {}, 125 | "source": [ 126 | "### Encuentra el planeta en la lista\n", 127 | "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." 128 | ] 129 | }, 130 | { 131 | "cell_type": "code", 132 | "execution_count": null, 133 | "metadata": {}, 134 | "outputs": [], 135 | "source": [ 136 | "# Busca el planeta en la lista" 137 | ] 138 | }, 139 | { 140 | "cell_type": "markdown", 141 | "metadata": {}, 142 | "source": [ 143 | "### Mostrar planetas más cercanos al sol que el que el usuario ingresó\n", 144 | "\n", 145 | "Con el índice determinado, ahora puedes agregar el código para mostrar los planetas más cercanos al sol." 146 | ] 147 | }, 148 | { 149 | "cell_type": "code", 150 | "execution_count": null, 151 | "metadata": {}, 152 | "outputs": [], 153 | "source": [ 154 | "# Muestra los planetas más cercanos al sol" 155 | ] 156 | }, 157 | { 158 | "cell_type": "markdown", 159 | "metadata": {}, 160 | "source": [ 161 | "# Mostrar planetas más alejados del sol que el que el usuario ingresó\n", 162 | "\n", 163 | "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." 164 | ] 165 | }, 166 | { 167 | "cell_type": "code", 168 | "execution_count": null, 169 | "metadata": {}, 170 | "outputs": [], 171 | "source": [ 172 | "# Muestra los planetas más lejanos al sol" 173 | ] 174 | }, 175 | { 176 | "cell_type": "markdown", 177 | "metadata": {}, 178 | "source": [ 179 | "## Soluciones" 180 | ] 181 | }, 182 | { 183 | "cell_type": "markdown", 184 | "metadata": { 185 | "slideshow": { 186 | "slide_type": "slide" 187 | } 188 | }, 189 | "source": [ 190 | "### Ejercicio 1" 191 | ] 192 | }, 193 | { 194 | "cell_type": "code", 195 | "execution_count": null, 196 | "metadata": { 197 | "slideshow": { 198 | "slide_type": "subslide" 199 | } 200 | }, 201 | "outputs": [], 202 | "source": [ 203 | "# Creamos la lista planets y la mostramos\n", 204 | "\n", 205 | "planets = ['Mercury', 'Venus', 'Earth', 'Mars', 'Jupiter', 'Saturn', 'Uranus', 'Neptune']\n", 206 | "\n", 207 | "print('There are', len(planets), 'planets')" 208 | ] 209 | }, 210 | { 211 | "cell_type": "code", 212 | "execution_count": null, 213 | "metadata": { 214 | "slideshow": { 215 | "slide_type": "subslide" 216 | } 217 | }, 218 | "outputs": [], 219 | "source": [ 220 | "# Agregamos a plutón y mostramos el último elemento\n", 221 | "\n", 222 | "planets.append('Pluto')\n", 223 | "\n", 224 | "print(planets[-1], 'is the last planet')" 225 | ] 226 | }, 227 | { 228 | "cell_type": "markdown", 229 | "metadata": { 230 | "slideshow": { 231 | "slide_type": "slide" 232 | } 233 | }, 234 | "source": [ 235 | "## Ejercicio 2" 236 | ] 237 | }, 238 | { 239 | "cell_type": "code", 240 | "execution_count": null, 241 | "metadata": { 242 | "slideshow": { 243 | "slide_type": "subslide" 244 | } 245 | }, 246 | "outputs": [], 247 | "source": [ 248 | "# Lista de planetas\n", 249 | "\n", 250 | "planets = ['Mercury', 'Venus', 'Earth', 'Mars', 'Jupiter', 'Saturn', 'Neptune']" 251 | ] 252 | }, 253 | { 254 | "cell_type": "code", 255 | "execution_count": null, 256 | "metadata": { 257 | "slideshow": { 258 | "slide_type": "subslide" 259 | } 260 | }, 261 | "outputs": [], 262 | "source": [ 263 | "# Solicitamos el nombre de un planeta *Pista: input()*\n", 264 | "user_planet = input('Please enter the name of the planet (with a capital letter to start)')" 265 | ] 266 | }, 267 | { 268 | "cell_type": "code", 269 | "execution_count": null, 270 | "metadata": { 271 | "slideshow": { 272 | "slide_type": "subslide" 273 | } 274 | }, 275 | "outputs": [], 276 | "source": [ 277 | "# Busca el planeta en la lista\n", 278 | "\n", 279 | "planet_index = planets.index(user_planet)" 280 | ] 281 | }, 282 | { 283 | "cell_type": "code", 284 | "execution_count": null, 285 | "metadata": { 286 | "slideshow": { 287 | "slide_type": "subslide" 288 | } 289 | }, 290 | "outputs": [], 291 | "source": [ 292 | "# Muestra los planetas más cercanos al sol\n", 293 | "\n", 294 | "print('Here are the planets closer than ' + user_planet)\n", 295 | "print(planets[0:planet_index])" 296 | ] 297 | }, 298 | { 299 | "cell_type": "code", 300 | "execution_count": null, 301 | "metadata": { 302 | "slideshow": { 303 | "slide_type": "subslide" 304 | } 305 | }, 306 | "outputs": [], 307 | "source": [ 308 | "# Muestra los planetas más lejanos al sol\n", 309 | "\n", 310 | "print('Here are the planets further than ' + user_planet)\n", 311 | "print(planets[planet_index + 1:])" 312 | ] 313 | } 314 | ], 315 | "metadata": { 316 | "celltoolbar": "Slideshow", 317 | "interpreter": { 318 | "hash": "b8bdd4e700647ba2b08c59e5df8b7da1dcf50a218bcd4c1bcd9b3dc92e8788e5" 319 | }, 320 | "kernelspec": { 321 | "display_name": "Python 3 (ipykernel)", 322 | "language": "python", 323 | "name": "python3" 324 | }, 325 | "language_info": { 326 | "codemirror_mode": { 327 | "name": "ipython", 328 | "version": 3 329 | }, 330 | "file_extension": ".py", 331 | "mimetype": "text/x-python", 332 | "name": "python", 333 | "nbconvert_exporter": "python", 334 | "pygments_lexer": "ipython3", 335 | "version": "3.11.2" 336 | }, 337 | "nteract": { 338 | "version": "nteract-front-end@1.0.0" 339 | } 340 | }, 341 | "nbformat": 4, 342 | "nbformat_minor": 4 343 | } 344 | -------------------------------------------------------------------------------- /Módulo 7 - Estructuras de control/.ipynb_checkpoints/Módulo7Katas-checkpoint.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": { 6 | "slideshow": { 7 | "slide_type": "slide" 8 | } 9 | }, 10 | "source": [ 11 | "# Ejercicio 1: Creación de un bucle \"while\"" 12 | ] 13 | }, 14 | { 15 | "cell_type": "markdown", 16 | "metadata": { 17 | "slideshow": { 18 | "slide_type": "slide" 19 | } 20 | }, 21 | "source": [ 22 | "### Ejercicio 1: Uso de ciclos `while` en Python\n", 23 | "\n", 24 | "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", 25 | "\n", 26 | "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", 27 | "\n", 28 | "> **TIP**\n", 29 | "> 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", 30 | "\n", 31 | "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`." 32 | ] 33 | }, 34 | { 35 | "cell_type": "code", 36 | "execution_count": null, 37 | "metadata": {}, 38 | "outputs": [], 39 | "source": [ 40 | "# Declara dos variables" 41 | ] 42 | }, 43 | { 44 | "cell_type": "markdown", 45 | "metadata": { 46 | "slideshow": { 47 | "slide_type": "slide" 48 | } 49 | }, 50 | "source": [ 51 | "### Crea un ciclo `while`\n", 52 | "\n", 53 | "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", 54 | "\n", 55 | "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", 56 | "\n", 57 | "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`." 58 | ] 59 | }, 60 | { 61 | "cell_type": "code", 62 | "execution_count": 2, 63 | "metadata": {}, 64 | "outputs": [], 65 | "source": [ 66 | "# Escribe el ciclo while solicitado" 67 | ] 68 | }, 69 | { 70 | "cell_type": "markdown", 71 | "metadata": {}, 72 | "source": [ 73 | "> 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!" 74 | ] 75 | }, 76 | { 77 | "cell_type": "markdown", 78 | "metadata": { 79 | "slideshow": { 80 | "slide_type": "slide" 81 | } 82 | }, 83 | "source": [ 84 | "## Ejercicio 2: Creación de un ciclo \"for\"" 85 | ] 86 | }, 87 | { 88 | "cell_type": "markdown", 89 | "metadata": { 90 | "slideshow": { 91 | "slide_type": "subslide" 92 | } 93 | }, 94 | "source": [ 95 | "### Ejercicio: - Ciclo para una lista\n", 96 | "\n", 97 | "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", 98 | "\n", 99 | "### Mostrar la lista de los planetas\n", 100 | "\n", 101 | "La variable `planets` almacena los nombres de planeta que ha introducido un usuario. Ahora usarás un ciclo para mostrar esas entradas.\n", 102 | "\n", 103 | "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`." 104 | ] 105 | }, 106 | { 107 | "cell_type": "code", 108 | "execution_count": null, 109 | "metadata": {}, 110 | "outputs": [], 111 | "source": [ 112 | "# Escribe tu ciclo for para iterar en una lista de planetas" 113 | ] 114 | }, 115 | { 116 | "cell_type": "markdown", 117 | "metadata": {}, 118 | "source": [ 119 | "## Soluciones" 120 | ] 121 | }, 122 | { 123 | "cell_type": "markdown", 124 | "metadata": { 125 | "slideshow": { 126 | "slide_type": "slide" 127 | } 128 | }, 129 | "source": [ 130 | "### Ejercicio 1" 131 | ] 132 | }, 133 | { 134 | "cell_type": "code", 135 | "execution_count": null, 136 | "metadata": { 137 | "slideshow": { 138 | "slide_type": "subslide" 139 | } 140 | }, 141 | "outputs": [], 142 | "source": [ 143 | "# Declaramos 2 variables\n", 144 | "\n", 145 | "new_planet = ''\n", 146 | "planets = []" 147 | ] 148 | }, 149 | { 150 | "cell_type": "code", 151 | "execution_count": null, 152 | "metadata": { 153 | "slideshow": { 154 | "slide_type": "subslide" 155 | } 156 | }, 157 | "outputs": [], 158 | "source": [ 159 | "# Escribe el ciclo while solicitado\n", 160 | "\n", 161 | "while new_planet.lower() != 'done':\n", 162 | " if new_planet:\n", 163 | " planets.append(new_planet)\n", 164 | " new_planet = input('Enter a new planet ')" 165 | ] 166 | }, 167 | { 168 | "cell_type": "markdown", 169 | "metadata": { 170 | "slideshow": { 171 | "slide_type": "slide" 172 | } 173 | }, 174 | "source": [ 175 | "### Ejercicio 2" 176 | ] 177 | }, 178 | { 179 | "cell_type": "code", 180 | "execution_count": null, 181 | "metadata": { 182 | "slideshow": { 183 | "slide_type": "subslide" 184 | } 185 | }, 186 | "outputs": [], 187 | "source": [ 188 | "# Escribe tu ciclo for para iterar en una lista de planetas\n", 189 | "\n", 190 | "for planet in planets:\n", 191 | " print(planet)" 192 | ] 193 | } 194 | ], 195 | "metadata": { 196 | "celltoolbar": "Slideshow", 197 | "interpreter": { 198 | "hash": "916dbcbb3f70747c44a77c7bcd40155683ae19c65e1c03b4aa3499c5328201f1" 199 | }, 200 | "kernelspec": { 201 | "display_name": "Python 3 (ipykernel)", 202 | "language": "python", 203 | "name": "python3" 204 | }, 205 | "language_info": { 206 | "codemirror_mode": { 207 | "name": "ipython", 208 | "version": 3 209 | }, 210 | "file_extension": ".py", 211 | "mimetype": "text/x-python", 212 | "name": "python", 213 | "nbconvert_exporter": "python", 214 | "pygments_lexer": "ipython3", 215 | "version": "3.11.2" 216 | }, 217 | "nteract": { 218 | "version": "nteract-front-end@1.0.0" 219 | } 220 | }, 221 | "nbformat": 4, 222 | "nbformat_minor": 2 223 | } 224 | -------------------------------------------------------------------------------- /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 fastrack de python 177 | 178 | Material desarrollado con base en los contenidos de MSLearn - 179 | 180 | Redes: 181 | * GitHub: [javierIA](https://github.com/javierIA) 182 | * Twitter: [@Xavi_Error](https://twitter.com/Xavi_Error) 183 | * Instagram: [xavierfloresx2](https://www.instagram.com/xavierfloresx2/) -------------------------------------------------------------------------------- /Módulo 7 - Estructuras de control/Módulo7Katas.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": { 6 | "slideshow": { 7 | "slide_type": "slide" 8 | } 9 | }, 10 | "source": [ 11 | "# Ejercicio 1: Creación de un bucle \"while\"" 12 | ] 13 | }, 14 | { 15 | "cell_type": "markdown", 16 | "metadata": { 17 | "slideshow": { 18 | "slide_type": "slide" 19 | } 20 | }, 21 | "source": [ 22 | "### Ejercicio 1: Uso de ciclos `while` en Python\n", 23 | "\n", 24 | "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", 25 | "\n", 26 | "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", 27 | "\n", 28 | "> **TIP**\n", 29 | "> 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", 30 | "\n", 31 | "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`." 32 | ] 33 | }, 34 | { 35 | "cell_type": "code", 36 | "execution_count": null, 37 | "metadata": {}, 38 | "outputs": [], 39 | "source": [ 40 | "# Declara dos variables" 41 | ] 42 | }, 43 | { 44 | "cell_type": "markdown", 45 | "metadata": { 46 | "slideshow": { 47 | "slide_type": "slide" 48 | } 49 | }, 50 | "source": [ 51 | "### Crea un ciclo `while`\n", 52 | "\n", 53 | "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", 54 | "\n", 55 | "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", 56 | "\n", 57 | "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`." 58 | ] 59 | }, 60 | { 61 | "cell_type": "code", 62 | "execution_count": 2, 63 | "metadata": {}, 64 | "outputs": [], 65 | "source": [ 66 | "# Escribe el ciclo while solicitado" 67 | ] 68 | }, 69 | { 70 | "cell_type": "markdown", 71 | "metadata": {}, 72 | "source": [ 73 | "> 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!" 74 | ] 75 | }, 76 | { 77 | "cell_type": "markdown", 78 | "metadata": { 79 | "slideshow": { 80 | "slide_type": "slide" 81 | } 82 | }, 83 | "source": [ 84 | "## Ejercicio 2: Creación de un ciclo \"for\"" 85 | ] 86 | }, 87 | { 88 | "cell_type": "markdown", 89 | "metadata": { 90 | "slideshow": { 91 | "slide_type": "subslide" 92 | } 93 | }, 94 | "source": [ 95 | "### Ejercicio: - Ciclo para una lista\n", 96 | "\n", 97 | "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", 98 | "\n", 99 | "### Mostrar la lista de los planetas\n", 100 | "\n", 101 | "La variable `planets` almacena los nombres de planeta que ha introducido un usuario. Ahora usarás un ciclo para mostrar esas entradas.\n", 102 | "\n", 103 | "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`." 104 | ] 105 | }, 106 | { 107 | "cell_type": "code", 108 | "execution_count": null, 109 | "metadata": {}, 110 | "outputs": [], 111 | "source": [ 112 | "# Escribe tu ciclo for para iterar en una lista de planetas" 113 | ] 114 | }, 115 | { 116 | "cell_type": "markdown", 117 | "metadata": {}, 118 | "source": [ 119 | "## Soluciones" 120 | ] 121 | }, 122 | { 123 | "cell_type": "markdown", 124 | "metadata": { 125 | "slideshow": { 126 | "slide_type": "slide" 127 | } 128 | }, 129 | "source": [ 130 | "### Ejercicio 1" 131 | ] 132 | }, 133 | { 134 | "cell_type": "code", 135 | "execution_count": null, 136 | "metadata": { 137 | "slideshow": { 138 | "slide_type": "subslide" 139 | } 140 | }, 141 | "outputs": [], 142 | "source": [ 143 | "# Declaramos 2 variables\n", 144 | "\n", 145 | "new_planet = ''\n", 146 | "planets = []" 147 | ] 148 | }, 149 | { 150 | "cell_type": "code", 151 | "execution_count": null, 152 | "metadata": { 153 | "slideshow": { 154 | "slide_type": "subslide" 155 | } 156 | }, 157 | "outputs": [], 158 | "source": [ 159 | "# Escribe el ciclo while solicitado\n", 160 | "\n", 161 | "while new_planet.lower() != 'done':\n", 162 | " if new_planet:\n", 163 | " planets.append(new_planet)\n", 164 | " new_planet = input('Enter a new planet ')" 165 | ] 166 | }, 167 | { 168 | "cell_type": "markdown", 169 | "metadata": { 170 | "slideshow": { 171 | "slide_type": "slide" 172 | } 173 | }, 174 | "source": [ 175 | "### Ejercicio 2" 176 | ] 177 | }, 178 | { 179 | "cell_type": "code", 180 | "execution_count": null, 181 | "metadata": { 182 | "slideshow": { 183 | "slide_type": "subslide" 184 | } 185 | }, 186 | "outputs": [], 187 | "source": [ 188 | "# Escribe tu ciclo for para iterar en una lista de planetas\n", 189 | "\n", 190 | "for planet in planets:\n", 191 | " print(planet)" 192 | ] 193 | } 194 | ], 195 | "metadata": { 196 | "celltoolbar": "Slideshow", 197 | "interpreter": { 198 | "hash": "916dbcbb3f70747c44a77c7bcd40155683ae19c65e1c03b4aa3499c5328201f1" 199 | }, 200 | "kernelspec": { 201 | "display_name": "Python 3 (ipykernel)", 202 | "language": "python", 203 | "name": "python3" 204 | }, 205 | "language_info": { 206 | "codemirror_mode": { 207 | "name": "ipython", 208 | "version": 3 209 | }, 210 | "file_extension": ".py", 211 | "mimetype": "text/x-python", 212 | "name": "python", 213 | "nbconvert_exporter": "python", 214 | "pygments_lexer": "ipython3", 215 | "version": "3.11.2" 216 | }, 217 | "nteract": { 218 | "version": "nteract-front-end@1.0.0" 219 | } 220 | }, 221 | "nbformat": 4, 222 | "nbformat_minor": 2 223 | } 224 | -------------------------------------------------------------------------------- /Módulo 8 - Administrar datos con diccionarios/.ipynb_checkpoints/Módulo8Katas-checkpoint.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": { 6 | "slideshow": { 7 | "slide_type": "slide" 8 | } 9 | }, 10 | "source": [ 11 | "# Ejercicio 1: Creación de diccionarios de Python" 12 | ] 13 | }, 14 | { 15 | "cell_type": "markdown", 16 | "metadata": { 17 | "slideshow": { 18 | "slide_type": "subslide" 19 | } 20 | }, 21 | "source": [ 22 | "### Ejercicio: Crear y modificar un diccionario de Python\n", 23 | "\n", 24 | "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", 25 | "\n", 26 | "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", 27 | "\n", 28 | "```python\n", 29 | "demo = {\n", 30 | " 'key': 'value',\n", 31 | " 'number': 42\n", 32 | "}\n", 33 | "```\n", 34 | "\n", 35 | "Para este ejercicio, crearás un diccionario que almacene información sobre el planeta Marte.\n", 36 | "\n", 37 | "\n", 38 | "> **TIP**\n", 39 | "> 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", 40 | "\n", 41 | "Agrega el código para crear un nuevo diccionario denominado 'planet'. Rellena con la siguiente información:\n", 42 | "\n", 43 | "```\n", 44 | "name: Mars\n", 45 | "moons: 2\n", 46 | "```" 47 | ] 48 | }, 49 | { 50 | "cell_type": "code", 51 | "execution_count": null, 52 | "metadata": {}, 53 | "outputs": [], 54 | "source": [ 55 | "# Crea un diccionario llamado planet con los datos propuestos" 56 | ] 57 | }, 58 | { 59 | "cell_type": "markdown", 60 | "metadata": {}, 61 | "source": [ 62 | "Para recuperar valores, puede utilizar el método `get` o corchetes (`[ ]`) con el nombre de la clave que desea recuperar." 63 | ] 64 | }, 65 | { 66 | "cell_type": "code", 67 | "execution_count": null, 68 | "metadata": {}, 69 | "outputs": [], 70 | "source": [ 71 | "# Muestra el nombre del planeta y el número de lunas que tiene." 72 | ] 73 | }, 74 | { 75 | "cell_type": "markdown", 76 | "metadata": { 77 | "slideshow": { 78 | "slide_type": "slide" 79 | } 80 | }, 81 | "source": [ 82 | "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", 83 | "\n", 84 | "\n", 85 | "```python\n", 86 | "demo['new_key'] = 'New value'\n", 87 | "```\n", 88 | "\n", 89 | "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", 90 | "\n", 91 | "```\n", 92 | "polar: 6752\n", 93 | "equatorial: 6792\n", 94 | "```\n" 95 | ] 96 | }, 97 | { 98 | "cell_type": "code", 99 | "execution_count": null, 100 | "metadata": {}, 101 | "outputs": [], 102 | "source": [ 103 | "# Agrega la clave circunferencia con los datos proporcionados previamente" 104 | ] 105 | }, 106 | { 107 | "cell_type": "markdown", 108 | "metadata": { 109 | "slideshow": { 110 | "slide_type": "subslide" 111 | } 112 | }, 113 | "source": [ 114 | "Imprime el nombre del planeta con su circunferencia polar." 115 | ] 116 | }, 117 | { 118 | "cell_type": "code", 119 | "execution_count": null, 120 | "metadata": {}, 121 | "outputs": [], 122 | "source": [ 123 | "# Imprime el nombre del planeta con su circunferencia polar." 124 | ] 125 | }, 126 | { 127 | "cell_type": "markdown", 128 | "metadata": {}, 129 | "source": [ 130 | "> 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!" 131 | ] 132 | }, 133 | { 134 | "cell_type": "markdown", 135 | "metadata": { 136 | "slideshow": { 137 | "slide_type": "slide" 138 | } 139 | }, 140 | "source": [ 141 | "## Ejercicio 2: Programación dinámica con diccionarios" 142 | ] 143 | }, 144 | { 145 | "cell_type": "markdown", 146 | "metadata": { 147 | "slideshow": { 148 | "slide_type": "subslide" 149 | } 150 | }, 151 | "source": [ 152 | "### Ejercicio: Cálculo de valores\n", 153 | "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." 154 | ] 155 | }, 156 | { 157 | "cell_type": "code", 158 | "execution_count": null, 159 | "metadata": { 160 | "slideshow": { 161 | "slide_type": "subslide" 162 | } 163 | }, 164 | "outputs": [], 165 | "source": [ 166 | "# Planets and moons\n", 167 | "\n", 168 | "planet_moons = {\n", 169 | " 'mercury': 0,\n", 170 | " 'venus': 0,\n", 171 | " 'earth': 1,\n", 172 | " 'mars': 2,\n", 173 | " 'jupiter': 79,\n", 174 | " 'saturn': 82,\n", 175 | " 'uranus': 27,\n", 176 | " 'neptune': 14,\n", 177 | " 'pluto': 5,\n", 178 | " 'haumea': 2,\n", 179 | " 'makemake': 1,\n", 180 | " 'eris': 1\n", 181 | "}" 182 | ] 183 | }, 184 | { 185 | "cell_type": "markdown", 186 | "metadata": { 187 | "slideshow": { 188 | "slide_type": "subslide" 189 | } 190 | }, 191 | "source": [ 192 | "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", 193 | "\n", 194 | "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" 195 | ] 196 | }, 197 | { 198 | "cell_type": "code", 199 | "execution_count": null, 200 | "metadata": { 201 | "slideshow": { 202 | "slide_type": "subslide" 203 | } 204 | }, 205 | "outputs": [], 206 | "source": [ 207 | "# Añade el código para determinar el número de lunas." 208 | ] 209 | }, 210 | { 211 | "cell_type": "markdown", 212 | "metadata": { 213 | "slideshow": { 214 | "slide_type": "subslide" 215 | } 216 | }, 217 | "source": [ 218 | "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." 219 | ] 220 | }, 221 | { 222 | "cell_type": "code", 223 | "execution_count": null, 224 | "metadata": { 225 | "slideshow": { 226 | "slide_type": "subslide" 227 | } 228 | }, 229 | "outputs": [], 230 | "source": [ 231 | "# Agrega el código para contar el número de lunas. " 232 | ] 233 | }, 234 | { 235 | "cell_type": "markdown", 236 | "metadata": { 237 | "slideshow": { 238 | "slide_type": "slide" 239 | } 240 | }, 241 | "source": [ 242 | "## Soluciones" 243 | ] 244 | }, 245 | { 246 | "cell_type": "markdown", 247 | "metadata": { 248 | "slideshow": { 249 | "slide_type": "subslide" 250 | } 251 | }, 252 | "source": [ 253 | "### Ejercicio 1:" 254 | ] 255 | }, 256 | { 257 | "cell_type": "code", 258 | "execution_count": null, 259 | "metadata": { 260 | "slideshow": { 261 | "slide_type": "subslide" 262 | } 263 | }, 264 | "outputs": [], 265 | "source": [ 266 | "# Crea un diccionario llamado planet con los datos propuestos\n", 267 | "\n", 268 | "planet = {\n", 269 | " 'name': 'Mars',\n", 270 | " 'moons': 2\n", 271 | "}" 272 | ] 273 | }, 274 | { 275 | "cell_type": "code", 276 | "execution_count": null, 277 | "metadata": { 278 | "slideshow": { 279 | "slide_type": "subslide" 280 | } 281 | }, 282 | "outputs": [], 283 | "source": [ 284 | "# Muestra el nombre del planeta y el número de lunas que tiene.\n", 285 | "\n", 286 | "print(f'{planet[\"name\"]} has {planet[\"moons\"]} moons')" 287 | ] 288 | }, 289 | { 290 | "cell_type": "code", 291 | "execution_count": null, 292 | "metadata": { 293 | "slideshow": { 294 | "slide_type": "subslide" 295 | } 296 | }, 297 | "outputs": [], 298 | "source": [ 299 | "# Agrega la clave circunferencia con los datos proporcionados previamente\n", 300 | "\n", 301 | "planet['circumference (km)'] = {\n", 302 | " 'polar': 6752,\n", 303 | " 'equatorial': 6792\n", 304 | "}" 305 | ] 306 | }, 307 | { 308 | "cell_type": "code", 309 | "execution_count": null, 310 | "metadata": { 311 | "slideshow": { 312 | "slide_type": "subslide" 313 | } 314 | }, 315 | "outputs": [], 316 | "source": [ 317 | "# Imprime el nombre del planeta con su circunferencia polar.\n", 318 | "\n", 319 | "print(f'{planet[\"name\"]} has a polar circumference of {planet[\"circumference (km)\"][\"polar\"]}')" 320 | ] 321 | }, 322 | { 323 | "cell_type": "markdown", 324 | "metadata": { 325 | "slideshow": { 326 | "slide_type": "slide" 327 | } 328 | }, 329 | "source": [ 330 | "### Ejercicio 2" 331 | ] 332 | }, 333 | { 334 | "cell_type": "code", 335 | "execution_count": null, 336 | "metadata": { 337 | "slideshow": { 338 | "slide_type": "subslide" 339 | } 340 | }, 341 | "outputs": [], 342 | "source": [ 343 | "# Añade el código para determinar el número de lunas.\n", 344 | "\n", 345 | "# Obtenemos la lista de las lunas\n", 346 | "# Almacenamos los resultados en una variable moons\n", 347 | "moons = planet_moons.values()\n", 348 | "\n", 349 | "# Obtenemos el total de planetas\n", 350 | "# Almacenamos los resultados en una variable llamada years\n", 351 | "planets = len(planet_moons.keys())" 352 | ] 353 | }, 354 | { 355 | "cell_type": "code", 356 | "execution_count": null, 357 | "metadata": { 358 | "slideshow": { 359 | "slide_type": "subslide" 360 | } 361 | }, 362 | "outputs": [], 363 | "source": [ 364 | "# Calcula el total_moons agregando todas las lunas\n", 365 | "# Almacena su valor en una variable llamada total_moons\n", 366 | "\n", 367 | "total_moons = 0\n", 368 | "for moon in moons:\n", 369 | " total_moons = total_moons + moon\n", 370 | "\n", 371 | "# Calcula el promedio dividiendo el total_moons por el número de planetas\n", 372 | "average = total_moons / planets\n", 373 | "\n", 374 | "# Muestra el promedio\n", 375 | "print(average)" 376 | ] 377 | } 378 | ], 379 | "metadata": { 380 | "celltoolbar": "Slideshow", 381 | "interpreter": { 382 | "hash": "916dbcbb3f70747c44a77c7bcd40155683ae19c65e1c03b4aa3499c5328201f1" 383 | }, 384 | "kernelspec": { 385 | "display_name": "Python 3 (ipykernel)", 386 | "language": "python", 387 | "name": "python3" 388 | }, 389 | "language_info": { 390 | "codemirror_mode": { 391 | "name": "ipython", 392 | "version": 3 393 | }, 394 | "file_extension": ".py", 395 | "mimetype": "text/x-python", 396 | "name": "python", 397 | "nbconvert_exporter": "python", 398 | "pygments_lexer": "ipython3", 399 | "version": "3.11.2" 400 | }, 401 | "nteract": { 402 | "version": "nteract-front-end@1.0.0" 403 | } 404 | }, 405 | "nbformat": 4, 406 | "nbformat_minor": 2 407 | } 408 | -------------------------------------------------------------------------------- /Módulo 8 - Administrar datos con diccionarios/Módulo8Katas.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": { 6 | "slideshow": { 7 | "slide_type": "slide" 8 | } 9 | }, 10 | "source": [ 11 | "# Ejercicio 1: Creación de diccionarios de Python" 12 | ] 13 | }, 14 | { 15 | "cell_type": "markdown", 16 | "metadata": { 17 | "slideshow": { 18 | "slide_type": "subslide" 19 | } 20 | }, 21 | "source": [ 22 | "### Ejercicio: Crear y modificar un diccionario de Python\n", 23 | "\n", 24 | "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", 25 | "\n", 26 | "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", 27 | "\n", 28 | "```python\n", 29 | "demo = {\n", 30 | " 'key': 'value',\n", 31 | " 'number': 42\n", 32 | "}\n", 33 | "```\n", 34 | "\n", 35 | "Para este ejercicio, crearás un diccionario que almacene información sobre el planeta Marte.\n", 36 | "\n", 37 | "\n", 38 | "> **TIP**\n", 39 | "> 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", 40 | "\n", 41 | "Agrega el código para crear un nuevo diccionario denominado 'planet'. Rellena con la siguiente información:\n", 42 | "\n", 43 | "```\n", 44 | "name: Mars\n", 45 | "moons: 2\n", 46 | "```" 47 | ] 48 | }, 49 | { 50 | "cell_type": "code", 51 | "execution_count": null, 52 | "metadata": {}, 53 | "outputs": [], 54 | "source": [ 55 | "# Crea un diccionario llamado planet con los datos propuestos" 56 | ] 57 | }, 58 | { 59 | "cell_type": "markdown", 60 | "metadata": {}, 61 | "source": [ 62 | "Para recuperar valores, puede utilizar el método `get` o corchetes (`[ ]`) con el nombre de la clave que desea recuperar." 63 | ] 64 | }, 65 | { 66 | "cell_type": "code", 67 | "execution_count": null, 68 | "metadata": {}, 69 | "outputs": [], 70 | "source": [ 71 | "# Muestra el nombre del planeta y el número de lunas que tiene." 72 | ] 73 | }, 74 | { 75 | "cell_type": "markdown", 76 | "metadata": { 77 | "slideshow": { 78 | "slide_type": "slide" 79 | } 80 | }, 81 | "source": [ 82 | "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", 83 | "\n", 84 | "\n", 85 | "```python\n", 86 | "demo['new_key'] = 'New value'\n", 87 | "```\n", 88 | "\n", 89 | "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", 90 | "\n", 91 | "```\n", 92 | "polar: 6752\n", 93 | "equatorial: 6792\n", 94 | "```\n" 95 | ] 96 | }, 97 | { 98 | "cell_type": "code", 99 | "execution_count": null, 100 | "metadata": {}, 101 | "outputs": [], 102 | "source": [ 103 | "# Agrega la clave circunferencia con los datos proporcionados previamente" 104 | ] 105 | }, 106 | { 107 | "cell_type": "markdown", 108 | "metadata": { 109 | "slideshow": { 110 | "slide_type": "subslide" 111 | } 112 | }, 113 | "source": [ 114 | "Imprime el nombre del planeta con su circunferencia polar." 115 | ] 116 | }, 117 | { 118 | "cell_type": "code", 119 | "execution_count": null, 120 | "metadata": {}, 121 | "outputs": [], 122 | "source": [ 123 | "# Imprime el nombre del planeta con su circunferencia polar." 124 | ] 125 | }, 126 | { 127 | "cell_type": "markdown", 128 | "metadata": {}, 129 | "source": [ 130 | "> 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!" 131 | ] 132 | }, 133 | { 134 | "cell_type": "markdown", 135 | "metadata": { 136 | "slideshow": { 137 | "slide_type": "slide" 138 | } 139 | }, 140 | "source": [ 141 | "## Ejercicio 2: Programación dinámica con diccionarios" 142 | ] 143 | }, 144 | { 145 | "cell_type": "markdown", 146 | "metadata": { 147 | "slideshow": { 148 | "slide_type": "subslide" 149 | } 150 | }, 151 | "source": [ 152 | "### Ejercicio: Cálculo de valores\n", 153 | "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." 154 | ] 155 | }, 156 | { 157 | "cell_type": "code", 158 | "execution_count": null, 159 | "metadata": { 160 | "slideshow": { 161 | "slide_type": "subslide" 162 | } 163 | }, 164 | "outputs": [], 165 | "source": [ 166 | "# Planets and moons\n", 167 | "\n", 168 | "planet_moons = {\n", 169 | " 'mercury': 0,\n", 170 | " 'venus': 0,\n", 171 | " 'earth': 1,\n", 172 | " 'mars': 2,\n", 173 | " 'jupiter': 79,\n", 174 | " 'saturn': 82,\n", 175 | " 'uranus': 27,\n", 176 | " 'neptune': 14,\n", 177 | " 'pluto': 5,\n", 178 | " 'haumea': 2,\n", 179 | " 'makemake': 1,\n", 180 | " 'eris': 1\n", 181 | "}" 182 | ] 183 | }, 184 | { 185 | "cell_type": "markdown", 186 | "metadata": { 187 | "slideshow": { 188 | "slide_type": "subslide" 189 | } 190 | }, 191 | "source": [ 192 | "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", 193 | "\n", 194 | "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" 195 | ] 196 | }, 197 | { 198 | "cell_type": "code", 199 | "execution_count": null, 200 | "metadata": { 201 | "slideshow": { 202 | "slide_type": "subslide" 203 | } 204 | }, 205 | "outputs": [], 206 | "source": [ 207 | "# Añade el código para determinar el número de lunas." 208 | ] 209 | }, 210 | { 211 | "cell_type": "markdown", 212 | "metadata": { 213 | "slideshow": { 214 | "slide_type": "subslide" 215 | } 216 | }, 217 | "source": [ 218 | "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." 219 | ] 220 | }, 221 | { 222 | "cell_type": "code", 223 | "execution_count": null, 224 | "metadata": { 225 | "slideshow": { 226 | "slide_type": "subslide" 227 | } 228 | }, 229 | "outputs": [], 230 | "source": [ 231 | "# Agrega el código para contar el número de lunas. " 232 | ] 233 | }, 234 | { 235 | "cell_type": "markdown", 236 | "metadata": { 237 | "slideshow": { 238 | "slide_type": "slide" 239 | } 240 | }, 241 | "source": [ 242 | "## Soluciones" 243 | ] 244 | }, 245 | { 246 | "cell_type": "markdown", 247 | "metadata": { 248 | "slideshow": { 249 | "slide_type": "subslide" 250 | } 251 | }, 252 | "source": [ 253 | "### Ejercicio 1:" 254 | ] 255 | }, 256 | { 257 | "cell_type": "code", 258 | "execution_count": null, 259 | "metadata": { 260 | "slideshow": { 261 | "slide_type": "subslide" 262 | } 263 | }, 264 | "outputs": [], 265 | "source": [ 266 | "# Crea un diccionario llamado planet con los datos propuestos\n", 267 | "\n", 268 | "planet = {\n", 269 | " 'name': 'Mars',\n", 270 | " 'moons': 2\n", 271 | "}" 272 | ] 273 | }, 274 | { 275 | "cell_type": "code", 276 | "execution_count": null, 277 | "metadata": { 278 | "slideshow": { 279 | "slide_type": "subslide" 280 | } 281 | }, 282 | "outputs": [], 283 | "source": [ 284 | "# Muestra el nombre del planeta y el número de lunas que tiene.\n", 285 | "\n", 286 | "print(f'{planet[\"name\"]} has {planet[\"moons\"]} moons')" 287 | ] 288 | }, 289 | { 290 | "cell_type": "code", 291 | "execution_count": null, 292 | "metadata": { 293 | "slideshow": { 294 | "slide_type": "subslide" 295 | } 296 | }, 297 | "outputs": [], 298 | "source": [ 299 | "# Agrega la clave circunferencia con los datos proporcionados previamente\n", 300 | "\n", 301 | "planet['circumference (km)'] = {\n", 302 | " 'polar': 6752,\n", 303 | " 'equatorial': 6792\n", 304 | "}" 305 | ] 306 | }, 307 | { 308 | "cell_type": "code", 309 | "execution_count": null, 310 | "metadata": { 311 | "slideshow": { 312 | "slide_type": "subslide" 313 | } 314 | }, 315 | "outputs": [], 316 | "source": [ 317 | "# Imprime el nombre del planeta con su circunferencia polar.\n", 318 | "\n", 319 | "print(f'{planet[\"name\"]} has a polar circumference of {planet[\"circumference (km)\"][\"polar\"]}')" 320 | ] 321 | }, 322 | { 323 | "cell_type": "markdown", 324 | "metadata": { 325 | "slideshow": { 326 | "slide_type": "slide" 327 | } 328 | }, 329 | "source": [ 330 | "### Ejercicio 2" 331 | ] 332 | }, 333 | { 334 | "cell_type": "code", 335 | "execution_count": null, 336 | "metadata": { 337 | "slideshow": { 338 | "slide_type": "subslide" 339 | } 340 | }, 341 | "outputs": [], 342 | "source": [ 343 | "# Añade el código para determinar el número de lunas.\n", 344 | "\n", 345 | "# Obtenemos la lista de las lunas\n", 346 | "# Almacenamos los resultados en una variable moons\n", 347 | "moons = planet_moons.values()\n", 348 | "\n", 349 | "# Obtenemos el total de planetas\n", 350 | "# Almacenamos los resultados en una variable llamada years\n", 351 | "planets = len(planet_moons.keys())" 352 | ] 353 | }, 354 | { 355 | "cell_type": "code", 356 | "execution_count": null, 357 | "metadata": { 358 | "slideshow": { 359 | "slide_type": "subslide" 360 | } 361 | }, 362 | "outputs": [], 363 | "source": [ 364 | "# Calcula el total_moons agregando todas las lunas\n", 365 | "# Almacena su valor en una variable llamada total_moons\n", 366 | "\n", 367 | "total_moons = 0\n", 368 | "for moon in moons:\n", 369 | " total_moons = total_moons + moon\n", 370 | "\n", 371 | "# Calcula el promedio dividiendo el total_moons por el número de planetas\n", 372 | "average = total_moons / planets\n", 373 | "\n", 374 | "# Muestra el promedio\n", 375 | "print(average)" 376 | ] 377 | } 378 | ], 379 | "metadata": { 380 | "celltoolbar": "Slideshow", 381 | "interpreter": { 382 | "hash": "916dbcbb3f70747c44a77c7bcd40155683ae19c65e1c03b4aa3499c5328201f1" 383 | }, 384 | "kernelspec": { 385 | "display_name": "Python 3 (ipykernel)", 386 | "language": "python", 387 | "name": "python3" 388 | }, 389 | "language_info": { 390 | "codemirror_mode": { 391 | "name": "ipython", 392 | "version": 3 393 | }, 394 | "file_extension": ".py", 395 | "mimetype": "text/x-python", 396 | "name": "python", 397 | "nbconvert_exporter": "python", 398 | "pygments_lexer": "ipython3", 399 | "version": "3.11.2" 400 | }, 401 | "nteract": { 402 | "version": "nteract-front-end@1.0.0" 403 | } 404 | }, 405 | "nbformat": 4, 406 | "nbformat_minor": 2 407 | } 408 | -------------------------------------------------------------------------------- /Módulo 9 - Funciones/.ipynb_checkpoints/Módulo9Katas-checkpoint.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": { 6 | "slideshow": { 7 | "slide_type": "slide" 8 | } 9 | }, 10 | "source": [ 11 | "# Ejercicio: Uso de funciones en Python" 12 | ] 13 | }, 14 | { 15 | "cell_type": "markdown", 16 | "metadata": { 17 | "slideshow": { 18 | "slide_type": "subslide" 19 | } 20 | }, 21 | "source": [ 22 | "### Ejercicio 1: Trabajar con argumentos en funciones\n", 23 | "\n", 24 | "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", 25 | "\n" 26 | ] 27 | }, 28 | { 29 | "cell_type": "markdown", 30 | "metadata": { 31 | "slideshow": { 32 | "slide_type": "subslide" 33 | } 34 | }, 35 | "source": [ 36 | "> **TIP**\n", 37 | "> 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", 38 | "\n", 39 | "Comienza por crear una función que necesite tres lecturas de combustible y devuelva un informe:" 40 | ] 41 | }, 42 | { 43 | "cell_type": "code", 44 | "execution_count": null, 45 | "metadata": {}, 46 | "outputs": [], 47 | "source": [ 48 | "# Función para leer 3 tanques de combustible y muestre el promedio\n" 49 | ] 50 | }, 51 | { 52 | "cell_type": "markdown", 53 | "metadata": {}, 54 | "source": [ 55 | "Ahora que hemos definido la función de informes, vamos a comprobarlo. Para esta misión, los tanques no están llenos:" 56 | ] 57 | }, 58 | { 59 | "cell_type": "code", 60 | "execution_count": null, 61 | "metadata": {}, 62 | "outputs": [], 63 | "source": [ 64 | "\n", 65 | "# Llamamos a la función que genera el reporte print(funcion(tanque1, tanque2, tanque3))" 66 | ] 67 | }, 68 | { 69 | "cell_type": "markdown", 70 | "metadata": {}, 71 | "source": [ 72 | "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:" 73 | ] 74 | }, 75 | { 76 | "cell_type": "code", 77 | "execution_count": null, 78 | "metadata": {}, 79 | "outputs": [], 80 | "source": [ 81 | "# Función promedio " 82 | ] 83 | }, 84 | { 85 | "cell_type": "markdown", 86 | "metadata": {}, 87 | "source": [ 88 | "Ahora actualiza la función de informes para llamando a la nueva función del promedio:\n" 89 | ] 90 | }, 91 | { 92 | "cell_type": "code", 93 | "execution_count": null, 94 | "metadata": {}, 95 | "outputs": [], 96 | "source": [ 97 | "# Actualiza la función" 98 | ] 99 | }, 100 | { 101 | "cell_type": "markdown", 102 | "metadata": {}, 103 | "source": [ 104 | "> 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!" 105 | ] 106 | }, 107 | { 108 | "cell_type": "markdown", 109 | "metadata": { 110 | "slideshow": { 111 | "slide_type": "slide" 112 | } 113 | }, 114 | "source": [ 115 | "## Ejercicio 2: Trabajo con argumentos de palabra clave" 116 | ] 117 | }, 118 | { 119 | "cell_type": "markdown", 120 | "metadata": { 121 | "slideshow": { 122 | "slide_type": "subslide" 123 | } 124 | }, 125 | "source": [ 126 | "### Ejercicio : Trabajar con argumentos de palabras clave en funciones\n", 127 | "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:" 128 | ] 129 | }, 130 | { 131 | "cell_type": "code", 132 | "execution_count": null, 133 | "metadata": {}, 134 | "outputs": [], 135 | "source": [ 136 | "# Función con un informe preciso de la misión. Considera hora de prelanzamiento, tiempo de vuelo, destino, tanque externo y tanque interno" 137 | ] 138 | }, 139 | { 140 | "cell_type": "markdown", 141 | "metadata": { 142 | "slideshow": { 143 | "slide_type": "subslide" 144 | } 145 | }, 146 | "source": [ 147 | "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`:" 148 | ] 149 | }, 150 | { 151 | "cell_type": "code", 152 | "execution_count": null, 153 | "metadata": {}, 154 | "outputs": [], 155 | "source": [ 156 | "# Escribe tu nueva función de reporte considerando lo anterior" 157 | ] 158 | }, 159 | { 160 | "cell_type": "markdown", 161 | "metadata": { 162 | "slideshow": { 163 | "slide_type": "subslide" 164 | } 165 | }, 166 | "source": [ 167 | "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:" 168 | ] 169 | }, 170 | { 171 | "cell_type": "code", 172 | "execution_count": null, 173 | "metadata": {}, 174 | "outputs": [], 175 | "source": [ 176 | "# Escribe tu nueva función" 177 | ] 178 | }, 179 | { 180 | "cell_type": "markdown", 181 | "metadata": { 182 | "slideshow": { 183 | "slide_type": "slide" 184 | } 185 | }, 186 | "source": [ 187 | "## Soluciones" 188 | ] 189 | }, 190 | { 191 | "cell_type": "markdown", 192 | "metadata": { 193 | "slideshow": { 194 | "slide_type": "subslide" 195 | } 196 | }, 197 | "source": [ 198 | "## Ejercicio 1" 199 | ] 200 | }, 201 | { 202 | "cell_type": "code", 203 | "execution_count": null, 204 | "metadata": { 205 | "slideshow": { 206 | "slide_type": "subslide" 207 | } 208 | }, 209 | "outputs": [], 210 | "source": [ 211 | "# Función para leer 3 tanques de combustible y muestre el promedio\n", 212 | "\n", 213 | "def generate_report(main_tank, external_tank, hydrogen_tank):\n", 214 | " total_average = (main_tank + external_tank + hydrogen_tank) / 3\n", 215 | " return f\"\"\"Fuel Report:\n", 216 | " Total Average: {total_average}%\n", 217 | " Main tank: {main_tank}%\n", 218 | " External tank: {external_tank}%\n", 219 | " Hydrogen tank: {hydrogen_tank}% \n", 220 | " \"\"\"\n" 221 | ] 222 | }, 223 | { 224 | "cell_type": "code", 225 | "execution_count": null, 226 | "metadata": { 227 | "slideshow": { 228 | "slide_type": "subslide" 229 | } 230 | }, 231 | "outputs": [], 232 | "source": [ 233 | "# Llamamos a la función que genera el reporte print(funcion(tanque1, tanque2, tanque3))\n", 234 | "print(generate_report(80, 70, 85))" 235 | ] 236 | }, 237 | { 238 | "cell_type": "code", 239 | "execution_count": null, 240 | "metadata": { 241 | "slideshow": { 242 | "slide_type": "subslide" 243 | } 244 | }, 245 | "outputs": [], 246 | "source": [ 247 | "# Función promedio \n", 248 | "def average(values):\n", 249 | " total = sum(values)\n", 250 | " number_of_items = len(values)\n", 251 | " return total / number_of_items\n", 252 | "\n", 253 | "# Test the averaging function with a list of integers:\n", 254 | "average([80, 85, 81]) " 255 | ] 256 | }, 257 | { 258 | "cell_type": "code", 259 | "execution_count": null, 260 | "metadata": { 261 | "slideshow": { 262 | "slide_type": "subslide" 263 | } 264 | }, 265 | "outputs": [], 266 | "source": [ 267 | "# Actualiza la función\n", 268 | "def generate_report(main_tank, external_tank, hydrogen_tank):\n", 269 | " return f\"\"\"Fuel Report:\n", 270 | " Total Average: {average([main_tank, external_tank, hydrogen_tank])}%\n", 271 | " Main tank: {main_tank}%\n", 272 | " External tank: {external_tank}%\n", 273 | " Hydrogen tank: {hydrogen_tank}% \n", 274 | " \"\"\"\n", 275 | "\n", 276 | "# Call the updated function again with different values\n", 277 | "print(generate_report(88, 76, 70))" 278 | ] 279 | }, 280 | { 281 | "cell_type": "markdown", 282 | "metadata": { 283 | "slideshow": { 284 | "slide_type": "slide" 285 | } 286 | }, 287 | "source": [ 288 | "### Ejercicio 2:" 289 | ] 290 | }, 291 | { 292 | "cell_type": "code", 293 | "execution_count": null, 294 | "metadata": { 295 | "slideshow": { 296 | "slide_type": "subslide" 297 | } 298 | }, 299 | "outputs": [], 300 | "source": [ 301 | "# Función con un informe preciso de la misión. Considera hora de prelanzamiento, tiempo de vuelo, destino, tanque externo y tanque interno\n", 302 | "\n", 303 | "def mission_report(pre_launch_time, flight_time, destination, external_tank, main_tank):\n", 304 | " return f\"\"\"\n", 305 | " Mission to {destination}\n", 306 | " Total travel time: {pre_launch_time + flight_time} minutes\n", 307 | " Total fuel left: {external_tank + main_tank} gallons\n", 308 | " \"\"\"\n", 309 | "\n", 310 | "print(mission_report(14, 51, \"Moon\", 200000, 300000))" 311 | ] 312 | }, 313 | { 314 | "cell_type": "code", 315 | "execution_count": null, 316 | "metadata": { 317 | "slideshow": { 318 | "slide_type": "subslide" 319 | } 320 | }, 321 | "outputs": [], 322 | "source": [ 323 | "# Escribe tu nueva función de reporte considerando lo anterior\n", 324 | "\n", 325 | "def mission_report(destination, *minutes, **fuel_reservoirs):\n", 326 | " return f\"\"\"\n", 327 | " Mission to {destination}\n", 328 | " Total travel time: {sum(minutes)} minutes\n", 329 | " Total fuel left: {sum(fuel_reservoirs.values())}\n", 330 | " \"\"\"\n", 331 | "\n", 332 | "print(mission_report(\"Moon\", 10, 15, 51, main=300000, external=200000))" 333 | ] 334 | }, 335 | { 336 | "cell_type": "code", 337 | "execution_count": null, 338 | "metadata": { 339 | "slideshow": { 340 | "slide_type": "subslide" 341 | } 342 | }, 343 | "outputs": [], 344 | "source": [ 345 | "# Escribe tu nueva función\n", 346 | "\n", 347 | "def mission_report(destination, *minutes, **fuel_reservoirs):\n", 348 | " main_report = f\"\"\"\n", 349 | " Mission to {destination}\n", 350 | " Total travel time: {sum(minutes)} minutes\n", 351 | " Total fuel left: {sum(fuel_reservoirs.values())}\n", 352 | " \"\"\"\n", 353 | " for tank_name, gallons in fuel_reservoirs.items():\n", 354 | " main_report += f\"{tank_name} tank --> {gallons} gallons left\\n\"\n", 355 | " return main_report\n", 356 | "\n", 357 | "print(mission_report(\"Moon\", 8, 11, 55, main=300000, external=200000))" 358 | ] 359 | } 360 | ], 361 | "metadata": { 362 | "celltoolbar": "Slideshow", 363 | "interpreter": { 364 | "hash": "205095b8b86ea82a021a8fc2ffba2b3bc9f8d0be25999901963b225939f75778" 365 | }, 366 | "kernelspec": { 367 | "display_name": "Python 3 (ipykernel)", 368 | "language": "python", 369 | "name": "python3" 370 | }, 371 | "language_info": { 372 | "codemirror_mode": { 373 | "name": "ipython", 374 | "version": 3 375 | }, 376 | "file_extension": ".py", 377 | "mimetype": "text/x-python", 378 | "name": "python", 379 | "nbconvert_exporter": "python", 380 | "pygments_lexer": "ipython3", 381 | "version": "3.11.2" 382 | }, 383 | "nteract": { 384 | "version": "nteract-front-end@1.0.0" 385 | } 386 | }, 387 | "nbformat": 4, 388 | "nbformat_minor": 2 389 | } 390 | -------------------------------------------------------------------------------- /Módulo 9 - Funciones/Módulo9Katas.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": { 6 | "slideshow": { 7 | "slide_type": "slide" 8 | } 9 | }, 10 | "source": [ 11 | " # Ejercicio: Uso de funciones en Python " 12 | ] 13 | }, 14 | { 15 | "cell_type": "markdown", 16 | "metadata": { 17 | "slideshow": { 18 | "slide_type": "subslide" 19 | } 20 | }, 21 | "source": [ 22 | "### Ejercicio 1: Trabajar con argumentos en funciones\n", 23 | "\n", 24 | "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", 25 | "\n" 26 | ] 27 | }, 28 | { 29 | "cell_type": "markdown", 30 | "metadata": { 31 | "slideshow": { 32 | "slide_type": "subslide" 33 | } 34 | }, 35 | "source": [ 36 | "> **TIP**\n", 37 | "> 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", 38 | "\n", 39 | "Comienza por crear una función que necesite tres lecturas de combustible y devuelva un informe:" 40 | ] 41 | }, 42 | { 43 | "cell_type": "code", 44 | "execution_count": null, 45 | "metadata": {}, 46 | "outputs": [], 47 | "source": [ 48 | "# Función para leer 3 tanques de combustible y muestre el promedio\n" 49 | ] 50 | }, 51 | { 52 | "cell_type": "markdown", 53 | "metadata": {}, 54 | "source": [ 55 | "Ahora que hemos definido la función de informes, vamos a comprobarlo. Para esta misión, los tanques no están llenos:" 56 | ] 57 | }, 58 | { 59 | "cell_type": "code", 60 | "execution_count": null, 61 | "metadata": {}, 62 | "outputs": [], 63 | "source": [ 64 | "\n", 65 | "# Llamamos a la función que genera el reporte print(funcion(tanque1, tanque2, tanque3))" 66 | ] 67 | }, 68 | { 69 | "cell_type": "markdown", 70 | "metadata": {}, 71 | "source": [ 72 | "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:" 73 | ] 74 | }, 75 | { 76 | "cell_type": "code", 77 | "execution_count": null, 78 | "metadata": {}, 79 | "outputs": [], 80 | "source": [ 81 | "# Función promedio " 82 | ] 83 | }, 84 | { 85 | "cell_type": "markdown", 86 | "metadata": {}, 87 | "source": [ 88 | "Ahora actualiza la función de informes para llamando a la nueva función del promedio:\n" 89 | ] 90 | }, 91 | { 92 | "cell_type": "code", 93 | "execution_count": null, 94 | "metadata": {}, 95 | "outputs": [], 96 | "source": [ 97 | "# Actualiza la función" 98 | ] 99 | }, 100 | { 101 | "cell_type": "markdown", 102 | "metadata": {}, 103 | "source": [ 104 | "> 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!" 105 | ] 106 | }, 107 | { 108 | "cell_type": "markdown", 109 | "metadata": { 110 | "slideshow": { 111 | "slide_type": "slide" 112 | } 113 | }, 114 | "source": [ 115 | "## Ejercicio 2: Trabajo con argumentos de palabra clave" 116 | ] 117 | }, 118 | { 119 | "cell_type": "markdown", 120 | "metadata": { 121 | "slideshow": { 122 | "slide_type": "subslide" 123 | } 124 | }, 125 | "source": [ 126 | "### Ejercicio : Trabajar con argumentos de palabras clave en funciones\n", 127 | "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:" 128 | ] 129 | }, 130 | { 131 | "cell_type": "code", 132 | "execution_count": null, 133 | "metadata": {}, 134 | "outputs": [], 135 | "source": [ 136 | "# Función con un informe preciso de la misión. Considera hora de prelanzamiento, tiempo de vuelo, destino, tanque externo y tanque interno" 137 | ] 138 | }, 139 | { 140 | "cell_type": "markdown", 141 | "metadata": { 142 | "slideshow": { 143 | "slide_type": "subslide" 144 | } 145 | }, 146 | "source": [ 147 | "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`:" 148 | ] 149 | }, 150 | { 151 | "cell_type": "code", 152 | "execution_count": null, 153 | "metadata": {}, 154 | "outputs": [], 155 | "source": [ 156 | "# Escribe tu nueva función de reporte considerando lo anterior" 157 | ] 158 | }, 159 | { 160 | "cell_type": "markdown", 161 | "metadata": { 162 | "slideshow": { 163 | "slide_type": "subslide" 164 | } 165 | }, 166 | "source": [ 167 | "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:" 168 | ] 169 | }, 170 | { 171 | "cell_type": "code", 172 | "execution_count": null, 173 | "metadata": {}, 174 | "outputs": [], 175 | "source": [ 176 | "# Escribe tu nueva función" 177 | ] 178 | }, 179 | { 180 | "cell_type": "markdown", 181 | "metadata": { 182 | "slideshow": { 183 | "slide_type": "slide" 184 | } 185 | }, 186 | "source": [ 187 | "## Soluciones" 188 | ] 189 | }, 190 | { 191 | "cell_type": "markdown", 192 | "metadata": { 193 | "slideshow": { 194 | "slide_type": "subslide" 195 | } 196 | }, 197 | "source": [ 198 | "## Ejercicio 1" 199 | ] 200 | }, 201 | { 202 | "cell_type": "code", 203 | "execution_count": null, 204 | "metadata": { 205 | "slideshow": { 206 | "slide_type": "subslide" 207 | } 208 | }, 209 | "outputs": [], 210 | "source": [ 211 | "# Función para leer 3 tanques de combustible y muestre el promedio\n", 212 | "\n", 213 | "def generate_report(main_tank, external_tank, hydrogen_tank):\n", 214 | " total_average = (main_tank + external_tank + hydrogen_tank) / 3\n", 215 | " return f\"\"\"Fuel Report:\n", 216 | " Total Average: {total_average}%\n", 217 | " Main tank: {main_tank}%\n", 218 | " External tank: {external_tank}%\n", 219 | " Hydrogen tank: {hydrogen_tank}% \n", 220 | " \"\"\"\n" 221 | ] 222 | }, 223 | { 224 | "cell_type": "code", 225 | "execution_count": null, 226 | "metadata": { 227 | "slideshow": { 228 | "slide_type": "subslide" 229 | } 230 | }, 231 | "outputs": [], 232 | "source": [ 233 | "# Llamamos a la función que genera el reporte print(funcion(tanque1, tanque2, tanque3))\n", 234 | "print(generate_report(80, 70, 85))" 235 | ] 236 | }, 237 | { 238 | "cell_type": "code", 239 | "execution_count": null, 240 | "metadata": { 241 | "slideshow": { 242 | "slide_type": "subslide" 243 | } 244 | }, 245 | "outputs": [], 246 | "source": [ 247 | "# Función promedio \n", 248 | "def average(values):\n", 249 | " total = sum(values)\n", 250 | " number_of_items = len(values)\n", 251 | " return total / number_of_items\n", 252 | "\n", 253 | "# Test the averaging function with a list of integers:\n", 254 | "average([80, 85, 81]) " 255 | ] 256 | }, 257 | { 258 | "cell_type": "code", 259 | "execution_count": null, 260 | "metadata": { 261 | "slideshow": { 262 | "slide_type": "subslide" 263 | } 264 | }, 265 | "outputs": [], 266 | "source": [ 267 | "# Actualiza la función\n", 268 | "def generate_report(main_tank, external_tank, hydrogen_tank):\n", 269 | " return f\"\"\"Fuel Report:\n", 270 | " Total Average: {average([main_tank, external_tank, hydrogen_tank])}%\n", 271 | " Main tank: {main_tank}%\n", 272 | " External tank: {external_tank}%\n", 273 | " Hydrogen tank: {hydrogen_tank}% \n", 274 | " \"\"\"\n", 275 | "\n", 276 | "# Call the updated function again with different values\n", 277 | "print(generate_report(88, 76, 70))" 278 | ] 279 | }, 280 | { 281 | "cell_type": "markdown", 282 | "metadata": { 283 | "slideshow": { 284 | "slide_type": "slide" 285 | } 286 | }, 287 | "source": [ 288 | "### Ejercicio 2:" 289 | ] 290 | }, 291 | { 292 | "cell_type": "code", 293 | "execution_count": null, 294 | "metadata": { 295 | "slideshow": { 296 | "slide_type": "subslide" 297 | } 298 | }, 299 | "outputs": [], 300 | "source": [ 301 | "# Función con un informe preciso de la misión. Considera hora de prelanzamiento, tiempo de vuelo, destino, tanque externo y tanque interno\n", 302 | "\n", 303 | "def mission_report(pre_launch_time, flight_time, destination, external_tank, main_tank):\n", 304 | " return f\"\"\"\n", 305 | " Mission to {destination}\n", 306 | " Total travel time: {pre_launch_time + flight_time} minutes\n", 307 | " Total fuel left: {external_tank + main_tank} gallons\n", 308 | " \"\"\"\n", 309 | "\n", 310 | "print(mission_report(14, 51, \"Moon\", 200000, 300000))" 311 | ] 312 | }, 313 | { 314 | "cell_type": "code", 315 | "execution_count": null, 316 | "metadata": { 317 | "slideshow": { 318 | "slide_type": "subslide" 319 | } 320 | }, 321 | "outputs": [], 322 | "source": [ 323 | "# Escribe tu nueva función de reporte considerando lo anterior\n", 324 | "\n", 325 | "def mission_report(destination, *minutes, **fuel_reservoirs):\n", 326 | " return f\"\"\"\n", 327 | " Mission to {destination}\n", 328 | " Total travel time: {sum(minutes)} minutes\n", 329 | " Total fuel left: {sum(fuel_reservoirs.values())}\n", 330 | " \"\"\"\n", 331 | "\n", 332 | "print(mission_report(\"Moon\", 10, 15, 51, main=300000, external=200000))" 333 | ] 334 | }, 335 | { 336 | "cell_type": "code", 337 | "execution_count": null, 338 | "metadata": { 339 | "slideshow": { 340 | "slide_type": "subslide" 341 | } 342 | }, 343 | "outputs": [], 344 | "source": [ 345 | "# Escribe tu nueva función\n", 346 | "\n", 347 | "def mission_report(destination, *minutes, **fuel_reservoirs):\n", 348 | " main_report = f\"\"\"\n", 349 | " Mission to {destination}\n", 350 | " Total travel time: {sum(minutes)} minutes\n", 351 | " Total fuel left: {sum(fuel_reservoirs.values())}\n", 352 | " \"\"\"\n", 353 | " for tank_name, gallons in fuel_reservoirs.items():\n", 354 | " main_report += f\"{tank_name} tank --> {gallons} gallons left\\n\"\n", 355 | " return main_report\n", 356 | "\n", 357 | "print(mission_report(\"Moon\", 8, 11, 55, main=300000, external=200000))" 358 | ] 359 | } 360 | ], 361 | "metadata": { 362 | "celltoolbar": "Slideshow", 363 | "interpreter": { 364 | "hash": "205095b8b86ea82a021a8fc2ffba2b3bc9f8d0be25999901963b225939f75778" 365 | }, 366 | "kernelspec": { 367 | "display_name": "Python 3 (ipykernel)", 368 | "language": "python", 369 | "name": "python3" 370 | }, 371 | "language_info": { 372 | "codemirror_mode": { 373 | "name": "ipython", 374 | "version": 3 375 | }, 376 | "file_extension": ".py", 377 | "mimetype": "text/x-python", 378 | "name": "python", 379 | "nbconvert_exporter": "python", 380 | "pygments_lexer": "ipython3", 381 | "version": "3.11.2" 382 | }, 383 | "nteract": { 384 | "version": "nteract-front-end@1.0.0" 385 | } 386 | }, 387 | "nbformat": 4, 388 | "nbformat_minor": 2 389 | } 390 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # Curso Propedéutico de Python 2 | 3 | ¡Bienvenido al Curso Propedéutico de Python! 4 | 5 | Este curso está diseñado para brindarte los conocimientos fundamentales sobre el lenguaje de programación Python. El objetivo principal es proporcionarte una base sólida para que puedas entender y utilizar Python de manera efectiva en tus proyectos futuros. 6 | 7 | Durante el curso propedéutico, aprenderás los siguientes temas: 8 | 9 | 1. **Introducción a Python**: Conocerás los conceptos básicos del lenguaje Python, su sintaxis y estructura. 10 | 11 | 2. **Variables y tipos de datos**: Aprenderás cómo trabajar con variables y los diferentes tipos de datos en Python, como enteros, flotantes, cadenas de texto y booleanos. 12 | 13 | 3. **Estructuras de control**: Descubrirás cómo utilizar estructuras de control como bucles y condicionales para controlar el flujo de tu programa. 14 | 15 | 4. **Funciones**: Aprenderás a definir y utilizar funciones, así como a trabajar con argumentos y parámetros. 16 | 17 | 5. **Colecciones de datos**: Explorarás las diferentes colecciones de datos en Python, como listas, tuplas y diccionarios, y aprenderás a manipular y acceder a sus elementos. 18 | 19 | 6. **Archivos**: Descubrirás cómo leer y escribir en archivos utilizando Python. 20 | 21 | 7. **Módulos y bibliotecas**: Aprenderás cómo importar módulos y utilizar bibliotecas externas para ampliar las funcionalidades de Python. 22 | 23 | 8. **Manejo de excepciones**: Conocerás cómo manejar errores y excepciones en Python para que tus programas sean más robustos. 24 | 25 | 9. **Programación orientada a objetos (POO)**: Obtendrás una introducción a los conceptos de POO en Python, incluyendo clases, objetos, herencia y encapsulación. 26 | 27 | Este curso propedéutico es adecuado para principiantes sin experiencia previa en programación, así como para aquellos que deseen consolidar sus conocimientos básicos de Python. 28 | 29 | Al finalizar el curso, deberías sentirte cómodo utilizando Python y estar preparado para adentrarte en áreas más avanzadas, como el análisis de datos, la inteligencia artificial o el desarrollo web. 30 | 31 | ¡Esperamos que disfrutes de este Curso Propedéutico de Python y que te sientas inspirado para seguir aprendiendo y desarrollando tus habilidades de programación! 32 | 33 | 34 | ## Curso Propedéutico de Python - Información adicional 35 | 36 | **Instructor del curso:** Ing. Javier Alejandro Flores 37 | 38 | El Ing. Javier Alejandro Flores es el Team Leader del AI Center y tiene más de 3 años de experiencia en inteligencia artificial y más de 7 años en programación. Es un desarrollador miembro de "Developers Circles of Facebook" y Google Expert México. Con su amplia experiencia y conocimientos en el campo de la inteligencia artificial y la programación, el Ing. Javier Alejandro Flores será el encargado de impartir las clases y guiar a los participantes a lo largo del curso. 39 | 40 | **Horarios:** El curso se llevará a cabo los días lunes, miércoles y viernes de 18:00 a 20:00. El formato será híbrido, lo que significa que tendrás la opción de asistir de forma presencial en el IA.Center o participar virtualmente a través de Teams. 41 | 42 | **Fecha de inicio:** El curso comenzará el 26 de junio de 2023. 43 | 44 | **Prerequisitos:** 45 | - Conocimientos en lenguajes de programación y habilidad básica/intermedia en Python. Se espera que los participantes tengan cierta experiencia previa en programación y un nivel básico o intermedio en el uso de Python. 46 | 47 | **Requisitos:** 48 | - Ser estudiante universitario: El curso está dirigido a estudiantes universitarios que deseen ampliar sus conocimientos en Python y las herramientas utilizadas en ciencia de datos. 49 | - Deseable estar en los últimos semestres: Aunque no es un requisito estricto, se espera que los participantes estén en los últimos semestres de su carrera universitaria para aprovechar al máximo el contenido del curso. 50 | 51 | **Perfil de ingreso:** 52 | - La persona tiene interés en profundizar en el lenguaje de programación Python y los módulos de trabajo para realizar actividades relacionadas a la ciencia de datos. 53 | - Además, tiene interés en trabajar de manera colaborativa para el desarrollo de proyectos. 54 | 55 | **Perfil de egreso:** 56 | - Al finalizar el curso, se espera que la persona haya adquirido las siguientes habilidades: 57 | - Capacidad para escribir código eficiente en Python, utilizando conceptos de programación orientada a objetos (POO) y clean architecture. 58 | - Conocimiento en la gestión de entornos virtuales para mantener proyectos Python organizados y reproducibles. 59 | - Habilidad para consumir recursos y servicios utilizando API's. 60 | - Manejo de control de versiones utilizando GitFlow. 61 | - Capacidad para trabajar en equipos de desarrollo de manera colaborativa. 62 | 63 | ¡Este curso te brindará las habilidades necesarias para desarrollarte en el mundo de la ciencia de datos y colaborar en proyectos de manera efectiva! -------------------------------------------------------------------------------- /images/button.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/javierIA/PythonFastTrackIACXBOSCH/aaf2891666385172fbfd28efbacb7434d2abfbca/images/button.png -------------------------------------------------------------------------------- /images/chart.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/javierIA/PythonFastTrackIACXBOSCH/aaf2891666385172fbfd28efbacb7434d2abfbca/images/chart.png -------------------------------------------------------------------------------- /images/choose-kernel.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/javierIA/PythonFastTrackIACXBOSCH/aaf2891666385172fbfd28efbacb7434d2abfbca/images/choose-kernel.png -------------------------------------------------------------------------------- /images/createn.gif: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/javierIA/PythonFastTrackIACXBOSCH/aaf2891666385172fbfd28efbacb7434d2abfbca/images/createn.gif -------------------------------------------------------------------------------- /images/jupyter-extension.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/javierIA/PythonFastTrackIACXBOSCH/aaf2891666385172fbfd28efbacb7434d2abfbca/images/jupyter-extension.png -------------------------------------------------------------------------------- /images/nivelesox.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/javierIA/PythonFastTrackIACXBOSCH/aaf2891666385172fbfd28efbacb7434d2abfbca/images/nivelesox.png -------------------------------------------------------------------------------- /images/pip.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/javierIA/PythonFastTrackIACXBOSCH/aaf2891666385172fbfd28efbacb7434d2abfbca/images/pip.png -------------------------------------------------------------------------------- /images/planet.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/javierIA/PythonFastTrackIACXBOSCH/aaf2891666385172fbfd28efbacb7434d2abfbca/images/planet.png -------------------------------------------------------------------------------- /images/pythonv.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/javierIA/PythonFastTrackIACXBOSCH/aaf2891666385172fbfd28efbacb7434d2abfbca/images/pythonv.png -------------------------------------------------------------------------------- /images/restart.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/javierIA/PythonFastTrackIACXBOSCH/aaf2891666385172fbfd28efbacb7434d2abfbca/images/restart.png -------------------------------------------------------------------------------- /images/runmark.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/javierIA/PythonFastTrackIACXBOSCH/aaf2891666385172fbfd28efbacb7434d2abfbca/images/runmark.png -------------------------------------------------------------------------------- /images/vscode.jpeg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/javierIA/PythonFastTrackIACXBOSCH/aaf2891666385172fbfd28efbacb7434d2abfbca/images/vscode.jpeg --------------------------------------------------------------------------------