├── M01_herramientaseinstalacion └── README.md ├── M02_introprogramación ├── Practica.ipynb ├── Practica.py └── README.md ├── M03_variablesydatos ├── Prep_Course_Homework_03-Resuelto.ipynb ├── Prep_Course_Homework_03-Resuelto.py ├── Prep_Course_Homework_03.ipynb ├── Prep_Course_Homework_03.md ├── Prep_Course_Homework_03.py └── README.md ├── M04_flujosdecontrol ├── Prep_Course_Homework_04-Resuelto.ipynb ├── Prep_Course_Homework_04-Resuelto.py ├── Prep_Course_Homework_04.ipynb ├── Prep_Course_Homework_04.md ├── Prep_Course_Homework_04.py └── README.md ├── M05_estructuradedatos ├── Prep_Course_Homework_05-Resuelto.ipynb ├── Prep_Course_Homework_05-Resuelto.py ├── Prep_Course_Homework_05.ipynb ├── Prep_Course_Homework_05.md ├── Prep_Course_Homework_05.py └── README.md ├── M06_iterablesiteradores ├── Prep_Course_Homework_06-Resuelto.ipynb ├── Prep_Course_Homework_06-Resuelto.py ├── Prep_Course_Homework_06.ipynb ├── Prep_Course_Homework_06.md ├── Prep_Course_Homework_06.py └── README.md ├── M07_funciones ├── Prep_Course_Homework_07-Resuelto.ipynb ├── Prep_Course_Homework_07-Resuelto.py ├── Prep_Course_Homework_07.ipynb ├── Prep_Course_Homework_07.md ├── Prep_Course_Homework_07.py └── README.md ├── M08_clasesyOOP ├── Prep_Course_Homework_08-Resuelto.ipynb ├── Prep_Course_Homework_08-Resuelto.py ├── Prep_Course_Homework_08.ipynb ├── Prep_Course_Homework_08.md ├── Prep_Course_Homework_08.py ├── README.md ├── __pycache__ │ └── herramientas.cpython-39.pyc └── herramientas.py ├── M09_errorhandling ├── Prep_Course_Homework_09-Resuelto.ipynb ├── Prep_Course_Homework_09-Resuelto.py ├── Prep_Course_Homework_09.ipynb ├── Prep_Course_Homework_09.md ├── Prep_Course_Homework_09.py ├── README.md ├── __pycache__ │ ├── checkpoint.cpython-39.pyc │ └── herramientas.cpython-39.pyc └── herramientas.py ├── M10_manejodearchivos ├── Prep_Course_Homework_09-Resuelto.ipynb ├── Prep_Course_Homework_09-Resuelto.py ├── Prep_Course_Homework_09.md ├── __pycache__ │ └── herramientas.cpython-39.pyc ├── clase09_ej1.py ├── clase09_ej2.csv ├── clase09_ej2.py ├── clase09_montañas_altas │ └── clase09_ej3.csv ├── datos.txt └── ejemplo_parametros.py ├── README.md ├── Simulación Challenge ├── README.md ├── checkpoint.py ├── checkpoint_Resuelto.py └── tests.py └── _src ├── assets ├── 00-PrimerosPasos │ ├── 1.png │ ├── 2.png │ ├── 3.png │ ├── 4.png │ ├── 5.png │ ├── atom_logo.png │ ├── atom_site.png │ ├── consola.png │ ├── dowload_vc.png │ ├── git_logo.png │ ├── github_home.png │ ├── github_login.png │ ├── github_logo.png │ ├── github_profile.png │ ├── github_register.png │ ├── github_repo.png │ ├── instalar_window.png │ ├── nodejs_logo.png │ ├── nodejs_screen.png │ ├── sublimeText_download.png │ ├── sublimeText_linux.png │ ├── sublimeText_logo.png │ ├── sublimeText_screen.png │ ├── vsc_console.png │ ├── vsc_download.png │ └── vsc_logo.png ├── 01_imagen01.jpg ├── 02_imagen01.jpg ├── 02_imagen07.jpg ├── 06_Referencia_Valor.gif ├── 1.png └── 2.png ├── data ├── config.json ├── layout.js └── styles │ ├── code.js │ ├── fonts.js │ ├── footer.js │ ├── header.js │ ├── lesson.js │ ├── lessonIntro.js │ ├── main.js │ ├── responsive.js │ ├── sidebar.js │ └── topbar.js └── layouts ├── intro.njk └── lesson.njk /M01_herramientaseinstalacion/README.md: -------------------------------------------------------------------------------- 1 | ![HenryLogo](https://d31uz8lwfmyn8g.cloudfront.net/Assets/logo-henry-white-lg.png) 2 | 3 | # Instalación de Herramientas 4 | 5 | 6 | #### Preparando tu computadora 7 | Antes de comenzar deberás descargar en tu computadora las siguientes herramientas de trabajo: 8 | 1. Editor de texto 9 | 2. Git 10 | 3. Github 11 | 4. Python 12 | 13 | Luego deberás realizar la clonación del [repositorio](https://github.com/soyHenry/Python-Prep). Te explicamos cómo hacerlo en el tutorial: https://youtu.be/nxu3EZVzP8I 14 | 15 | > **Importante**: Github cambió el método de autenticación, ahora es por PAT (Personal Access Token), para crearlo pueden seguir este [link](https://docs.github.com/es/authentication/keeping-your-account-and-data-secure/creating-a-personal-access-token). Pueden elegir expiration infinita para hacerlo una sóla vez. 16 | 17 | ## SLACK 18 | 19 | Slack es una plataforma de comunicación que utilizamos en Henry para estar conectados. Por este medio es MUY IMPORTANTE, por alli vas a recibir comunicados y mantener conversaciones con toda la comunidad de Henry. 20 | 21 | Para ingresar al espacio de Slack del Prep Course de Henry, por favor revisa el los mails que recibiste al avanzar con el proceso de admisión dado que ahí encontrarás el link de acceso 22 | 23 | ## Editores de Texto 24 | 25 | Para poder escribir código que pueda ser interpretado por un lenguaje de programación, necesitamos utilizar un editor de texto. 26 | 27 | ## Visual Studio Code 28 | 29 | ![VSC Console](/_src/assets/00-PrimerosPasos/vsc_console.png) 30 | 31 | Es un editor desarrollado por Microsoft. 32 | 33 | Tiene integrado el control de versiones mediante Git y Github para tener un seguimiento de tus proyectos. Brinda una cantidad de extensiones que facilitan el trabajo de un desarrollador. 34 | 35 | Para descargarlo, nos dirigimos al sitio oficial, en la sección Download y descargamos el instalador según nuestro Sistema Operativo: 36 | 37 | 38 | 39 | ![VSC Download](/_src/assets/00-PrimerosPasos/vsc_download.png) 40 | 41 | Una vez finalizada la descarga, procedemos a ejecutar el instalador. 42 | 43 | ## Git 44 | 45 | ### ¿Qué es Git? 46 | 47 | Git es un sistema de control de versiones, distribuido y open source. Un control de versiones es un sistema que registra los cambios realizados en un archivo o conjunto de archivos a lo largo del tiempo, de modo que puedas recuperar versiones específicas más adelante. 48 | 49 | ### Instalación 50 | 51 | #### Para Mac y Linux 52 | 53 | Ver estos enlaces: 54 | 55 | 56 | 57 | 58 | 59 | 60 | 61 | #### Para Windows 62 | 63 | Ingreso a y descarga la última versión. 64 | 65 | ![installGit](/_src/assets/00-PrimerosPasos/instalar_window.png) 66 | 67 | Una vez descargado, se abre el archivo .exe y van a visualizar la siguiente ventana 68 | 69 | ![installGit](/_src/assets/00-PrimerosPasos/1.png) 70 | 71 | Clickeamos “Next” hasta que llegamos a esta parte: 72 | 73 | ![installGit](/_src/assets/00-PrimerosPasos/2.png) 74 | 75 | En este momento de la instalación, si quieren, pueden elegir el editor de texto que van a usar. (Importante, ténganlo instalado antes de instalar Git) 76 | 77 | Seguimos clickeando “Next” y luego “Install” 78 | 79 | ![installGit](/_src/assets/00-PrimerosPasos/3.png) 80 | 81 | Por último, ¡finalizar! Si seleccionan la opción "Launch Git Bash", una vez que finalizan la instalación se va a abrir la consola 82 | 83 | ![installGit](/_src/assets/00-PrimerosPasos/4.png) 84 | 85 | Otra forma de abrir la consola es haciendo click derecho sobre el escritorio y elegir la opción "Git Bash Here" 86 | 87 | ![installGit](/_src/assets/00-PrimerosPasos/consola.png) 88 | 89 | Una vez instalado Git van a poder visualizar la consola: ingresamos el comando `git --version` para chequear que está instalado. Si ven la consola así, ya están listos para comenzar a trabajar! 90 | 91 | ![installGit](/_src/assets/00-PrimerosPasos/5.png) 92 | 93 | ## GitHub 94 | 95 | ### ¿Qué es GitHub? 96 | 97 | Es una red para almacenar tus repositorios, sería un repositorio de repositorios. Es uno de los tantos disponibles en internet, y el más popular. GitHub **NO** es lo mismo que Git, aunque funcionen muy bien juntos. Github es un lugar donde podés compartir tu código o encontrar otros proyectos. También actúa como portfolio para cualquier código en el que hayas trabajado. 98 | 99 | ### Comenzando 100 | 101 | 1. Para comenzar nos creamos una cuenta --- > 🚀 102 | 103 | ![GitHub-Register](/_src/assets/00-PrimerosPasos/github_register.png) 104 | 105 | 2. Una vez registrados, ingresamos con usuario y contraseña: 106 | 107 | ![GitHub-Login](/_src/assets/00-PrimerosPasos/github_login.png) 108 | 109 | 3. Listo! Ahora vemos una página de inicio como la siguiente: 110 | 111 | ![GitHub-Home](/_src/assets/00-PrimerosPasos/github_home.png) 112 | 113 | A la izquierda tenemos un acceso rápido a **mis repositorios**. 114 | 115 | En el centro vemos la actividad de los usuarios a quienes seguimos. 116 | 117 | En la parte superior derecha, vemos nuestra imagen de perfil. Desde ahí podemos desplegar opciones para gestionar nuestro perfil, repositorios y configuración. Si accedemos a nuestro perfil encontramos algo parecido a esto: 118 | 119 | ![GitHub-profile](/_src/assets/00-PrimerosPasos/github_profile.png) 120 | 121 | Podemos poner una foto de perfil, editar el nombre, agregar la ubicación, link y organizaciones a las que pertenecemos. En el centro podemos fijar los repositorios que queremos mostrar para que estén visibles en nuestro perfil. 122 | 123 | Más abajo se muestra un diagrama de todas las contribuciones que vamos haciendo a los repositorios. 124 | 125 | Si accedemos a la pestaña de arriba que dice `repositorios` veremos una lista de todos ellos. Cuando elegimos un repositorio para ver, nos lleva a una página como esta: 126 | 127 | ![GitHub-repo](/_src/assets/00-PrimerosPasos/github_repo.png) 128 | 129 | Así se ve un repositorio. Arriba a la izquierda tenemos el `nombre de usuario/nombre del repo`. 130 | 131 | En el centro podemos ver todos los archivos que tiene dentro el repo. El botón verde que dice `Code` es importante, si clickeamos ahí vamos a poder obtener la url del repo, para así poder **_clonarlo_** (esto lo veremos más adelante). 132 | 133 | Arriba a la derecha encontramos tres botones. `Watch` nos permite seguir un repositorio, mientras que con `Star` podemos marcar como favorito un repo que nos guste. Por último tenemos `Fork`, este es **muy** importante, lo vamos a necesitar cuando hagamos el **_Challenge!_** 134 | 135 | Ya tenemos todo para empezar... Éxitos!!! 🍀 136 | 137 | ## Python 138 | 139 | ### ¿Qué es Python? 140 | 141 | Es un lenguaje de programación sencillo de leer y escribir debido a su alta similitud con el lenguaje humano. Además, se trata de un lenguaje multiplataforma de código abierto y, por lo tanto, gratuito, lo que permite desarrollar software sin límites 142 | 143 | ### Instalación 144 | 145 | Si estás usando Windows: 146 | 147 | Elige una versión 3.10 148 | 1. Para obtener el instalador dirígete a [https://www.python.org/downloads/](https://www.python.org/downloads/) 149 | 2. Descarga el instalador y ejecútalo en tu computadora. 150 | 3. Habilita la casilla de verificación en Install launcher for all users y Add Python 3.8 to PATH. A continuación presiona en Install Now. Windows te solicitará permisos para instalar Python en tu computadora. 151 | 4. Al finalizar la instalación se abrirá una ventana, en ella deberás presionar en la opción Disable path length limit. Windows te solicitará permisos para realizar este cambio. 152 | 153 | Si estás usando Mac: 154 | 155 | Mac OS X suele tener python instalado por defecto. Para verificarlo abrí la terminal, en el buscador de tu Mac, y escribí Python. Comprobar que está correctamente instalado: 156 | 157 | ```bash 158 | Python 159 | Python 2.7.13 (default, Mar 25 2021, 18:52:10) 160 | [GCC 4.2.1 Compatible Apple LLVM 10.0.1 (clang-1001.0.37.14)] on darwin 161 | Type "help", "copyright", "credits" or "license" for more information. 162 | >>> 163 | ``` 164 | 165 | Si no te figura o queres descargar la última versión dirígete a: [https://es.wikibooks.org/wiki/Python/Instalaci%C3%B3n_de_Python/Python_en_Mac_OS_X](https://es.wikibooks.org/wiki/Python/Instalaci%C3%B3n_de_Python/Python_en_Mac_OS_X) 166 | 167 | Si estás usando Linux: 168 | 169 | En una distribución estándar Linux dispone por defecto el intérprete Python instalado, para comprobar la correcta instalación solamente debería ejecutar el comando en la consola: 170 | 171 | ```bash 172 | python 173 | Python 2.7.13 (default, Sep 26 2018, 18:42:22) 174 | [GCC 6.3.0 20170516] on linux2 175 | Type "help", "copyright", "credits" or "license" for more information. 176 | >>> 177 | ``` 178 | 179 | Si le muestra los mensajes anteriores está correctamente instalado el intérprete Python en su Linux. 180 | 181 | Si al ejecutar el comando anterior muestra el mensaje: 182 | 183 | ```bash 184 | python 185 | bash: python: no se encontró la orden 186 | ``` 187 | 188 | Esto es debido a que no tiene instalado el intérprete, así que debe ejecutar el siguiente comando: 189 | ```bash 190 | sudo apt-get install -y python-dev 191 | ``` 192 | 193 | De nuevo vuelva a ejecutar en su consola de comando el comando python. Ya están listos para comenzar a trabajar 194 | 195 | 196 | 197 | 198 | Si tienes dudas sobre este tema, puedes consultarlas en el canal **#m01_instalaciónherramientas** 199 | 200 | -------------------------------------------------------------------------------- /M02_introprogramación/Practica.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "attachments": {}, 5 | "cell_type": "markdown", 6 | "metadata": {}, 7 | "source": [ 8 | "Este es un archivo de prueba, sin actividades =) .\n", 9 | "\n", 10 | "A partir del próximo módulo: M03_variablesydatos vas a tener actividades para realizar." 11 | ] 12 | }, 13 | { 14 | "cell_type": "code", 15 | "execution_count": 1, 16 | "metadata": {}, 17 | "outputs": [ 18 | { 19 | "name": "stdout", 20 | "output_type": "stream", 21 | "text": [ 22 | "Hola Mundo!\n", 23 | "20\n", 24 | "19\n", 25 | "18\n", 26 | "17\n", 27 | "16\n", 28 | "15\n", 29 | "14\n", 30 | "13\n", 31 | "12\n", 32 | "11\n", 33 | "10\n", 34 | "9\n", 35 | "8\n", 36 | "7\n", 37 | "6\n", 38 | "5\n", 39 | "4\n", 40 | "3\n", 41 | "2\n", 42 | "1\n" 43 | ] 44 | } 45 | ], 46 | "source": [ 47 | "print('Hola Mundo!')\n", 48 | "a = 20\n", 49 | "while a > 0:\n", 50 | " \n", 51 | " print(a)\n", 52 | " a -= 1" 53 | ] 54 | } 55 | ], 56 | "metadata": { 57 | "kernelspec": { 58 | "display_name": "Python 3", 59 | "language": "python", 60 | "name": "python3" 61 | }, 62 | "language_info": { 63 | "codemirror_mode": { 64 | "name": "ipython", 65 | "version": 3 66 | }, 67 | "file_extension": ".py", 68 | "mimetype": "text/x-python", 69 | "name": "python", 70 | "nbconvert_exporter": "python", 71 | "pygments_lexer": "ipython3", 72 | "version": "3.10.11" 73 | }, 74 | "orig_nbformat": 4 75 | }, 76 | "nbformat": 4, 77 | "nbformat_minor": 2 78 | } 79 | -------------------------------------------------------------------------------- /M02_introprogramación/Practica.py: -------------------------------------------------------------------------------- 1 | 2 | # Este es un archivo de prueba, sin actividades =) . 3 | 4 | # A partir del próximo módulo: M03_variablesydatos vas a tener actividades para realizar. 5 | 6 | print('Hola Mundo!') 7 | a = 20 8 | while a > 0: 9 | print(a) 10 | a -= 1 11 | -------------------------------------------------------------------------------- /M02_introprogramación/README.md: -------------------------------------------------------------------------------- 1 | ![HenryLogo](https://d31uz8lwfmyn8g.cloudfront.net/Assets/logo-henry-white-lg.png) 2 | 3 | # Introducción a la Programación 4 | 5 | ## ¿Qué es la Programación? 6 | 7 | Comencemos con un ejemplo, en la imagen se representa un pequeño robot abeja en una esquina del cuadrilátero, y en la otra esquina una flor. El objetivo del robot abeja es llegar hasta la flor, esquivando los arbustos que hay de por medio. Para esto, hay que decirle cómo se debe mover, pero solo puede saltar de a un casillero por vez. La forma en que se le puede "decir" es a través de instrucciones y estas son: "arriba", "abajo", "izquierda" y "derecha". Por supuesto, teniendo en cuenta que debe moverse dentro del cuadrilátero. 8 | 9 | Ahora bien, surgen algunas preguntas: 10 | 11 | * ¿Cuántas instrucciones son necesarias? 12 | 13 | * Al ser más de una instrucción ¿Es importante el orden en que se ejecutan? 14 | 15 | * ¿Hay más de una forma en que el robot abeja pueda llegar a la flor? 16 | 17 | * ¿Hay un camino óptimo? 18 | 19 | * ¿Cómo puedo medir si un camino es el óptimo con respecto a otros caminos? 20 | 21 | ![unaImagenConBoxShadow](../_src/assets/01_imagen01.jpg) 22 | 23 | Cualquiera de las siguientes, podrían ser una solución: 24 | * Derecha, Derecha, Arriba, Arriba, Derecha, Derecha, Arriba, Arriba, Arriba, Derecha, Derecha, Arriba 25 | * Derecha, Derecha, Derecha, Derecha, Derecha, Derecha, Arriba, Arriba, Arriba, Izquierda, Izquierda, Arriba, Arriba, Derecha, Arriba, Derecha 26 | * Arriba, Derecha, Derecha, Arriba, Arriba, Arriba, Arriba, Arriba, Derecha, Derecha, Derecha, Derecha, Arriba 27 | 28 | Lo importante, en principio, es que notemos que al resolver el problema planteado, lo que estamos haciendo, utilizando un pensamiento lógico, es precisamente, **programación** 29 | 30 | Entonces, **programar, es armar una secuencia lógica de pasos a seguir, en pos de cumplir un objetivo.** En el ejemplo visto, tuvimos un contexto que nos marcaba las posibilidades y restricciones del problema, por ejemplo moverse dentro del cuadrilátero o no chocar con los arbustos. Y también un conjunto de instrucciones disponibles, que definían el lenguaje que teníamos que usar, para que el robot comprenda las instrucciones. Lo que usamos fue un lenguaje formal, muy básico y que fue suficiente para resolver el problema. Estos lenguajes, se denominan lenguajes de programación, nos permiten plasmar esas instrucciones necesarias para darle una solución al problema que queremos resolver, generando así un programa (o software). 31 | 32 | Los primeros lenguajes de programación se escribían en instrucciones que podían interpretar las computadoras muy fácilmente, pero que resultaban menos amigables a las personas, tales como el lenguaje ensamblador (o Assembler) o Fortran, desarrollado en 1955. Con el tiempo, esto fue cambiando, se fueron desarrollando lenguajes de programación de más alto nivel y con diferentes aplicaciones, que por lo general eran comerciales o científicas, pero también con fines educativos, es decir, lenguajes desarrollados para aprender a programar, y consecuentemente, más sencillos. 33 | 34 | Éste último, es el caso de **Python**, que nace a finales de la década del 80 y fue pensado para principiantes por su facilidad de aprendizaje y uso. Su código era compacto pero legible. Con el correr de los años fue incluyendo mejoras hasta llegar también a ser de licencia libre. Hoy por hoy, es usado desde simples "scripts", hasta grandes servidores web que proveen servicio ininterrumpido las 24hs. Es utilizado para la programación de interfaces gráficas y bases de datos. Además tiene una amplia aceptación por científicos que hacen aplicaciones para las supercomputadoras más rápidas del mundo y por los niños que recién están comenzando a programar. 35 | La generalización del Big Data en los últimos años, seguida de la explosión de la Inteligencia Artificial, Machine Learning y el surgimiento de la Ciencia de Datos como una nueva área de trabajo con especialistas propios, ha revolucionado el panorama ya que muchas de las nuevas herramientas que han surgido han sido desarrolladas en Python o nos ofrecen Python como la forma predilecta de interactuar con ellas. 36 | Podemos hablar de tecnología para Big Data como PySpark, de herramientas para Data Science como Pandas, NumPy, Matplotlib o Jupyter. De herramientas del procesamiento del lenguaje natural como NLTK, y por último el área de Deep Learning como Tensorflow, MXNet o Scikit-Learn. 37 | 38 | ## Sintaxis de un lenguaje de programación 39 | 40 | Para el ejemplo se utilizó un lenguaje con el que era posible determinar los pasos a seguir por el robot abeja hasta llegar a la flor, y nos fue suficiente para poder entender cómo resolver el problema. El hecho es que, los lenguajes de programación que utilizamos, deben ser más específicos todavía, necesitamos tener un nivel de detalle mayor en nuestras instrucciones, por ejemplo, en lugar de la instrucción "Arriba", podría ser, especificar la cantidad de celdas que hay que moverse, e incluso qué implica "moverse", que seguramente será cambiar el estado de la propia abeja. 41 | Por otro lado también habrá un marco de referencia, es decir, el tablero donde se mueve la abeja y está la flor, en sí mismo, es algo que debemos conocer, saber donde hay ubicado un arbusto y donde no, saber cuales son los límites, y que pasa si con las instrucciones que le damos a la abeja, hacemos que rebase esos límites. 42 | Para solventar esa complejidad, necesitamos un **set de instrucciones** un poco más complejo para poder interactuar con el computador y una forma de representar los datos de la realidad, es decir, dimensiones del tablero donde se mueve la abeja, posición de la abeja, posición de la flor, ubicaciones de los arbustos. Esto se hace mediante lo que se conoce como **estructuras** de datos, las cuales permiten representar la realidad. De hecho, todos **los datos son una representación de la realidad**. 43 | La sintaxis de un programa, consiste en un conjunto de palabras reservadas a instrucciones, con una estructura específica, tal y como funciona un lenguaje como el que usamos los humanos para comunicarnos, como el español o el inglés. Los lenguajes de programación también tienen su sintaxis, que está compuesta por diferentes elementos, como ser variables para representar el dato de la realidad, sentencias para representar las instrucciones o estructuras de control que conforman el cuerpo del programa. 44 | 45 | ## El Zen de Python 46 | 47 | Para conocer mejor el lenguaje que estaremos aprendiendo les compartimos una colección de los 19 principios que influyen en el diseño del lenguaje Python. De alguna manera, muestran la filosofía del mismo: 48 | 49 | 1) Bello es mejor que feo. 50 | 2) Explícito es mejor que implícito. 51 | 3) Simple es mejor que complejo. 52 | 4) Complejo es mejor que complicado. 53 | 5) Plano es mejor que anidado. 54 | 6) Espaciado es mejor que denso. 55 | 7) La legibilidad es importante. 56 | 8) Los casos especiales no son lo suficientemente especiales como para romper las reglas. 57 | 9) Sin embargo la practicidad gana a la pureza. 58 | 10) Los errores nunca deben pasar silenciosamente. 59 | 11) A menos que se silencien explícitamente. 60 | 12) Frente a la ambigüedad, evitar la tentación de adivinar. 61 | 13) Debería haber una, y preferiblemente solo una, manera obvia de hacerlo. 62 | 14) A pesar de que esa manera no sea obvia a menos que seas Holandés (el creador lo era) 63 | 15) Ahora es mejor que nunca. 64 | 16) A pesar de que nunca es muchas veces mejor que ahora mismo. 65 | 17) Si la implementación es difícil de explicar, es una mala idea. 66 | 18) Si la implementación es fácil de explicar, puede que sea una buena idea. 67 | 19) Los namespaces son una gran idea, ¡tengamos más de esos! 68 | 69 | ## Recursos adicionales 70 | 71 | * [Introducción al Pensamiento Computacional] (https://github.com/karlbehrensg/introduccion-pensamiento-computacional) 72 | * [Entrenamiento Básico] (https://entrenamiento-python-basico.readthedocs.io/es/latest) 73 | * [El Libro de Python] (https://ellibrodepython.com/) 74 | * [Python para todos] (https://www.py4e.com) 75 | * [Curso Python Videos] (https://youtu.be/G2FCfQj-9ig) 76 | * [Visualizar tu código] (https://memlayout.com/) 77 | * [Visualizar tu código] (https://pythontutor.com/visualize.html#mode=edit) 78 | 79 | * Si tienes dudas sobre este tema, puedes consultarlas en el canal **#m02_introprogramacion** de Slack -------------------------------------------------------------------------------- /M03_variablesydatos/Prep_Course_Homework_03-Resuelto.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python 2 | # coding: utf-8 3 | 4 | # ## Variables 5 | 6 | # 1) Crear una variable que contenga un elemento del conjunto de números enteros y luego imprimir por pantalla 7 | 8 | # In[7]: 9 | 10 | 11 | a = 12 12 | print(a) 13 | 14 | 15 | # 2) Imprimir el tipo de dato de la constante 8.5 16 | 17 | # In[3]: 18 | 19 | 20 | type(8.5) 21 | 22 | 23 | # 3) Imprimir el tipo de dato de la variable creada en el punto 1 24 | 25 | # In[8]: 26 | 27 | 28 | type(a) 29 | 30 | 31 | # 4) Crear una variable que contenga tu nombre 32 | 33 | # In[2]: 34 | 35 | 36 | mi_nombre = 'juan carlos perez' 37 | 38 | 39 | # 5) Crear una variable que contenga un número complejo 40 | 41 | # In[3]: 42 | 43 | 44 | n_complejo = 5 + 5j 45 | 46 | 47 | # 6) Mostrar el tipo de dato de la variable crada en el punto 5 48 | 49 | # In[4]: 50 | 51 | 52 | type(n_complejo) 53 | 54 | 55 | # 7) Crear una variable que contenga el valor del número Pi redondeado a 4 decimales 56 | 57 | # In[1]: 58 | 59 | 60 | pi = 3.1416 61 | 62 | 63 | # 8) Crear una variable que contenga el valor 'True' y otra que contenga el valor True. ¿Se trata de lo mismo? 64 | 65 | # In[3]: 66 | 67 | 68 | var1 = 'True' 69 | var2 = True 70 | 71 | 72 | # 9) Imprimir el tipo de dato correspondientes a las variables creadas en el punto 8 73 | 74 | # In[5]: 75 | 76 | 77 | print('La variable 1 es de tipo ', type(var1), ' y la variable 2 es de tipo ', type(var2)) 78 | 79 | 80 | # 10) Asignar a una variable, la suma de un número entero y otro decimal 81 | 82 | # In[1]: 83 | 84 | 85 | a = 5.2 + 4 86 | 87 | 88 | # 11) Realizar una operación de suma de números complejos 89 | 90 | # In[2]: 91 | 92 | 93 | a = 3 + 1j 94 | b = 1 + 3j 95 | print(a + b) 96 | 97 | 98 | # 12) Realizar una operación de suma de un número real y otro complejo 99 | 100 | # In[4]: 101 | 102 | 103 | c = a + 1.61 104 | print(c) 105 | 106 | 107 | # 13) Realizar una operación de multiplicación 108 | 109 | # In[5]: 110 | 111 | 112 | print(3 * 2) 113 | 114 | 115 | # 14) Mostrar el resultado de elevar 2 a la octava potencia 116 | 117 | # In[6]: 118 | 119 | 120 | print(2**8) 121 | 122 | 123 | # 15) Obtener el cociente de la división de 27 entre 4 en una variable y luego mostrarla 124 | 125 | # In[8]: 126 | 127 | 128 | a = 27 / 4 129 | print(a) 130 | 131 | 132 | # 16) De la división anterior solamente mostrar la parte entera 133 | 134 | # In[9]: 135 | 136 | 137 | print(27 // 4) 138 | 139 | 140 | # 17) De la división de 27 entre 4 mostrar solamente el resto 141 | 142 | # In[1]: 143 | 144 | 145 | 27 % 4 146 | 147 | 148 | # 18) Utilizando como operandos el número 4 y los resultados obtenidos en los puntos 16 y 17. Obtener 27 como resultado 149 | 150 | # In[2]: 151 | 152 | 153 | 6 * 4 + 3 154 | 155 | 156 | # 19) Utilizar el operador "+" en una operación donde intervengan solo variables alfanuméricas 157 | 158 | # In[3]: 159 | 160 | 161 | var1 = 'Buenos ' 162 | var2 = 'Aires' 163 | print(var1 + var2) 164 | 165 | 166 | # 20) Evaluar si "2" es igual a 2. ¿Por qué ocurre eso? 167 | 168 | # In[4]: 169 | 170 | 171 | 2 == '2' 172 | 173 | 174 | # 21) Utilizar las funciones de cambio de tipo de dato, para que la validación del punto 20 resulte verdadera 175 | 176 | # In[11]: 177 | 178 | 179 | 2 == int('2') 180 | 181 | 182 | # 22) ¿Por qué arroja error el siguiente cambio de tipo de datos? a = float('3,8') 183 | 184 | # In[12]: 185 | 186 | 187 | a = float('3,8') 188 | 189 | 190 | # 23) Crear una variable con el valor 3, y utilizar el operador '-=' para modificar su contenido 191 | 192 | # In[15]: 193 | 194 | 195 | a = -3 196 | a -= 1 197 | print(a) 198 | 199 | 200 | # 24) Realizar la operacion 1 << 2 ¿Por qué da ese resultado? ¿Qué es el sistema de numeración binario? 201 | 202 | # In[29]: 203 | 204 | 205 | 1 << 2 206 | 207 | 208 | # 25) Realizar la operación 2 + '2' ¿Por qué no está permitido? ¿Si los dos operandos serían del mismo tipo, siempre arrojaría el mismo resultado? 209 | 210 | # In[23]: 211 | 212 | 213 | 2 + '2' 214 | 215 | 216 | # In[25]: 217 | 218 | 219 | float(2) + float('2') 220 | 221 | 222 | # In[26]: 223 | 224 | 225 | int(2) + int('2') 226 | 227 | 228 | # In[27]: 229 | 230 | 231 | str(2) + str('2') 232 | 233 | 234 | # 26) Realizar una operación válida entre valores de tipo entero y string 235 | 236 | # In[30]: 237 | 238 | 239 | var1 = 'este texto se repite ' 240 | var2 = 3 241 | print(var1 * var2 + str(var2) + ' veces') 242 | 243 | -------------------------------------------------------------------------------- /M03_variablesydatos/Prep_Course_Homework_03.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "attachments": {}, 5 | "cell_type": "markdown", 6 | "metadata": {}, 7 | "source": [ 8 | "## Variables" 9 | ] 10 | }, 11 | { 12 | "attachments": {}, 13 | "cell_type": "markdown", 14 | "metadata": {}, 15 | "source": [ 16 | "1) Crear una variable que contenga un elemento del conjunto de números enteros y luego imprimir por pantalla" 17 | ] 18 | }, 19 | { 20 | "cell_type": "code", 21 | "execution_count": null, 22 | "metadata": {}, 23 | "outputs": [], 24 | "source": [] 25 | }, 26 | { 27 | "attachments": {}, 28 | "cell_type": "markdown", 29 | "metadata": {}, 30 | "source": [ 31 | "2) Imprimir el tipo de dato de la constante 8.5" 32 | ] 33 | }, 34 | { 35 | "cell_type": "code", 36 | "execution_count": null, 37 | "metadata": {}, 38 | "outputs": [], 39 | "source": [] 40 | }, 41 | { 42 | "attachments": {}, 43 | "cell_type": "markdown", 44 | "metadata": {}, 45 | "source": [ 46 | "3) Imprimir el tipo de dato de la variable creada en el punto 1" 47 | ] 48 | }, 49 | { 50 | "cell_type": "code", 51 | "execution_count": null, 52 | "metadata": {}, 53 | "outputs": [], 54 | "source": [] 55 | }, 56 | { 57 | "attachments": {}, 58 | "cell_type": "markdown", 59 | "metadata": {}, 60 | "source": [ 61 | "4) Crear una variable que contenga tu nombre" 62 | ] 63 | }, 64 | { 65 | "cell_type": "code", 66 | "execution_count": null, 67 | "metadata": {}, 68 | "outputs": [], 69 | "source": [] 70 | }, 71 | { 72 | "attachments": {}, 73 | "cell_type": "markdown", 74 | "metadata": {}, 75 | "source": [ 76 | "5) Crear una variable que contenga un número complejo" 77 | ] 78 | }, 79 | { 80 | "cell_type": "code", 81 | "execution_count": null, 82 | "metadata": {}, 83 | "outputs": [], 84 | "source": [] 85 | }, 86 | { 87 | "attachments": {}, 88 | "cell_type": "markdown", 89 | "metadata": {}, 90 | "source": [ 91 | "6) Mostrar el tipo de dato de la variable crada en el punto 5" 92 | ] 93 | }, 94 | { 95 | "cell_type": "code", 96 | "execution_count": null, 97 | "metadata": {}, 98 | "outputs": [], 99 | "source": [] 100 | }, 101 | { 102 | "attachments": {}, 103 | "cell_type": "markdown", 104 | "metadata": {}, 105 | "source": [ 106 | "7) Crear una variable que contenga el valor del número Pi redondeado a 4 decimales" 107 | ] 108 | }, 109 | { 110 | "cell_type": "code", 111 | "execution_count": null, 112 | "metadata": {}, 113 | "outputs": [], 114 | "source": [] 115 | }, 116 | { 117 | "attachments": {}, 118 | "cell_type": "markdown", 119 | "metadata": {}, 120 | "source": [ 121 | "8) Crear una variable que contenga el valor 'True' y otra que contenga el valor True. ¿Se trata de lo mismo?" 122 | ] 123 | }, 124 | { 125 | "cell_type": "code", 126 | "execution_count": null, 127 | "metadata": {}, 128 | "outputs": [], 129 | "source": [] 130 | }, 131 | { 132 | "attachments": {}, 133 | "cell_type": "markdown", 134 | "metadata": {}, 135 | "source": [ 136 | "9) Imprimir el tipo de dato correspondientes a las variables creadas en el punto 8" 137 | ] 138 | }, 139 | { 140 | "cell_type": "code", 141 | "execution_count": null, 142 | "metadata": {}, 143 | "outputs": [], 144 | "source": [] 145 | }, 146 | { 147 | "attachments": {}, 148 | "cell_type": "markdown", 149 | "metadata": {}, 150 | "source": [ 151 | "10) Asignar a una variable, la suma de un número entero y otro decimal" 152 | ] 153 | }, 154 | { 155 | "cell_type": "code", 156 | "execution_count": null, 157 | "metadata": {}, 158 | "outputs": [], 159 | "source": [] 160 | }, 161 | { 162 | "attachments": {}, 163 | "cell_type": "markdown", 164 | "metadata": {}, 165 | "source": [ 166 | "11) Realizar una operación de suma de números complejos" 167 | ] 168 | }, 169 | { 170 | "cell_type": "code", 171 | "execution_count": null, 172 | "metadata": {}, 173 | "outputs": [], 174 | "source": [] 175 | }, 176 | { 177 | "attachments": {}, 178 | "cell_type": "markdown", 179 | "metadata": {}, 180 | "source": [ 181 | "12) Realizar una operación de suma de un número real y otro complejo" 182 | ] 183 | }, 184 | { 185 | "cell_type": "code", 186 | "execution_count": null, 187 | "metadata": {}, 188 | "outputs": [], 189 | "source": [] 190 | }, 191 | { 192 | "attachments": {}, 193 | "cell_type": "markdown", 194 | "metadata": {}, 195 | "source": [ 196 | "13) Realizar una operación de multiplicación" 197 | ] 198 | }, 199 | { 200 | "cell_type": "code", 201 | "execution_count": null, 202 | "metadata": {}, 203 | "outputs": [], 204 | "source": [] 205 | }, 206 | { 207 | "attachments": {}, 208 | "cell_type": "markdown", 209 | "metadata": {}, 210 | "source": [ 211 | "14) Mostrar el resultado de elevar 2 a la octava potencia" 212 | ] 213 | }, 214 | { 215 | "cell_type": "code", 216 | "execution_count": null, 217 | "metadata": {}, 218 | "outputs": [], 219 | "source": [] 220 | }, 221 | { 222 | "attachments": {}, 223 | "cell_type": "markdown", 224 | "metadata": {}, 225 | "source": [ 226 | "15) Obtener el cociente de la división de 27 entre 4 en una variable y luego mostrarla" 227 | ] 228 | }, 229 | { 230 | "cell_type": "code", 231 | "execution_count": null, 232 | "metadata": {}, 233 | "outputs": [], 234 | "source": [] 235 | }, 236 | { 237 | "attachments": {}, 238 | "cell_type": "markdown", 239 | "metadata": {}, 240 | "source": [ 241 | "16) De la división anterior solamente mostrar la parte entera" 242 | ] 243 | }, 244 | { 245 | "cell_type": "code", 246 | "execution_count": null, 247 | "metadata": {}, 248 | "outputs": [], 249 | "source": [] 250 | }, 251 | { 252 | "attachments": {}, 253 | "cell_type": "markdown", 254 | "metadata": {}, 255 | "source": [ 256 | "17) De la división de 27 entre 4 mostrar solamente el resto" 257 | ] 258 | }, 259 | { 260 | "cell_type": "code", 261 | "execution_count": null, 262 | "metadata": {}, 263 | "outputs": [], 264 | "source": [] 265 | }, 266 | { 267 | "attachments": {}, 268 | "cell_type": "markdown", 269 | "metadata": {}, 270 | "source": [ 271 | "18) Utilizando como operandos el número 4 y los resultados obtenidos en los puntos 16 y 17. Obtener 27 como resultado" 272 | ] 273 | }, 274 | { 275 | "cell_type": "code", 276 | "execution_count": null, 277 | "metadata": {}, 278 | "outputs": [], 279 | "source": [] 280 | }, 281 | { 282 | "attachments": {}, 283 | "cell_type": "markdown", 284 | "metadata": {}, 285 | "source": [ 286 | "19) Utilizar el operador \"+\" en una operación donde intervengan solo variables alfanuméricas" 287 | ] 288 | }, 289 | { 290 | "cell_type": "code", 291 | "execution_count": null, 292 | "metadata": {}, 293 | "outputs": [], 294 | "source": [] 295 | }, 296 | { 297 | "attachments": {}, 298 | "cell_type": "markdown", 299 | "metadata": {}, 300 | "source": [ 301 | "20) Evaluar si \"2\" es igual a 2. ¿Por qué ocurre eso?" 302 | ] 303 | }, 304 | { 305 | "cell_type": "code", 306 | "execution_count": null, 307 | "metadata": {}, 308 | "outputs": [], 309 | "source": [] 310 | }, 311 | { 312 | "attachments": {}, 313 | "cell_type": "markdown", 314 | "metadata": {}, 315 | "source": [ 316 | "21) Utilizar las funciones de cambio de tipo de dato, para que la validación del punto 20 resulte verdadera" 317 | ] 318 | }, 319 | { 320 | "cell_type": "code", 321 | "execution_count": null, 322 | "metadata": {}, 323 | "outputs": [], 324 | "source": [] 325 | }, 326 | { 327 | "attachments": {}, 328 | "cell_type": "markdown", 329 | "metadata": {}, 330 | "source": [ 331 | "22) ¿Por qué arroja error el siguiente cambio de tipo de datos? a = float('3,8')" 332 | ] 333 | }, 334 | { 335 | "cell_type": "code", 336 | "execution_count": null, 337 | "metadata": {}, 338 | "outputs": [], 339 | "source": [] 340 | }, 341 | { 342 | "attachments": {}, 343 | "cell_type": "markdown", 344 | "metadata": {}, 345 | "source": [ 346 | "23) Crear una variable con el valor 3, y utilizar el operador '-=' para modificar su contenido y que de como resultado 2." 347 | ] 348 | }, 349 | { 350 | "cell_type": "code", 351 | "execution_count": null, 352 | "metadata": {}, 353 | "outputs": [], 354 | "source": [] 355 | }, 356 | { 357 | "attachments": {}, 358 | "cell_type": "markdown", 359 | "metadata": {}, 360 | "source": [ 361 | "24) Realizar la operacion 1 << 2 ¿Por qué da ese resultado? ¿Qué es el sistema de numeración binario?" 362 | ] 363 | }, 364 | { 365 | "cell_type": "code", 366 | "execution_count": null, 367 | "metadata": {}, 368 | "outputs": [], 369 | "source": [] 370 | }, 371 | { 372 | "attachments": {}, 373 | "cell_type": "markdown", 374 | "metadata": {}, 375 | "source": [ 376 | "25) Realizar la operación 2 + '2' ¿Por qué no está permitido? ¿Si los dos operandos serían del mismo tipo, siempre arrojaría el mismo resultado?" 377 | ] 378 | }, 379 | { 380 | "cell_type": "code", 381 | "execution_count": null, 382 | "metadata": {}, 383 | "outputs": [], 384 | "source": [] 385 | }, 386 | { 387 | "attachments": {}, 388 | "cell_type": "markdown", 389 | "metadata": {}, 390 | "source": [ 391 | "26) Realizar una operación válida entre valores de tipo entero y string" 392 | ] 393 | }, 394 | { 395 | "cell_type": "code", 396 | "execution_count": null, 397 | "metadata": {}, 398 | "outputs": [], 399 | "source": [] 400 | } 401 | ], 402 | "metadata": { 403 | "interpreter": { 404 | "hash": "c85384e4cb51c8b72350f3a8712cc8351fdc3955e32a27f9b60c6242ab125f01" 405 | }, 406 | "kernelspec": { 407 | "display_name": "Python 3 (ipykernel)", 408 | "language": "python", 409 | "name": "python3" 410 | }, 411 | "language_info": { 412 | "codemirror_mode": { 413 | "name": "ipython", 414 | "version": 3 415 | }, 416 | "file_extension": ".py", 417 | "mimetype": "text/x-python", 418 | "name": "python", 419 | "nbconvert_exporter": "python", 420 | "pygments_lexer": "ipython3", 421 | "version": "3.10.11" 422 | } 423 | }, 424 | "nbformat": 4, 425 | "nbformat_minor": 4 426 | } 427 | -------------------------------------------------------------------------------- /M03_variablesydatos/Prep_Course_Homework_03.md: -------------------------------------------------------------------------------- 1 | ## Variables 2 | 3 | 1) Crear una variable que contenga un elemento del conjunto de números enteros y luego imprimir por pantalla 4 | 5 | 2) Imprimir el tipo de dato de la constante 8.5 6 | 7 | 3) Imprimir el tipo de dato de la variable creada en el punto 1 8 | 9 | 4) Crear una variable que contenga tu nombre 10 | 11 | 5) Crear una variable que contenga un número complejo 12 | 13 | 6) Mostrar el tipo de dato de la variable crada en el punto 5 14 | 15 | 7) Crear una variable que contenga el valor del número Pi redondeado a 4 decimales 16 | 17 | 8) Crear una variable que contenga el valor 'True' y otra que contenga el valor True. ¿Se trata de lo mismo? 18 | 19 | 9) Imprimir el tipo de dato correspondientes a las variables creadas en el punto 8 20 | 21 | 10) Asignar a una variable, la suma de un número entero y otro decimal 22 | 23 | 11) Realizar una operación de suma de números complejos 24 | 25 | 12) Realizar una operación de suma de un número real y otro complejo 26 | 27 | 13) Realizar una operación de multiplicación 28 | 29 | 14) Mostrar el resultado de elevar 2 a la octava potencia 30 | 31 | 15) Obtener el cociente de la división de 27 entre 4 en una variable y luego mostrarla 32 | 33 | 16) De la división anterior solamente mostrar la parte entera 34 | 35 | 17) De la división de 27 entre 4 mostrar solamente el resto 36 | 37 | 18) Utilizando como operandos el número 4 y los resultados obtenidos en los puntos 16 y 17. Obtener 27 como resultado 38 | 39 | 19) Utilizar el operador "+" en una operación donde intervengan solo variables alfanuméricas 40 | 41 | 20) Evaluar si "2" es igual a 2. ¿Por qué ocurre eso? 42 | 43 | 21) Utilizar las funciones de cambio de tipo de dato, para que la validación del punto 20 resulte verdadera 44 | 45 | 22) ¿Por qué arroja error el siguiente cambio de tipo de datos? a = float('3,8') 46 | 47 | 23) Crear una variable con el valor 3, y utilizar el operador '-=' para modificar su contenido 48 | 49 | 24) Realizar la operacion 1 << 2 ¿Por qué da ese resultado? ¿Qué es el sistema de numeración binario? 50 | 51 | 25) Realizar la operación 2 + '2' ¿Por qué no está permitido? ¿Si los dos operandos serían del mismo tipo, siempre arrojaría el mismo resultado? 52 | 53 | 26) Realizar una operación válida entre valores de tipo entero y string 54 | -------------------------------------------------------------------------------- /M03_variablesydatos/Prep_Course_Homework_03.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python 2 | # coding: utf-8 3 | 4 | # ## Variables 5 | 6 | # 1) Crear una variable que contenga un elemento del conjunto de números enteros y luego imprimir por pantalla 7 | 8 | # In[7]: 9 | 10 | 11 | 12 | 13 | # 2) Imprimir el tipo de dato de la constante 8.5 14 | 15 | # In[3]: 16 | 17 | 18 | 19 | 20 | 21 | # 3) Imprimir el tipo de dato de la variable creada en el punto 1 22 | 23 | # In[8]: 24 | 25 | 26 | 27 | 28 | 29 | # 4) Crear una variable que contenga tu nombre 30 | 31 | # In[2]: 32 | 33 | 34 | 35 | 36 | # 5) Crear una variable que contenga un número complejo 37 | 38 | # In[3]: 39 | 40 | 41 | 42 | 43 | 44 | # 6) Mostrar el tipo de dato de la variable crada en el punto 5 45 | 46 | # In[4]: 47 | 48 | 49 | 50 | 51 | 52 | # 7) Crear una variable que contenga el valor del número Pi redondeado a 4 decimales 53 | 54 | # In[1]: 55 | 56 | 57 | pi = 3.1416 58 | 59 | 60 | # 8) Crear una variable que contenga el valor 'True' y otra que contenga el valor True. ¿Se trata de lo mismo? 61 | 62 | # In[3]: 63 | 64 | 65 | 66 | 67 | 68 | # 9) Imprimir el tipo de dato correspondientes a las variables creadas en el punto 8 69 | 70 | # In[5]: 71 | 72 | 73 | 74 | 75 | 76 | # 10) Asignar a una variable, la suma de un número entero y otro decimal 77 | 78 | # In[1]: 79 | 80 | 81 | 82 | 83 | 84 | # 11) Realizar una operación de suma de números complejos 85 | 86 | # In[2]: 87 | 88 | 89 | 90 | 91 | 92 | # 12) Realizar una operación de suma de un número real y otro complejo 93 | 94 | # In[4]: 95 | 96 | 97 | 98 | 99 | 100 | # 13) Realizar una operación de multiplicación 101 | 102 | # In[5]: 103 | 104 | 105 | 106 | 107 | 108 | # 14) Mostrar el resultado de elevar 2 a la octava potencia 109 | 110 | # In[6]: 111 | 112 | 113 | 114 | 115 | # 15) Obtener el cociente de la división de 27 entre 4 en una variable y luego mostrarla 116 | 117 | # In[8]: 118 | 119 | 120 | 121 | 122 | 123 | # 16) De la división anterior solamente mostrar la parte entera 124 | 125 | # In[9]: 126 | 127 | 128 | 129 | 130 | 131 | # 17) De la división de 27 entre 4 mostrar solamente el resto 132 | 133 | # In[1]: 134 | 135 | 136 | 137 | 138 | 139 | # 18) Utilizando como operandos el número 4 y los resultados obtenidos en los puntos 16 y 17. Obtener 27 como resultado 140 | 141 | # In[2]: 142 | 143 | 144 | 145 | 146 | 147 | # 19) Utilizar el operador "+" en una operación donde intervengan solo variables alfanuméricas 148 | 149 | # In[3]: 150 | 151 | 152 | 153 | 154 | 155 | # 20) Evaluar si "2" es igual a 2. ¿Por qué ocurre eso? 156 | 157 | # In[4]: 158 | 159 | 160 | 161 | 162 | 163 | # 21) Utilizar las funciones de cambio de tipo de dato, para que la validación del punto 20 resulte verdadera 164 | 165 | # In[11]: 166 | 167 | 168 | 169 | 170 | 171 | # 22) ¿Por qué arroja error el siguiente cambio de tipo de datos? a = float('3,8') 172 | 173 | # In[12]: 174 | 175 | 176 | 177 | 178 | 179 | # 23) Crear una variable con el valor 3, y utilizar el operador '-=' para modificar su contenido y que de como resultado 2. 180 | 181 | # In[15]: 182 | 183 | 184 | 185 | 186 | 187 | # 24) Realizar la operacion 1 << 2 ¿Por qué da ese resultado? ¿Qué es el sistema de numeración binario? 188 | 189 | # In[29]: 190 | 191 | 192 | 193 | 194 | 195 | # 25) Realizar la operación 2 + '2' ¿Por qué no está permitido? ¿Si los dos operandos serían del mismo tipo, siempre arrojaría el mismo resultado? 196 | 197 | # In[23]: 198 | 199 | 200 | 201 | 202 | 203 | 204 | # 26) Realizar una operación válida entre valores de tipo entero y string 205 | 206 | # In[30]: 207 | 208 | 209 | 210 | -------------------------------------------------------------------------------- /M03_variablesydatos/README.md: -------------------------------------------------------------------------------- 1 | ![HenryLogo](https://d31uz8lwfmyn8g.cloudfront.net/Assets/logo-henry-white-lg.png) 2 | 3 | 4 | ## Principales Objetivos de Aprendizaje para esta Clase 5 | 6 | - Conocer el concepto de Variables y Constantes 7 | - Conocer el concepto de Tipos de Datos 8 | 9 | 10 | ## Variables 11 | 12 | Una variable es un espacio de memoria donde guardamos un dato, ese espacio de memoria a la vez recibe un nombre y esto conforma la estructura de datos más simple que podemos encontrar. 13 | 14 | ![unaImagenConBoxShadow](../_src/assets/02_imagen01.jpg) 15 | 16 | Por otro lado existen ciertas normas a la hora de nombrar variables: 17 | 18 | * El nombre no puede empezar con un número
19 | Por ejemplo "mi_variable" sería correcto, pero "123mi_variable" sería erróneo 20 | * No se permite el uso de guiones del medio -
21 | Por ejemplo "mi-variable" sería erróneo 22 | * No se permite el uso de espacios.
23 | Por ejemplo "mi variable" sería erróneo 24 | * No usar nombres reservados para Python. Las palabras reservadas son utilizadas por Python internamente, por lo que no podemos usarlas para nuestras variables o funciones.
25 | Por ejemplo, a veces podríamos usar "int" ó "for" y esto nos daría error, porque como se verá más adelante, esas palabras son parte de la sintaxis de Python. 26 | 27 | ### Constantes 28 | 29 | Sin embargo, cuando ese dato no lo alojamos en una variable y lo utilizamos directamente, recibe el nombre de constante. 30 | 31 | ### Tipos de Datos 32 | 33 | Es importante notar, que podemos encontrarnos con datos de tipos distintos, es decir numéricos, alfanuméricos o booleanos. 34 | 35 | En Python tenemos los siguientes: 36 | * Enteros: el conjunto de números enteros 37 | * Floats: el conjunto de números reales o de punto flotante 38 | * Cadenas o Strings: es texto, caracteres alfanuméricos que se introducen entre comillas dobles o simples 39 | * Booleanos: representan Verdadero ó Falso 40 | * Complejos: el conjunto de números complejos 41 | 42 | Todo valor que pueda ser asignado a una variable tiene asociado un tipo de dato y esto establece qué operaciones se pueden realizar sobre la misma. 43 | 44 |
45 |

46 | Tip: En Python hay algunas funcionalidades ya presentes por defecto, como por ejemplo la funcion **print()** que permite mostrar una salida por pantalla y la función range() que devuelve un rango numérico según los parámetros que recibe y con la función **type()** es posible ver el tipo de dato de una variable 47 |

48 |
49 | 50 | ### Operaciones entre Variables 51 | 52 | Con diferentes tipos de datos podemos hacer diferentes tipos de operaciones. Y hay operaciones no permitidas entre variables de diferentes tipos de datos. 53 | 54 | **Operaciones aritméticas:** 55 | 56 | | Operación | Operador | Ejemplo | 57 | | :--- | :----: | ---: | 58 | | Suma | + | 3 + 5.5 = 8.5 | 59 | | Resta | - | 4 - 1 = 3 | 60 | | Multiplicación | * | 4 * 2 = 8 | 61 | | Potenciación | 42 | 4**2 = 16 | 62 | | División (Cociente) | / | 4 / 2 = 2 | 63 | | División (parte entera) | // | 14 // 3 = 4 | 64 | | División (resto) | % | 14 % 3 = 2 | 65 | 66 | **Operadores relacionales:** 67 | 68 | | Operación | Operador | Ejemplo | 69 | | :--- | :----: | ---: | 70 | | == | Igual | 10 == 3 = False | 71 | | != | Distinto | 10 != 3 = True | 72 | | > | Mayor | 10 > 3 = True | 73 | | < | Menor | 10 < 3 = False | 74 | | >= | Mayor o igual | 10 >= 3 = True | 75 | | <= | Menor o igual | 10 <= 3 = False | 76 | 77 | **Operaciones de asignación:** 78 | 79 | | Operación | Operador | Ejemplo | 80 | | :--- | :----: | ---: | 81 | | = | x=7 | x=7 | 82 | | += | x+=2 | x=x+2 = 9 | 83 | | -= | x-=2 | x=x-2 = 5 | 84 | | *= | x*=2 | x=x*2 = 14 | 85 | | /= | x/=2 | x=x/2 = 3.5 | 86 | | %= | x%=2 | x=x%2 = 1 | 87 | | //= | x//=2 | x=x//2 = 3 | 88 | | **= | x**=2 | x=x**2 = 49 | 89 | | &= | x&=2 | x=x&2 = 2 | 90 | | ^= | x^=2 | x=x^2 = 5 | 91 | | >>= | x>>=2 | x=x>>2 = 1 | 92 | | <<= | x<<=2 | x=x<<=2 = 28 | 93 | 94 | 95 | Operación: |=
96 | Operador: x|=2
97 | Ejemplo: x=x|2 = 7
98 | 99 | Cuando tratamos con texto, podemos hacer otras operaciones: 100 | 101 | | Operación | Operador | Ejemplo | 102 | | :--- | :----: | ---: | 103 | | Concatenar | + | 'hola ' + 'mundo !' = 'hola mundo!' | 104 | | Multiplicar | * | 'ja ' * 3 = 'ja ja ja' | 105 | 106 | Algunos ejemplos en Python: 107 | 108 | ```python 109 | >>> a = 'Hola ' 110 | >>> b = 'Mundo !' 111 | >>> print(a + b) 112 | Hola Mundo ! 113 | 114 | >>> x = 3 115 | >>> y = 12 116 | >>> print(x + y) 117 | 15 118 | 119 | >>> print(a + x) 120 | --------------------------------------------------------------------------- 121 | TypeError Traceback (most recent call last) 122 | ~\AppData\Local\Temp/ipykernel_18232/136165486.py in 123 | ----> 1 print(a + x) 124 | 125 | TypeError: can only concatenate str (not "int") to str 126 | ``` 127 | 128 | Notar que en las operaciones que no están permitidas arroja un error, que es muy descriptivo. En este caso no es posible sumar un valor entero con un valor alfanumérico. 129 | 130 | ```python 131 | >>> # Dividir "y" entre "x" 132 | >>> y = 9 133 | >>> x = 3 134 | >>> print(y/x) 135 | 3.0 136 | 137 | >>> # Potencia de "y" elevado a la "x" 138 | >>> y = 2 139 | >>> x = 4 140 | >>> print(y**x) 141 | 16 142 | 143 | >>> # Devolver el resto de la división 144 | >>> y = 13 145 | >>> x = 3 146 | >>> print(y%x) 147 | 1 148 | 149 | >>> # Imprimir el tipo de dato de una variable y una constante 150 | >>> y = 2.5 151 | >>> type(y) 152 | float 153 | >>> type(2.5) 154 | float 155 | ``` 156 | 157 | Notar que anteponiendo el carácter numeral (#) es posible agregar comentarios en el código. Por otra parte, la función **type()** es muy útil para saber a qué tipo de dato corresponde un elemento. 158 | 159 | **Operaciones Lógicas** 160 | 161 | Son operaciones en las que entran en uso el tipo de datos booleano, es decir, que nos permiten representar valores verdadero o falso. Para verlo mejor, es necesario recurrir a lo que llamamos tablas de verdad. 162 | Veremos muy comúnmente representar verdadero con un "1" y falso con un "0". 163 | 164 | Tabla del operador lógico "and", se verifican que A y B sean verdaderas. 165 | | A | B | A and B | 166 | | :- | :--: | -: | 167 | | 1 | 0 | 0 | 168 | | 0 | 0 | 0 | 169 | | 0 | 1 | 0 | 170 | | 1 | 1 | 1 | 171 | 172 | Tabla del operador lógico "or", se verifican que A o B sean verdaderas. 173 | | A | B | A or B | 174 | | :- | :--: | -: | 175 | | 1 | 0 | 1 | 176 | | 0 | 0 | 0 | 177 | | 0 | 1 | 1 | 178 | | 1 | 1 | 1 | 179 | 180 | Tambien es posible representar la negación, con el operador not() 181 | 182 | Tabla del operador lógico "Or Exclusiva", se verifica ((A and not(B)) or (not(A) and B)) 183 | | A | B | A "or exclusiva" B | 184 | | :- | :--: | -: | 185 | | 1 | 0 | 1 | 186 | | 0 | 0 | 0 | 187 | | 0 | 1 | 1 | 188 | | 1 | 1 | 0 | 189 | 190 | ```python 191 | >>> a = True 192 | >>> b = False 193 | >>> print(a or b) 194 | True 195 | ``` 196 | 197 |
198 |

199 | Tips: Notar que las constantes "True" y "False" se escriben con la primer letra mayúscula y el resto minúsculas, de otra forma arrojaría un error 200 |

201 |
202 | 203 | ### Conversión de tipos de datos 204 | 205 | Puede haber ocasiones en las que desee especificar un tipo en una variable. Esto se puede hacer con lo que se denomina **casting**. 206 | La conversión de tipo de dato en python se realiza mediante funciones: 207 | 208 | int(): construye un número entero a partir de un literal entero, un literal flotante (eliminando todos los decimales) o un literal de cadena (siempre que la cadena represente un número entero) 209 | float(): construye un número flotante a partir de un literal entero, un literal flotante o un literal de cadena (siempre que la cadena represente un flotante o un entero) 210 | str(): construye una cadena a partir de una amplia variedad de tipos de datos, incluidas cadenas, literales enteros y literales flotantes 211 | 212 | ```python 213 | >>> x = '2' 214 | >>> print(type(x)) 215 | 216 | >>> x = int(x) 217 | >>> print(type(x)) 218 | 219 | >>> y = int(2.8) 220 | >>> print(y) 221 | 2 222 | ``` 223 | 224 | ## Recursos adicionales 225 | 226 | * [Cheat Lists] (https://intellipaat.com/blog/tutorial/python-tutorial/data-structures-with-python-cheat-sheet/?US) 227 | 228 | 229 | * Si tienes dudas sobre este tema, puedes consultarlas en el canal **#m03_variablesydatos** de Slack -------------------------------------------------------------------------------- /M04_flujosdecontrol/Prep_Course_Homework_04-Resuelto.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python 2 | # coding: utf-8 3 | 4 | # ## Flujos de Control 5 | 6 | # 1) Crear una variable que contenga un elemento del conjunto de números enteros y luego imprimir por pantalla si es mayor o menor a cero 7 | 8 | # In[4]: 9 | 10 | 11 | a = 10 12 | if (a < 0): 13 | print('La variable es menor a cero') 14 | elif (a > 0): 15 | print('La varaible es mayor a cero') 16 | else: 17 | print('La variable es igual a cero') 18 | 19 | 20 | # 2) Crear dos variables y un condicional que informe si son del mismo tipo de dato 21 | 22 | # In[5]: 23 | 24 | 25 | a = 2 26 | b = 'hola' 27 | if (type(a) == type(b)): 28 | print('Las variables son del mismo tipo de dato') 29 | else: 30 | print('Las variables son de tipos de dato diferentes') 31 | 32 | 33 | # 3) Para los valores enteros del 1 al 20, imprimir por pantalla si es par o impar 34 | 35 | # In[7]: 36 | 37 | 38 | for i in range(1, 21): 39 | if i % 2 == 0: 40 | print('El número ', str(i), ' es par') 41 | else: 42 | print('El número ', str(i), ' es impar') 43 | 44 | 45 | # 4) En un ciclo for mostrar para los valores entre 0 y 5 el resultado de elevarlo a la potencia igual a 3 46 | 47 | # In[9]: 48 | 49 | 50 | for i in range(0, 6): 51 | print('Valor:', str(i), ' Elevado a la 3ra potencia:', str(i**3)) 52 | 53 | 54 | # 5) Crear una variable que contenga un número entero y realizar un ciclo for la misma cantidad de ciclos 55 | 56 | # In[10]: 57 | 58 | 59 | n = 12 60 | for i in range(0, n): 61 | pass 62 | print(i) 63 | 64 | 65 | # 6) Utilizar un ciclo while para realizar el factorial de un número guardado en una variable, sólo si la variable contiene un número entero mayor a 0 66 | 67 | # In[33]: 68 | 69 | 70 | n = 5 71 | if (type(n) == int): 72 | if (n > 0): 73 | factorial = n 74 | while (n > 2): 75 | n = n - 1 76 | factorial = factorial * n 77 | print('El factorial es', factorial) 78 | else: 79 | print('La variable no es mayor a cero') 80 | else: 81 | print('La variable no es un entero') 82 | 83 | 84 | 85 | # 7) Crear un ciclo for dentro de un ciclo while 86 | 87 | # In[38]: 88 | 89 | 90 | n = 0 91 | while(n < 5): 92 | n += 1 93 | for i in range(1,n): 94 | print('Ciclo while nro ' + str(n)) 95 | print('Ciclo for nro ' + str(i)) 96 | 97 | 98 | # 8) Crear un ciclo while dentro de un ciclo for 99 | 100 | # In[3]: 101 | 102 | 103 | n = 5 104 | for i in range(1, n): 105 | while(n < 5): 106 | n -= 1 107 | print('Ciclo while nro ' + str(n)) 108 | print('Ciclo for nro ' + str(i)) 109 | 110 | 111 | # 9) Imprimir los números primos existentes entre 0 y 30 112 | 113 | # In[54]: 114 | 115 | 116 | tope_rango=30 117 | n = 0 118 | primo = True 119 | while (n < tope_rango): 120 | for div in range(2, n): 121 | if (n % div == 0): 122 | primo = False 123 | if (primo): 124 | print(n) 125 | else: 126 | primo = True 127 | n += 1 128 | 129 | 130 | # 10) ¿Se puede mejorar el proceso del punto 9? Utilizar las sentencias break y/ó continue para tal fin 131 | 132 | # In[55]: 133 | 134 | 135 | n = 0 136 | primo = True 137 | while (n < tope_rango): 138 | for div in range(2, n): 139 | if (n % div == 0): 140 | primo = False 141 | break 142 | if (primo): 143 | print(n) 144 | else: 145 | primo = True 146 | n += 1 147 | 148 | 149 | # 11) En los puntos 9 y 10, se diseño un código que encuentra números primos y además se lo optimizó. ¿Es posible saber en qué medida se optimizó? 150 | 151 | # In[56]: 152 | 153 | 154 | ciclos_sin_break = 0 155 | n = 0 156 | primo = True 157 | while (n < tope_rango): 158 | for div in range(2, n): 159 | ciclos_sin_break += 1 160 | if (n % div == 0): 161 | primo = False 162 | if (primo): 163 | print(n) 164 | else: 165 | primo = True 166 | n += 1 167 | print('Cantidad de ciclos: ' + str(ciclos_sin_break)) 168 | 169 | 170 | # In[57]: 171 | 172 | 173 | ciclos_con_break = 0 174 | n = 0 175 | primo = True 176 | while (n < tope_rango): 177 | for div in range(2, n): 178 | ciclos_con_break += 1 179 | if (n % div == 0): 180 | primo = False 181 | break 182 | if (primo): 183 | print(n) 184 | else: 185 | primo = True 186 | n += 1 187 | print('Cantidad de ciclos: ' + str(ciclos_con_break)) 188 | print('Se optimizó a un ' + str(ciclos_con_break/ciclos_sin_break) + '% de ciclos aplicando break') 189 | 190 | 191 | # 12) Aplicando continue, armar un ciclo while que solo imprima los valores divisibles por 12, dentro del rango de números de 100 a 300 192 | 193 | # In[62]: 194 | 195 | 196 | n = 99 197 | while(n <= 300): 198 | n += 1 199 | if (n % 12 != 0): 200 | continue 201 | print(n, ' es divisible por 12') 202 | 203 | 204 | # 13) Utilizar la función **input()** que permite hacer ingresos por teclado, para encontrar números primos y dar la opción al usario de buscar el siguiente 205 | 206 | # In[73]: 207 | 208 | 209 | n = 1 210 | sigue = 1 211 | primo = True 212 | while (sigue == 1): 213 | for div in range(2, n): 214 | if (n % div == 0): 215 | primo = False 216 | break 217 | if (primo): 218 | print(n) 219 | print('¿Desea encontrar el siguiente número primo?') 220 | if (input() != '1'): 221 | print('Se finaliza el proceso') 222 | break 223 | else: 224 | primo = True 225 | n += 1 226 | 227 | 228 | # 14) Crear un ciclo while que encuentre dentro del rango de 100 a 300 el primer número divisible por 3 y además múltiplo de 6 229 | 230 | # In[75]: 231 | 232 | 233 | n = 100 234 | while(n<=300): 235 | if (n % 6 == 0): 236 | print('El número es: ', str(n)) 237 | break 238 | n += 1 239 | 240 | -------------------------------------------------------------------------------- /M04_flujosdecontrol/Prep_Course_Homework_04.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "attachments": {}, 5 | "cell_type": "markdown", 6 | "metadata": {}, 7 | "source": [ 8 | "## Flujos de Control" 9 | ] 10 | }, 11 | { 12 | "attachments": {}, 13 | "cell_type": "markdown", 14 | "metadata": {}, 15 | "source": [ 16 | "1) Crear una variable que contenga un elemento del conjunto de números enteros y luego imprimir por pantalla si es mayor o menor a cero" 17 | ] 18 | }, 19 | { 20 | "cell_type": "code", 21 | "execution_count": null, 22 | "metadata": {}, 23 | "outputs": [], 24 | "source": [] 25 | }, 26 | { 27 | "attachments": {}, 28 | "cell_type": "markdown", 29 | "metadata": {}, 30 | "source": [ 31 | "2) Crear dos variables y un condicional que informe si son del mismo tipo de dato" 32 | ] 33 | }, 34 | { 35 | "cell_type": "code", 36 | "execution_count": null, 37 | "metadata": {}, 38 | "outputs": [], 39 | "source": [] 40 | }, 41 | { 42 | "attachments": {}, 43 | "cell_type": "markdown", 44 | "metadata": {}, 45 | "source": [ 46 | "3) Para los valores enteros del 1 al 20, imprimir por pantalla si es par o impar" 47 | ] 48 | }, 49 | { 50 | "cell_type": "code", 51 | "execution_count": null, 52 | "metadata": {}, 53 | "outputs": [], 54 | "source": [] 55 | }, 56 | { 57 | "attachments": {}, 58 | "cell_type": "markdown", 59 | "metadata": {}, 60 | "source": [ 61 | "4) En un ciclo for mostrar para los valores entre 0 y 5 el resultado de elevarlo a la potencia igual a 3" 62 | ] 63 | }, 64 | { 65 | "cell_type": "code", 66 | "execution_count": null, 67 | "metadata": {}, 68 | "outputs": [], 69 | "source": [] 70 | }, 71 | { 72 | "attachments": {}, 73 | "cell_type": "markdown", 74 | "metadata": {}, 75 | "source": [ 76 | "5) Crear una variable que contenga un número entero y realizar un ciclo for la misma cantidad de ciclos" 77 | ] 78 | }, 79 | { 80 | "cell_type": "code", 81 | "execution_count": null, 82 | "metadata": {}, 83 | "outputs": [], 84 | "source": [] 85 | }, 86 | { 87 | "attachments": {}, 88 | "cell_type": "markdown", 89 | "metadata": {}, 90 | "source": [ 91 | "6) Utilizar un ciclo while para realizar el factorial de un número guardado en una variable, sólo si la variable contiene un número entero mayor a 0" 92 | ] 93 | }, 94 | { 95 | "cell_type": "code", 96 | "execution_count": null, 97 | "metadata": {}, 98 | "outputs": [], 99 | "source": [] 100 | }, 101 | { 102 | "attachments": {}, 103 | "cell_type": "markdown", 104 | "metadata": {}, 105 | "source": [ 106 | "7) Crear un ciclo for dentro de un ciclo while" 107 | ] 108 | }, 109 | { 110 | "cell_type": "code", 111 | "execution_count": null, 112 | "metadata": {}, 113 | "outputs": [], 114 | "source": [] 115 | }, 116 | { 117 | "attachments": {}, 118 | "cell_type": "markdown", 119 | "metadata": {}, 120 | "source": [ 121 | "8) Crear un ciclo while dentro de un ciclo for" 122 | ] 123 | }, 124 | { 125 | "cell_type": "code", 126 | "execution_count": null, 127 | "metadata": {}, 128 | "outputs": [], 129 | "source": [] 130 | }, 131 | { 132 | "attachments": {}, 133 | "cell_type": "markdown", 134 | "metadata": {}, 135 | "source": [ 136 | "9) Imprimir los números primos existentes entre 0 y 30" 137 | ] 138 | }, 139 | { 140 | "cell_type": "code", 141 | "execution_count": null, 142 | "metadata": {}, 143 | "outputs": [], 144 | "source": [] 145 | }, 146 | { 147 | "attachments": {}, 148 | "cell_type": "markdown", 149 | "metadata": {}, 150 | "source": [ 151 | "10) ¿Se puede mejorar el proceso del punto 9? Utilizar las sentencias break y/ó continue para tal fin" 152 | ] 153 | }, 154 | { 155 | "cell_type": "code", 156 | "execution_count": null, 157 | "metadata": {}, 158 | "outputs": [], 159 | "source": [] 160 | }, 161 | { 162 | "attachments": {}, 163 | "cell_type": "markdown", 164 | "metadata": {}, 165 | "source": [ 166 | "11) En los puntos 9 y 10, se diseño un código que encuentra números primos y además se lo optimizó. ¿Es posible saber en qué medida se optimizó?" 167 | ] 168 | }, 169 | { 170 | "cell_type": "code", 171 | "execution_count": null, 172 | "metadata": {}, 173 | "outputs": [], 174 | "source": [] 175 | }, 176 | { 177 | "attachments": {}, 178 | "cell_type": "markdown", 179 | "metadata": {}, 180 | "source": [ 181 | "12) Aplicando continue, armar un ciclo while que solo imprima los valores divisibles por 12, dentro del rango de números de 100 a 300" 182 | ] 183 | }, 184 | { 185 | "cell_type": "code", 186 | "execution_count": null, 187 | "metadata": {}, 188 | "outputs": [], 189 | "source": [] 190 | }, 191 | { 192 | "attachments": {}, 193 | "cell_type": "markdown", 194 | "metadata": {}, 195 | "source": [ 196 | "13) Utilizar la función **input()** que permite hacer ingresos por teclado, para encontrar números primos y dar la opción al usario de buscar el siguiente" 197 | ] 198 | }, 199 | { 200 | "cell_type": "code", 201 | "execution_count": null, 202 | "metadata": {}, 203 | "outputs": [], 204 | "source": [] 205 | }, 206 | { 207 | "attachments": {}, 208 | "cell_type": "markdown", 209 | "metadata": {}, 210 | "source": [ 211 | "14) Crear un ciclo while que encuentre dentro del rango de 100 a 300 el primer número divisible por 3 y además múltiplo de 6" 212 | ] 213 | }, 214 | { 215 | "cell_type": "code", 216 | "execution_count": null, 217 | "metadata": {}, 218 | "outputs": [], 219 | "source": [] 220 | } 221 | ], 222 | "metadata": { 223 | "interpreter": { 224 | "hash": "c85384e4cb51c8b72350f3a8712cc8351fdc3955e32a27f9b60c6242ab125f01" 225 | }, 226 | "kernelspec": { 227 | "display_name": "Python 3 (ipykernel)", 228 | "language": "python", 229 | "name": "python3" 230 | }, 231 | "language_info": { 232 | "codemirror_mode": { 233 | "name": "ipython", 234 | "version": 3 235 | }, 236 | "file_extension": ".py", 237 | "mimetype": "text/x-python", 238 | "name": "python", 239 | "nbconvert_exporter": "python", 240 | "pygments_lexer": "ipython3", 241 | "version": "3.10.6" 242 | } 243 | }, 244 | "nbformat": 4, 245 | "nbformat_minor": 4 246 | } 247 | -------------------------------------------------------------------------------- /M04_flujosdecontrol/Prep_Course_Homework_04.md: -------------------------------------------------------------------------------- 1 | ## Flujos de Control 2 | 3 | 1) Crear una variable que contenga un elemento del conjunto de números enteros y luego imprimir por pantalla si es mayor o menor a cero 4 | 5 | 2) Crear dos variables y un condicional que informe si son del mismo tipo de dato 6 | 7 | 3) Para los valores enteros del 1 al 20, imprimir por pantalla si es par o impar 8 | 9 | 4) En un ciclo for mostrar para los valores entre 0 y 5 el resultado de elevarlo a la potencia igual a 3 10 | 11 | 5) Crear una variable que contenga un número entero y realizar un ciclo for la misma cantidad de ciclos 12 | 13 | 6) Utilizar un ciclo while para realizar el factorial de un número guardado en una variable, sólo si la variable contiene un número entero mayor a 0 14 | 15 | 7) Crear un ciclo for dentro de un ciclo while 16 | 17 | 8) Crear un ciclo while dentro de un ciclo for 18 | 19 | 9) Imprimir los números primos existentes entre 0 y 30 20 | 21 | 10) ¿Se puede mejorar el proceso del punto 9? Utilizar las sentencias break y/ó continue para tal fin 22 | 23 | 11) En los puntos 9 y 10, se diseño un código que encuentra números primos y además se lo optimizó. ¿Es posible saber en qué medida se optimizó? 24 | 25 | 12) Aplicando continue, armar un ciclo while que solo imprima los valores divisibles por 12, dentro del rango de números de 100 a 300 26 | 27 | 13) Utilizar la función **input()** que permite hacer ingresos por teclado, para encontrar números primos y dar la opción al usario de buscar el siguiente 28 | 29 | 14) Crear un ciclo while que encuentre dentro del rango de 100 a 300 el primer número divisible por 3 y además múltiplo de 6 30 | -------------------------------------------------------------------------------- /M04_flujosdecontrol/Prep_Course_Homework_04.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python 2 | # coding: utf-8 3 | 4 | # ## Flujos de Control 5 | 6 | # 1) Crear una variable que contenga un elemento del conjunto de números enteros y luego imprimir por pantalla si es mayor o menor a cero 7 | 8 | # In[4]: 9 | 10 | 11 | 12 | 13 | 14 | # 2) Crear dos variables y un condicional que informe si son del mismo tipo de dato 15 | 16 | # In[5]: 17 | 18 | 19 | 20 | 21 | 22 | # 3) Para los valores enteros del 1 al 20, imprimir por pantalla si es par o impar 23 | 24 | # In[7]: 25 | 26 | 27 | 28 | 29 | 30 | # 4) En un ciclo for mostrar para los valores entre 0 y 5 el resultado de elevarlo a la potencia igual a 3 31 | 32 | # In[9]: 33 | 34 | 35 | 36 | 37 | 38 | # 5) Crear una variable que contenga un número entero y realizar un ciclo for la misma cantidad de ciclos 39 | 40 | # In[10]: 41 | 42 | 43 | 44 | 45 | 46 | # 6) Utilizar un ciclo while para realizar el factoreo de un número guardado en una variable, sólo si la variable contiene un número entero mayor a 0 47 | 48 | # In[33]: 49 | 50 | 51 | 52 | 53 | 54 | # 7) Crear un ciclo for dentro de un ciclo while 55 | 56 | # In[38]: 57 | 58 | 59 | 60 | 61 | 62 | # 8) Crear un ciclo while dentro de un ciclo for 63 | 64 | # In[3]: 65 | 66 | 67 | 68 | 69 | 70 | # 9) Imprimir los números primos existentes entre 0 y 30 71 | 72 | # In[54]: 73 | 74 | 75 | 76 | 77 | # 10) ¿Se puede mejorar el proceso del punto 9? Utilizar las sentencias break y/ó continue para tal fin 78 | 79 | # In[55]: 80 | 81 | 82 | 83 | 84 | 85 | # 11) En los puntos 9 y 10, se diseño un código que encuentra números primos y además se lo optimizó. ¿Es posible saber en qué medida se optimizó? 86 | 87 | # In[56]: 88 | 89 | 90 | 91 | 92 | # In[57]: 93 | 94 | 95 | 96 | 97 | # 12) Aplicando continue, armar un ciclo while que solo imprima los valores divisibles por 12, dentro del rango de números de 100 a 300 98 | 99 | # In[62]: 100 | 101 | 102 | 103 | 104 | 105 | # 13) Utilizar la función **input()** que permite hacer ingresos por teclado, para encontrar números primos y dar la opción al usario de buscar el siguiente 106 | 107 | # In[73]: 108 | 109 | 110 | 111 | 112 | # 14) Crear un ciclo while que encuentre dentro del rango de 100 a 300 el primer número divisible por 3 y además múltiplo de 6 113 | 114 | # In[75]: 115 | 116 | 117 | 118 | -------------------------------------------------------------------------------- /M04_flujosdecontrol/README.md: -------------------------------------------------------------------------------- 1 | ![HenryLogo](https://d31uz8lwfmyn8g.cloudfront.net/Assets/logo-henry-white-lg.png) 2 | 3 | ## Principales Objetivos de Aprendizaje para esta Clase 4 | 5 | - Conocer el concepto de los Flujos de Control 6 | - Conocer cómo se usan los Condicionales en Programación 7 | - Conocer el concepto de Ciclos Iterativos 8 | 9 | ## Flujos de Control 10 | 11 | ### Condicionales 12 | 13 | Los condicionales son bloques de código que se ejecutan únicamente si se cumple una condición. 14 | El resultado de esta condición debe ser booleano (True o False). 15 | Esto se logra mediante la sentencia **if**. 16 | Con la sentencia **elif** se puede agregar un número arbitrario de condiciones. 17 | Por otra parte, se puede ejecutar código si la/s condición/es no se cumple/n con la sentencia **else**. 18 | 19 | 20 | ```python 21 | >>> valor = 0 22 | >>> if (valor < 0): 23 | >>> print('El número es negativo') 24 | >>> elif (valor > 0): 25 | >>> print('El número es positivo') 26 | >>> else: 27 | >>> print('El número es igual a cero') 28 | El número es igual a cero 29 | ``` 30 | 31 | ### Ciclos Iterativos o Loops 32 | 33 | Son bloques de código que se repiten una cierta cantidad de veces en función de ciertas condiciones. 34 | 35 | Un ciclo **for** repite un bloque de código tantas veces como elementos haya dentro del rango entre 1 y 10: 36 | 37 | ```python 38 | >>> for n in range(1,10): 39 | >>> print(n) 40 | 1 41 | 2 42 | 3 43 | 4 44 | 5 45 | 6 46 | 7 47 | 8 48 | 9 49 | ``` 50 | 51 | Un ciclo **while** repite un bloque de código mientras que cierta condición se cumpla: 52 | 53 | ```python 54 | >>> n = 1 55 | >>> while (n < 10): 56 | >>> print(n) 57 | >>> n = n + 1 58 | 1 59 | 2 60 | 3 61 | 4 62 | 5 63 | 6 64 | 7 65 | 8 66 | 9 67 | ``` 68 | 69 |
70 |

71 | Hemos llegado hasta este punto y se repasaron algunos de los conceptos más fundamentales de la programación y de Python, pero es necesario detenerse en algunos detalles, que tienen que ver precisamente con el lenguaje que estamos utilizando: 72 | 73 | * En Python es importante la indentación, notar que el código que se ejecuta dentro de una sentencia if, for o while está indentado. 74 | * También es importante notar los ":" 75 | * En Python, cada vez que hagamos referencia a un rango, por ejemplo "1,10" el primer número se incluye y el último no. 76 |

77 |
78 | 79 | ### Sentencia Break 80 | 81 | La sentencia break permite alterar el comportamiento de los bucles while y for. Concretamente, permite terminar con la ejecución del bucle. Esto significa que una vez se encuentra la palabra break, el bucle se habrá terminado. 82 | Veamos cómo podemos usar el break con bucles for. El range(5) generaría 5 iteraciones, donde la i valdría de 0 a 4. Sin embargo, en la primera iteración, terminamos el bucle prematuramente. 83 | El break hace que nada más empezar el bucle, se rompa y se salga sin haber hecho nada. 84 | 85 | ```python 86 | >>> for i in range(5): 87 | >>> print(i) 88 | >>> break 89 | 0 90 | ``` 91 | 92 | Un ejemplo un poco más útil, sería el de buscar una letra en una palabra. Se itera toda la palabra y en el momento en el que se encuentra la letra que buscábamos, se rompe el bucle y se sale. Esto es algo muy útil porque si ya encontramos lo que estábamos buscando, no tendría mucho sentido seguir iterando la lista, ya que desperdiciaríamos recursos. 93 | 94 | ```python 95 | >>> cadena = 'Python' 96 | >>> for letra in cadena: 97 | >>> if letra == 'h': 98 | >>> print("Se encontró la h") 99 | >>> break 100 | >>> print(letra) 101 | P 102 | y 103 | t 104 | Se encontró la h 105 | ``` 106 | 107 | El break también nos permite alterar el comportamiento del while. En el ejemplo, la condición while True haría que la sección de código se ejecutará indefinidamente, pero al hacer uso del break, el bucle se romperá cuando x valga cero. 108 | 109 | ```python 110 | >>> x = 5 111 | >>> while True: 112 | >>> x -= 1 113 | >>> print(x) 114 | >>> if x == 0: 115 | >>> break 116 | >>> print("Fin del bucle") 117 | 4 118 | 3 119 | 2 120 | 1 121 | 0 122 | Fin del bucle 123 | ``` 124 | 125 | Por norma general, y salvo casos muy concretos, si ves un while True, es probable que haya un break dentro del bucle. 126 | 127 | ### Sentencia Continue 128 | 129 | El uso de continue al igual que el ya visto break, permite modificar el comportamiento de de los bucles while y for. 130 | Concretamente, la sentencia continue se salta todo el código restante en la iteración actual y vuelve al principio en el caso de que aún queden iteraciones por completar. 131 | La diferencia con la sentencia break es que el continue no rompe el bucle, si no que pasa a la siguiente iteración saltando el código pendiente. 132 | En el siguiente ejemplo vemos como al encontrar la letra P se llama al continue, lo que hace que se salte el print(). Es por ello por lo que no vemos la letra P impresa en pantalla. 133 | 134 | ```python 135 | >>> cadena = 'Python' 136 | >>> for letra in cadena: 137 | >>> if letra == 'P': 138 | >>> continue 139 | >>> print(letra) 140 | y 141 | t 142 | h 143 | o 144 | n 145 | ``` 146 | 147 | * Si tienes dudas sobre este tema, puedes consultarlas en el canal **#m04_flujosdecontrol** de Slack 148 | -------------------------------------------------------------------------------- /M05_estructuradedatos/Prep_Course_Homework_05-Resuelto.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python 2 | # coding: utf-8 3 | 4 | # ## Estructuras de Datos 5 | 6 | # 1) Crear una lista que contenga nombres de ciudades del mundo que contenga más de 5 elementos e imprimir por pantalla 7 | 8 | # In[3]: 9 | 10 | 11 | lis = ['Buenos Aires','Brasilia','Asunción','Montevideo','Santiago','Lima','Caracas','Bogotá'] 12 | print(lis) 13 | 14 | 15 | # 2) Imprimir por pantalla el segundo elemento de la lista 16 | 17 | # In[4]: 18 | 19 | 20 | print(lis[1]) 21 | 22 | 23 | # 3) Imprimir por pantalla del segundo al cuarto elemento 24 | 25 | # In[8]: 26 | 27 | 28 | print(lis[1:4]) 29 | 30 | 31 | # 4) Visualizar el tipo de dato de la lista 32 | 33 | # In[12]: 34 | 35 | 36 | print(type(lis)) 37 | 38 | 39 | # 5) Visualizar todos los elementos de la lista a partir del tercero de manera genérica, es decir, sin explicitar la posición del último elemento 40 | 41 | # In[14]: 42 | 43 | 44 | print(lis[2:]) 45 | 46 | 47 | # 6) Visualizar los primeros 4 elementos de la lista 48 | 49 | # In[15]: 50 | 51 | 52 | print(lis[:4]) 53 | 54 | 55 | 56 | # 7) Agregar una ciudad más a la lista que ya exista y otra que no ¿Arroja algún tipo de error? 57 | 58 | # In[16]: 59 | 60 | 61 | lis.append('Ciudad de Méjico') 62 | 63 | 64 | # In[17]: 65 | 66 | 67 | lis.append('Montevideo') 68 | 69 | 70 | # In[18]: 71 | 72 | 73 | print(lis) 74 | 75 | 76 | # 8) Agregar otra ciudad, pero en la cuarta posición 77 | 78 | # In[20]: 79 | 80 | 81 | lis.insert(3, 'Quito') 82 | 83 | 84 | # In[21]: 85 | 86 | 87 | print(lis) 88 | 89 | 90 | # 9) Concatenar otra lista a la ya creada 91 | 92 | # In[22]: 93 | 94 | 95 | lis.extend(['Madrid','Roma','Bruselas']) 96 | print(lis) 97 | 98 | 99 | # 10) Encontrar el índice de la ciudad que en el punto 7 agregamos duplicada. ¿Se nota alguna particularidad? 100 | 101 | # In[23]: 102 | 103 | 104 | print(lis.index('Montevideo')) 105 | 106 | 107 | # 11) ¿Qué pasa si se busca un elemento que no existe? 108 | 109 | # In[24]: 110 | 111 | 112 | print(lis.index('París')) 113 | 114 | 115 | # 12) Eliminar un elemento de la lista 116 | 117 | # In[25]: 118 | 119 | 120 | lis.remove('Buenos Aires') 121 | 122 | 123 | # In[26]: 124 | 125 | 126 | print(lis) 127 | 128 | 129 | # 13) ¿Qué pasa si el elemento a eliminar no existe? 130 | 131 | # In[27]: 132 | 133 | 134 | lis.remove('Buenos Aires') 135 | 136 | 137 | # 14) Extraer el úlimo elemento de la lista, guardarlo en una variable e imprimirlo 138 | 139 | # In[28]: 140 | 141 | 142 | ultimo = lis.pop() 143 | print(ultimo) 144 | 145 | 146 | # 15) Mostrar la lista multiplicada por 4 147 | 148 | # In[29]: 149 | 150 | 151 | print(lis * 4) 152 | 153 | 154 | # 16) Crear una tupla que contenga los números enteros del 1 al 20 155 | 156 | # In[32]: 157 | 158 | 159 | tup = (1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20) 160 | print(type(tup)) 161 | print(tup) 162 | 163 | 164 | # 17) Imprimir desde el índice 10 al 15 de la tupla 165 | 166 | # In[35]: 167 | 168 | 169 | print(tup[10:16]) 170 | 171 | 172 | # 18) Evaluar si los números 20 y 30 están dentro de la tupla 173 | 174 | # In[41]: 175 | 176 | 177 | print(20 in tup) 178 | print(30 in tup) 179 | 180 | 181 | # 19) Con la lista creada en el punto 1, validar la existencia del elemento 'París' y si no existe, agregarlo. Utilizar una variable e informar lo sucedido. 182 | 183 | # In[48]: 184 | 185 | 186 | elemento = 'París' 187 | if (not(elemento in lis)): 188 | lis.append(elemento) 189 | print('Se insertó el elemento', elemento) 190 | else: 191 | print('El elemento', elemento, 'ya existía') 192 | 193 | 194 | # 20) Mostrar la cantidad de veces que se encuentra un elemento específico dentro de la tupla y de la lista 195 | 196 | # In[51]: 197 | 198 | 199 | print(tup.count(10)) 200 | print(lis.count('Montevideo')) 201 | 202 | 203 | # 21) Convertir la tupla en una lista 204 | 205 | # In[52]: 206 | 207 | 208 | lis2=list(tup) 209 | print(lis2) 210 | 211 | 212 | # 22) Desempaquetar solo los primeros 3 elementos de la tupla en 3 variables 213 | 214 | # In[55]: 215 | 216 | 217 | v1, v2, v3, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = tup 218 | print(v1) 219 | print(v2) 220 | print(v3) 221 | 222 | 223 | # 23) Crear un diccionario utilizando la lista crada en el punto 1, asignandole la clave "ciudad". Agregar tambien otras claves, como puede ser "Pais" y "Continente". 224 | 225 | # In[57]: 226 | 227 | 228 | dicc = { 'Ciudad': lis, 229 | 'País': ['Brasil','Paraguay','Ecuador','Uruguay','Chile','Perú','Venezuela','Colombia','Méjico','Uruguay','España','Italia','Francia'], 230 | 'Continente' : ['América','América','América','América','América','América','América','América','América','América','Europa','Europa','Europa']} 231 | 232 | 233 | # In[58]: 234 | 235 | 236 | print(dicc) 237 | 238 | 239 | # 24) Imprimir las claves del diccionario 240 | 241 | # In[59]: 242 | 243 | 244 | print(dicc.keys()) 245 | 246 | 247 | # 25) Imprimir las ciudades a través de su clave 248 | 249 | # In[61]: 250 | 251 | 252 | print(dicc['Ciudad']) 253 | 254 | -------------------------------------------------------------------------------- /M05_estructuradedatos/Prep_Course_Homework_05.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "attachments": {}, 5 | "cell_type": "markdown", 6 | "metadata": {}, 7 | "source": [ 8 | "## Estructuras de Datos" 9 | ] 10 | }, 11 | { 12 | "attachments": {}, 13 | "cell_type": "markdown", 14 | "metadata": {}, 15 | "source": [ 16 | "1) Crear una lista que contenga nombres de ciudades del mundo que contenga más de 5 elementos e imprimir por pantalla" 17 | ] 18 | }, 19 | { 20 | "cell_type": "code", 21 | "execution_count": null, 22 | "metadata": {}, 23 | "outputs": [], 24 | "source": [] 25 | }, 26 | { 27 | "attachments": {}, 28 | "cell_type": "markdown", 29 | "metadata": {}, 30 | "source": [ 31 | "2) Imprimir por pantalla el segundo elemento de la lista" 32 | ] 33 | }, 34 | { 35 | "cell_type": "code", 36 | "execution_count": null, 37 | "metadata": {}, 38 | "outputs": [], 39 | "source": [] 40 | }, 41 | { 42 | "attachments": {}, 43 | "cell_type": "markdown", 44 | "metadata": {}, 45 | "source": [ 46 | "3) Imprimir por pantalla del segundo al cuarto elemento" 47 | ] 48 | }, 49 | { 50 | "cell_type": "code", 51 | "execution_count": null, 52 | "metadata": {}, 53 | "outputs": [], 54 | "source": [] 55 | }, 56 | { 57 | "attachments": {}, 58 | "cell_type": "markdown", 59 | "metadata": {}, 60 | "source": [ 61 | "4) Visualizar el tipo de dato de la lista" 62 | ] 63 | }, 64 | { 65 | "cell_type": "code", 66 | "execution_count": null, 67 | "metadata": {}, 68 | "outputs": [], 69 | "source": [] 70 | }, 71 | { 72 | "attachments": {}, 73 | "cell_type": "markdown", 74 | "metadata": {}, 75 | "source": [ 76 | "5) Visualizar todos los elementos de la lista a partir del tercero de manera genérica, es decir, sin explicitar la posición del último elemento" 77 | ] 78 | }, 79 | { 80 | "cell_type": "code", 81 | "execution_count": null, 82 | "metadata": {}, 83 | "outputs": [], 84 | "source": [] 85 | }, 86 | { 87 | "attachments": {}, 88 | "cell_type": "markdown", 89 | "metadata": {}, 90 | "source": [ 91 | "6) Visualizar los primeros 4 elementos de la lista" 92 | ] 93 | }, 94 | { 95 | "cell_type": "code", 96 | "execution_count": null, 97 | "metadata": {}, 98 | "outputs": [], 99 | "source": [] 100 | }, 101 | { 102 | "attachments": {}, 103 | "cell_type": "markdown", 104 | "metadata": {}, 105 | "source": [ 106 | "7) Agregar una ciudad más a la lista que ya exista y otra que no ¿Arroja algún tipo de error?" 107 | ] 108 | }, 109 | { 110 | "cell_type": "code", 111 | "execution_count": null, 112 | "metadata": {}, 113 | "outputs": [], 114 | "source": [] 115 | }, 116 | { 117 | "attachments": {}, 118 | "cell_type": "markdown", 119 | "metadata": {}, 120 | "source": [ 121 | "8) Agregar otra ciudad, pero en la cuarta posición" 122 | ] 123 | }, 124 | { 125 | "cell_type": "code", 126 | "execution_count": null, 127 | "metadata": {}, 128 | "outputs": [], 129 | "source": [] 130 | }, 131 | { 132 | "attachments": {}, 133 | "cell_type": "markdown", 134 | "metadata": {}, 135 | "source": [ 136 | "9) Concatenar otra lista a la ya creada" 137 | ] 138 | }, 139 | { 140 | "cell_type": "code", 141 | "execution_count": null, 142 | "metadata": {}, 143 | "outputs": [], 144 | "source": [] 145 | }, 146 | { 147 | "attachments": {}, 148 | "cell_type": "markdown", 149 | "metadata": {}, 150 | "source": [ 151 | "10) Encontrar el índice de la ciudad que en el punto 7 agregamos duplicada. ¿Se nota alguna particularidad?" 152 | ] 153 | }, 154 | { 155 | "cell_type": "code", 156 | "execution_count": null, 157 | "metadata": {}, 158 | "outputs": [], 159 | "source": [] 160 | }, 161 | { 162 | "attachments": {}, 163 | "cell_type": "markdown", 164 | "metadata": {}, 165 | "source": [ 166 | "11) ¿Qué pasa si se busca un elemento que no existe?" 167 | ] 168 | }, 169 | { 170 | "cell_type": "code", 171 | "execution_count": null, 172 | "metadata": {}, 173 | "outputs": [], 174 | "source": [] 175 | }, 176 | { 177 | "attachments": {}, 178 | "cell_type": "markdown", 179 | "metadata": {}, 180 | "source": [ 181 | "12) Eliminar un elemento de la lista" 182 | ] 183 | }, 184 | { 185 | "cell_type": "code", 186 | "execution_count": null, 187 | "metadata": {}, 188 | "outputs": [], 189 | "source": [] 190 | }, 191 | { 192 | "attachments": {}, 193 | "cell_type": "markdown", 194 | "metadata": {}, 195 | "source": [ 196 | "13) ¿Qué pasa si el elemento a eliminar no existe?" 197 | ] 198 | }, 199 | { 200 | "cell_type": "code", 201 | "execution_count": null, 202 | "metadata": {}, 203 | "outputs": [], 204 | "source": [] 205 | }, 206 | { 207 | "attachments": {}, 208 | "cell_type": "markdown", 209 | "metadata": {}, 210 | "source": [ 211 | "14) Extraer el úlimo elemento de la lista, guardarlo en una variable e imprimirlo" 212 | ] 213 | }, 214 | { 215 | "cell_type": "code", 216 | "execution_count": null, 217 | "metadata": {}, 218 | "outputs": [], 219 | "source": [] 220 | }, 221 | { 222 | "attachments": {}, 223 | "cell_type": "markdown", 224 | "metadata": {}, 225 | "source": [ 226 | "15) Mostrar la lista multiplicada por 4" 227 | ] 228 | }, 229 | { 230 | "cell_type": "code", 231 | "execution_count": null, 232 | "metadata": {}, 233 | "outputs": [], 234 | "source": [] 235 | }, 236 | { 237 | "attachments": {}, 238 | "cell_type": "markdown", 239 | "metadata": {}, 240 | "source": [ 241 | "16) Crear una tupla que contenga los números enteros del 1 al 20" 242 | ] 243 | }, 244 | { 245 | "cell_type": "code", 246 | "execution_count": null, 247 | "metadata": {}, 248 | "outputs": [], 249 | "source": [] 250 | }, 251 | { 252 | "attachments": {}, 253 | "cell_type": "markdown", 254 | "metadata": {}, 255 | "source": [ 256 | "17) Imprimir desde el índice 10 al 15 de la tupla" 257 | ] 258 | }, 259 | { 260 | "cell_type": "code", 261 | "execution_count": null, 262 | "metadata": {}, 263 | "outputs": [], 264 | "source": [] 265 | }, 266 | { 267 | "attachments": {}, 268 | "cell_type": "markdown", 269 | "metadata": {}, 270 | "source": [ 271 | "18) Evaluar si los números 20 y 30 están dentro de la tupla" 272 | ] 273 | }, 274 | { 275 | "cell_type": "code", 276 | "execution_count": null, 277 | "metadata": {}, 278 | "outputs": [], 279 | "source": [] 280 | }, 281 | { 282 | "attachments": {}, 283 | "cell_type": "markdown", 284 | "metadata": {}, 285 | "source": [ 286 | "19) Con la lista creada en el punto 1, validar la existencia del elemento 'París' y si no existe, agregarlo. Utilizar una variable e informar lo sucedido." 287 | ] 288 | }, 289 | { 290 | "cell_type": "code", 291 | "execution_count": null, 292 | "metadata": {}, 293 | "outputs": [], 294 | "source": [] 295 | }, 296 | { 297 | "attachments": {}, 298 | "cell_type": "markdown", 299 | "metadata": {}, 300 | "source": [ 301 | "20) Mostrar la cantidad de veces que se encuentra un elemento específico dentro de la tupla y de la lista" 302 | ] 303 | }, 304 | { 305 | "cell_type": "code", 306 | "execution_count": null, 307 | "metadata": {}, 308 | "outputs": [], 309 | "source": [] 310 | }, 311 | { 312 | "attachments": {}, 313 | "cell_type": "markdown", 314 | "metadata": {}, 315 | "source": [ 316 | "21) Convertir la tupla en una lista" 317 | ] 318 | }, 319 | { 320 | "cell_type": "code", 321 | "execution_count": null, 322 | "metadata": {}, 323 | "outputs": [], 324 | "source": [] 325 | }, 326 | { 327 | "attachments": {}, 328 | "cell_type": "markdown", 329 | "metadata": {}, 330 | "source": [ 331 | "22) Desempaquetar solo los primeros 3 elementos de la tupla en 3 variables" 332 | ] 333 | }, 334 | { 335 | "cell_type": "code", 336 | "execution_count": null, 337 | "metadata": {}, 338 | "outputs": [], 339 | "source": [] 340 | }, 341 | { 342 | "attachments": {}, 343 | "cell_type": "markdown", 344 | "metadata": {}, 345 | "source": [ 346 | "23) Crear un diccionario utilizando la lista crada en el punto 1, asignandole la clave \"ciudad\". Agregar tambien otras claves, como puede ser \"Pais\" y \"Continente\"." 347 | ] 348 | }, 349 | { 350 | "cell_type": "code", 351 | "execution_count": null, 352 | "metadata": {}, 353 | "outputs": [], 354 | "source": [] 355 | }, 356 | { 357 | "attachments": {}, 358 | "cell_type": "markdown", 359 | "metadata": {}, 360 | "source": [ 361 | "24) Imprimir las claves del diccionario" 362 | ] 363 | }, 364 | { 365 | "cell_type": "code", 366 | "execution_count": null, 367 | "metadata": {}, 368 | "outputs": [], 369 | "source": [] 370 | }, 371 | { 372 | "attachments": {}, 373 | "cell_type": "markdown", 374 | "metadata": {}, 375 | "source": [ 376 | "25) Imprimir las ciudades a través de su clave" 377 | ] 378 | }, 379 | { 380 | "cell_type": "code", 381 | "execution_count": null, 382 | "metadata": {}, 383 | "outputs": [], 384 | "source": [] 385 | } 386 | ], 387 | "metadata": { 388 | "interpreter": { 389 | "hash": "c85384e4cb51c8b72350f3a8712cc8351fdc3955e32a27f9b60c6242ab125f01" 390 | }, 391 | "kernelspec": { 392 | "display_name": "Python 3 (ipykernel)", 393 | "language": "python", 394 | "name": "python3" 395 | }, 396 | "language_info": { 397 | "codemirror_mode": { 398 | "name": "ipython", 399 | "version": 3 400 | }, 401 | "file_extension": ".py", 402 | "mimetype": "text/x-python", 403 | "name": "python", 404 | "nbconvert_exporter": "python", 405 | "pygments_lexer": "ipython3", 406 | "version": "3.9.7" 407 | } 408 | }, 409 | "nbformat": 4, 410 | "nbformat_minor": 4 411 | } 412 | -------------------------------------------------------------------------------- /M05_estructuradedatos/Prep_Course_Homework_05.md: -------------------------------------------------------------------------------- 1 | ## Estructuras de Datos 2 | 3 | 1) Crear una lista que contenga nombres de ciudades del mundo que contenga más de 5 elementos e imprimir por pantalla 4 | 5 | 2) Imprimir por pantalla el segundo elemento de la lista 6 | 7 | 3) Imprimir por pantalla del segundo al cuarto elemento 8 | 9 | 4) Visualizar el tipo de dato de la lista 10 | 11 | 5) Visualizar todos los elementos de la lista a partir del tercero de manera genérica, es decir, sin explicitar la posición del último elemento 12 | 13 | 6) Visualizar los primeros 4 elementos de la lista 14 | 15 | 7) Agregar una ciudad más a la lista que ya exista y otra que no ¿Arroja algún tipo de error? 16 | 17 | 8) Agregar otra ciudad, pero en la cuarta posición 18 | 19 | 9) Concatenar otra lista a la ya creada 20 | 21 | 10) Encontrar el índice de la ciudad que en el punto 7 agregamos duplicada. ¿Se nota alguna particularidad? 22 | 23 | 11) ¿Qué pasa si se busca un elemento que no existe? 24 | 25 | 12) Eliminar un elemento de la lista 26 | 27 | 13) ¿Qué pasa si el elemento a eliminar no existe? 28 | 29 | 14) Extraer el úlimo elemento de la lista, guardarlo en una variable e imprimirlo 30 | 31 | 15) Mostrar la lista multiplicada por 4 32 | 33 | 16) Crear una tupla que contenga los números enteros del 1 al 20 34 | 35 | 17) Imprimir desde el índice 10 al 15 de la tupla 36 | 37 | 18) Evaluar si los números 20 y 30 están dentro de la tupla 38 | 39 | 19) Con la lista creada en el punto 1, validar la existencia del elemento 'París' y si no existe, agregarlo. Utilizar una variable e informar lo sucedido. 40 | 41 | 20) Mostrar la cantidad de veces que se encuentra un elemento específico dentro de la tupla y de la lista 42 | 43 | 21) Convertir la tupla en una lista 44 | 45 | 22) Desempaquetar solo los primeros 3 elementos de la tupla en 3 variables 46 | 47 | 23) Crear un diccionario utilizando la lista crada en el punto 1, asignandole la clave "ciudad". Agregar tambien otras claves, como puede ser "Pais" y "Continente". 48 | 49 | 24) Imprimir las claves del diccionario 50 | 51 | 25) Imprimir las ciudades a través de su clave 52 | -------------------------------------------------------------------------------- /M05_estructuradedatos/Prep_Course_Homework_05.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python 2 | # coding: utf-8 3 | 4 | # ## Estructuras de Datos 5 | 6 | # 1) Crear una lista que contenga nombres de ciudades del mundo que contenga más de 5 elementos e imprimir por pantalla 7 | 8 | # In[3]: 9 | 10 | 11 | 12 | 13 | # 2) Imprimir por pantalla el segundo elemento de la lista 14 | 15 | # In[4]: 16 | 17 | 18 | 19 | 20 | # 3) Imprimir por pantalla del segundo al cuarto elemento 21 | 22 | # In[8]: 23 | 24 | 25 | 26 | 27 | 28 | # 4) Visualizar el tipo de dato de la lista 29 | 30 | # In[12]: 31 | 32 | 33 | 34 | 35 | 36 | # 5) Visualizar todos los elementos de la lista a partir del tercero de manera genérica, es decir, sin explicitar la posición del último elemento 37 | 38 | # In[14]: 39 | 40 | 41 | 42 | 43 | 44 | # 6) Visualizar los primeros 4 elementos de la lista 45 | 46 | # In[15]: 47 | 48 | 49 | 50 | 51 | 52 | 53 | # 7) Agregar una ciudad más a la lista que ya exista y otra que no ¿Arroja algún tipo de error? 54 | 55 | # In[16]: 56 | 57 | 58 | 59 | 60 | 61 | 62 | 63 | 64 | 65 | # 8) Agregar otra ciudad, pero en la cuarta posición 66 | 67 | # In[20]: 68 | 69 | 70 | 71 | 72 | 73 | # In[21]: 74 | 75 | 76 | 77 | 78 | # 9) Concatenar otra lista a la ya creada 79 | 80 | # In[22]: 81 | 82 | 83 | 84 | 85 | # 10) Encontrar el índice de la ciudad que en el punto 7 agregamos duplicada. ¿Se nota alguna particularidad? 86 | 87 | # In[23]: 88 | 89 | 90 | 91 | 92 | 93 | # 11) ¿Qué pasa si se busca un elemento que no existe? 94 | 95 | # In[24]: 96 | 97 | 98 | 99 | 100 | 101 | # 12) Eliminar un elemento de la lista 102 | 103 | # In[25]: 104 | 105 | 106 | 107 | 108 | 109 | # 13) ¿Qué pasa si el elemento a eliminar no existe? 110 | 111 | # In[27]: 112 | 113 | 114 | 115 | 116 | 117 | # 14) Extraer el úlimo elemento de la lista, guardarlo en una variable e imprimirlo 118 | 119 | # In[28]: 120 | 121 | 122 | 123 | 124 | 125 | # 15) Mostrar la lista multiplicada por 4 126 | 127 | # In[29]: 128 | 129 | 130 | 131 | 132 | # 16) Crear una tupla que contenga los números enteros del 1 al 20 133 | 134 | # In[32]: 135 | 136 | 137 | 138 | 139 | # 17) Imprimir desde el índice 10 al 15 de la tupla 140 | 141 | # In[35]: 142 | 143 | 144 | 145 | 146 | # 18) Evaluar si los números 20 y 30 están dentro de la tupla 147 | 148 | # In[41]: 149 | 150 | 151 | 152 | 153 | 154 | # 19) Con la lista creada en el punto 1, validar la existencia del elemento 'París' y si no existe, agregarlo. Utilizar una variable e informar lo sucedido. 155 | 156 | # In[48]: 157 | 158 | 159 | 160 | 161 | 162 | # 20) Mostrar la cantidad de veces que se encuentra un elemento específico dentro de la tupla y de la lista 163 | 164 | # In[51]: 165 | 166 | 167 | 168 | 169 | 170 | # 21) Convertir la tupla en una lista 171 | 172 | # In[52]: 173 | 174 | 175 | 176 | 177 | 178 | # 22) Desempaquetar solo los primeros 3 elementos de la tupla en 3 variables 179 | 180 | # In[55]: 181 | 182 | 183 | 184 | 185 | 186 | # 23) Crear un diccionario utilizando la lista crada en el punto 1, asignandole la clave "ciudad". Agregar tambien otras claves, como puede ser "Pais" y "Continente". 187 | 188 | # In[57]: 189 | 190 | 191 | 192 | 193 | 194 | 195 | # 24) Imprimir las claves del diccionario 196 | 197 | # In[59]: 198 | 199 | 200 | 201 | 202 | # 25) Imprimir las ciudades a través de su clave 203 | 204 | # In[61]: 205 | 206 | 207 | 208 | 209 | -------------------------------------------------------------------------------- /M05_estructuradedatos/README.md: -------------------------------------------------------------------------------- 1 | ![HenryLogo](https://d31uz8lwfmyn8g.cloudfront.net/Assets/logo-henry-white-lg.png) 2 | 3 | 4 | ## Principales Objetivos de Aprendizaje para esta Clase 5 | 6 | - Conocer la diferencia entre una variable y una estructura de datos 7 | - Manejar el tipo de dato lista en Python 8 | 9 | ## Estructuras de datos 10 | 11 | Anteriormente se mencionó que un dato representa la realidad, y se presentó el concepto de variable, que es un elemento que nos permite guardar un dato dentro de nuestro programa. Sin embargo, rápidamente vamos a llegar a la conclusión de que una variable puede llegar a quedar insuficiente para ciertas representaciones. Ante esta situación, en los lenguajes de programación tenemos estructuras de datos más complejas, en el caso de Python contamos con listas, tuplas y diccionarios. 12 | 13 | ### Lista 14 | 15 | Una estructura de datos muy importante en Python es la lista, que consiste en una serie de elementos ordenados. 16 | Esos elementos pueden ser de distinto tipo, e incluso pueden ser de tipo lista también.
17 | 18 | Operaciones con listas: 19 | * Creacion 20 | ```python 21 | mi_lista = ['Rojo','Azul','Amarillo','Naranja','Violeta','Verde'] 22 | ``` 23 | * Imprimir 24 | ```python 25 | print(mi_lista) 26 | ``` 27 | * Ver el tipo de dato 28 | ```python 29 | type(mi_lista) 30 | ``` 31 | 32 | Las listas, así como otras estructuras de datos que se verán en adelante, tienen varios elementos, motivo por el cual cuando se quiere acceder en específico se requiere de un **índice** que va a hacer referencia al elemento dentro de la lista: 33 | 34 | * Imprimir el tercer elemento de la lista (el índice comienza en cero) 35 | ```python 36 | print(mi_lista[2]) 37 | ``` 38 | * Acceder a un rango dentro de la lista (el límite inferior se incluye y el superior se excluye) 39 | ```python 40 | print(mi_lista[0:2]) 41 | ``` 42 | * Al no poner primer valor, Python asume que es un 0 43 | ```python 44 | >>> print(mi_lista[:2]) 45 | ['Rojo', 'Azul'] 46 | ``` 47 | * Al no poner segundo valor, Python asume que se trata de todos los elementos a partir del primero 48 | ```python 49 | >>> print(mi_lista[0:]) 50 | ['Rojo', 'Azul', 'Amarillo', 'Naranja', 'Violeta', 'Verde'] 51 | ``` 52 | * Agregar un elemento al final de la lista (Si el elemento ya existe va a quedar duplicado) 53 | ```python 54 | mi_lista.append('Blanco') 55 | ``` 56 | * Agregar un elemento especificando el índice 57 | ```python 58 | >>> mi_lista.insert(3,'Negro') 59 | >>> print(mi_lista[:]) 60 | ['Rojo', 'Azul', 'Amarillo', 'Negro', 'Naranja', 'Violeta', 'Verde'] 61 | ``` 62 | * Concatenar una nueva lista a la lista previamente creada 63 | ```python 64 | mi_lista.extend(['Marrón','Gris']) 65 | ``` 66 | * Encontrar el índice de un valor específico 67 | ```python 68 | >>> print(mi_lista.index('Azul')) 69 | 1 70 | ``` 71 | * Eliminar un elemento de la lista (Si el elemento no existe va a arrojar un error) 72 | ```python 73 | >>> mi_lista.remove('Blanco') 74 | --------------------------------------------------------------------------- 75 | ValueError Traceback (most recent call last) 76 | ~\AppData\Local\Temp/ipykernel_10044/308548076.py in 77 | ----> 1 mi_lista.remove('Blanco') 78 | 79 | ValueError: list.remove(x): x not in list 80 | >>> mi_lista.remove('Negro') 81 | ``` 82 | * Extraer y recuperar el último elemento de la lista 83 | ```python 84 | >>> ultimo = mi_lista.pop() 85 | >>> print(ultimo) 86 | Gris 87 | ``` 88 | * Multiplicar la lista 3 veces 89 | ```python 90 | >>> print(['a','b','c'] * 3) 91 | ['a', 'b', 'c', 'a', 'b', 'c', 'a', 'b', 'c'] 92 | ``` 93 | * Ordenar una lista de menor a mayor 94 | ```python 95 | >>> lista= [1,4,3,6,8,2] 96 | >>> lista.sort() 97 | >>> print(lista) 98 | [1,2,3,4,6,8] 99 | ``` 100 | * Ordenar una lista de mayor a menor 101 | ```python 102 | >>> lista= [1,4,3,6,8,2] 103 | >>> lista.sort(reverse=True) 104 | >>> print(lista) 105 | [8,6,4,3,2,1] 106 | ``` 107 | 108 | ### Tupla 109 | 110 | Son una estructura similar a las listas, la diferencia está en que no se pueden modificar una vez creadas, es decir que son **inmutables**: 111 | 112 | * Convertir una lista a tupla 113 | ```python 114 | mi_tupla=tuple(mi_lista) 115 | ``` 116 | * Imprimir el índice 1 de la tupla 117 | ```python 118 | >>> print(mi_tupla[1]) 119 | Azul 120 | ``` 121 | * Evaluar si un elemento está contenido en la tupla (Devuelve un valor booleano) 122 | ```python 123 | >>> 'Rojo' in mi_tupla 124 | True 125 | ``` 126 | * Evaluar las veces que está un elemento específico 127 | ```python 128 | >>> mi_tupla.count('Rojo') 129 | 1 130 | ``` 131 | * Tupla con un solo elemento 132 | ```python 133 | mi_tupla_unitaria = ('Blanco',) 134 | ``` 135 | * Empaquetado de tupla, tupla sin paréntesis 136 | ```python 137 | mi_tupla='Gaspar', 5, 8, 1999 138 | ``` 139 | * Desempaquetado de tupla, se guardan los valores en orden de las variables 140 | ```python 141 | >>> nombre, dia, mes, año = mi_tupla 142 | >>> print("Nombre: ", nombre, " - Dia:", dia, " - Mes: ", mes, " - Año: ", año) 143 | Nombre: Gaspar - Dia: 5 - Mes: 8 - Año: 1999 144 | ``` 145 | * Convertir una tupla en una lista 146 | ```python 147 | mi_lista=list(mi_tupla) 148 | ``` 149 | 150 | ### Diccionario 151 | 152 | Un diccionario tiene una organización de 'clave' y 'valor': 153 | 154 | * Crear un diccionario 155 | ```python 156 | mi_diccionario = { 'Colores Primarios': ['Rojo','Azul','Amarillo'], 157 | 'Colores secundarios': ['Naranja','Violeta','Verde'], 158 | 'Clave3': 10, 159 | 'Clave4': False} 160 | ``` 161 | * Imprimir un valor a través de su clave 162 | ```python 163 | >>> print(mi_diccionario['Colores secundarios']) 164 | ['Naranja', 'Violeta', 'Verde'] 165 | ``` 166 | * Agregar un valor 167 | ```python 168 | mi_diccionario['Clave5']='Otro ejemplo' 169 | ``` 170 | * Cambiar un valor 171 | ```python 172 | mi_diccionario['Clave3']=2 173 | ``` 174 | * Eliminar un elemento de un diccionario a través de su clave 175 | ```python 176 | del mi_diccionario['Clave4'] 177 | ``` 178 | * Utilizar una tupla como clave de un diccionario 179 | ```python 180 | mi_tupla=("Argentina", "Italia", "Inglaterra") 181 | mi_diccionario={mi_tupla[0]:"Buenos Aires", 182 | mi_tupla[1]:"Roma", 183 | mi_tupla[2]:"Londres"} 184 | ``` 185 | * Colocar una tupla dentro de un diccionario 186 | ```python 187 | mi_diccionario={'Clave1':'Valor1', 'Clave2':(1,2,3,4,5)} 188 | ``` 189 | * Colocar una lista dentro de un diccionario (Notar que la diferencia está en el paréntesis '()' y el corchete '[]') 190 | ```python 191 | mi_diccionario={'Clave1':'Valor1', 'Clave2':[1,2,3,4,5]} 192 | ``` 193 | * Colocar un diccionario dentro de un diccionario 194 | ```python 195 | mi_diccionario={'Clave1':'Valor1', 'Clave2':{'numeros':[1,2,3,4,5]}} 196 | ``` 197 | * Imprimir las claves del diccionario 198 | ```python 199 | >>> print(mi_diccionario.keys()) 200 | dict_keys(['Clave1', 'Clave2']) 201 | ``` 202 | * Imprimir los valores del diccionario 203 | ```python 204 | >>> print(mi_diccionario.values()) 205 | dict_values(['Valor1', {'numeros': [1, 2, 3, 4, 5]}]) 206 | ``` 207 | * Imprimir la longitud del diccionario 208 | ```python 209 | >>> len(mi_diccionario) 210 | 2 211 | ``` 212 |
213 |

214 | Tips: La funcionalidad **del** permite eliminar cualquier estructura de datos y la funcionalidad **len** permite obtener el tamaño de la estructura de datos 215 |

216 |
217 | 218 | * Si tienes dudas sobre este tema, puedes consultarlas en el canal **#m09_errorhandling** de Slack -------------------------------------------------------------------------------- /M06_iterablesiteradores/Prep_Course_Homework_06-Resuelto.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python 2 | # coding: utf-8 3 | 4 | # ## Iteradores e iterables 5 | 6 | # 1) A partir de una lista vacía, utilizar un ciclo while para cargar allí números negativos del -15 al -1 7 | 8 | # In[1]: 9 | 10 | 11 | lista = [] 12 | n = -15 13 | while (n < 0): 14 | lista.append(n) 15 | n += 1 16 | print(lista) 17 | 18 | 19 | # 2) ¿Con un ciclo while sería posible recorrer la lista para imprimir sólo los números pares? 20 | 21 | # In[3]: 22 | 23 | 24 | n = 0 25 | while (n < len(lista)): 26 | if (lista[n] % 2 == 0): 27 | print(lista[n]) 28 | n += 1 29 | 30 | 31 | # 3) Resolver el punto anterior sin utilizar un ciclo while 32 | 33 | # In[4]: 34 | 35 | 36 | for elemento in lista: 37 | if (elemento % 2 == 0): 38 | print(elemento) 39 | 40 | 41 | # 4) Utilizar el iterable para recorrer sólo los primeros 3 elementos 42 | 43 | # In[7]: 44 | 45 | 46 | for elemento in lista[:3]: 47 | print(elemento) 48 | 49 | 50 | # 5) Utilizar la función **enumerate** para obtener dentro del iterable, tambien el índice al que corresponde el elemento 51 | 52 | # In[9]: 53 | 54 | 55 | for i, e in enumerate(lista): 56 | print(i, e) 57 | 58 | 59 | # 6) Dada la siguiente lista de números enteros entre 1 y 20, crear un ciclo donde se completen los valores faltantes: lista = [1,2,5,7,8,10,13,14,15,17,20] 60 | 61 | # In[10]: 62 | 63 | 64 | lista = [1,2,5,7,8,10,13,14,15,17,20] 65 | 66 | 67 | # In[11]: 68 | 69 | 70 | n = 1 71 | while(n <= 20): 72 | if (not(n in lista)): 73 | lista.insert((n-1), n) 74 | n += 1 75 | print(lista) 76 | 77 | 78 | # 7) La sucesión de Fibonacci es un listado de números que sigue la fórmula:
79 | # n0 = 0
80 | # n1 = 1
81 | # ni = ni-1 + ni-2
82 | # Crear una lista con los primeros treinta números de la sucesión.
83 | 84 | # In[23]: 85 | 86 | 87 | fibo = [0,1] 88 | n = 2 89 | while(n < 30): 90 | fibo.append(fibo[n-1]+fibo[n-2]) 91 | n += 1 92 | print(fibo) 93 | 94 | 95 | # 8) Realizar la suma de todos elementos de la lista del punto anterior 96 | 97 | # In[24]: 98 | 99 | 100 | sum(fibo) 101 | 102 | 103 | # 9) La proporción aurea se expresa con una proporción matemática que nace el número irracional Phi= 1,618… que los griegos llamaron número áureo. El cuál se puede aproximar con la sucesión de Fibonacci. Con la lista del ejercicio anterior, imprimir el cociente de los últimos 5 pares de dos números contiguos:
104 | # Donde i es la cantidad total de elementos
105 | # ni-1 / ni
106 | # ni-2 / ni-1
107 | # ni-3 / ni-2
108 | # ni-4 / ni-3
109 | # ni-5 / ni-4
110 | # 111 | 112 | # In[38]: 113 | 114 | 115 | primeros = 15 116 | n = primeros - 5 117 | while(n < primeros): 118 | print(fibo[n]/fibo[n-1]) 119 | n += 1 120 | 121 | 122 | # 10) A partir de la variable cadena ya dada, mostrar en qué posiciones aparece la letra "n"
123 | # cadena = 'Hola Mundo. Esto es una practica del lenguaje de programación Python' 124 | 125 | # In[39]: 126 | 127 | 128 | cadena = 'Hola Mundo. Esto es una practica del lenguaje de programación Python' 129 | for i, c in enumerate(cadena): 130 | if c == 'n': 131 | print(i) 132 | 133 | 134 | # 11) Crear un diccionario e imprimir sus claves utilizando un iterador 135 | 136 | # In[40]: 137 | 138 | 139 | dicc = { 'Ciudad': ['Buenos Aires','Caracas','Bogotá','Lisboa','Roma'], 140 | 'País': ['Argentina','Venezuela','Colombia','Portugal','Italia'], 141 | 'Continente' : ['América','América','América','Europa','Europa']} 142 | for i in dicc: 143 | print(i) 144 | 145 | 146 | # 12) Convertir en una lista la variable "cadena" del punto 10 y luego recorrerla con un iterador 147 | 148 | # In[41]: 149 | 150 | 151 | cadena = 'Hola Mundo. Esto es una practica del lenguaje de programación Python' 152 | print(type(cadena)) 153 | cadena = list(cadena) 154 | print(type(cadena)) 155 | 156 | 157 | # In[45]: 158 | 159 | 160 | recorre = iter(cadena) 161 | largo = len(cadena) 162 | for i in range(0, largo): 163 | print(next(recorre)) 164 | 165 | 166 | # 13) Crear dos listas y unirlas en una tupla utilizando la función zip 167 | 168 | # In[48]: 169 | 170 | 171 | lis1 = ['run','fly','sleep'] 172 | lis2 = ['correr','volar','dormir'] 173 | lisz = zip(lis1, lis2) 174 | print(type(lisz)) 175 | print(list(lisz)) 176 | 177 | 178 | # 14) A partir de la siguiente lista de números, crear una nueva sólo si el número es divisible por 7
179 | # lis = [18,21,29,32,35,42,56,60,63,71,84,90,91,100] 180 | 181 | # In[49]: 182 | 183 | 184 | lis = [18,21,29,32,35,42,56,60,63,71,84,90,91,100] 185 | lis2 = [i for i in lis if i % 7 == 0] 186 | print(lis2) 187 | 188 | 189 | # 15) A partir de la lista de a continuación, contar la cantidad total de elementos que contiene, teniendo en cuenta que un elemento de la lista podría ser otra lista:
190 | # lis = [[1,2,3,4],'rojo','verde',[True,False,False],['uno','dos','tres']] 191 | 192 | # In[56]: 193 | 194 | 195 | lis = [[1,2,3,4],'rojo','verde',[True,False,False],['uno','dos','tres']] 196 | 197 | 198 | # In[51]: 199 | 200 | 201 | type(lis) 202 | 203 | 204 | # In[57]: 205 | 206 | 207 | cantidad = 0 208 | for elemento in lis: 209 | if (type(elemento) == list): 210 | cantidad += len(elemento) 211 | else: 212 | cantidad += 1 213 | print('La cantidad total de elementos es', cantidad) 214 | 215 | 216 | # 16) Tomar la lista del punto anterior y convertir cada elemento en una lista si no lo es 217 | 218 | # In[58]: 219 | 220 | 221 | for indice, elemento in enumerate(lis): 222 | if (type(elemento) != list): 223 | lis[indice]=[elemento] 224 | print(lis) 225 | 226 | -------------------------------------------------------------------------------- /M06_iterablesiteradores/Prep_Course_Homework_06.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "attachments": {}, 5 | "cell_type": "markdown", 6 | "metadata": {}, 7 | "source": [ 8 | "## Iteradores e iterables" 9 | ] 10 | }, 11 | { 12 | "attachments": {}, 13 | "cell_type": "markdown", 14 | "metadata": {}, 15 | "source": [ 16 | "1) A partir de una lista vacía, utilizar un ciclo while para cargar allí números negativos del -15 al -1" 17 | ] 18 | }, 19 | { 20 | "cell_type": "code", 21 | "execution_count": null, 22 | "metadata": {}, 23 | "outputs": [], 24 | "source": [] 25 | }, 26 | { 27 | "attachments": {}, 28 | "cell_type": "markdown", 29 | "metadata": {}, 30 | "source": [ 31 | "2) ¿Con un ciclo while sería posible recorrer la lista para imprimir sólo los números pares?" 32 | ] 33 | }, 34 | { 35 | "cell_type": "code", 36 | "execution_count": null, 37 | "metadata": {}, 38 | "outputs": [], 39 | "source": [] 40 | }, 41 | { 42 | "attachments": {}, 43 | "cell_type": "markdown", 44 | "metadata": {}, 45 | "source": [ 46 | "3) Resolver el punto anterior sin utilizar un ciclo while" 47 | ] 48 | }, 49 | { 50 | "cell_type": "code", 51 | "execution_count": null, 52 | "metadata": {}, 53 | "outputs": [], 54 | "source": [] 55 | }, 56 | { 57 | "attachments": {}, 58 | "cell_type": "markdown", 59 | "metadata": {}, 60 | "source": [ 61 | "4) Utilizar el iterable para recorrer sólo los primeros 3 elementos" 62 | ] 63 | }, 64 | { 65 | "cell_type": "code", 66 | "execution_count": null, 67 | "metadata": {}, 68 | "outputs": [], 69 | "source": [] 70 | }, 71 | { 72 | "attachments": {}, 73 | "cell_type": "markdown", 74 | "metadata": {}, 75 | "source": [ 76 | "5) Utilizar la función **enumerate** para obtener dentro del iterable, tambien el índice al que corresponde el elemento" 77 | ] 78 | }, 79 | { 80 | "cell_type": "code", 81 | "execution_count": null, 82 | "metadata": {}, 83 | "outputs": [], 84 | "source": [] 85 | }, 86 | { 87 | "attachments": {}, 88 | "cell_type": "markdown", 89 | "metadata": {}, 90 | "source": [ 91 | "6) Dada la siguiente lista de números enteros entre 1 y 20, crear un ciclo donde se completen los valores faltantes: lista = [1,2,5,7,8,10,13,14,15,17,20]" 92 | ] 93 | }, 94 | { 95 | "cell_type": "code", 96 | "execution_count": null, 97 | "metadata": {}, 98 | "outputs": [], 99 | "source": [] 100 | }, 101 | { 102 | "attachments": {}, 103 | "cell_type": "markdown", 104 | "metadata": {}, 105 | "source": [ 106 | "7) La sucesión de Fibonacci es un listado de números que sigue la fórmula:
\n", 107 | "n0 = 0
\n", 108 | "n1 = 1
\n", 109 | "ni = ni-1 + ni-2
\n", 110 | "Crear una lista con los primeros treinta números de la sucesión.
" 111 | ] 112 | }, 113 | { 114 | "cell_type": "code", 115 | "execution_count": null, 116 | "metadata": {}, 117 | "outputs": [], 118 | "source": [] 119 | }, 120 | { 121 | "attachments": {}, 122 | "cell_type": "markdown", 123 | "metadata": {}, 124 | "source": [ 125 | "8) Realizar la suma de todos elementos de la lista del punto anterior" 126 | ] 127 | }, 128 | { 129 | "cell_type": "code", 130 | "execution_count": null, 131 | "metadata": {}, 132 | "outputs": [], 133 | "source": [] 134 | }, 135 | { 136 | "attachments": {}, 137 | "cell_type": "markdown", 138 | "metadata": {}, 139 | "source": [ 140 | "9) La proporción aurea se expresa con una proporción matemática que nace el número irracional Phi= 1,618… que los griegos llamaron número áureo. El cuál se puede aproximar con la sucesión de Fibonacci. Con la lista del ejercicio anterior, imprimir el cociente de los últimos 5 pares de dos números contiguos:
\n", 141 | "Donde i es la cantidad total de elementos
\n", 142 | "ni-1 / ni
\n", 143 | "ni-2 / ni-1
\n", 144 | "ni-3 / ni-2
\n", 145 | "ni-4 / ni-3
\n", 146 | "ni-5 / ni-4
\n", 147 | " " 148 | ] 149 | }, 150 | { 151 | "cell_type": "code", 152 | "execution_count": null, 153 | "metadata": {}, 154 | "outputs": [], 155 | "source": [] 156 | }, 157 | { 158 | "attachments": {}, 159 | "cell_type": "markdown", 160 | "metadata": {}, 161 | "source": [ 162 | "10) A partir de la variable cadena ya dada, mostrar en qué posiciones aparece la letra \"n\"
\n", 163 | "cadena = 'Hola Mundo. Esto es una practica del lenguaje de programación Python'" 164 | ] 165 | }, 166 | { 167 | "cell_type": "code", 168 | "execution_count": null, 169 | "metadata": {}, 170 | "outputs": [], 171 | "source": [] 172 | }, 173 | { 174 | "attachments": {}, 175 | "cell_type": "markdown", 176 | "metadata": {}, 177 | "source": [ 178 | "11) Crear un diccionario e imprimir sus claves utilizando un iterador" 179 | ] 180 | }, 181 | { 182 | "cell_type": "code", 183 | "execution_count": null, 184 | "metadata": {}, 185 | "outputs": [], 186 | "source": [] 187 | }, 188 | { 189 | "attachments": {}, 190 | "cell_type": "markdown", 191 | "metadata": {}, 192 | "source": [ 193 | "12) Convertir en una lista la variable \"cadena\" del punto 10 y luego recorrerla con un iterador " 194 | ] 195 | }, 196 | { 197 | "cell_type": "code", 198 | "execution_count": null, 199 | "metadata": {}, 200 | "outputs": [], 201 | "source": [] 202 | }, 203 | { 204 | "attachments": {}, 205 | "cell_type": "markdown", 206 | "metadata": {}, 207 | "source": [ 208 | "13) Crear dos listas y unirlas en una tupla utilizando la función zip" 209 | ] 210 | }, 211 | { 212 | "cell_type": "code", 213 | "execution_count": null, 214 | "metadata": {}, 215 | "outputs": [], 216 | "source": [] 217 | }, 218 | { 219 | "attachments": {}, 220 | "cell_type": "markdown", 221 | "metadata": {}, 222 | "source": [ 223 | "14) A partir de la siguiente lista de números, crear una nueva sólo si el número es divisible por 7
\n", 224 | "lis = [18,21,29,32,35,42,56,60,63,71,84,90,91,100]" 225 | ] 226 | }, 227 | { 228 | "cell_type": "code", 229 | "execution_count": null, 230 | "metadata": {}, 231 | "outputs": [], 232 | "source": [] 233 | }, 234 | { 235 | "attachments": {}, 236 | "cell_type": "markdown", 237 | "metadata": {}, 238 | "source": [ 239 | "15) A partir de la lista de a continuación, contar la cantidad total de elementos que contiene, teniendo en cuenta que un elemento de la lista podría ser otra lista:
\n", 240 | "lis = [[1,2,3,4],'rojo','verde',[True,False,False],['uno','dos','tres']]" 241 | ] 242 | }, 243 | { 244 | "cell_type": "code", 245 | "execution_count": null, 246 | "metadata": {}, 247 | "outputs": [], 248 | "source": [] 249 | }, 250 | { 251 | "attachments": {}, 252 | "cell_type": "markdown", 253 | "metadata": {}, 254 | "source": [ 255 | "16) Tomar la lista del punto anterior y convertir cada elemento en una lista si no lo es" 256 | ] 257 | }, 258 | { 259 | "cell_type": "code", 260 | "execution_count": null, 261 | "metadata": {}, 262 | "outputs": [], 263 | "source": [] 264 | } 265 | ], 266 | "metadata": { 267 | "interpreter": { 268 | "hash": "c85384e4cb51c8b72350f3a8712cc8351fdc3955e32a27f9b60c6242ab125f01" 269 | }, 270 | "kernelspec": { 271 | "display_name": "Python 3 (ipykernel)", 272 | "language": "python", 273 | "name": "python3" 274 | }, 275 | "language_info": { 276 | "codemirror_mode": { 277 | "name": "ipython", 278 | "version": 3 279 | }, 280 | "file_extension": ".py", 281 | "mimetype": "text/x-python", 282 | "name": "python", 283 | "nbconvert_exporter": "python", 284 | "pygments_lexer": "ipython3", 285 | "version": "3.9.7" 286 | } 287 | }, 288 | "nbformat": 4, 289 | "nbformat_minor": 4 290 | } 291 | -------------------------------------------------------------------------------- /M06_iterablesiteradores/Prep_Course_Homework_06.md: -------------------------------------------------------------------------------- 1 | ## Iteradores e iterables 2 | 3 | 1) A partir de una lista vacía, utilizar un ciclo while para cargar allí números negativos del -15 al -1 4 | 5 | 2) ¿Con un ciclo while sería posible recorrer la lista para imprimir sólo los números pares? 6 | 7 | 3) Resolver el punto anterior sin utilizar un ciclo while 8 | 9 | 4) Utilizar el iterable para recorrer sólo los primeros 3 elementos 10 | 11 | 5) Utilizar la función **enumerate** para obtener dentro del iterable, tambien el índice al que corresponde el elemento 12 | 13 | 6) Dada la siguiente lista de números enteros entre 1 y 20, crear un ciclo donde se completen los valores faltantes: lista = [1,2,5,7,8,10,13,14,15,17,20] 14 | 15 | 7) La sucesión de Fibonacci es un listado de números que sigue la fórmula:
16 | n0 = 0
17 | n1 = 1
18 | ni = ni-1 + ni-2
19 | Crear una lista con los primeros treinta números de la sucesión.
20 | 21 | 8) Realizar la suma de todos elementos de la lista del punto anterior 22 | 23 | 9) La proporción aurea se expresa con una proporción matemática que nace el número irracional Phi= 1,618… que los griegos llamaron número áureo. El cuál se puede aproximar con la sucesión de Fibonacci. Con la lista del ejercicio anterior, imprimir el cociente de los últimos 5 pares de dos números contiguos:
24 | Donde i es la cantidad total de elementos
25 | ni-1 / ni
26 | ni-2 / ni-1
27 | ni-3 / ni-2
28 | ni-4 / ni-3
29 | ni-5 / ni-4
30 | 31 | 32 | 10) A partir de la variable cadena ya dada, mostrar en qué posiciones aparece la letra "n"
33 | cadena = 'Hola Mundo. Esto es una practica del lenguaje de programación Python' 34 | 35 | 11) Crear un diccionario e imprimir sus claves utilizando un iterador 36 | 37 | 12) Convertir en una lista la variable "cadena" del punto 10 y luego recorrerla con un iterador 38 | 39 | 13) Crear dos listas y unirlas en una tupla utilizando la función zip 40 | 41 | 14) A partir de la siguiente lista de números, crear una nueva sólo si el número es divisible por 7
42 | lis = [18,21,29,32,35,42,56,60,63,71,84,90,91,100] 43 | 44 | 15) A partir de la lista de a continuación, contar la cantidad total de elementos que contiene, teniendo en cuenta que un elemento de la lista podría ser otra lista:
45 | lis = [[1,2,3,4],'rojo','verde',[True,False,False],['uno','dos','tres']] 46 | 47 | 16) Tomar la lista del punto anterior y convertir cada elemento en una lista si no lo es 48 | -------------------------------------------------------------------------------- /M06_iterablesiteradores/Prep_Course_Homework_06.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python 2 | # coding: utf-8 3 | 4 | # ## Iteradores e iterables 5 | 6 | # 1) A partir de una lista vacía, utilizar un ciclo while para cargar allí números negativos del -15 al -1 7 | 8 | # In[1]: 9 | 10 | 11 | 12 | 13 | 14 | # 2) ¿Con un ciclo while sería posible recorrer la lista para imprimir sólo los números pares? 15 | 16 | # In[3]: 17 | 18 | 19 | 20 | 21 | 22 | # 3) Resolver el punto anterior sin utilizar un ciclo while 23 | 24 | # In[4]: 25 | 26 | 27 | 28 | 29 | 30 | # 4) Utilizar el iterable para recorrer sólo los primeros 3 elementos 31 | 32 | # In[7]: 33 | 34 | 35 | 36 | 37 | # 5) Utilizar la función **enumerate** para obtener dentro del iterable, tambien el índice al que corresponde el elemento 38 | 39 | # In[9]: 40 | 41 | 42 | 43 | 44 | # 6) Dada la siguiente lista de números enteros entre 1 y 20, crear un ciclo donde se completen los valores faltantes: lista = [1,2,5,7,8,10,13,14,15,17,20] 45 | 46 | # In[10]: 47 | 48 | 49 | 50 | 51 | 52 | # In[11]: 53 | 54 | 55 | n = 1 56 | 57 | 58 | 59 | # 7) La sucesión de Fibonacci es un listado de números que sigue la fórmula:
60 | # n0 = 0
61 | # n1 = 1
62 | # ni = ni-1 + ni-2
63 | # Crear una lista con los primeros treinta números de la sucesión.
64 | 65 | # In[23]: 66 | 67 | 68 | 69 | 70 | 71 | # 8) Realizar la suma de todos elementos de la lista del punto anterior 72 | 73 | # In[24]: 74 | 75 | 76 | 77 | 78 | # 9) La proporción aurea se expresa con una proporción matemática que nace el número irracional Phi= 1,618… que los griegos llamaron número áureo. El cuál se puede aproximar con la sucesión de Fibonacci. Con la lista del ejercicio anterior, imprimir el cociente de los últimos 5 pares de dos números contiguos:
79 | # Donde i es la cantidad total de elementos
80 | # ni-1 / ni
81 | # ni-2 / ni-1
82 | # ni-3 / ni-2
83 | # ni-4 / ni-3
84 | # ni-5 / ni-4
85 | # 86 | 87 | # In[38]: 88 | 89 | 90 | 91 | 92 | # 10) A partir de la variable cadena ya dada, mostrar en qué posiciones aparece la letra "n"
93 | # cadena = 'Hola Mundo. Esto es una practica del lenguaje de programación Python' 94 | 95 | # In[39]: 96 | 97 | 98 | 99 | 100 | 101 | # 11) Crear un diccionario e imprimir sus claves utilizando un iterador 102 | 103 | # In[40]: 104 | 105 | 106 | 107 | 108 | 109 | # 12) Convertir en una lista la variable "cadena" del punto 10 y luego recorrerla con un iterador 110 | 111 | # In[41]: 112 | 113 | 114 | 115 | 116 | 117 | # In[45]: 118 | 119 | 120 | 121 | 122 | 123 | # 13) Crear dos listas y unirlas en una tupla utilizando la función zip 124 | 125 | # In[48]: 126 | 127 | 128 | 129 | 130 | 131 | # 14) A partir de la siguiente lista de números, crear una nueva sólo si el número es divisible por 7
132 | # lis = [18,21,29,32,35,42,56,60,63,71,84,90,91,100] 133 | 134 | # In[49]: 135 | 136 | 137 | 138 | 139 | 140 | # 15) A partir de la lista de a continuación, contar la cantidad total de elementos que contiene, teniendo en cuenta que un elemento de la lista podría ser otra lista:
141 | # lis = [[1,2,3,4],'rojo','verde',[True,False,False],['uno','dos','tres']] 142 | 143 | # In[56]: 144 | 145 | 146 | 147 | 148 | # In[51]: 149 | 150 | 151 | 152 | 153 | 154 | # In[57]: 155 | 156 | 157 | 158 | 159 | 160 | # 16) Tomar la lista del punto anterior y convertir cada elemento en una lista si no lo es 161 | 162 | # In[58]: 163 | 164 | 165 | 166 | -------------------------------------------------------------------------------- /M06_iterablesiteradores/README.md: -------------------------------------------------------------------------------- 1 | ![HenryLogo](https://d31uz8lwfmyn8g.cloudfront.net/Assets/logo-henry-white-lg.png) 2 | 3 | 4 | ## Principales Objetivos de Aprendizaje para esta Clase 5 | 6 | - Conocer los conceptos de Iteradores e Iterables 7 | 8 | ## Iteradores e Iterables 9 | 10 | Permiten iterar colecciones de datos que sean iterables. Si tenemos una determinada colección de datos, en este caso una lista con varios valores, y queremos mostrar sus valores uno a uno por pantalla podría resolverse de la siguiente manera con un while. 11 | 12 | ```python 13 | >>> lista = [5, 4, 9, 2] 14 | >>> i = 0 15 | >>> while i < len(lista): 16 | >>> elemento = lista[i] 17 | >>> print(elemento) 18 | >>> i += 1 19 | 5 20 | 4 21 | 9 22 | 2 23 | ``` 24 | 25 | Aunque es una forma válida, en Python existe una forma mucho más fácil de iterar una lista. Dicha forma es la siguiente. 26 | 27 | ```python 28 | >>> lista = [5, 4, 9, 2] 29 | >>> for elemento in lista: 30 | >>> print(elemento) 31 | 5 32 | 4 33 | 9 34 | 2 35 | ``` 36 | 37 | ### Iterables 38 | 39 | Una clase iterable es una clase que puede ser iterada. Dentro de Python hay gran cantidad de clases iterables como las listas, strings, diccionarios o archivos. Si tenemos una clase iterable, podemos usarla a la derecha del for de la siguiente manera. 40 | 41 | ```python 42 | for elemento in [clase_iterable]: 43 | ``` 44 | 45 | En el ciclo for, como se puede ver, la variable elemento irá tomando los valores de cada elemento presente en la clase iterable. De esta manera, ya no tenemos que ir accediendo manualmente con [] a cada elemento. 46 | Anteriormente hemos visto un ejemplo iterando una lista, pero también podemos iterar una cadena, ya que es una clase iterable. Al iterar una cadena se nos devuelve cada letra presente en la misma. La sintaxis se asemeja bastante al lenguaje natural, sería algo así como decir “poner en c cada elemento presente en la cadena”. 47 | 48 | ```python 49 | >>> cadena = "Hola" 50 | >>> for c in cadena: 51 | >>> print(c) 52 | H 53 | o 54 | l 55 | a 56 | ``` 57 | 58 | Además de obtener el elemento dentro del iterable, también es posible obtener el índice en el que está posicionado utilizando la función **enumerate** 59 | 60 | ```python 61 | >>> cadena = "Hola" 62 | >>> for i, c in enumerate(cadena): 63 | >>> print(i, c) 64 | 0 H 65 | 1 o 66 | 2 l 67 | 3 a 68 | ``` 69 | 70 | Para saber si una clase es iterable o no hay dos opciones. La primera sería consultar la documentación oficial de Python. La segunda es ver si la clase u objeto en cuestión hereda de Iterable. Con isinstance() podemos comprobar si una clase hereda de otra. 71 | 72 | ```python 73 | >>> from collections import Iterable 74 | >>> cadena = "Hola" 75 | >>> numero = 3 76 | >>> print("cadena", isinstance(cadena, Iterable)) 77 | >>> print("numero", isinstance(numero, Iterable)) 78 | cadena True 79 | numero False 80 | ``` 81 | 82 | Python nos ofrece también diferentes métodos que pueden ser usados sobre clases iterables como los que se muestran a continuación: 83 | 84 | * list() convierte a lista una clase iterable 85 | * sum() para sumar 86 | * join() permite unir cada elemento de una clase iterable con el primer argumento usado. 87 | 88 | ```python 89 | >>> print(list("Hola")) 90 | ['H', 'o', 'l', 'a'] 91 | 92 | >>> print(sum([1, 2, 3])) 93 | 6 94 | 95 | >>> print("-".join("Hola")) 96 | H-o-l-a 97 | ``` 98 | 99 | De la misma forma que iteramos una cadena o una lista, también podemos iterar un diccionario. El iterador del diccionario devuelve las claves o keys del mismo. 100 | 101 | ```python 102 | >>> mi_dict = {'a':1, 'b':2, 'c':3} 103 | >>> for i in mi_dict: 104 | >>> print(i) 105 | a 106 | b 107 | c 108 | ``` 109 | 110 | ### Iteradores 111 | 112 | Se podría explicar la diferencia entre iteradores e iterables usando un libro como analogía. El libro sería nuestra clase iterable, ya que tiene diferentes páginas a las que podemos acceder. El libro podría ser una lista, y cada página un elemento de la lista. Por otro lado, el iterador sería un marcapáginas, es decir, una referencia que nos indica en qué posición estamos del libro, y que puede ser usado para “navegar” por él. 113 | Es posible obtener un iterador a partir de una clase iterable con la función iter(). En el siguiente ejemplo podemos ver como obtenemos el iterador del libro. 114 | 115 | ```python 116 | >>> libro = ['página1', 'página2', 'página3', 'página4'] 117 | >>> marcapaginas = iter(libro) 118 | ``` 119 | 120 | Llegados a este punto, nuestro marcapáginas almacena un iterador. Se trata de un objeto que podemos usar para navegar a través del libro. Usando la función next() sobre el iterador, podemos ir accediendo secuencialmente a cada elemento de nuestra lista (las páginas de libro). 121 | 122 | ```python 123 | >>> print(next(marcapaginas)) 124 | >>> print(next(marcapaginas)) 125 | >>> print(next(marcapaginas)) 126 | >>> print(next(marcapaginas)) 127 | página1 128 | página2 129 | página3 130 | página4 131 | ``` 132 | 133 | Algo parecido a esto es lo que sucede por debajo cuando usamos el for sobre una clase iterable. Se va accediendo secuencialmente a los elementos hasta que la excepción StopIteration es lanzada. Dicha excepción se lanza cuando hemos llegado al final, y no existen más elementos que iterar. 134 | 135 | ```python 136 | >>> print(next(marcapaginas)) 137 | --------------------------------------------------------------------------- 138 | StopIteration Traceback (most recent call last) 139 | ~\AppData\Local\Temp/ipykernel_10044/1391636315.py in 140 | ----> 1 print(next(marcapaginas)) 141 | ``` 142 | 143 | Una nota muy importante es que cuando el iterador es obtenido con iter() como hemos visto, apunta por defecto fuera de la lista. Es decir, si queremos acceder al primer elemento de la lista, deberemos llamar una vez a next(). 144 | Por otro lado, a diferencia de un marcapáginas de un libro, el iterador sólo puede ir hacia delante. No es posible retroceder. 145 | 146 | 147 | ### Sentencia zip 148 | 149 | Dadas dos listas, digamos lista1 y lista2, al pasarlas a **zip** como entrada, el elemento 1 de lista1 se asocia con el elemento 1 de lista2, el elemento 2 de lista1 se asocia con el elemento 2 de lista2, el elemento 3 de lista1 se asocia con el elemento 3 de lista2, y así sucesivamente. Es decir que el resultado será una tupla donde cada elemento tendrá todos y cada uno de los elementos i-ésimos de las listas pasadas como entrada. 150 | 151 | ```python 152 | >>> a = [1, 2] 153 | >>> b = ["Uno", "Dos"] 154 | >>> c = zip(a, b) 155 | >>> type(c) 156 | zip 157 | >>> list(c) 158 | [(1, 'Uno'), (2, 'Dos')] 159 | ``` 160 | 161 | ### Añadiendo condicionales 162 | 163 | Hemos visto cómo modificar todos los elementos de un iterable (como una lista) de diferentes maneras, pero ¿y si quisiéramos realizar la operación sobre el elemento sólo si una determinada condición se cumple? Debemos añadir un condicional if. 164 | La expresión genérica sería la siguiente. 165 | 166 | lista = [expresión for elemento in iterable if condición] 167 | 168 | Por lo tanto la expresión sólo se aplicará al elemento si se cumple la condición. Veamos un ejemplo con una frase, de la que queremos saber el número de erres que tiene. 169 | 170 | ```python 171 | >>> frase = "El perro de san roque no tiene rabo" 172 | >>> erres = [i for i in frase if i == 'r'] 173 | >>> print(errores) 174 | ['r', 'r', 'r', 'r'] 175 | >>> print(len(erres)) 176 | 4 177 | ``` 178 | 179 | Lo que hace el código anterior es iterar cada letra de la frase, y si es una r, se añade a la lista. De esta manera el resultado es una lista con tantas letras r como la frase original tiene, y podemos calcular las veces que se repite con len(). 180 | 181 | * Si tienes dudas sobre este tema, puedes consultarlas en el canal **#m06_iterablesiteradores** de Slack -------------------------------------------------------------------------------- /M07_funciones/Prep_Course_Homework_07-Resuelto.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python 2 | # coding: utf-8 3 | 4 | # ## Funciones 5 | 6 | # 1) Crear una función que reciba un número como parámetro y devuelva si True si es primo y False si no lo es 7 | 8 | # In[1]: 9 | 10 | 11 | def verifica_primo(nro): 12 | es_primo = True 13 | for i in range(2, nro): 14 | if nro % i == 0: 15 | es_primo = False 16 | break 17 | return es_primo 18 | 19 | 20 | # 2) Utilizando la función del punto 1, realizar otra función que reciba de parámetro una lista de números y devuelva sólo aquellos que son primos en otra lista 21 | 22 | # In[25]: 23 | 24 | 25 | def extrae_primos_de_lista(lista): 26 | lista_primos = [] 27 | for elemento in lista: 28 | if verifica_primo(int(elemento)): 29 | lista_primos.append(elemento) 30 | return lista_primos 31 | 32 | 33 | # In[26]: 34 | 35 | 36 | lis_completa = [1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20] 37 | lis_primos = extrae_primos_de_lista(lis_completa) 38 | lis_primos 39 | 40 | 41 | # 3) Crear una función que al recibir una lista de números, devuelva el que más se repite y cuántas veces lo hace. Si hay más de un "más repetido", que devuelva cualquiera 42 | 43 | # In[33]: 44 | 45 | 46 | def valor_modal(lista): 47 | lista_unicos = [] 48 | lista_repeticiones = [] 49 | if len(lista) == 0: 50 | return None 51 | for elemento in lista: 52 | if elemento in lista_unicos: 53 | i = lista_unicos.index(elemento) 54 | lista_repeticiones[i] += 1 55 | else: 56 | lista_unicos.append(elemento) 57 | lista_repeticiones.append(1) 58 | moda = lista_unicos[0] 59 | maximo = lista_repeticiones[0] 60 | for i, elemento in enumerate(lista_unicos): 61 | if lista_repeticiones[i] > maximo: 62 | moda = lista_unicos[i] 63 | maximo = lista_repeticiones[i] 64 | return moda, maximo 65 | 66 | 67 | # In[36]: 68 | 69 | 70 | lis = [1,1,5,6,8,10,22,5,6,4,11,9,5] 71 | moda, repite = valor_modal(lis) 72 | print('El valor modal es', moda, 'y se repite', repite, 'veces.') 73 | 74 | 75 | # 4) Crear una función que convierta entre grados Celsius, Farenheit y Kelvin
76 | # Fórmula 1 : (°C × 9/5) + 32 = °F
77 | # Fórmula 2 : °C + 273.15 = °K
78 | # Debe recibir 3 parámetros: el valor, la medida de orígen y la medida de destino 79 | # 80 | 81 | # In[56]: 82 | 83 | 84 | def conversion_grados(valor, origen, destino): 85 | if (origen == 'celsius'): 86 | if (destino == 'celsius'): 87 | valor_destino = valor 88 | elif (destino == 'farenheit'): 89 | valor_destino = (valor * 9 / 5) + 32 90 | elif (destino == 'kelvin'): 91 | valor_destino = valor + 273.15 92 | else: 93 | print('Parámetro de Destino incorrecto') 94 | elif (origen == 'farenheit'): 95 | if (destino == 'celsius'): 96 | valor_destino = (valor - 32) * 5 / 9 97 | elif (destino == 'farenheit'): 98 | valor_destino = valor 99 | elif (destino == 'kelvin'): 100 | valor_destino = ((valor - 32) * 5 / 9) + 273.15 101 | else: 102 | print('Parámetro de Destino incorrecto') 103 | elif (origen == 'kelvin'): 104 | if (destino == 'celsius'): 105 | valor_destino = valor - 273.15 106 | elif (destino == 'farenheit'): 107 | valor_destino = ((valor - 273.15) * 9 / 5) + 32 108 | elif (destino == 'kelvin'): 109 | valor_destino = valor 110 | else: 111 | print('Parámetro de Destino incorrecto') 112 | else: 113 | print('Parámetro de Origen incorrecto') 114 | return valor_destino 115 | 116 | 117 | # In[59]: 118 | 119 | 120 | print('1 grado Celsius a Celsius:', conversion_grados(1, 'celsius', 'celsius')) 121 | print('1 grado Celsius a Kelvin:', conversion_grados(1, 'celsius', 'kelvin')) 122 | print('1 grado Celsius a Farenheit:', conversion_grados(1, 'celsius', 'farenheit')) 123 | print('1 grado Kelvin a Celsius:', conversion_grados(1, 'kelvin', 'celsius')) 124 | print('1 grado Kelvin a Kelvin:', conversion_grados(1, 'kelvin', 'kelvin')) 125 | print('1 grado Kelvin a Farenheit:', conversion_grados(1, 'kelvin', 'farenheit')) 126 | print('1 grado Farenheit a Celsius:', conversion_grados(1, 'farenheit', 'celsius')) 127 | print('1 grado Farenheit a Kelvin:', conversion_grados(1, 'farenheit', 'kelvin')) 128 | print('1 grado Farenheit a Farenheit:', conversion_grados(1, 'farenheit', 'farenheit')) 129 | 130 | 131 | # 5) Iterando una lista con los tres valores posibles de temperatura que recibe la función del punto 5, hacer un print para cada combinación de los mismos: 132 | 133 | # In[62]: 134 | 135 | 136 | metricas = ['celsius','kelvin','farenheit'] 137 | for i in range(0,3): 138 | for j in range(0,3): 139 | print('1 grado', metricas[i], 'a', metricas[j],':', conversion_grados(1, metricas[i], metricas[j])) 140 | 141 | 142 | # 6) Armar una función que devuelva el factorial de un número. Tener en cuenta que el usuario puede equivocarse y enviar de parámetro un número no entero o negativo 143 | 144 | # In[65]: 145 | 146 | 147 | def factorial(numero): 148 | if(type(numero) != int): 149 | return 'El numero debe ser un entero' 150 | if(numero < 0): 151 | return 'El numero debe ser pisitivo' 152 | if (numero > 1): 153 | numero = numero * factorial(numero - 1) 154 | return numero 155 | print(factorial(3)) 156 | print(factorial(-2)) 157 | print(factorial(1.23)) 158 | print(factorial('6')) 159 | 160 | -------------------------------------------------------------------------------- /M07_funciones/Prep_Course_Homework_07.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "attachments": {}, 5 | "cell_type": "markdown", 6 | "metadata": {}, 7 | "source": [ 8 | "## Funciones" 9 | ] 10 | }, 11 | { 12 | "attachments": {}, 13 | "cell_type": "markdown", 14 | "metadata": {}, 15 | "source": [ 16 | "1) Crear una función que reciba un número como parámetro y devuelva True si es primo y False si no lo es" 17 | ] 18 | }, 19 | { 20 | "cell_type": "code", 21 | "execution_count": null, 22 | "metadata": {}, 23 | "outputs": [], 24 | "source": [] 25 | }, 26 | { 27 | "attachments": {}, 28 | "cell_type": "markdown", 29 | "metadata": {}, 30 | "source": [ 31 | "2) Utilizando la función del punto 1, realizar otra función que reciba de parámetro una lista de números y devuelva sólo aquellos que son primos en otra lista" 32 | ] 33 | }, 34 | { 35 | "cell_type": "code", 36 | "execution_count": null, 37 | "metadata": {}, 38 | "outputs": [], 39 | "source": [] 40 | }, 41 | { 42 | "attachments": {}, 43 | "cell_type": "markdown", 44 | "metadata": {}, 45 | "source": [ 46 | "3) Crear una función que al recibir una lista de números, devuelva el que más se repite y cuántas veces lo hace. Si hay más de un \"más repetido\", que devuelva cualquiera" 47 | ] 48 | }, 49 | { 50 | "cell_type": "code", 51 | "execution_count": null, 52 | "metadata": {}, 53 | "outputs": [], 54 | "source": [] 55 | }, 56 | { 57 | "attachments": {}, 58 | "cell_type": "markdown", 59 | "metadata": {}, 60 | "source": [ 61 | "4) Crear una función que convierta entre grados Celsius, Farenheit y Kelvin
\n", 62 | "Fórmula 1\t: (°C × 9/5) + 32 = °F
\n", 63 | "Fórmula 2\t: °C + 273.15 = °K
\n", 64 | "Debe recibir 3 parámetros: el valor, la medida de orígen y la medida de destino\n" 65 | ] 66 | }, 67 | { 68 | "cell_type": "code", 69 | "execution_count": null, 70 | "metadata": {}, 71 | "outputs": [], 72 | "source": [] 73 | }, 74 | { 75 | "attachments": {}, 76 | "cell_type": "markdown", 77 | "metadata": {}, 78 | "source": [ 79 | "5) Iterando una lista con los tres valores posibles de temperatura que recibe la función del punto 5, hacer un print para cada combinación de los mismos:" 80 | ] 81 | }, 82 | { 83 | "cell_type": "code", 84 | "execution_count": null, 85 | "metadata": {}, 86 | "outputs": [], 87 | "source": [] 88 | }, 89 | { 90 | "attachments": {}, 91 | "cell_type": "markdown", 92 | "metadata": {}, 93 | "source": [ 94 | "6) Armar una función que devuelva el factorial de un número. Tener en cuenta que el usuario puede equivocarse y enviar de parámetro un número no entero o negativo" 95 | ] 96 | }, 97 | { 98 | "cell_type": "code", 99 | "execution_count": null, 100 | "metadata": {}, 101 | "outputs": [], 102 | "source": [] 103 | } 104 | ], 105 | "metadata": { 106 | "interpreter": { 107 | "hash": "c85384e4cb51c8b72350f3a8712cc8351fdc3955e32a27f9b60c6242ab125f01" 108 | }, 109 | "kernelspec": { 110 | "display_name": "Python 3 (ipykernel)", 111 | "language": "python", 112 | "name": "python3" 113 | }, 114 | "language_info": { 115 | "codemirror_mode": { 116 | "name": "ipython", 117 | "version": 3 118 | }, 119 | "file_extension": ".py", 120 | "mimetype": "text/x-python", 121 | "name": "python", 122 | "nbconvert_exporter": "python", 123 | "pygments_lexer": "ipython3", 124 | "version": "3.9.7" 125 | } 126 | }, 127 | "nbformat": 4, 128 | "nbformat_minor": 4 129 | } 130 | -------------------------------------------------------------------------------- /M07_funciones/Prep_Course_Homework_07.md: -------------------------------------------------------------------------------- 1 | ## Funciones 2 | 3 | 1) Crear una función que reciba un número como parámetro y devuelva si True si es primo y False si no lo es 4 | 5 | 2) Utilizando la función del punto 1, realizar otra función que reciba de parámetro una lista de números y devuelva sólo aquellos que son primos en otra lista 6 | 7 | 3) Crear una función que al recibir una lista de números, devuelva el que más se repite y cuántas veces lo hace. Si hay más de un "más repetido", que devuelva cualquiera 8 | 9 | 4) Crear una función que convierta entre grados Celsius, Farenheit y Kelvin
10 | Fórmula 1 : (°C × 9/5) + 32 = °F
11 | Fórmula 2 : °C + 273.15 = °K
12 | Debe recibir 3 parámetros: el valor, la medida de orígen y la medida de destino 13 | 14 | 15 | 5) Iterando una lista con los tres valores posibles de temperatura que recibe la función del punto 5, hacer un print para cada combinación de los mismos: 16 | 17 | 6) Armar una función que devuelva el factorial de un número. Tener en cuenta que el usuario puede equivocarse y enviar de parámetro un número no entero o negativo 18 | -------------------------------------------------------------------------------- /M07_funciones/Prep_Course_Homework_07.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python 2 | # coding: utf-8 3 | 4 | # ## Funciones 5 | 6 | # 1) Crear una función que reciba un número como parámetro y devuelva si True si es primo y False si no lo es 7 | 8 | # In[1]: 9 | 10 | 11 | 12 | 13 | 14 | # 2) Utilizando la función del punto 1, realizar otra función que reciba de parámetro una lista de números y devuelva sólo aquellos que son primos en otra lista 15 | 16 | # In[25]: 17 | 18 | 19 | 20 | 21 | # 3) Crear una función que al recibir una lista de números, devuelva el que más se repite y cuántas veces lo hace. Si hay más de un "más repetido", que devuelva cualquiera 22 | 23 | # In[33]: 24 | 25 | 26 | 27 | 28 | 29 | # 4) Crear una función que convierta entre grados Celsius, Farenheit y Kelvin
30 | # Fórmula 1 : (°C × 9/5) + 32 = °F
31 | # Fórmula 2 : °C + 273.15 = °K
32 | # Debe recibir 3 parámetros: el valor, la medida de orígen y la medida de destino 33 | # 34 | 35 | # In[56]: 36 | 37 | 38 | 39 | # 5) Iterando una lista con los tres valores posibles de temperatura que recibe la función del punto 5, hacer un print para cada combinación de los mismos: 40 | 41 | # In[62]: 42 | 43 | 44 | 45 | 46 | # 6) Armar una función que devuelva el factorial de un número. Tener en cuenta que el usuario puede equivocarse y enviar de parámetro un número no entero o negativo 47 | 48 | # In[65]: 49 | 50 | 51 | 52 | 53 | -------------------------------------------------------------------------------- /M08_clasesyOOP/Prep_Course_Homework_08.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "attachments": {}, 5 | "cell_type": "markdown", 6 | "metadata": {}, 7 | "source": [ 8 | "## Clases y Programación Orientada a Objetos" 9 | ] 10 | }, 11 | { 12 | "attachments": {}, 13 | "cell_type": "markdown", 14 | "metadata": {}, 15 | "source": [ 16 | "1) Crear la clase vehículo que contenga los atributos:
\n", 17 | "Color
\n", 18 | "Si es moto, auto, camioneta ó camión
\n", 19 | "Cilindrada del motor" 20 | ] 21 | }, 22 | { 23 | "cell_type": "code", 24 | "execution_count": null, 25 | "metadata": {}, 26 | "outputs": [], 27 | "source": [] 28 | }, 29 | { 30 | "attachments": {}, 31 | "cell_type": "markdown", 32 | "metadata": {}, 33 | "source": [ 34 | "2) A la clase Vehiculo creada en el punto 1, agregar los siguientes métodos:
\n", 35 | "Acelerar
\n", 36 | "Frenar
\n", 37 | "Doblar
" 38 | ] 39 | }, 40 | { 41 | "cell_type": "code", 42 | "execution_count": null, 43 | "metadata": {}, 44 | "outputs": [], 45 | "source": [] 46 | }, 47 | { 48 | "attachments": {}, 49 | "cell_type": "markdown", 50 | "metadata": {}, 51 | "source": [ 52 | "3) Instanciar 3 objetos de la clase vehículo y ejecutar sus métodos, probar luego el resultado" 53 | ] 54 | }, 55 | { 56 | "cell_type": "code", 57 | "execution_count": null, 58 | "metadata": {}, 59 | "outputs": [], 60 | "source": [] 61 | }, 62 | { 63 | "attachments": {}, 64 | "cell_type": "markdown", 65 | "metadata": {}, 66 | "source": [ 67 | "4) Agregar a la clase Vehiculo, un método que muestre su estado, es decir, a que velocidad se encuentra y su dirección. Y otro método que muestre color, tipo y cilindrada" 68 | ] 69 | }, 70 | { 71 | "cell_type": "code", 72 | "execution_count": null, 73 | "metadata": {}, 74 | "outputs": [], 75 | "source": [] 76 | }, 77 | { 78 | "attachments": {}, 79 | "cell_type": "markdown", 80 | "metadata": {}, 81 | "source": [ 82 | "5) Crear una clase que permita utilizar las funciones creadas en la práctica del módulo 7
\n", 83 | "Verificar Primo
\n", 84 | "Valor modal
\n", 85 | "Conversión grados
\n", 86 | "Factorial
" 87 | ] 88 | }, 89 | { 90 | "cell_type": "code", 91 | "execution_count": null, 92 | "metadata": {}, 93 | "outputs": [], 94 | "source": [] 95 | }, 96 | { 97 | "attachments": {}, 98 | "cell_type": "markdown", 99 | "metadata": {}, 100 | "source": [ 101 | "6) Probar las funciones incorporadas en la clase del punto 5" 102 | ] 103 | }, 104 | { 105 | "cell_type": "code", 106 | "execution_count": null, 107 | "metadata": {}, 108 | "outputs": [], 109 | "source": [] 110 | }, 111 | { 112 | "attachments": {}, 113 | "cell_type": "markdown", 114 | "metadata": {}, 115 | "source": [ 116 | "7) Es necesario que la clase creada en el punto 5 contenga una lista, sobre la cual se apliquen las funciones incorporadas" 117 | ] 118 | }, 119 | { 120 | "cell_type": "code", 121 | "execution_count": null, 122 | "metadata": {}, 123 | "outputs": [], 124 | "source": [] 125 | }, 126 | { 127 | "attachments": {}, 128 | "cell_type": "markdown", 129 | "metadata": {}, 130 | "source": [ 131 | "8) Crear un archivo .py aparte y ubicar allí la clase generada en el punto anterior. Luego realizar la importación del módulo y probar alguna de sus funciones" 132 | ] 133 | }, 134 | { 135 | "cell_type": "code", 136 | "execution_count": null, 137 | "metadata": {}, 138 | "outputs": [], 139 | "source": [] 140 | } 141 | ], 142 | "metadata": { 143 | "interpreter": { 144 | "hash": "c85384e4cb51c8b72350f3a8712cc8351fdc3955e32a27f9b60c6242ab125f01" 145 | }, 146 | "kernelspec": { 147 | "display_name": "Python 3 (ipykernel)", 148 | "language": "python", 149 | "name": "python3" 150 | }, 151 | "language_info": { 152 | "codemirror_mode": { 153 | "name": "ipython", 154 | "version": 3 155 | }, 156 | "file_extension": ".py", 157 | "mimetype": "text/x-python", 158 | "name": "python", 159 | "nbconvert_exporter": "python", 160 | "pygments_lexer": "ipython3", 161 | "version": "3.9.7" 162 | } 163 | }, 164 | "nbformat": 4, 165 | "nbformat_minor": 4 166 | } 167 | -------------------------------------------------------------------------------- /M08_clasesyOOP/Prep_Course_Homework_08.md: -------------------------------------------------------------------------------- 1 | ## Clases y Programación Orientada a Objetos 2 | 3 | 1) Crear la clase vehículo que contenga los atributos:
4 | Color
5 | Si es moto, auto, camioneta ó camión
6 | Cilindrada del motor 7 | 8 | 2) A la clase Vehiculo creada en el punto 1, agregar los siguientes métodos:
9 | Acelerar
10 | Frenar
11 | Doblar
12 | 13 | 3) Instanciar 3 objetos de la clase vehículo y ejecutar sus métodos, probar luego el resultado 14 | 15 | 4) Agregar a la clase Vehiculo, un método que muestre su estado, es decir, a que velocidad se encuentra y su dirección. Y otro método que muestre color, tipo y cilindrada 16 | 17 | 5) Crear una clase que permita utilizar las funciones creadas en la práctica del módulo 6
18 | Verificar Primo
19 | Valor modal
20 | Conversión grados
21 | Factorial
22 | 23 | 6) Probar las funciones incorporadas en la clase del punto 5 24 | 25 | 7) Es necesario que la clase creada en el punto 5 contenga una lista, sobre la cual se aplquen las funciones incorporadas 26 | 27 | 8) Crear un archivo .py aparte y ubicar allí la clase generada en el punto anterior. Luego realizar la importación del módulo y probar alguna de sus funciones 28 | -------------------------------------------------------------------------------- /M08_clasesyOOP/Prep_Course_Homework_08.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python 2 | # coding: utf-8 3 | 4 | # ## Clases y Programación Orientada a Objetos 5 | 6 | # 1) Crear la clase vehículo que contenga los atributos:
7 | # Color
8 | # Si es moto, auto, camioneta ó camión
9 | # Cilindrada del motor 10 | 11 | # In[1]: 12 | 13 | 14 | 15 | 16 | # 2) A la clase Vehiculo creada en el punto 1, agregar los siguientes métodos:
17 | # Acelerar
18 | # Frenar
19 | # Doblar
20 | 21 | # In[5]: 22 | 23 | 24 | 25 | 26 | 27 | # 3) Instanciar 3 objetos de la clase vehículo y ejecutar sus métodos, probar luego el resultado 28 | 29 | # In[6]: 30 | 31 | 32 | 33 | 34 | 35 | # 4) Agregar a la clase Vehiculo, un método que muestre su estado, es decir, a que velocidad se encuentra y su dirección. Y otro método que muestre color, tipo y cilindrada 36 | 37 | # In[12]: 38 | 39 | 40 | 41 | 42 | 43 | 44 | # In[13]: 45 | 46 | 47 | 48 | 49 | 50 | 51 | # 5) Crear una clase que permita utilizar las funciones creadas en la práctica del módulo 7
52 | # Verificar Primo
53 | # Valor modal
54 | # Conversión grados
55 | # Factorial
56 | 57 | # In[33]: 58 | 59 | 60 | 61 | 62 | 63 | 64 | # 6) Probar las funciones incorporadas en la clase del punto 5 65 | 66 | # In[28]: 67 | 68 | 69 | 70 | 71 | 72 | # 7) Es necesario que la clase creada en el punto 5 contenga una lista, sobre la cual se aplquen las funciones incorporadas 73 | 74 | # In[55]: 75 | 76 | 77 | 78 | 79 | # 8) Crear un archivo .py aparte y ubicar allí la clase generada en el punto anterior. Luego realizar la importación del módulo y probar alguna de sus funciones 80 | 81 | # In[1]: 82 | 83 | 84 | 85 | 86 | -------------------------------------------------------------------------------- /M08_clasesyOOP/__pycache__/herramientas.cpython-39.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/soyHenry/Python-Prep/de9f7e7300b0b45fbd909a36983fa6064730c34d/M08_clasesyOOP/__pycache__/herramientas.cpython-39.pyc -------------------------------------------------------------------------------- /M08_clasesyOOP/herramientas.py: -------------------------------------------------------------------------------- 1 | class Herramientas: 2 | def __init__(self, lista_numeros): 3 | self.lista = lista_numeros 4 | 5 | def verifica_primo(self): 6 | ''' 7 | Explico lo que hace la funcion 8 | ''' 9 | for i in self.lista: 10 | if (self.__verifica_primo(i)): 11 | print('El elemento', i, 'SI es un numero primo') 12 | else: 13 | print('El elemento', i, 'NO es un numero primo') 14 | 15 | def conversion_grados(self, origen, destino): 16 | for i in self.lista: 17 | print(i, 'grados', origen, 'son', self.__conversion_grados(i, origen, destino),'grados',destino) 18 | 19 | def factorial(self): 20 | for i in self.lista: 21 | print('El factorial de ', i, 'es', self.__factorial(i)) 22 | 23 | def __verifica_primo(self, nro): 24 | es_primo = True 25 | for i in range(2, nro): 26 | if nro % i == 0: 27 | es_primo = False 28 | break 29 | return es_primo 30 | 31 | def valor_modal(self, menor): 32 | lista_unicos = [] 33 | lista_repeticiones = [] 34 | if len(self.lista) == 0: 35 | return None 36 | if (menor): 37 | self.lista.sort() 38 | else: 39 | self.lista.sort(reverse=True) 40 | for elemento in self.lista: 41 | if elemento in lista_unicos: 42 | i = lista_unicos.index(elemento) 43 | lista_repeticiones[i] += 1 44 | else: 45 | lista_unicos.append(elemento) 46 | lista_repeticiones.append(1) 47 | moda = lista_unicos[0] 48 | maximo = lista_repeticiones[0] 49 | for i, elemento in enumerate(lista_unicos): 50 | if lista_repeticiones[i] > maximo: 51 | moda = lista_unicos[i] 52 | maximo = lista_repeticiones[i] 53 | return moda, maximo 54 | 55 | def __conversion_grados(self, valor, origen, destino): 56 | valor_destino = None 57 | if (origen == 'celsius'): 58 | if (destino == 'celsius'): 59 | valor_destino = valor 60 | elif (destino == 'farenheit'): 61 | valor_destino = (valor * 9 / 5) + 32 62 | elif (destino == 'kelvin'): 63 | valor_destino = valor + 273.15 64 | else: 65 | print('Parámetro de Destino incorrecto') 66 | elif (origen == 'farenheit'): 67 | if (destino == 'celsius'): 68 | valor_destino = (valor - 32) * 5 / 9 69 | elif (destino == 'farenheit'): 70 | valor_destino = valor 71 | elif (destino == 'kelvin'): 72 | valor_destino = ((valor - 32) * 5 / 9) + 273.15 73 | else: 74 | print('Parámetro de Destino incorrecto') 75 | elif (origen == 'kelvin'): 76 | if (destino == 'celsius'): 77 | valor_destino = valor - 273.15 78 | elif (destino == 'farenheit'): 79 | valor_destino = ((valor - 273.15) * 9 / 5) + 32 80 | elif (destino == 'kelvin'): 81 | valor_destino = valor 82 | else: 83 | print('Parámetro de Destino incorrecto') 84 | else: 85 | print('Parámetro de Origen incorrecto') 86 | return valor_destino 87 | 88 | def __factorial(self, numero): 89 | if(type(numero) != int): 90 | return 'El numero debe ser un entero' 91 | if(numero < 0): 92 | return 'El numero debe ser pisitivo' 93 | if (numero > 1): 94 | numero = numero * self.__factorial(numero - 1) 95 | return numero -------------------------------------------------------------------------------- /M09_errorhandling/Prep_Course_Homework_09-Resuelto.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python 2 | # coding: utf-8 3 | 4 | # ## Manejo de errores 5 | 6 | # 1) Con la clase creada en el módulo 8, tener en cuenta diferentes casos en que el código pudiera arrojar error. Por ejemplo, en la creación del objeto recibimos una lista de números enteros pero ¿qué pasa si se envía otro tipo de dato? 7 | 8 | # In[1]: 9 | 10 | 11 | import sys 12 | sys.path.append(r'/C:/Users/lopez/Documents/Henry/Repos/Python-Prep/08 - Error Handling/herramientas.py') 13 | 14 | 15 | # In[2]: 16 | 17 | 18 | import herramientas as h 19 | 20 | 21 | # In[3]: 22 | 23 | 24 | h1 = h.Herramientas('hola') 25 | 26 | 27 | # In[4]: 28 | 29 | 30 | h1 = h.Herramientas([2,3,5,6,2]) 31 | 32 | 33 | # 2) En la función que hace la conversión de grados, validar que los parámetros enviados sean los esperados, de no serlo, informar cuáles son los valores esperados. 34 | 35 | # In[5]: 36 | 37 | 38 | import importlib 39 | importlib.reload(h) 40 | 41 | 42 | # In[6]: 43 | 44 | 45 | h1 = h.Herramientas([2,3,5,6,2]) 46 | 47 | 48 | # In[7]: 49 | 50 | 51 | h1.conversion_grados(1,2) 52 | 53 | 54 | # In[8]: 55 | 56 | 57 | h1.conversion_grados('celsius','farenheit') 58 | 59 | 60 | # 3) Importar el modulo "unittest" y crear los siguientes casos de pruebas sobre la clase utilizada en el punto 2
61 | # Creacion del objeto incorrecta
62 | # Creacion correcta del objeto
63 | # Metodo valor_modal()
64 | # 65 | # Se puede usar "raise ValueError()" en la creación de la clase para verificar el error. Investigar sobre esta funcionalidad. 66 | 67 | # In[9]: 68 | 69 | 70 | import unittest 71 | 72 | 73 | # In[11]: 74 | 75 | 76 | class ProbandoMiClase(unittest.TestCase): 77 | 78 | def test_crear_objeto1(self): 79 | param = 'hola' 80 | self.assertRaises(ValueError, h.Herramientas, param) 81 | #self.failUnlessRaises(ValueError, h.Herramientas, param) 82 | 83 | def test_crear_objeto2(self): 84 | param = [1,2,2,5] 85 | h1 = h.Herramientas(param) 86 | self.assertEqual(h1.lista, param) 87 | 88 | def test_valor_modal(self): 89 | lis = [1,2,1,3] 90 | h1 = h.Herramientas(lis) 91 | moda, veces = h1.valor_modal(False) 92 | moda = [moda] 93 | moda.append(veces) 94 | resultado = [1, 2] 95 | self.assertEqual(moda, resultado) 96 | 97 | 98 | # In[12]: 99 | 100 | 101 | unittest.main(argv=[''], verbosity=2, exit=False) 102 | 103 | 104 | # 4) Probar una creación incorrecta y visualizar la salida del "raise" 105 | 106 | # In[13]: 107 | 108 | 109 | h2 = h.Herramientas('algo') 110 | 111 | 112 | # 6) Agregar casos de pruebas para el método verifica_primos() realizando el cambio en la clase, para que devuelva una lista de True o False en función de que el elemento en la posisicón sea o no primo 113 | 114 | # In[14]: 115 | 116 | 117 | class ProbandoMiClase2(unittest.TestCase): 118 | 119 | def test_verifica_primos1(self): 120 | lis = [2,3,8,10,13] 121 | h1 = h.Herramientas(lis) 122 | primos = h1.verifica_primo() 123 | primos_esperado = [True, True, False, False, True] 124 | self.assertEqual(primos, primos_esperado) 125 | 126 | 127 | # In[15]: 128 | 129 | 130 | importlib.reload(h) 131 | 132 | 133 | # In[16]: 134 | 135 | 136 | unittest.main(argv=[''], verbosity=2, exit=False) 137 | 138 | 139 | # 7) Agregar casos de pruebas para el método conversion_grados() 140 | 141 | # In[17]: 142 | 143 | 144 | class ProbandoMiClase3(unittest.TestCase): 145 | 146 | def test_verifica_conversion1(self): 147 | lis = [2,3,8,10,13] 148 | h1 = h.Herramientas(lis) 149 | grados = h1.conversion_grados('celsius','farenheit') 150 | grados_esperado = [35.6, 37.4, 46.4, 50.0, 55.4] 151 | self.assertEqual(grados, grados_esperado) 152 | 153 | 154 | # In[18]: 155 | 156 | 157 | importlib.reload(h) 158 | 159 | 160 | # In[19]: 161 | 162 | 163 | unittest.main(argv=[''], verbosity=2, exit=False) 164 | 165 | 166 | # 8) Agregar casos de pruebas para el método factorial() 167 | 168 | # In[20]: 169 | 170 | 171 | class ProbandoMiClase4(unittest.TestCase): 172 | 173 | def test_verifica_factorial(self): 174 | lis = [2,3,8,10,13] 175 | h1 = h.Herramientas(lis) 176 | factorial = h1.factorial() 177 | factorial_esperado = [2, 6, 40320, 3628800, 6227020800] 178 | self.assertEqual(factorial, factorial_esperado) 179 | 180 | 181 | # In[21]: 182 | 183 | 184 | importlib.reload(h) 185 | 186 | 187 | # In[22]: 188 | 189 | 190 | unittest.main(argv=[''], verbosity=2, exit=False) 191 | 192 | -------------------------------------------------------------------------------- /M09_errorhandling/Prep_Course_Homework_09.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "attachments": {}, 5 | "cell_type": "markdown", 6 | "metadata": {}, 7 | "source": [ 8 | "## Manejo de errores" 9 | ] 10 | }, 11 | { 12 | "attachments": {}, 13 | "cell_type": "markdown", 14 | "metadata": {}, 15 | "source": [ 16 | "1) Con la clase creada en el módulo 7, tener en cuenta diferentes casos en que el código pudiera arrojar error. Por ejemplo, en la creación del objeto recibimos una lista de números enteros pero ¿qué pasa si se envía otro tipo de dato?" 17 | ] 18 | }, 19 | { 20 | "cell_type": "code", 21 | "execution_count": null, 22 | "metadata": {}, 23 | "outputs": [], 24 | "source": [] 25 | }, 26 | { 27 | "attachments": {}, 28 | "cell_type": "markdown", 29 | "metadata": {}, 30 | "source": [ 31 | "2) En la función que hace la conversión de grados, validar que los parámetros enviados sean los esperados, de no serlo, informar cuáles son los valores esperados." 32 | ] 33 | }, 34 | { 35 | "cell_type": "code", 36 | "execution_count": null, 37 | "metadata": {}, 38 | "outputs": [], 39 | "source": [] 40 | }, 41 | { 42 | "attachments": {}, 43 | "cell_type": "markdown", 44 | "metadata": {}, 45 | "source": [ 46 | "3) Importar el modulo \"unittest\" y crear los siguientes casos de pruebas sobre la clase utilizada en el punto 2
\n", 47 | "Creacion del objeto incorrecta
\n", 48 | "Creacion correcta del objeto
\n", 49 | "Metodo valor_modal()
\n", 50 | "\n", 51 | "Se puede usar \"raise ValueError()\" en la creación de la clase para verificar el error. Investigar sobre esta funcionalidad." 52 | ] 53 | }, 54 | { 55 | "cell_type": "code", 56 | "execution_count": null, 57 | "metadata": {}, 58 | "outputs": [], 59 | "source": [] 60 | }, 61 | { 62 | "attachments": {}, 63 | "cell_type": "markdown", 64 | "metadata": {}, 65 | "source": [ 66 | "4) Probar una creación incorrecta y visualizar la salida del \"raise\"" 67 | ] 68 | }, 69 | { 70 | "cell_type": "code", 71 | "execution_count": null, 72 | "metadata": {}, 73 | "outputs": [], 74 | "source": [] 75 | }, 76 | { 77 | "attachments": {}, 78 | "cell_type": "markdown", 79 | "metadata": {}, 80 | "source": [ 81 | "6) Agregar casos de pruebas para el método verifica_primos() realizando el cambio en la clase, para que devuelva una lista de True o False en función de que el elemento en la posisicón sea o no primo" 82 | ] 83 | }, 84 | { 85 | "cell_type": "code", 86 | "execution_count": null, 87 | "metadata": {}, 88 | "outputs": [], 89 | "source": [] 90 | }, 91 | { 92 | "attachments": {}, 93 | "cell_type": "markdown", 94 | "metadata": {}, 95 | "source": [ 96 | "7) Agregar casos de pruebas para el método conversion_grados()" 97 | ] 98 | }, 99 | { 100 | "cell_type": "code", 101 | "execution_count": null, 102 | "metadata": {}, 103 | "outputs": [], 104 | "source": [] 105 | }, 106 | { 107 | "attachments": {}, 108 | "cell_type": "markdown", 109 | "metadata": {}, 110 | "source": [ 111 | "8) Agregar casos de pruebas para el método factorial()" 112 | ] 113 | }, 114 | { 115 | "cell_type": "code", 116 | "execution_count": null, 117 | "metadata": {}, 118 | "outputs": [], 119 | "source": [] 120 | } 121 | ], 122 | "metadata": { 123 | "interpreter": { 124 | "hash": "c85384e4cb51c8b72350f3a8712cc8351fdc3955e32a27f9b60c6242ab125f01" 125 | }, 126 | "kernelspec": { 127 | "display_name": "Python 3 (ipykernel)", 128 | "language": "python", 129 | "name": "python3" 130 | }, 131 | "language_info": { 132 | "codemirror_mode": { 133 | "name": "ipython", 134 | "version": 3 135 | }, 136 | "file_extension": ".py", 137 | "mimetype": "text/x-python", 138 | "name": "python", 139 | "nbconvert_exporter": "python", 140 | "pygments_lexer": "ipython3", 141 | "version": "3.9.7" 142 | } 143 | }, 144 | "nbformat": 4, 145 | "nbformat_minor": 4 146 | } 147 | -------------------------------------------------------------------------------- /M09_errorhandling/Prep_Course_Homework_09.md: -------------------------------------------------------------------------------- 1 | ## Manejo de errores 2 | 3 | 1) Con la clase creada en el módulo 7, tener en cuenta diferentes casos en que el código pudiera arrojar error. Por ejemplo, en la creación del objeto recibimos una lista de números enteros pero ¿qué pasa si se envía otro tipo de dato? 4 | 5 | 2) En la función que hace la conversión de grados, validar que los parámetros enviados sean los esperados, de no serlo, informar cuáles son los valores esperados. 6 | 7 | 3) Importar el modulo "unittest" y crear los siguientes casos de pruebas sobre la clase utilizada en el punto 2
8 | Creacion del objeto incorrecta
9 | Creacion correcta del objeto
10 | Metodo valor_modal()
11 | 12 | Se puede usar "raise ValueError()" en la creación de la clase para verificar el error. Investigar sobre esta funcionalidad. 13 | 14 | 4) Probar una creación incorrecta y visualizar la salida del "raise" 15 | 16 | 6) Agregar casos de pruebas para el método verifica_primos() realizando el cambio en la clase, para que devuelva una lista de True o False en función de que el elemento en la posisicón sea o no primo 17 | 18 | 7) Agregar casos de pruebas para el método conversion_grados() 19 | 20 | 8) Agregar casos de pruebas para el método factorial() -------------------------------------------------------------------------------- /M09_errorhandling/Prep_Course_Homework_09.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python 2 | # coding: utf-8 3 | 4 | # ## Manejo de errores 5 | 6 | # 1) Con la clase creada en el módulo 7, tener en cuenta diferentes casos en que el código pudiera arrojar error. Por ejemplo, en la creación del objeto recibimos una lista de números enteros pero ¿qué pasa si se envía otro tipo de dato? 7 | 8 | # In[1]: 9 | 10 | 11 | 12 | 13 | # 2) En la función que hace la conversión de grados, validar que los parámetros enviados sean los esperados, de no serlo, informar cuáles son los valores esperados. 14 | 15 | # In[5]: 16 | 17 | 18 | 19 | 20 | 21 | # 3) Importar el modulo "unittest" y crear los siguientes casos de pruebas sobre la clase utilizada en el punto 2
22 | # Creacion del objeto incorrecta
23 | # Creacion correcta del objeto
24 | # Metodo valor_modal()
25 | # 26 | # Se puede usar "raise ValueError()" en la creación de la clase para verificar el error. Investigar sobre esta funcionalidad. 27 | 28 | # In[9]: 29 | 30 | 31 | 32 | 33 | # 4) Probar una creación incorrecta y visualizar la salida del "raise" 34 | 35 | # In[13]: 36 | 37 | 38 | 39 | 40 | # 6) Agregar casos de pruebas para el método verifica_primos() realizando el cambio en la clase, para que devuelva una lista de True o False en función de que el elemento en la posisicón sea o no primo 41 | 42 | # In[14]: 43 | 44 | 45 | 46 | 47 | # 7) Agregar casos de pruebas para el método conversion_grados() 48 | 49 | # In[17]: 50 | 51 | 52 | 53 | 54 | # 8) Agregar casos de pruebas para el método factorial() 55 | 56 | # In[20]: 57 | 58 | 59 | 60 | 61 | -------------------------------------------------------------------------------- /M09_errorhandling/__pycache__/checkpoint.cpython-39.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/soyHenry/Python-Prep/de9f7e7300b0b45fbd909a36983fa6064730c34d/M09_errorhandling/__pycache__/checkpoint.cpython-39.pyc -------------------------------------------------------------------------------- /M09_errorhandling/__pycache__/herramientas.cpython-39.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/soyHenry/Python-Prep/de9f7e7300b0b45fbd909a36983fa6064730c34d/M09_errorhandling/__pycache__/herramientas.cpython-39.pyc -------------------------------------------------------------------------------- /M09_errorhandling/herramientas.py: -------------------------------------------------------------------------------- 1 | class Herramientas: 2 | def __init__(self, lista_numeros): 3 | if (type(lista_numeros) != list): 4 | self.lista = [] 5 | raise ValueError('Se ha creado una lista vacía. Se esperaba una lista de núemeros enteros') 6 | else: 7 | self.lista = lista_numeros 8 | 9 | def verifica_primo(self): 10 | lista_primos = [] 11 | for i in self.lista: 12 | if (self.__verifica_primo(i)): 13 | lista_primos.append(True) 14 | else: 15 | lista_primos.append(False) 16 | return lista_primos 17 | 18 | def conversion_grados(self, origen, destino): 19 | parametros_esperados = ['celsius','kelvin','farenheit'] 20 | lista_conversion = [] 21 | if str(origen) not in parametros_esperados: 22 | print('Los parametros esperados son:', parametros_esperados) 23 | return lista_conversion 24 | if str(destino) not in parametros_esperados: 25 | print('Los parametros esperados son:', parametros_esperados) 26 | return lista_conversion 27 | for i in self.lista: 28 | lista_conversion.append(self.__conversion_grados(i, origen, destino)) 29 | return lista_conversion 30 | 31 | def factorial(self): 32 | lista_factorial = [] 33 | for i in self.lista: 34 | lista_factorial.append(self.__factorial(i)) 35 | return lista_factorial 36 | 37 | def __verifica_primo(self, nro): 38 | es_primo = True 39 | for i in range(2, nro): 40 | if nro % i == 0: 41 | es_primo = False 42 | break 43 | return es_primo 44 | 45 | def valor_modal(self, menor): 46 | lista_unicos = [] 47 | lista_repeticiones = [] 48 | if len(self.lista) == 0: 49 | return None 50 | if (menor): 51 | self.lista.sort() 52 | else: 53 | self.lista.sort(reverse=True) 54 | for elemento in self.lista: 55 | if elemento in lista_unicos: 56 | i = lista_unicos.index(elemento) 57 | lista_repeticiones[i] += 1 58 | else: 59 | lista_unicos.append(elemento) 60 | lista_repeticiones.append(1) 61 | moda = lista_unicos[0] 62 | maximo = lista_repeticiones[0] 63 | for i, elemento in enumerate(lista_unicos): 64 | if lista_repeticiones[i] > maximo: 65 | moda = lista_unicos[i] 66 | maximo = lista_repeticiones[i] 67 | return moda, maximo 68 | 69 | def __conversion_grados(self, valor, origen, destino): 70 | valor_destino = None 71 | if (origen == 'celsius'): 72 | if (destino == 'celsius'): 73 | valor_destino = valor 74 | elif (destino == 'farenheit'): 75 | valor_destino = (valor * 9 / 5) + 32 76 | else: 77 | valor_destino = valor + 273.15 78 | elif (origen == 'farenheit'): 79 | if (destino == 'celsius'): 80 | valor_destino = (valor - 32) * 5 / 9 81 | elif (destino == 'farenheit'): 82 | valor_destino = valor 83 | else: 84 | valor_destino = ((valor - 32) * 5 / 9) + 273.15 85 | else: 86 | if (destino == 'celsius'): 87 | valor_destino = valor - 273.15 88 | elif (destino == 'farenheit'): 89 | valor_destino = ((valor - 273.15) * 9 / 5) + 32 90 | else: 91 | valor_destino = valor 92 | return valor_destino 93 | 94 | def __factorial(self, numero): 95 | if(type(numero) != int): 96 | return 'El numero debe ser un entero' 97 | if(numero < 0): 98 | return 'El numero debe ser pisitivo' 99 | if (numero > 1): 100 | numero = numero * self.__factorial(numero - 1) 101 | return numero -------------------------------------------------------------------------------- /M10_manejodearchivos/Prep_Course_Homework_09-Resuelto.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "## Entrada / Salida" 8 | ] 9 | }, 10 | { 11 | "cell_type": "markdown", 12 | "metadata": {}, 13 | "source": [ 14 | "1) Crear un script con el nombre \"clase09_ej1.py\" que reciba 3 parametros a elección, verificando que sean exactamente esa cantidad, y muestre como salida los parámetros recibidos" 15 | ] 16 | }, 17 | { 18 | "cell_type": "markdown", 19 | "metadata": {}, 20 | "source": [ 21 | "2) Crear un script con el nombre \"clase09_ej2.py2\" que reciba como un valor de temperatura en grados centígrados, un valor de humedad y por último si llovio (Con True o False). Y que cada vez que sea invocado, cargue en el archivo provisto \"clase09_ej2.csv\" una marca de tiempo y esa información." 22 | ] 23 | }, 24 | { 25 | "cell_type": "markdown", 26 | "metadata": {}, 27 | "source": [ 28 | "Para trabajar con tipos de datos relacionados con la medición del tiempo, como ser fechas, horarios o marcas de tiempo se puede utilizar la clase *datetime*" 29 | ] 30 | }, 31 | { 32 | "cell_type": "code", 33 | "execution_count": 1, 34 | "metadata": {}, 35 | "outputs": [], 36 | "source": [ 37 | "import datetime" 38 | ] 39 | }, 40 | { 41 | "cell_type": "code", 42 | "execution_count": 2, 43 | "metadata": {}, 44 | "outputs": [ 45 | { 46 | "name": "stdout", 47 | "output_type": "stream", 48 | "text": [ 49 | "Ahora = 2022-02-04 16:37:10.072897\n", 50 | "Fecha fija = 2020-05-10 00:00:00\n" 51 | ] 52 | } 53 | ], 54 | "source": [ 55 | "x = datetime.datetime.now()\n", 56 | "print(\"Ahora =\",x)\n", 57 | "x = datetime.datetime(2020, 5, 10)\n", 58 | "print(\"Fecha fija =\",x)" 59 | ] 60 | }, 61 | { 62 | "cell_type": "code", 63 | "execution_count": 3, 64 | "metadata": {}, 65 | "outputs": [ 66 | { 67 | "name": "stdout", 68 | "output_type": "stream", 69 | "text": [ 70 | "objeto datetime = 2022-05-10 12:30:00\n", 71 | "timestamp = 1652196600.0\n", 72 | "fecha hora = 2022-05-10 12:30:00\n" 73 | ] 74 | } 75 | ], 76 | "source": [ 77 | "fecha_hora = '2022-05-10 12:30:00'\n", 78 | "objeto_datetime = datetime.datetime.strptime(fecha_hora, '%Y-%m-%d %H:%M:%S')\n", 79 | "print(\"objeto datetime =\", objeto_datetime)\n", 80 | "marca_de_tiempo = datetime.datetime.timestamp(objeto_datetime)\n", 81 | "print(\"timestamp =\", marca_de_tiempo)\n", 82 | "fecha_hora2 = datetime.datetime.fromtimestamp(marca_de_tiempo)\n", 83 | "print(\"fecha hora =\", fecha_hora2)" 84 | ] 85 | }, 86 | { 87 | "cell_type": "markdown", 88 | "metadata": {}, 89 | "source": [ 90 | "3) Crear un archivo a partir de los datos presentes en el diccionario provisto. El cual debe contener en la primera fila el nombre de las claves y luego cada línea los elementos i-ésimos de las listas de valores contiguos y separados por coma ','. Este archivo debe llamarse clase09_ej3.csv" 91 | ] 92 | }, 93 | { 94 | "cell_type": "code", 95 | "execution_count": 1, 96 | "metadata": {}, 97 | "outputs": [], 98 | "source": [ 99 | "montañas = {'nombre':[ 'Everest','K2','Kanchenjunga','Lhotse','Makalu',\n", 100 | " 'Cho Oyu','Dhaulagiri','Manaslu','Nanga Parbat','Annapurna I'],\n", 101 | " 'orden':[1,2,3,4,5,6,7,8,9,10],\n", 102 | " 'cordillera':['Himalaya','Karakórum','Himalaya','Himalaya','Himalaya'\n", 103 | " ,'Himalaya','Himalaya','Himalaya','Karakórum','Himalaya'],\n", 104 | " 'pais': ['Nepal','Pakistán','Nepal','Nepal','Nepal','Nepal','Nepal','Nepal',\n", 105 | " 'Pakistán','Nepal'],\n", 106 | " 'altura':[8849,8611,8586,8516,8485,8188,8167,8163,8125,8091]}" 107 | ] 108 | }, 109 | { 110 | "cell_type": "code", 111 | "execution_count": 11, 112 | "metadata": {}, 113 | "outputs": [], 114 | "source": [ 115 | "import os\n", 116 | "archivo = open('clase09_ej3.csv', 'w')" 117 | ] 118 | }, 119 | { 120 | "cell_type": "code", 121 | "execution_count": 12, 122 | "metadata": {}, 123 | "outputs": [], 124 | "source": [ 125 | "for clave in montañas.keys():\n", 126 | " if (clave == 'altura'):\n", 127 | " archivo.write(clave+'\\n')\n", 128 | " else:\n", 129 | " archivo.write(clave+',')" 130 | ] 131 | }, 132 | { 133 | "cell_type": "code", 134 | "execution_count": 13, 135 | "metadata": {}, 136 | "outputs": [], 137 | "source": [ 138 | "ind = 0\n", 139 | "while (ind < 10):\n", 140 | " archivo.write(montañas['nombre'][ind]+',')\n", 141 | " archivo.write(str(montañas['orden'][ind])+',')\n", 142 | " archivo.write(montañas['cordillera'][ind]+',')\n", 143 | " archivo.write(montañas['pais'][ind]+',')\n", 144 | " archivo.write(str(montañas['altura'][ind])+'\\n')\n", 145 | " ind += 1" 146 | ] 147 | }, 148 | { 149 | "cell_type": "code", 150 | "execution_count": 14, 151 | "metadata": {}, 152 | "outputs": [], 153 | "source": [ 154 | "archivo.close()" 155 | ] 156 | }, 157 | { 158 | "cell_type": "markdown", 159 | "metadata": {}, 160 | "source": [ 161 | "4) Mostrar el tamaño en MB del archivo generado en el punto 3" 162 | ] 163 | }, 164 | { 165 | "cell_type": "code", 166 | "execution_count": 22, 167 | "metadata": {}, 168 | "outputs": [ 169 | { 170 | "name": "stdout", 171 | "output_type": "stream", 172 | "text": [ 173 | "El archivo tiene un tamaño de 0.36 MB\n" 174 | ] 175 | } 176 | ], 177 | "source": [ 178 | "print('El archivo tiene un tamaño de', str(round(os.path.getsize('clase09_ej3.csv')/1024,2)),'MB')" 179 | ] 180 | }, 181 | { 182 | "cell_type": "markdown", 183 | "metadata": {}, 184 | "source": [ 185 | "5) Crear una carpeta llamada clase09_montañas_altas" 186 | ] 187 | }, 188 | { 189 | "cell_type": "code", 190 | "execution_count": 23, 191 | "metadata": {}, 192 | "outputs": [], 193 | "source": [ 194 | "os.makedirs('clase09_montañas_altas')" 195 | ] 196 | }, 197 | { 198 | "cell_type": "markdown", 199 | "metadata": {}, 200 | "source": [ 201 | "6) Copiar el archivo clase09_ej3.scv en la carpeta clase09_montañas_altas usando la sentencia **os.system**" 202 | ] 203 | }, 204 | { 205 | "cell_type": "code", 206 | "execution_count": 24, 207 | "metadata": {}, 208 | "outputs": [ 209 | { 210 | "data": { 211 | "text/plain": [ 212 | "0" 213 | ] 214 | }, 215 | "execution_count": 24, 216 | "metadata": {}, 217 | "output_type": "execute_result" 218 | } 219 | ], 220 | "source": [ 221 | "os.system('copy clase09_ej3.csv clase09_montañas_altas')" 222 | ] 223 | }, 224 | { 225 | "cell_type": "markdown", 226 | "metadata": {}, 227 | "source": [ 228 | "7) Listar el contenido de la carpeta clase09_montañas_altas" 229 | ] 230 | }, 231 | { 232 | "cell_type": "code", 233 | "execution_count": 29, 234 | "metadata": {}, 235 | "outputs": [ 236 | { 237 | "data": { 238 | "text/plain": [ 239 | "['clase09_ej3.csv']" 240 | ] 241 | }, 242 | "execution_count": 29, 243 | "metadata": {}, 244 | "output_type": "execute_result" 245 | } 246 | ], 247 | "source": [ 248 | "os.listdir('./clase09_montañas_altas')" 249 | ] 250 | } 251 | ], 252 | "metadata": { 253 | "interpreter": { 254 | "hash": "c85384e4cb51c8b72350f3a8712cc8351fdc3955e32a27f9b60c6242ab125f01" 255 | }, 256 | "kernelspec": { 257 | "display_name": "Python 3 (ipykernel)", 258 | "language": "python", 259 | "name": "python3" 260 | }, 261 | "language_info": { 262 | "codemirror_mode": { 263 | "name": "ipython", 264 | "version": 3 265 | }, 266 | "file_extension": ".py", 267 | "mimetype": "text/x-python", 268 | "name": "python", 269 | "nbconvert_exporter": "python", 270 | "pygments_lexer": "ipython3", 271 | "version": "3.9.7" 272 | } 273 | }, 274 | "nbformat": 4, 275 | "nbformat_minor": 4 276 | } 277 | -------------------------------------------------------------------------------- /M10_manejodearchivos/Prep_Course_Homework_09-Resuelto.py: -------------------------------------------------------------------------------- 1 | # %% [markdown] 2 | # ## Entrada / Salida 3 | 4 | # %% [markdown] 5 | # 1) Crear un script con el nombre "clase09_ej1.py" que reciba 3 parametros a elección, verificando que sean exactamente esa cantidad, y muestre como salida los parámetros recibidos 6 | 7 | # %% [markdown] 8 | # 2) Crear un script con el nombre "clase09_ej2.py2" que reciba como un valor de temperatura en grados centígrados, un valor de humedad y por último si llovio (Con True o False). Y que cada vez que sea invocado, cargue en el archivo provisto "clase09_ej2.csv" una marca de tiempo y esa información. 9 | 10 | # %% [markdown] 11 | # Para trabajar con tipos de datos relacionados con la medición del tiempo, como ser fechas, horarios o marcas de tiempo se puede utilizar la clase *datetime* 12 | 13 | # %% 14 | import datetime 15 | 16 | # %% 17 | x = datetime.datetime.now() 18 | print("Ahora =",x) 19 | x = datetime.datetime(2020, 5, 10) 20 | print("Fecha fija =",x) 21 | 22 | # %% 23 | fecha_hora = '2022-05-10 12:30:00' 24 | objeto_datetime = datetime.datetime.strptime(fecha_hora, '%Y-%m-%d %H:%M:%S') 25 | print("objeto datetime =", objeto_datetime) 26 | marca_de_tiempo = datetime.datetime.timestamp(objeto_datetime) 27 | print("timestamp =", marca_de_tiempo) 28 | fecha_hora2 = datetime.datetime.fromtimestamp(marca_de_tiempo) 29 | print("fecha hora =", fecha_hora2) 30 | 31 | # %% [markdown] 32 | # 3) Crear un archivo a partir de los datos presentes en el diccionario provisto. El cual debe contener en la primera fila el nombre de las claves y luego cada línea los elementos i-ésimos de las listas de valores contiguos y separados por coma ','. Este archivo debe llamarse clase09_ej3.csv 33 | 34 | # %% 35 | montañas = {'nombre':[ 'Everest','K2','Kanchenjunga','Lhotse','Makalu', 36 | 'Cho Oyu','Dhaulagiri','Manaslu','Nanga Parbat','Annapurna I'], 37 | 'orden':[1,2,3,4,5,6,7,8,9,10], 38 | 'cordillera':['Himalaya','Karakórum','Himalaya','Himalaya','Himalaya' 39 | ,'Himalaya','Himalaya','Himalaya','Karakórum','Himalaya'], 40 | 'pais': ['Nepal','Pakistán','Nepal','Nepal','Nepal','Nepal','Nepal','Nepal', 41 | 'Pakistán','Nepal'], 42 | 'altura':[8849,8611,8586,8516,8485,8188,8167,8163,8125,8091]} 43 | 44 | # %% 45 | import os 46 | archivo = open('clase09_ej3.csv', 'w') 47 | 48 | # %% 49 | for clave in montañas.keys(): 50 | if (clave == 'altura'): 51 | archivo.write(clave+'\n') 52 | else: 53 | archivo.write(clave+',') 54 | 55 | # %% 56 | ind = 0 57 | while (ind < 10): 58 | archivo.write(montañas['nombre'][ind]+',') 59 | archivo.write(str(montañas['orden'][ind])+',') 60 | archivo.write(montañas['cordillera'][ind]+',') 61 | archivo.write(montañas['pais'][ind]+',') 62 | archivo.write(str(montañas['altura'][ind])+'\n') 63 | ind += 1 64 | 65 | # %% 66 | archivo.close() 67 | 68 | # %% [markdown] 69 | # 4) Mostrar el tamaño en MB del archivo generado en el punto 3 70 | 71 | # %% 72 | print('El archivo tiene un tamaño de', str(round(os.path.getsize('clase09_ej3.csv')/1024,2)),'MB') 73 | 74 | # %% [markdown] 75 | # 5) Crear una carpeta llamada clase09_montañas_altas 76 | 77 | # %% 78 | os.makedirs('clase09_montañas_altas') 79 | 80 | # %% [markdown] 81 | # 6) Copiar el archivo clase09_ej3.scv en la carpeta clase09_montañas_altas usando la sentencia **os.system** 82 | 83 | # %% 84 | os.system('copy clase09_ej3.csv clase09_montañas_altas') 85 | 86 | # %% [markdown] 87 | # 7) Listar el contenido de la carpeta clase09_montañas_altas 88 | 89 | # %% 90 | os.listdir('./clase09_montañas_altas') 91 | 92 | 93 | -------------------------------------------------------------------------------- /M10_manejodearchivos/Prep_Course_Homework_09.md: -------------------------------------------------------------------------------- 1 | ## Entrada / Salida 2 | 3 | 1) Crear un script con el nombre "clase09_ej1.py" que reciba 3 parametros a elección, verificando que sean exactamente esa cantidad, y muestre como salida los parámetros recibidos 4 | 5 | 2) Crear un script con el nombre "clase09_ej2.py2" que reciba como un valor de temperatura en grados centígrados, un valor de humedad y por último si llovio (Con True o False). Y que cada vez que sea invocado, cargue en el archivo provisto "clase09_ej2.csv" una marca de tiempo y esa información. 6 | 7 | Para trabajar con tipos de datos relacionados con la medición del tiempo, como ser fechas, horarios o marcas de tiempo se puede utilizar la clase *datetime* 8 | 9 | ``` python 10 | import datetime 11 | 12 | x = datetime.datetime.now() 13 | print("Ahora =",x) 14 | x = datetime.datetime(2020, 5, 10) 15 | print("Fecha fija =",x) 16 | 17 | fecha_hora = '2022-05-10 12:30:00' 18 | objeto_datetime = datetime.datetime.strptime(fecha_hora, '%Y-%m-%d %H:%M:%S') 19 | print("objeto datetime =", objeto_datetime) 20 | marca_de_tiempo = datetime.datetime.timestamp(objeto_datetime) 21 | print("timestamp =", marca_de_tiempo) 22 | fecha_hora2 = datetime.datetime.fromtimestamp(marca_de_tiempo) 23 | print("fecha hora =", fecha_hora2) 24 | ``` 25 | 26 | 3) Crear un archivo a partir de los datos presentes en el diccionario provisto. El cual debe contener en la primera fila el nombre de las claves y luego cada línea los elementos i-ésimos de las listas de valores contiguos y separados por coma ','. Este archivo debe llamarse clase09_ej3.csv 27 | 28 | ``` python 29 | montañas = {'nombre':[ 'Everest','K2','Kanchenjunga','Lhotse','Makalu', 30 | 'Cho Oyu','Dhaulagiri','Manaslu','Nanga Parbat','Annapurna I'], 31 | 'orden':[1,2,3,4,5,6,7,8,9,10], 32 | 'cordillera':['Himalaya','Karakórum','Himalaya','Himalaya','Himalaya' 33 | ,'Himalaya','Himalaya','Himalaya','Karakórum','Himalaya'], 34 | 'pais': ['Nepal','Pakistán','Nepal','Nepal','Nepal','Nepal','Nepal','Nepal', 35 | 'Pakistán','Nepal'], 36 | 'altura':[8849,8611,8586,8516,8485,8188,8167,8163,8125,8091]} 37 | ``` 38 | 39 | 4) Mostrar el tamaño en MB del archivo generado en el punto 3 40 | 41 | 5) Crear una carpeta llamada clase09_montañas_altas 42 | 43 | 6) Copiar el archivo clase09_ej3.scv en la carpeta clase09_montañas_altas usando la sentencia **os.system** 44 | 45 | 7) Listar el contenido de la carpeta clase09_montañas_altas -------------------------------------------------------------------------------- /M10_manejodearchivos/__pycache__/herramientas.cpython-39.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/soyHenry/Python-Prep/de9f7e7300b0b45fbd909a36983fa6064730c34d/M10_manejodearchivos/__pycache__/herramientas.cpython-39.pyc -------------------------------------------------------------------------------- /M10_manejodearchivos/clase09_ej1.py: -------------------------------------------------------------------------------- 1 | import sys 2 | # Comprobación de seguridad, ejecutar sólo si se recibe 3 argumentos 3 | if len(sys.argv) == 4: 4 | print("El primer parámetro es:",sys.argv[1]) 5 | print("El segundo parámetro es:",sys.argv[2]) 6 | print("El tercer parámetro es:",sys.argv[3]) 7 | else: 8 | print("ERROR: Introdujo una cantidad de argumentos distinta de tres (3)") 9 | print('Ejemplo: clase09_ej1.py 1 2 3') -------------------------------------------------------------------------------- /M10_manejodearchivos/clase09_ej2.csv: -------------------------------------------------------------------------------- 1 | timestamp,humedad,temperatura,lluvia 2 | 1645191499,29,45,False 3 | 1645191585,29,47,False 4 | 1645191620,27,50,False 5 | 1645191651,27,50,False 6 | 1645191869,30,40,False 7 | 1645191902,31,45,True 8 | -------------------------------------------------------------------------------- /M10_manejodearchivos/clase09_ej2.py: -------------------------------------------------------------------------------- 1 | import sys 2 | # Comprobación de seguridad, ejecutar sólo si se recibe 3 argumentos 3 | if len(sys.argv) == 2: 4 | import datetime 5 | import os 6 | marca_de_tiempo = datetime.datetime.now() 7 | marca_de_tiempo = int(datetime.datetime.timestamp(marca_de_tiempo)) 8 | 9 | #temperatura = sys.argv[1] 10 | #humedad = sys.argv[2] 11 | lluvia = sys.argv[1] 12 | temperatura = input('Ingrese la temperatura en grados centígrados') 13 | humedad = input('Ingrese el porcentaje de humedad') 14 | linea = str(marca_de_tiempo) + ',' + temperatura + ',' + humedad + ',' + lluvia 15 | 16 | logs_lluvia = open('clase09_ej2.csv', 'a') 17 | logs_lluvia.write(linea+'\n') 18 | logs_lluvia.close() 19 | 20 | else: 21 | print("ERROR: Introdujo una cantidad de argumentos distinta de tres (3)") 22 | print('Ejemplo: clase09_ej1.py ') -------------------------------------------------------------------------------- /M10_manejodearchivos/clase09_montañas_altas/clase09_ej3.csv: -------------------------------------------------------------------------------- 1 | nombre,orden,cordillera,pais,altura 2 | Everest,1,Himalaya,Nepal,8849 3 | K2,2,Karakórum,Pakistán,8611 4 | Kanchenjunga,3,Himalaya,Nepal,8586 5 | Lhotse,4,Himalaya,Nepal,8516 6 | Makalu,5,Himalaya,Nepal,8485 7 | Cho Oyu,6,Himalaya,Nepal,8188 8 | Dhaulagiri,7,Himalaya,Nepal,8167 9 | Manaslu,8,Himalaya,Nepal,8163 10 | Nanga Parbat,9,Karakórum,Pakistán,8125 11 | Annapurna I,10,Himalaya,Nepal,8091 12 | Aconcagua,11,Los Andes,Argentina,7000 13 | -------------------------------------------------------------------------------- /M10_manejodearchivos/datos.txt: -------------------------------------------------------------------------------- 1 | Esto es un archivo de ejemplo 2 | Segunda linea 3 | Tercera linea 4 | -------------------------------------------------------------------------------- /M10_manejodearchivos/ejemplo_parametros.py: -------------------------------------------------------------------------------- 1 | import sys 2 | # Comprobación de seguridad, ejecutar sólo si se reciben 2 3 | # argumentos realemente 4 | if len(sys.argv) == 3: 5 | texto = sys.argv[1] 6 | repeticiones = int(sys.argv[2]) 7 | for r in range(repeticiones): 8 | print(texto) 9 | else: 10 | print("ERROR: Introdujo uno (1) o más de dos (2) argumentos") 11 | print("SOLUCIÓN: Introduce los argumentos correctamente") 12 | print('Ejemplo: ejemplo_parametros.py "Texto" 5') 13 | 14 | print("El argumento 0 es el nombre del archivo:", sys.argv[0]) -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | ![HenryLogo](https://d31uz8lwfmyn8g.cloudfront.net/Assets/logo-henry-white-lg.png) 2 | 3 | 4 | # **🧑‍💻 PREP COURSE | HENRY 👩‍💻** 5 | 6 | ## **📌 INTRODUCCIÓN** 7 | 8 | ¡Hola 😄! Bienvenid@ al Prep Course para la carrera de Data Science 9 | 10 | En este curso introductorio podrás aprender y practicar todo el contenido que necesitas para alcanzar un nivel intermedio en Python, el lenguaje con el que vas a trabajar en la carrera. Encontrarás todo el material que necesitas para lograr avanzar en la evaluación del Henry Challenge (último paso para ingresar a la carrera de Data). 11 | 12 |
13 | 14 | ## **🔎 ¿QUÉ ES EL PREP COURSE?** 15 | 16 | El Prep Course (curso preparatorio) es un curso diseñado con la finalidad de nivelar a todos nuestros aplicantes. Con este curso darás tus primeros pasos en el mundo de la tecnología y aprenderás esos conceptos básicos que son necesarios para poder realizar la carrera. 17 | 18 | El curso consiste en una serie de videos, material teórico y ejercicios con los que podrás aprender nuestro lenguaje de desarrollo: Python. Puedes avanzar con el contenido a tu ritmo y de manera asincrónica (es decir, en los horarios y tiempos que tu prefieras).Una vez que hayas terminado de estudiarlo, podrás continuar con el contenido de matemática que se encuentra en: [Prep de Matemática](math.prep.soyhenry.com) 19 | Cuando hayas finalizado, podrás inscribirte para realizar el Henry Challenge. 20 | 21 |
22 | 23 | ## **📖 ¿QUÉ ES EL HENRY CHALLENGE?** 24 | 25 | Es un examen en el que evaluamos los conceptos que se aprenden durante el Prep Course. El examen tiene la finalidad de asegurarnos que realmente has adquirido los conocimientos, dado que tenerlos bien claros es la clave del éxito para que puedas avanzar sin problemas dentro de la carrera. El examen se realiza todos sábado por medio sábados, con previo registro e [inscripción](https://admissions.soyhenry.com/ ). Podrás rendirlo hasta 3 veces. Tambien incluye una evaluación de Matematica, pero solamente para conocer tu nivel. 26 | 27 |
28 | 29 | ## **🤨 ¿QUÉ PUEDO HACER SI TENGO DUDAS?** 30 | 31 | 32 | 33 | - **SLACK:** es nuestra plataforma de comunicación, donde podrás ponerte en contacto con nuestra comunidad que siempre te ayudará a resolver todas tus dudas. Encontrarás acceso a Slack desde la [plataforma de admisión](https://www.admissions.soyhenry.com/) o desde los mails que recibiste al momento de aplicar. 34 | 35 | 36 | 37 |
38 | 39 | ## **😋 ¿CÓMO AVANZAR EN ESTE PROCESO?** 40 | 41 | Para avanzar debes seguir el material teórico junto con los videos de este curso introductorio. Para afianzar tus conocimientos y comenzar a practicar realiza cada una de estas **_Homeworks_**. Esto te facilitará resolver el Henry Challenge. 42 | 43 | Cualquier duda, nos puedes escribir a admisiones@soyhenry.com 44 | 45 |
46 | -------------------------------------------------------------------------------- /Simulación Challenge/README.md: -------------------------------------------------------------------------------- 1 | # HENRY CHALLENGE - Python y Matemática 2 | 3 | ### Bienvenido al Henry Challenge sobre Python y Matemática para la carrera Data Science. 4 | 5 |

¡ Por favor lee TODO este material con atención !

6 | 7 | ## INTRODUCCION 8 | 9 | El Henry Challenge es un desafío técnico donde evaluamos conceptos básicos sobre Python. 10 | En esta instancia, buscamos asegurarnos que todos nuestros aplicantes tengan una base de conocimientos mínimos necesarios para luego seguir aprendiendo temas nuevos. 11 | 12 | >El Challenge debe resolverse de manera individual. Si te copias o recibes ayuda de compañeros, además de estar incumpliendo con las normas de Henry (lo que te dejaría afuera de la carrera), estarás perjudicándote a ti mismo, porque el primer día de clase estarías extremadamente perdido. 13 | 14 | ¿Se puede volver a rendir el HC? 15 | - Si, el HC se puede rendir tantas veces como ustedes quieran! No hay límite de intentos. 16 | 17 | ¿Qué hago una vez entregado el HC? 18 | - ¡A esperar! Los van a estar contactando en un plazo no mayor a una semana para confirmarles, tanto si quedaron, como si no lo hicieron. 19 | 20 | ## PASOS PARA RESOLVER EL CHECKPOINT: 21 | 22 | ### 1. FORK 23 | 24 | Primero debes forkear este repo, haciendo click en el botón `fork` de arriba a la derecha. 25 | 26 | Una vez que tengas una copia de este repo en tu cuenta de `github`, cloná el repo dentro de una nueva carpeta (asegurate de no utilizar la misma que el prep curse). Una vez clonado entrá a esa carpeta y ejecutá los siguientes comandos: 27 | 28 | python tests.py 29 | 30 | >Si ves los tests fallando, estás listo para comenzar, si no lee bien el output para identificar el error. 31 | 32 | 33 | ### 2. RESOLVER EL CHALLENGE DE PYTHON 34 | 35 | Tu tarea es completar el código en `checkpoint.py` de tal forma que pasen la mayoría de los tests, incluido el extra credit. 36 | 37 | ### 3. RESOLVER EL CHALLENGE DE MATEMÁTICA 38 | 39 | Tu tarea será leer el enunciado y resolverlo en el formulario que se adjunta. 40 | 41 | ### 4. ENTREGAR TU CHECKPOINT 42 | 43 | Correr por ultima vez los tests y verificar cuantos pasan. Ten en cuenta que si te aparece "1 failed;1 total" es porque tienes un error de sintaxis: seguramente falta o sobra un corchete, paréntesis, dos puntos, etc. 44 | Saca un print de pantalla de tus tests. 45 | Luego, debes subir un commit a tu repo. Para hacerlo, debes ejecutar el siguiente comando: 46 | 47 | git add . 48 | git commit -m 'checkpoint commit' 49 | git push origin main 50 | 51 | Una vez finalizado, chequea: 52 | 1. Que veas los cambios reflejados en el repo de tu cuenta de github (entrando a tu repo desde el browser.) 53 | 2. Que no haya un require - solo debe haber codigo dentro de las funciones de cada ejercicio 54 | 55 | 56 | Atención: no debes realizar un commit después de la hora de entrega porque se anulara la totalidad del examen. 57 | >Revisar la hora del entrega del examen en los emails que te llegaron. 58 | 59 | ### ¿TENES ALGUN PROBLEMA / CONSULTA? 60 | 61 | 1. Busca la solución en la "guía de errores comunes". 62 | 63 | 2. Si no la encuentras, revisa el canal de #henry_challenge en Slack. Probablemente a algún compañero le paso algo similar y ya lo consulto. 64 | 65 | 3. Si no encuentras la respuesta, puedes publicar un mensaje en dicho canal. 66 | 67 | > No se puede hacer consultas sobre la resolucion de los ejercicios. 68 | 69 | ### GUIA DE ERRORES COMUNES 70 | 71 | Para identificar el error, vas a tener que leerlo en la consola. 72 | 73 | * 1 failed, 1 total: 74 | 1. Tenes un error de sintaxis. Revisa el último ejercicio que hayas hecho, seguramente falta o sobra un corchete, paréntesis, dos puntos, etc. 75 | 76 | * Author identity unknown. 77 | 1. Intenta ejecutar los siguientes comandos para configurar tu cuenta: 78 | * git config --global user.name "Tu usuario de GitHub aca" 79 | * git config --global user.email "Tu email aca" 80 | 81 | 2. Ingresa a [Github](https://docs.github.com/es/authentication/keeping-your-account-and-data-secure/creating-a-personal-access-token) y sigue las instrucciones para configurar tu token. 82 | 83 | * La consola se tilda en `Runs`: 84 | 1. Revisa tu código, tenes un bucle infinito. Tenes que checkear la condición de corte de tus bucles. 85 | -------------------------------------------------------------------------------- /Simulación Challenge/checkpoint.py: -------------------------------------------------------------------------------- 1 | # Importante: No modificar ni el nombre ni los argumetos que reciben las funciones, sólo deben escribir 2 | # código dentro de las funciones ya definidas. 3 | 4 | def Factorial(numero): 5 | ''' 6 | Esta función devuelve el factorial del número pasado como parámetro. 7 | En caso de que no sea de tipo entero y/o sea menor que 1, debe retornar nulo. 8 | Recibe un argumento: 9 | numero: Será el número con el que se calcule el factorial 10 | Ej: 11 | Factorial(4) debe retornar 24 12 | Factorial(-2) debe retornar nulo 13 | ''' 14 | #Tu código aca: 15 | return 'Funcion incompleta' 16 | 17 | def EsPrimo(valor): 18 | ''' 19 | Esta función devuelve el valor booleano True si el número reibido como parámetro es primo, de lo 20 | contrario devuelve False.. 21 | En caso de que el parámetro no sea de tipo entero debe retornar nulo. 22 | Recibe un argumento: 23 | valor: Será el número a evaluar 24 | Ej: 25 | EsPrimo(7) debe retornar True 26 | EsPrimo(8) debe retornar False 27 | ''' 28 | #Tu código aca: 29 | return 'Funcion incompleta' 30 | 31 | def ClaseAnimal(especie, color): 32 | ''' 33 | Esta función devuelve un objeto instanciado de la clase Animal, 34 | la cual debe tener los siguientes atributos: 35 | Edad (Un valor de tipo de dato entero, que debe inicializarse en cero) 36 | Especie (Un valor de tipo de dato string) 37 | Color (Un valor de tipo de dato string) 38 | y debe tener el siguiente método: 39 | CumplirAnios (este método debe sumar uno al atributo Edad y debe devolver ese valor) 40 | Recibe dos argumento: 41 | especie: Dato que se asignará al atributo Especie del objeto de la clase Animal 42 | color: Dato que se asignará al atributo Color del objeto de la clase Animal 43 | Ej: 44 | a = ClaseAnimal('perro','blanco') 45 | a.CumpliAnios() -> debe devolver 1 46 | a.CumpliAnios() -> debe devolver 2 47 | a.CumpliAnios() -> debe devolver 3 48 | ''' 49 | #Tu código aca: 50 | return 'Funcion incompleta' 51 | -------------------------------------------------------------------------------- /Simulación Challenge/checkpoint_Resuelto.py: -------------------------------------------------------------------------------- 1 | # Importante: No modificar ni el nombre ni los argumetos que reciben las funciones, sólo deben escribir 2 | # código dentro de las funciones ya definidas. 3 | 4 | def Factorial(numero): 5 | ''' 6 | Esta función devuelve el factorial del número pasado como parámetro. 7 | En caso de que no sea de tipo entero y/o sea menor que 1, debe retornar nulo. 8 | Recibe un argumento: 9 | numero: Será el número con el que se calcule el factorial 10 | Ej: 11 | Factorial(4) debe retornar 24 12 | Factorial(-2) debe retornar nulo 13 | ''' 14 | #Tu código aca: 15 | if type(numero) != int: 16 | return None 17 | if numero < 1: 18 | return None 19 | factorial = 1 20 | while (numero > 1): 21 | factorial = factorial * numero #(factorial*=numero) 22 | numero = numero - 1 #(numero-=1) 23 | return factorial 24 | 25 | def EsPrimo(valor): 26 | ''' 27 | Esta función devuelve el valor booleano True si el número reibido como parámetro es primo, de lo 28 | contrario devuelve False.. 29 | En caso de que el parámetro no sea de tipo entero debe retornar nulo. 30 | Recibe un argumento: 31 | valor: Será el número a evaluar 32 | Ej: 33 | EsPrimo(7) debe retornar True 34 | EsPrimo(8) debe retornar False 35 | ''' 36 | #Tu código aca: 37 | if type(valor) != int: 38 | return None 39 | 40 | primo = True 41 | for i in range(2,valor): 42 | if (valor%i == 0): 43 | primo = False 44 | break 45 | return primo 46 | 47 | def ClaseAnimal(especie, color): 48 | ''' 49 | Esta función devuelve un objeto instanciado de la clase Animal, 50 | la cual debe tener los siguientes atributos: 51 | Edad (Un valor de tipo de dato entero, que debe inicializarse en cero) 52 | Especie (Un valor de tipo de dato string) 53 | Color (Un valor de tipo de dato string) 54 | y debe tener el siguiente método: 55 | CumplirAnios (este método debe sumar uno al atributo Edad y debe devolver ese valor) 56 | Recibe dos argumento: 57 | especie: Dato que se asignará al atributo Especie del objeto de la clase Animal 58 | color: Dato que se asignará al atributo Color del objeto de la clase Animal 59 | Ej: 60 | a = ClaseAnimal('perro','blanco') 61 | a.CumpliAnios() -> debe devolver 1 62 | a.CumpliAnios() -> debe devolver 2 63 | a.CumpliAnios() -> debe devolver 3 64 | ''' 65 | #Tu código aca: 66 | class Animal: 67 | def __init__(self, especie, color): 68 | self.edad = 0 69 | self.especie = especie 70 | self.color = color 71 | 72 | def CumplirAnios(self): 73 | self.edad = self.edad + 1 #(self.edad += 1) 74 | return self.edad 75 | 76 | return Animal(especie,color) 77 | -------------------------------------------------------------------------------- /Simulación Challenge/tests.py: -------------------------------------------------------------------------------- 1 | import unittest 2 | import os 3 | import checkpoint as ch 4 | 5 | class PruebaHenryChallenge(unittest.TestCase): 6 | 7 | def test_Factorial_01(self): 8 | valor_test = ch.Factorial(5) 9 | valor_esperado = 120 10 | self.assertEqual(valor_test, valor_esperado) 11 | 12 | def test_Factorial_02(self): 13 | valor_test = ch.Factorial(1) 14 | valor_esperado = 1 15 | self.assertEqual(valor_test, valor_esperado) 16 | 17 | def test_Factorial_03(self): 18 | valor_test = ch.Factorial(0) 19 | valor_esperado = None 20 | self.assertEqual(valor_test, valor_esperado) 21 | 22 | def test_EsPrimo_01(self): 23 | valor_test = ch.EsPrimo(5) 24 | valor_esperado = True 25 | self.assertEqual(valor_test, valor_esperado) 26 | 27 | def test_EsPrimo_02(self): 28 | valor_test = ch.EsPrimo(27) 29 | valor_esperado = False 30 | self.assertEqual(valor_test, valor_esperado) 31 | 32 | def test_EsPrimo_03(self): 33 | valor_test = ch.EsPrimo('parametro incorrecto') 34 | valor_esperado = None 35 | self.assertEqual(valor_test, valor_esperado) 36 | 37 | def test_ClaseAnimal_01(self): 38 | a = ch.ClaseAnimal('perro','negro') 39 | valor_test = a.CumplirAnios() 40 | valor_test = a.CumplirAnios() 41 | valor_test = a.CumplirAnios() 42 | valor_esperado = 3 43 | self.assertEqual(valor_test, valor_esperado) 44 | 45 | def test_ClaseAnimal_02(self): 46 | a = ch.ClaseAnimal('ballena','azul') 47 | for i in range(0,10): 48 | valor_test = a.CumplirAnios() 49 | valor_esperado = 10 50 | self.assertEqual(valor_test, valor_esperado) 51 | 52 | def test_ClaseAnimal_03(self): 53 | a = ch.ClaseAnimal('tortuga','verde') 54 | for i in range(0,100): 55 | valor_test = a.CumplirAnios() 56 | valor_esperado = 100 57 | self.assertEqual(valor_test, valor_esperado) 58 | 59 | resultado_test = unittest.main(argv=[''], verbosity=2, exit=False) 60 | 61 | hc_tests = resultado_test.result.testsRun 62 | hc_fallas = len(resultado_test.result.failures) 63 | hc_errores = len(resultado_test.result.errors) 64 | hc_ok = hc_tests - hc_fallas - hc_errores 65 | 66 | archivo_test = open('resultado_test.csv', 'w') 67 | archivo_test.write('Total_Tests,Total_Fallas,Total_Errores,Total_Correctos\n') 68 | archivo_test.write(str(hc_tests)+','+str(hc_fallas)+','+str(hc_errores)+','+str(hc_ok)+'\n') 69 | archivo_test.close() 70 | 71 | print('Resumen') 72 | print('Total Tests:', str(hc_tests)) 73 | print('Total Fallas:', str(hc_fallas)) 74 | print('Total Errores:', str(hc_errores)) 75 | print('Total Correctos:', str(hc_ok)) -------------------------------------------------------------------------------- /_src/assets/00-PrimerosPasos/1.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/soyHenry/Python-Prep/de9f7e7300b0b45fbd909a36983fa6064730c34d/_src/assets/00-PrimerosPasos/1.png -------------------------------------------------------------------------------- /_src/assets/00-PrimerosPasos/2.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/soyHenry/Python-Prep/de9f7e7300b0b45fbd909a36983fa6064730c34d/_src/assets/00-PrimerosPasos/2.png -------------------------------------------------------------------------------- /_src/assets/00-PrimerosPasos/3.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/soyHenry/Python-Prep/de9f7e7300b0b45fbd909a36983fa6064730c34d/_src/assets/00-PrimerosPasos/3.png -------------------------------------------------------------------------------- /_src/assets/00-PrimerosPasos/4.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/soyHenry/Python-Prep/de9f7e7300b0b45fbd909a36983fa6064730c34d/_src/assets/00-PrimerosPasos/4.png -------------------------------------------------------------------------------- /_src/assets/00-PrimerosPasos/5.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/soyHenry/Python-Prep/de9f7e7300b0b45fbd909a36983fa6064730c34d/_src/assets/00-PrimerosPasos/5.png -------------------------------------------------------------------------------- /_src/assets/00-PrimerosPasos/atom_logo.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/soyHenry/Python-Prep/de9f7e7300b0b45fbd909a36983fa6064730c34d/_src/assets/00-PrimerosPasos/atom_logo.png -------------------------------------------------------------------------------- /_src/assets/00-PrimerosPasos/atom_site.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/soyHenry/Python-Prep/de9f7e7300b0b45fbd909a36983fa6064730c34d/_src/assets/00-PrimerosPasos/atom_site.png -------------------------------------------------------------------------------- /_src/assets/00-PrimerosPasos/consola.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/soyHenry/Python-Prep/de9f7e7300b0b45fbd909a36983fa6064730c34d/_src/assets/00-PrimerosPasos/consola.png -------------------------------------------------------------------------------- /_src/assets/00-PrimerosPasos/dowload_vc.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/soyHenry/Python-Prep/de9f7e7300b0b45fbd909a36983fa6064730c34d/_src/assets/00-PrimerosPasos/dowload_vc.png -------------------------------------------------------------------------------- /_src/assets/00-PrimerosPasos/git_logo.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/soyHenry/Python-Prep/de9f7e7300b0b45fbd909a36983fa6064730c34d/_src/assets/00-PrimerosPasos/git_logo.png -------------------------------------------------------------------------------- /_src/assets/00-PrimerosPasos/github_home.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/soyHenry/Python-Prep/de9f7e7300b0b45fbd909a36983fa6064730c34d/_src/assets/00-PrimerosPasos/github_home.png -------------------------------------------------------------------------------- /_src/assets/00-PrimerosPasos/github_login.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/soyHenry/Python-Prep/de9f7e7300b0b45fbd909a36983fa6064730c34d/_src/assets/00-PrimerosPasos/github_login.png -------------------------------------------------------------------------------- /_src/assets/00-PrimerosPasos/github_logo.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/soyHenry/Python-Prep/de9f7e7300b0b45fbd909a36983fa6064730c34d/_src/assets/00-PrimerosPasos/github_logo.png -------------------------------------------------------------------------------- /_src/assets/00-PrimerosPasos/github_profile.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/soyHenry/Python-Prep/de9f7e7300b0b45fbd909a36983fa6064730c34d/_src/assets/00-PrimerosPasos/github_profile.png -------------------------------------------------------------------------------- /_src/assets/00-PrimerosPasos/github_register.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/soyHenry/Python-Prep/de9f7e7300b0b45fbd909a36983fa6064730c34d/_src/assets/00-PrimerosPasos/github_register.png -------------------------------------------------------------------------------- /_src/assets/00-PrimerosPasos/github_repo.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/soyHenry/Python-Prep/de9f7e7300b0b45fbd909a36983fa6064730c34d/_src/assets/00-PrimerosPasos/github_repo.png -------------------------------------------------------------------------------- /_src/assets/00-PrimerosPasos/instalar_window.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/soyHenry/Python-Prep/de9f7e7300b0b45fbd909a36983fa6064730c34d/_src/assets/00-PrimerosPasos/instalar_window.png -------------------------------------------------------------------------------- /_src/assets/00-PrimerosPasos/nodejs_logo.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/soyHenry/Python-Prep/de9f7e7300b0b45fbd909a36983fa6064730c34d/_src/assets/00-PrimerosPasos/nodejs_logo.png -------------------------------------------------------------------------------- /_src/assets/00-PrimerosPasos/nodejs_screen.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/soyHenry/Python-Prep/de9f7e7300b0b45fbd909a36983fa6064730c34d/_src/assets/00-PrimerosPasos/nodejs_screen.png -------------------------------------------------------------------------------- /_src/assets/00-PrimerosPasos/sublimeText_download.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/soyHenry/Python-Prep/de9f7e7300b0b45fbd909a36983fa6064730c34d/_src/assets/00-PrimerosPasos/sublimeText_download.png -------------------------------------------------------------------------------- /_src/assets/00-PrimerosPasos/sublimeText_linux.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/soyHenry/Python-Prep/de9f7e7300b0b45fbd909a36983fa6064730c34d/_src/assets/00-PrimerosPasos/sublimeText_linux.png -------------------------------------------------------------------------------- /_src/assets/00-PrimerosPasos/sublimeText_logo.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/soyHenry/Python-Prep/de9f7e7300b0b45fbd909a36983fa6064730c34d/_src/assets/00-PrimerosPasos/sublimeText_logo.png -------------------------------------------------------------------------------- /_src/assets/00-PrimerosPasos/sublimeText_screen.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/soyHenry/Python-Prep/de9f7e7300b0b45fbd909a36983fa6064730c34d/_src/assets/00-PrimerosPasos/sublimeText_screen.png -------------------------------------------------------------------------------- /_src/assets/00-PrimerosPasos/vsc_console.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/soyHenry/Python-Prep/de9f7e7300b0b45fbd909a36983fa6064730c34d/_src/assets/00-PrimerosPasos/vsc_console.png -------------------------------------------------------------------------------- /_src/assets/00-PrimerosPasos/vsc_download.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/soyHenry/Python-Prep/de9f7e7300b0b45fbd909a36983fa6064730c34d/_src/assets/00-PrimerosPasos/vsc_download.png -------------------------------------------------------------------------------- /_src/assets/00-PrimerosPasos/vsc_logo.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/soyHenry/Python-Prep/de9f7e7300b0b45fbd909a36983fa6064730c34d/_src/assets/00-PrimerosPasos/vsc_logo.png -------------------------------------------------------------------------------- /_src/assets/01_imagen01.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/soyHenry/Python-Prep/de9f7e7300b0b45fbd909a36983fa6064730c34d/_src/assets/01_imagen01.jpg -------------------------------------------------------------------------------- /_src/assets/02_imagen01.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/soyHenry/Python-Prep/de9f7e7300b0b45fbd909a36983fa6064730c34d/_src/assets/02_imagen01.jpg -------------------------------------------------------------------------------- /_src/assets/02_imagen07.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/soyHenry/Python-Prep/de9f7e7300b0b45fbd909a36983fa6064730c34d/_src/assets/02_imagen07.jpg -------------------------------------------------------------------------------- /_src/assets/06_Referencia_Valor.gif: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/soyHenry/Python-Prep/de9f7e7300b0b45fbd909a36983fa6064730c34d/_src/assets/06_Referencia_Valor.gif -------------------------------------------------------------------------------- /_src/assets/1.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/soyHenry/Python-Prep/de9f7e7300b0b45fbd909a36983fa6064730c34d/_src/assets/1.png -------------------------------------------------------------------------------- /_src/assets/2.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/soyHenry/Python-Prep/de9f7e7300b0b45fbd909a36983fa6064730c34d/_src/assets/2.png -------------------------------------------------------------------------------- /_src/data/config.json: -------------------------------------------------------------------------------- 1 | { 2 | "repoTitle": "Python - Prep Course", 3 | "airtableFormId": "shra8F6NjMaKPeNgc" 4 | } 5 | -------------------------------------------------------------------------------- /_src/data/layout.js: -------------------------------------------------------------------------------- 1 | module.exports = 'lesson.njk' 2 | -------------------------------------------------------------------------------- /_src/data/styles/code.js: -------------------------------------------------------------------------------- 1 | const Cache = require('@11ty/eleventy-cache-assets') 2 | 3 | module.exports = async function () { 4 | const url = 'https://d31uz8lwfmyn8g.cloudfront.net/Styles/code.css' 5 | const style = await Cache(url, { 6 | duration: '1d', 7 | type: 'txt', 8 | directory: '_cache' 9 | }) 10 | return style 11 | } 12 | -------------------------------------------------------------------------------- /_src/data/styles/fonts.js: -------------------------------------------------------------------------------- 1 | const Cache = require('@11ty/eleventy-cache-assets') 2 | 3 | module.exports = async function () { 4 | const url = 'https://d31uz8lwfmyn8g.cloudfront.net/Styles/fonts.css' 5 | const style = await Cache(url, { 6 | duration: '1d', 7 | type: 'txt', 8 | directory: '_cache' 9 | }) 10 | return style 11 | } 12 | -------------------------------------------------------------------------------- /_src/data/styles/footer.js: -------------------------------------------------------------------------------- 1 | const Cache = require('@11ty/eleventy-cache-assets') 2 | 3 | module.exports = async function () { 4 | const url = 'https://d31uz8lwfmyn8g.cloudfront.net/Styles/footer.css' 5 | const style = await Cache(url, { 6 | duration: '1d', 7 | type: 'txt', 8 | directory: '_cache' 9 | }) 10 | return style 11 | } 12 | -------------------------------------------------------------------------------- /_src/data/styles/header.js: -------------------------------------------------------------------------------- 1 | const Cache = require('@11ty/eleventy-cache-assets') 2 | 3 | module.exports = async function () { 4 | const url = 'https://d31uz8lwfmyn8g.cloudfront.net/Styles/header.css' 5 | const style = await Cache(url, { 6 | duration: '1d', 7 | type: 'txt', 8 | directory: '_cache' 9 | }) 10 | return style 11 | } 12 | -------------------------------------------------------------------------------- /_src/data/styles/lesson.js: -------------------------------------------------------------------------------- 1 | const Cache = require('@11ty/eleventy-cache-assets') 2 | 3 | module.exports = async function () { 4 | const url = 'https://d31uz8lwfmyn8g.cloudfront.net/Styles/lesson.css' 5 | const style = await Cache(url, { 6 | duration: '1d', 7 | type: 'txt', 8 | directory: '_cache' 9 | }) 10 | return style 11 | } 12 | -------------------------------------------------------------------------------- /_src/data/styles/lessonIntro.js: -------------------------------------------------------------------------------- 1 | const Cache = require('@11ty/eleventy-cache-assets') 2 | 3 | module.exports = async function () { 4 | const url = 'https://d31uz8lwfmyn8g.cloudfront.net/Styles/lessonIntro.css' 5 | const style = await Cache(url, { 6 | duration: '1d', 7 | type: 'txt', 8 | directory: '_cache' 9 | }) 10 | return style 11 | } 12 | -------------------------------------------------------------------------------- /_src/data/styles/main.js: -------------------------------------------------------------------------------- 1 | const Cache = require('@11ty/eleventy-cache-assets') 2 | 3 | module.exports = async function () { 4 | const url = 'https://d31uz8lwfmyn8g.cloudfront.net/Styles/main.css' 5 | const style = await Cache(url, { 6 | duration: '1d', 7 | type: 'txt', 8 | directory: '_cache' 9 | }) 10 | return style 11 | } 12 | -------------------------------------------------------------------------------- /_src/data/styles/responsive.js: -------------------------------------------------------------------------------- 1 | const Cache = require('@11ty/eleventy-cache-assets') 2 | 3 | module.exports = async function () { 4 | const url = 'https://d31uz8lwfmyn8g.cloudfront.net/Styles/responsive.css' 5 | const style = await Cache(url, { 6 | duration: '1d', 7 | type: 'txt', 8 | directory: '_cache' 9 | }) 10 | return style 11 | } 12 | -------------------------------------------------------------------------------- /_src/data/styles/sidebar.js: -------------------------------------------------------------------------------- 1 | const Cache = require('@11ty/eleventy-cache-assets') 2 | 3 | module.exports = async function () { 4 | const url = 'https://d31uz8lwfmyn8g.cloudfront.net/Styles/sidebar.css' 5 | const style = await Cache(url, { 6 | duration: '1d', 7 | type: 'txt', 8 | directory: '_cache' 9 | }) 10 | return style 11 | } 12 | -------------------------------------------------------------------------------- /_src/data/styles/topbar.js: -------------------------------------------------------------------------------- 1 | const Cache = require('@11ty/eleventy-cache-assets') 2 | 3 | module.exports = async function () { 4 | const url = 'https://d31uz8lwfmyn8g.cloudfront.net/Styles/topbar.css' 5 | const style = await Cache(url, { 6 | duration: '1d', 7 | type: 'txt', 8 | directory: '_cache' 9 | }) 10 | return style 11 | } 12 | -------------------------------------------------------------------------------- /_src/layouts/intro.njk: -------------------------------------------------------------------------------- 1 | --- 2 | logoNav: 'https://d31uz8lwfmyn8g.cloudfront.net/Assets/logo-henry-white-sm.png' 3 | favicon: 'https://d31uz8lwfmyn8g.cloudfront.net/Assets/favicon.png' 4 | --- 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | {{ config.repoTitle }} 16 | 17 | {% set css %} 18 | {{ styles.fonts | safe }} 19 | {{ styles.header | safe }} 20 | {{ styles.main | safe }} 21 | {{ styles.topbar | safe }} 22 | {{ styles.sidebar | safe }} 23 | {{ styles.lessonIntro | safe }} 24 | {{ styles.code | safe }} 25 | {{ styles.footer | safe }} 26 | {{ styles.responsive | safe }} 27 | {% endset %} 28 | 29 | 32 | 33 | 34 | 35 | 36 |
37 |
38 | logo Henry{{ config.repoTitle }} 39 |
40 |
41 | 42 | 43 | 44 | 47 |
48 |
49 | 50 |
51 |
52 | logo Henry 53 |
54 | {{ config.repoTitle }} 55 |
56 |
57 |
58 | 59 |
60 |
61 | {# Navigation #} 62 | {{ collections.all | eleventyNavigation | bootstrapNav({ 63 | listChildItemClass: "dropdown-menu shadow", 64 | activeKey: eleventyNavigation.key, 65 | listItemClass: "link", 66 | activeListItemClass: "activeLink" 67 | }) | safe }} 68 |
69 | 70 |
71 |
72 | {# Lesson (markdown content) #} 73 | {{ content | safe }} 74 |
75 |
76 | 77 |
78 | 79 | 80 | -------------------------------------------------------------------------------- /_src/layouts/lesson.njk: -------------------------------------------------------------------------------- 1 | --- 2 | logoNav: 'https://d31uz8lwfmyn8g.cloudfront.net/Assets/logo-henry-white-sm.png' 3 | favicon: 'https://d31uz8lwfmyn8g.cloudfront.net/Assets/favicon.png' 4 | --- 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | {{ lessonTitle }} | {{ config.repoTitle }} 16 | {# #} 17 | 18 | {% set css %} 19 | {{ styles.fonts | safe }} 20 | {{ styles.header | safe }} 21 | {{ styles.main | safe }} 22 | {{ styles.topbar | safe }} 23 | {{ styles.sidebar | safe }} 24 | {{ styles.lesson | safe }} 25 | {{ styles.code | safe }} 26 | {{ styles.footer | safe }} 27 | {{ styles.responsive | safe }} 28 | {% endset %} 29 | 30 | 33 | 34 | 35 | 36 | 37 |
38 | 39 |
40 |
41 | logo Henry{{ lessonTitle }} 42 |
43 |
44 | 45 | 46 | 47 | 50 |
51 |
52 | 53 |
54 |
55 | logo Henry 56 |
57 | {{ lessonTitle }} | {{ config.repoTitle }} 58 |
59 |
60 |
61 | 62 |
63 |
64 | {# Navigation #} 65 | {{ collections.all | eleventyNavigation | bootstrapNav({ 66 | listChildItemClass: "dropdown-menu shadow", 67 | activeKey: eleventyNavigation.key, 68 | listItemClass: "link", 69 | activeListItemClass: "activeLink" 70 | }) | safe }} 71 |
72 | 73 |
74 |
75 | Contenido de la clase 76 |
77 |
78 | {# Table of contents #} 79 | {{ content | toc | safe }} 80 |
81 |
82 | 83 |
84 |
85 | Tiempo de lectura {{ content | readingTime }} 86 |
87 | {% if quizzID %} 88 |
89 | Quizz 📚 90 |
91 | {% endif %} 92 | 93 | {% if homeworkUrl %} 94 |
95 | Homework 📝 96 |
97 | {% endif %} 98 |
99 | 100 |
101 | {# Lesson (markdown content) #} 102 | {{ content | safe }} 103 |
104 | 105 |
106 | 107 | {% if feedbackID %} 108 | 113 | {% endif %} 114 | 115 |
116 |
117 |

Hecho con 💛 por alumnos de Henry

118 |
119 |
120 | 121 |
122 | {% readerBar "3px", 123 | "black", 124 | "yellow" %} 125 |
126 | 127 | 128 | --------------------------------------------------------------------------------