├── images ├── di.png ├── if.png ├── tabla1.png ├── utfsm.png ├── while.png ├── if-else.png ├── variable.jpg ├── if-elif-else.png ├── leche_huevos.png ├── asignacion_var.jpg └── diagrama_flujo.pdf ├── README.md ├── Clase15_Listas_Problemas_2019.ipynb ├── Clase02_Uso_Trinket_2019.ipynb ├── Clase07_Funciones_2019.ipynb ├── Clase08_Funciones_Ciclos_2019.ipynb ├── Clase01_Intro_Programacion_2019.ipynb ├── Clase03_Algoritmos_Trinket_2019.ipynb ├── Clase06_Ciclos_2019.ipynb └── Clase17_Tuplas_2019.ipynb /images/di.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/gonzalezf/Computer-Programming-IWI-131/main/images/di.png -------------------------------------------------------------------------------- /images/if.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/gonzalezf/Computer-Programming-IWI-131/main/images/if.png -------------------------------------------------------------------------------- /images/tabla1.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/gonzalezf/Computer-Programming-IWI-131/main/images/tabla1.png -------------------------------------------------------------------------------- /images/utfsm.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/gonzalezf/Computer-Programming-IWI-131/main/images/utfsm.png -------------------------------------------------------------------------------- /images/while.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/gonzalezf/Computer-Programming-IWI-131/main/images/while.png -------------------------------------------------------------------------------- /images/if-else.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/gonzalezf/Computer-Programming-IWI-131/main/images/if-else.png -------------------------------------------------------------------------------- /images/variable.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/gonzalezf/Computer-Programming-IWI-131/main/images/variable.jpg -------------------------------------------------------------------------------- /images/if-elif-else.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/gonzalezf/Computer-Programming-IWI-131/main/images/if-elif-else.png -------------------------------------------------------------------------------- /images/leche_huevos.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/gonzalezf/Computer-Programming-IWI-131/main/images/leche_huevos.png -------------------------------------------------------------------------------- /images/asignacion_var.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/gonzalezf/Computer-Programming-IWI-131/main/images/asignacion_var.jpg -------------------------------------------------------------------------------- /images/diagrama_flujo.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/gonzalezf/Computer-Programming-IWI-131/main/images/diagrama_flujo.pdf -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | ### Computer-Programming-IWI-131 2 | Python programming classes for freshman engineering students at Universidad Técnica Federico Santa María, Chile 3 | 4 | **Descripción de la Asignatura**: La asignatura Programación de Computadores (sigla IWI-131) forma parte de los planes de estudio de todas las carreras de Ingeniería nivel Civil de la UTFSM, y tiene por objetivo principal desarrollar en los estudiantes el pensamiento algorítmico para resolver problemas de ingeniería empleando un lenguaje de programación estructurada. 5 | 6 | * Créditos USM : 3 7 | * Créditos SCT : 5 8 | * Prerequisitos: No tiene. 9 | * Eje Formativo: Ciencias de la Ingeniería. 10 | 11 | **Resultados del aprendizaje**: Al aprobar la asignatura el alumno será capaz de: 12 | 13 | * Implementar programas utilizando una metodología algorítmica y aplicar las estructuras de control de un lenguaje de programación. 14 | * Resolver diversos problemas aplicando subprogramas y estructuras de datos básicas como listas y diccionarios. 15 | * Implementar programas de ingeniería utilizando archivos de textos y bibliotecas avanzadas. 16 | 17 | **Actividades de la Asignatura**: 18 | * Clase de cátedra (en la sala de clases), 19 | * actividades en equipo (en la sala de clases) y, 20 | * ayudantía en laboratorio (en laboratorio). 21 | 22 | **Contenidos**: 23 | 1. Introducción y reglas del curso 24 | 2. Introducción a Trinket 25 | 3. Algoritmos en Trinket 26 | 4. Introducción a Python 3.X 27 | 5. Estructuras condicionales 28 | 6. Estructura de repetición WHILE 29 | 7. Funciones 30 | 8. Definición de funciones avanzadas 31 | 9. Strings y ciclos 32 | 10. Listas y ciclo FOR 33 | 11. Ejercicios de Listas 34 | 12. Listas bi-dimensionales 35 | 13. Tuplas 36 | 14. Diccionarios 37 | 15. Procesamiento de texto 38 | 16. Archivo de texto 39 | -------------------------------------------------------------------------------- /Clase15_Listas_Problemas_2019.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": { 6 | "slideshow": { 7 | "slide_type": "slide" 8 | } 9 | }, 10 | "source": [ 11 | "\"\"\n", 12 | "\"\"\n", 13 | "\n", 14 | "
\n", 15 | "
\n", 16 | "

IWI131 Programación


\n", 17 | "

Resolución de Problemas con Listas

\n", 18 | "

\n", 19 | "Departamento de Informática
\n", 20 | "Universidad Técnica Federico Santa María\n", 21 | "
" 22 | ] 23 | }, 24 | { 25 | "cell_type": "markdown", 26 | "metadata": { 27 | "slideshow": { 28 | "slide_type": "slide" 29 | } 30 | }, 31 | "source": [ 32 | "## WARNING: Copiado de listas\n", 33 | "Es necesario tener precaución cuando se intenta copiar una lista." 34 | ] 35 | }, 36 | { 37 | "cell_type": "code", 38 | "execution_count": null, 39 | "metadata": { 40 | "slideshow": { 41 | "slide_type": "fragment" 42 | } 43 | }, 44 | "outputs": [], 45 | "source": [ 46 | "a = list(\"514\")\n", 47 | "b = a\n", 48 | "b[0] = 1000\n", 49 | "print(\"a=\",a)\n", 50 | "print(\"b=\",b)" 51 | ] 52 | }, 53 | { 54 | "cell_type": "markdown", 55 | "metadata": { 56 | "slideshow": { 57 | "slide_type": "fragment" 58 | } 59 | }, 60 | "source": [ 61 | "¿Cómo solucionar el problema anterior?" 62 | ] 63 | }, 64 | { 65 | "cell_type": "code", 66 | "execution_count": null, 67 | "metadata": { 68 | "slideshow": { 69 | "slide_type": "fragment" 70 | } 71 | }, 72 | "outputs": [], 73 | "source": [ 74 | "a = list(\"514\")\n", 75 | "b = list(a)\n", 76 | "b[0] = 1000\n", 77 | "print(\"a=\",a)\n", 78 | "print(\"b=\",b)" 79 | ] 80 | }, 81 | { 82 | "cell_type": "markdown", 83 | "metadata": { 84 | "slideshow": { 85 | "slide_type": "slide" 86 | } 87 | }, 88 | "source": [ 89 | "## WARNING: Copiado de listas\n", 90 | "Esto también afecta a las funciones." 91 | ] 92 | }, 93 | { 94 | "cell_type": "code", 95 | "execution_count": null, 96 | "metadata": { 97 | "slideshow": { 98 | "slide_type": "fragment" 99 | } 100 | }, 101 | "outputs": [], 102 | "source": [ 103 | "def funcion_malvada(lista):\n", 104 | " lista.append(10)\n", 105 | " return sum(lista)" 106 | ] 107 | }, 108 | { 109 | "cell_type": "code", 110 | "execution_count": null, 111 | "metadata": { 112 | "slideshow": { 113 | "slide_type": "fragment" 114 | } 115 | }, 116 | "outputs": [], 117 | "source": [ 118 | "L=[1,2,3,4]\n", 119 | "print(L)\n", 120 | "print(funcion_malvada(L))\n", 121 | "print(L)" 122 | ] 123 | }, 124 | { 125 | "cell_type": "markdown", 126 | "metadata": { 127 | "slideshow": { 128 | "slide_type": "slide" 129 | } 130 | }, 131 | "source": [ 132 | "¿Cómo solucionar el problema anterior?" 133 | ] 134 | }, 135 | { 136 | "cell_type": "code", 137 | "execution_count": null, 138 | "metadata": { 139 | "slideshow": { 140 | "slide_type": "fragment" 141 | } 142 | }, 143 | "outputs": [], 144 | "source": [ 145 | "L=[1,2,3,4]\n", 146 | "print(L)\n", 147 | "print(funcion_malvada(list(L)))\n", 148 | "print(L)" 149 | ] 150 | }, 151 | { 152 | "cell_type": "markdown", 153 | "metadata": { 154 | "slideshow": { 155 | "slide_type": "fragment" 156 | } 157 | }, 158 | "source": [ 159 | "La función `list(L)` crea una copia de una la lista `L`, así no se modifica la original." 160 | ] 161 | }, 162 | { 163 | "cell_type": "markdown", 164 | "metadata": { 165 | "slideshow": { 166 | "slide_type": "slide" 167 | } 168 | }, 169 | "source": [ 170 | "## Manejo de listas relacionadas" 171 | ] 172 | }, 173 | { 174 | "cell_type": "markdown", 175 | "metadata": { 176 | "slideshow": { 177 | "slide_type": "fragment" 178 | } 179 | }, 180 | "source": [ 181 | "Una asignatura universitaria almacena la lista del curso y sus notas en listas. Todas estas están relacionadas por sus índice. " 182 | ] 183 | }, 184 | { 185 | "cell_type": "code", 186 | "execution_count": null, 187 | "metadata": { 188 | "slideshow": { 189 | "slide_type": "fragment" 190 | } 191 | }, 192 | "outputs": [], 193 | "source": [ 194 | "curso=['Simón','Sebastian','Rodrigo','Angélica','Pablo','Francisca']\n", 195 | "c1=[90,60,80,100,75,70]\n", 196 | "c2=[80,70,70,75,90,100]\n", 197 | "c3=[65,100,90,90,100,80]" 198 | ] 199 | }, 200 | { 201 | "cell_type": "markdown", 202 | "metadata": { 203 | "slideshow": { 204 | "slide_type": "fragment" 205 | } 206 | }, 207 | "source": [ 208 | "Cree un programa que genere e imprima el promedio de cada alumno. Además, muestre el promedio de todo el curso." 209 | ] 210 | }, 211 | { 212 | "cell_type": "code", 213 | "execution_count": null, 214 | "metadata": { 215 | "slideshow": { 216 | "slide_type": "slide" 217 | } 218 | }, 219 | "outputs": [], 220 | "source": [ 221 | "promedios=[]\n", 222 | "\n", 223 | "\n", 224 | "for indice in list(range(len(curso))):\n", 225 | " prom=[c1[indice], c2[indice], c3[indice]]\n", 226 | " promedios.append(round(sum(prom)/len(prom)))\n", 227 | " print(\"El promedio de\",curso[indice],\"es\",promedios[indice])\n", 228 | "\n", 229 | "print(\"El promedio del curso es\", round(sum(promedios)/len(promedios)))" 230 | ] 231 | }, 232 | { 233 | "cell_type": "markdown", 234 | "metadata": { 235 | "slideshow": { 236 | "slide_type": "slide" 237 | } 238 | }, 239 | "source": [ 240 | "Realice una función que reciba las listas `curso` y `promedios` como parámetros y determine el alumno con mayor promedio del curso." 241 | ] 242 | }, 243 | { 244 | "cell_type": "code", 245 | "execution_count": null, 246 | "metadata": { 247 | "slideshow": { 248 | "slide_type": "fragment" 249 | } 250 | }, 251 | "outputs": [], 252 | "source": [ 253 | "def mejor(curso, promedios):\n", 254 | " mayor=-1\n", 255 | " \n", 256 | " for indice in list(range(len(curso))):\n", 257 | " if promedios[indice] > mayor: #que pasa si >=?\n", 258 | " mayor=promedios[indice]\n", 259 | " mejor=curso[indice]\n", 260 | " \n", 261 | " return mejor" 262 | ] 263 | }, 264 | { 265 | "cell_type": "code", 266 | "execution_count": null, 267 | "metadata": { 268 | "slideshow": { 269 | "slide_type": "fragment" 270 | } 271 | }, 272 | "outputs": [], 273 | "source": [ 274 | "print(mejor(curso,promedios))" 275 | ] 276 | }, 277 | { 278 | "cell_type": "markdown", 279 | "metadata": { 280 | "slideshow": { 281 | "slide_type": "slide" 282 | } 283 | }, 284 | "source": [ 285 | "## Uso de funciones aleatorias para Listas\n", 286 | "La librería `random` incluye funciones para selección aleatoria desde listas. Echemos un vistazo a la función `choice`." 287 | ] 288 | }, 289 | { 290 | "cell_type": "markdown", 291 | "metadata": { 292 | "slideshow": { 293 | "slide_type": "fragment" 294 | } 295 | }, 296 | "source": [ 297 | "El Loto es un juego de azar en donde se seleccionan aleatoriamente 6 números, sin repetirse, de una tombola con valores entre el 1 y el 41. Desarrolle un programa que simule un sorteo." 298 | ] 299 | }, 300 | { 301 | "cell_type": "markdown", 302 | "metadata": { 303 | "slideshow": { 304 | "slide_type": "slide" 305 | } 306 | }, 307 | "source": [ 308 | "### Sin Listas" 309 | ] 310 | }, 311 | { 312 | "cell_type": "code", 313 | "execution_count": null, 314 | "metadata": { 315 | "slideshow": { 316 | "slide_type": "fragment" 317 | } 318 | }, 319 | "outputs": [], 320 | "source": [ 321 | "from random import randint\n", 322 | "\n", 323 | "n1=randint(1,41)\n", 324 | "\n", 325 | "n2=randint(1,41)\n", 326 | "while n2==n1:\n", 327 | " n2=randint(1,41)\n", 328 | " \n", 329 | "n3=randint(1,41)\n", 330 | "while n3==n1 or n3==n2:\n", 331 | " n3=randint(1,41)\n", 332 | "\n", 333 | "n4=randint(1,41)\n", 334 | "while n4==n1 or n4==n2 or n4==n3:\n", 335 | " n4=randint(1,41)\n", 336 | "\n", 337 | "n5=randint(1,41)\n", 338 | "while n5==n1 or n5==n2 or n5==n3 or n5==n4:\n", 339 | " n5=randint(1,41)\n", 340 | "\n", 341 | "n6=randint(1,41)\n", 342 | "while n6==n1 or n6==n2 or n6==n3 or n6==n4 or n6==n5:\n", 343 | " n6=randint(1,41)\n", 344 | " \n", 345 | "print(\"Los numeros sorteados son:\",n1,n2,n3,n4,n5,n6)" 346 | ] 347 | }, 348 | { 349 | "cell_type": "markdown", 350 | "metadata": { 351 | "slideshow": { 352 | "slide_type": "slide" 353 | } 354 | }, 355 | "source": [ 356 | "### Con Listas" 357 | ] 358 | }, 359 | { 360 | "cell_type": "code", 361 | "execution_count": null, 362 | "metadata": { 363 | "slideshow": { 364 | "slide_type": "fragment" 365 | } 366 | }, 367 | "outputs": [], 368 | "source": [ 369 | "from random import choice\n", 370 | "\n", 371 | "sorteo=[]\n", 372 | "tombola=list(range(1,41))\n", 373 | "\n", 374 | "while len(sorteo)<6:\n", 375 | " x=choice(tombola)\n", 376 | " sorteo.append(x)\n", 377 | " tombola.remove(x)\n", 378 | "\n", 379 | "print(\"Los numeros sorteados son:\", sorteo)" 380 | ] 381 | } 382 | ], 383 | "metadata": { 384 | "anaconda-cloud": {}, 385 | "celltoolbar": "Slideshow", 386 | "kernelspec": { 387 | "display_name": "Python 3", 388 | "language": "python", 389 | "name": "python3" 390 | }, 391 | "language_info": { 392 | "codemirror_mode": { 393 | "name": "ipython", 394 | "version": 3 395 | }, 396 | "file_extension": ".py", 397 | "mimetype": "text/x-python", 398 | "name": "python", 399 | "nbconvert_exporter": "python", 400 | "pygments_lexer": "ipython3", 401 | "version": "3.7.3" 402 | } 403 | }, 404 | "nbformat": 4, 405 | "nbformat_minor": 1 406 | } 407 | -------------------------------------------------------------------------------- /Clase02_Uso_Trinket_2019.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": { 6 | "colab_type": "text", 7 | "id": "pt13utk-64lr", 8 | "slideshow": { 9 | "slide_type": "slide" 10 | } 11 | }, 12 | "source": [ 13 | "\"\"\n", 14 | "\"\"\n", 15 | "\n", 16 | "
\n", 17 | "
\n", 18 | "

IWI131 Programación


\n", 19 | "

Trinket: variables, entradas, salidas y funciones

\n", 20 | "

\n", 21 | "Departamento de Informática
\n", 22 | "Universidad Técnica Federico Santa María\n", 23 | "
" 24 | ] 25 | }, 26 | { 27 | "cell_type": "markdown", 28 | "metadata": { 29 | "colab_type": "text", 30 | "id": "mHRDJobpZpfo", 31 | "slideshow": { 32 | "slide_type": "slide" 33 | } 34 | }, 35 | "source": [ 36 | "# Instrucciones" 37 | ] 38 | }, 39 | { 40 | "cell_type": "markdown", 41 | "metadata": { 42 | "colab_type": "text", 43 | "id": "cFZZ7ueYZ1U0", 44 | "slideshow": { 45 | "slide_type": "fragment" 46 | } 47 | }, 48 | "source": [ 49 | "**Instrucciones:** son las ordenes básicas que deben ser ejecutadas. Generalmente una por una. Un algortimo se compone de muchas de estas instrucciones para realizar una tarea. Por ejemplo: caminar 5 pasos hacia adelante, sumar dos números, mostrar por pantalla un resultado, etc.\n", 50 | "\n", 51 | "Veremos un primer ejemplo usando Trinket: dibujar un cuadrado" 52 | ] 53 | }, 54 | { 55 | "cell_type": "code", 56 | "execution_count": 7, 57 | "metadata": { 58 | "colab": { 59 | "base_uri": "https://localhost:8080/", 60 | "height": 521 61 | }, 62 | "colab_type": "code", 63 | "executionInfo": { 64 | "elapsed": 615, 65 | "status": "ok", 66 | "timestamp": 1551111259126, 67 | "user": { 68 | "displayName": "Sergio Campos", 69 | "photoUrl": "", 70 | "userId": "12155360713523385064" 71 | }, 72 | "user_tz": 180 73 | }, 74 | "id": "GpuDJQ75gnHf", 75 | "outputId": "55e72acb-de02-4232-9793-a412656772d4", 76 | "scrolled": false, 77 | "slideshow": { 78 | "slide_type": "slide" 79 | } 80 | }, 81 | "outputs": [ 82 | { 83 | "data": { 84 | "text/html": [ 85 | "" 86 | ], 87 | "text/plain": [ 88 | "" 89 | ] 90 | }, 91 | "metadata": {}, 92 | "output_type": "display_data" 93 | } 94 | ], 95 | "source": [ 96 | "from IPython.core.display import display, HTML\n", 97 | "display(HTML(''))" 98 | ] 99 | }, 100 | { 101 | "cell_type": "markdown", 102 | "metadata": { 103 | "colab_type": "text", 104 | "id": "fUPD79aQGxtT", 105 | "slideshow": { 106 | "slide_type": "slide" 107 | } 108 | }, 109 | "source": [ 110 | "# Repeticiones" 111 | ] 112 | }, 113 | { 114 | "cell_type": "markdown", 115 | "metadata": { 116 | "colab_type": "text", 117 | "id": "zTtm_WM2Jrgn", 118 | "slideshow": { 119 | "slide_type": "fragment" 120 | } 121 | }, 122 | "source": [ 123 | "Muy a menudo es necesario realizar tareas especificas varias veces. Se le puede dar al computador instruccion por instruccion, pero cuando es necesario hacerlo muchas veces esto no resulta practico.\n", 124 | "Para resolver este problema, es posible realizar ciclos (loops, en ingles) que de manera compacta se le pide realizar al computador una misma tarea varias veces." 125 | ] 126 | }, 127 | { 128 | "cell_type": "code", 129 | "execution_count": 8, 130 | "metadata": { 131 | "colab": { 132 | "base_uri": "https://localhost:8080/", 133 | "height": 421 134 | }, 135 | "colab_type": "code", 136 | "executionInfo": { 137 | "elapsed": 965, 138 | "status": "ok", 139 | "timestamp": 1551118258819, 140 | "user": { 141 | "displayName": "Sergio Campos", 142 | "photoUrl": "", 143 | "userId": "12155360713523385064" 144 | }, 145 | "user_tz": 180 146 | }, 147 | "id": "gWhuqx1VbLaF", 148 | "outputId": "ace9ddc9-e813-4043-e40f-8caa4fb1da41", 149 | "scrolled": false, 150 | "slideshow": { 151 | "slide_type": "slide" 152 | } 153 | }, 154 | "outputs": [ 155 | { 156 | "data": { 157 | "text/html": [ 158 | "" 159 | ], 160 | "text/plain": [ 161 | "" 162 | ] 163 | }, 164 | "metadata": {}, 165 | "output_type": "display_data" 166 | } 167 | ], 168 | "source": [ 169 | "from IPython.core.display import display, HTML\n", 170 | "display(HTML(''))" 171 | ] 172 | }, 173 | { 174 | "cell_type": "markdown", 175 | "metadata": { 176 | "colab_type": "text", 177 | "id": "PdXOpjMTBOTP", 178 | "slideshow": { 179 | "slide_type": "slide" 180 | } 181 | }, 182 | "source": [ 183 | "# Entradas y Salidas\n" 184 | ] 185 | }, 186 | { 187 | "cell_type": "markdown", 188 | "metadata": { 189 | "colab_type": "text", 190 | "id": "N_ojijG-HY0a", 191 | "slideshow": { 192 | "slide_type": "fragment" 193 | } 194 | }, 195 | "source": [ 196 | "\n", 197 | "* *Entradas* (input, en ingles) es la información que se entrega al algoritmo para que pueda realizar la tarea deseada.\n", 198 | "\n", 199 | "* *Salidas* (output, en ingles) es la información que entrega el algortimo como resultado, parcial o final, de su ejecución.\n", 200 | "\n", 201 | "En esta sesión nos enfocaremos en **entradas**." 202 | ] 203 | }, 204 | { 205 | "cell_type": "code", 206 | "execution_count": 9, 207 | "metadata": { 208 | "scrolled": false, 209 | "slideshow": { 210 | "slide_type": "slide" 211 | } 212 | }, 213 | "outputs": [ 214 | { 215 | "data": { 216 | "text/html": [ 217 | "" 218 | ], 219 | "text/plain": [ 220 | "" 221 | ] 222 | }, 223 | "metadata": {}, 224 | "output_type": "display_data" 225 | } 226 | ], 227 | "source": [ 228 | "from IPython.core.display import display, HTML\n", 229 | "display(HTML(''))" 230 | ] 231 | }, 232 | { 233 | "cell_type": "markdown", 234 | "metadata": { 235 | "colab_type": "text", 236 | "id": "R_0p3hdj7Mfm", 237 | "slideshow": { 238 | "slide_type": "slide" 239 | } 240 | }, 241 | "source": [ 242 | "# Variables\n", 243 | "\n" 244 | ] 245 | }, 246 | { 247 | "cell_type": "markdown", 248 | "metadata": { 249 | "colab_type": "text", 250 | "id": "BwFv2O-d8bG6", 251 | "slideshow": { 252 | "slide_type": "fragment" 253 | } 254 | }, 255 | "source": [ 256 | "Las variables son espacios de almacenamiento, en donde guardaremos los datos con los que trabaja el algoritmo. \n", 257 | "Pueden cambiar su valor cuantas veces queramos mediante asignaciones.\n", 258 | "\n", 259 | "
\n", 260 | "\"\"\n", 261 | "
" 262 | ] 263 | }, 264 | { 265 | "cell_type": "markdown", 266 | "metadata": { 267 | "colab_type": "text", 268 | "id": "sM0hqzOdBowd", 269 | "slideshow": { 270 | "slide_type": "slide" 271 | } 272 | }, 273 | "source": [ 274 | "**Asignación de variables:** Para cambiar el valor almacenado en una variable utilizamos una operación de asignación, denotada por un igual o por una flecha a la izquierda.\n", 275 | "\n", 276 | "Las **entradas** las manejaremos generalmente en **variables**\n", 277 | "\n", 278 | "
\n", 279 | "\"\"\n", 280 | "
" 281 | ] 282 | }, 283 | { 284 | "cell_type": "code", 285 | "execution_count": 10, 286 | "metadata": { 287 | "slideshow": { 288 | "slide_type": "slide" 289 | } 290 | }, 291 | "outputs": [ 292 | { 293 | "data": { 294 | "text/html": [ 295 | "" 296 | ], 297 | "text/plain": [ 298 | "" 299 | ] 300 | }, 301 | "metadata": {}, 302 | "output_type": "display_data" 303 | } 304 | ], 305 | "source": [ 306 | "from IPython.core.display import display, HTML\n", 307 | "display(HTML(''))" 308 | ] 309 | }, 310 | { 311 | "cell_type": "markdown", 312 | "metadata": { 313 | "colab_type": "text", 314 | "id": "gUBrQKevHMpZ", 315 | "slideshow": { 316 | "slide_type": "slide" 317 | } 318 | }, 319 | "source": [ 320 | "# Funciones" 321 | ] 322 | }, 323 | { 324 | "cell_type": "markdown", 325 | "metadata": { 326 | "colab_type": "text", 327 | "id": "yWiVY-_fegaF", 328 | "slideshow": { 329 | "slide_type": "fragment" 330 | } 331 | }, 332 | "source": [ 333 | "Una función es un grupo de 1 o más instrucciones agrupadas. La función generalmente tendra datos de entrada y datos de salida.\n", 334 | "\n", 335 | "Ahora veremos un ejemplo donde se entregará el números de lados y el largo de estos, y permitirá dibujar una figura mediante una función." 336 | ] 337 | }, 338 | { 339 | "cell_type": "code", 340 | "execution_count": 11, 341 | "metadata": { 342 | "colab": { 343 | "base_uri": "https://localhost:8080/", 344 | "height": 621 345 | }, 346 | "colab_type": "code", 347 | "executionInfo": { 348 | "elapsed": 757, 349 | "status": "ok", 350 | "timestamp": 1551118416748, 351 | "user": { 352 | "displayName": "Sergio Campos", 353 | "photoUrl": "", 354 | "userId": "12155360713523385064" 355 | }, 356 | "user_tz": 180 357 | }, 358 | "id": "uDkp4b4Cenlb", 359 | "outputId": "f75f0668-0b73-4744-cf3b-6a6eb2c8f60a", 360 | "slideshow": { 361 | "slide_type": "slide" 362 | } 363 | }, 364 | "outputs": [ 365 | { 366 | "data": { 367 | "text/html": [ 368 | "" 369 | ], 370 | "text/plain": [ 371 | "" 372 | ] 373 | }, 374 | "metadata": {}, 375 | "output_type": "display_data" 376 | } 377 | ], 378 | "source": [ 379 | "from IPython.core.display import display, HTML\n", 380 | "display(HTML(''))" 381 | ] 382 | }, 383 | { 384 | "cell_type": "code", 385 | "execution_count": 12, 386 | "metadata": { 387 | "colab": { 388 | "base_uri": "https://localhost:8080/", 389 | "height": 621 390 | }, 391 | "colab_type": "code", 392 | "executionInfo": { 393 | "elapsed": 757, 394 | "status": "ok", 395 | "timestamp": 1551118416748, 396 | "user": { 397 | "displayName": "Sergio Campos", 398 | "photoUrl": "", 399 | "userId": "12155360713523385064" 400 | }, 401 | "user_tz": 180 402 | }, 403 | "id": "uDkp4b4Cenlb", 404 | "outputId": "f75f0668-0b73-4744-cf3b-6a6eb2c8f60a", 405 | "slideshow": { 406 | "slide_type": "slide" 407 | } 408 | }, 409 | "outputs": [ 410 | { 411 | "data": { 412 | "text/html": [ 413 | "" 414 | ], 415 | "text/plain": [ 416 | "" 417 | ] 418 | }, 419 | "metadata": {}, 420 | "output_type": "display_data" 421 | } 422 | ], 423 | "source": [ 424 | "from IPython.core.display import display, HTML\n", 425 | "display(HTML(''))" 426 | ] 427 | }, 428 | { 429 | "cell_type": "markdown", 430 | "metadata": { 431 | "colab_type": "text", 432 | "id": "K5kJ69JN3T1t", 433 | "slideshow": { 434 | "slide_type": "slide" 435 | } 436 | }, 437 | "source": [ 438 | "# Ejercicios:\n", 439 | "1.- Dibuje una estrella de 5 puntas donde se le debe entregar al comienzo: la ubicacion inicial y el largo del trazo." 440 | ] 441 | }, 442 | { 443 | "cell_type": "code", 444 | "execution_count": 13, 445 | "metadata": { 446 | "colab": { 447 | "base_uri": "https://localhost:8080/", 448 | "height": 521 449 | }, 450 | "colab_type": "code", 451 | "executionInfo": { 452 | "elapsed": 772, 453 | "status": "ok", 454 | "timestamp": 1551118328848, 455 | "user": { 456 | "displayName": "Sergio Campos", 457 | "photoUrl": "", 458 | "userId": "12155360713523385064" 459 | }, 460 | "user_tz": 180 461 | }, 462 | "id": "9V9oa1XQh0Uk", 463 | "outputId": "9b7f7bf9-c98d-47fc-a078-a9acff85105a", 464 | "scrolled": false, 465 | "slideshow": { 466 | "slide_type": "fragment" 467 | } 468 | }, 469 | "outputs": [ 470 | { 471 | "data": { 472 | "text/html": [ 473 | "" 474 | ], 475 | "text/plain": [ 476 | "" 477 | ] 478 | }, 479 | "metadata": {}, 480 | "output_type": "display_data" 481 | } 482 | ], 483 | "source": [ 484 | "from IPython.core.display import display, HTML\n", 485 | "display(HTML(''))" 486 | ] 487 | }, 488 | { 489 | "cell_type": "markdown", 490 | "metadata": { 491 | "colab_type": "text", 492 | "id": "8KRUM5MR3y4u", 493 | "slideshow": { 494 | "slide_type": "slide" 495 | } 496 | }, 497 | "source": [ 498 | "2.- Dibuje *N* estrellas de 5 puntas ubicadas en posiciones elegidas aleatoriamente." 499 | ] 500 | }, 501 | { 502 | "cell_type": "code", 503 | "execution_count": 14, 504 | "metadata": { 505 | "colab": { 506 | "base_uri": "https://localhost:8080/", 507 | "height": 521 508 | }, 509 | "colab_type": "code", 510 | "executionInfo": { 511 | "elapsed": 765, 512 | "status": "ok", 513 | "timestamp": 1551118364944, 514 | "user": { 515 | "displayName": "Sergio Campos", 516 | "photoUrl": "", 517 | "userId": "12155360713523385064" 518 | }, 519 | "user_tz": 180 520 | }, 521 | "id": "Xqy08_i3iDIk", 522 | "outputId": "f2f23d87-c971-4c0a-beeb-ff1be54fd25a", 523 | "slideshow": { 524 | "slide_type": "fragment" 525 | } 526 | }, 527 | "outputs": [ 528 | { 529 | "data": { 530 | "text/html": [ 531 | "" 532 | ], 533 | "text/plain": [ 534 | "" 535 | ] 536 | }, 537 | "metadata": {}, 538 | "output_type": "display_data" 539 | } 540 | ], 541 | "source": [ 542 | "from IPython.core.display import display, HTML\n", 543 | "display(HTML(''))" 544 | ] 545 | }, 546 | { 547 | "cell_type": "code", 548 | "execution_count": null, 549 | "metadata": {}, 550 | "outputs": [], 551 | "source": [] 552 | } 553 | ], 554 | "metadata": { 555 | "celltoolbar": "Slideshow", 556 | "colab": { 557 | "collapsed_sections": [], 558 | "name": "Clase02_Uso_Trinket_2019.ipynb", 559 | "provenance": [], 560 | "version": "0.3.2" 561 | }, 562 | "kernelspec": { 563 | "display_name": "Python 3", 564 | "language": "python", 565 | "name": "python3" 566 | }, 567 | "language_info": { 568 | "codemirror_mode": { 569 | "name": "ipython", 570 | "version": 3 571 | }, 572 | "file_extension": ".py", 573 | "mimetype": "text/x-python", 574 | "name": "python", 575 | "nbconvert_exporter": "python", 576 | "pygments_lexer": "ipython3", 577 | "version": "3.7.2" 578 | } 579 | }, 580 | "nbformat": 4, 581 | "nbformat_minor": 1 582 | } 583 | -------------------------------------------------------------------------------- /Clase07_Funciones_2019.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": { 6 | "slideshow": { 7 | "slide_type": "slide" 8 | } 9 | }, 10 | "source": [ 11 | "\"\"\n", 12 | "\"\"\n", 13 | "\n", 14 | "
\n", 15 | "
\n", 16 | "

IWI131 Programación


\n", 17 | "

Funciones

\n", 18 | "

\n", 19 | "Departamento de Informática
\n", 20 | "Universidad Técnica Federico Santa María\n", 21 | "
" 22 | ] 23 | }, 24 | { 25 | "cell_type": "markdown", 26 | "metadata": { 27 | "slideshow": { 28 | "slide_type": "slide" 29 | } 30 | }, 31 | "source": [ 32 | "# Funciones" 33 | ] 34 | }, 35 | { 36 | "cell_type": "markdown", 37 | "metadata": { 38 | "slideshow": { 39 | "slide_type": "fragment" 40 | } 41 | }, 42 | "source": [ 43 | "Hasta el momento se ha visto que existen funciones ya definidas que pueden ser utilizadas. Ejemplo de estas funciones son:\n", 44 | "* `abs()`\n", 45 | "* `print()`\n", 46 | "* `float()`\n", 47 | "* etc.\n", 48 | "\n" 49 | ] 50 | }, 51 | { 52 | "cell_type": "markdown", 53 | "metadata": { 54 | "slideshow": { 55 | "slide_type": "slide" 56 | } 57 | }, 58 | "source": [ 59 | "Sin embargo, en ocasiones necesitamos crear funciones para realizar ciertas tareas específicas. Para realizar esto, se deben tener presente 2 aspectos:\n", 60 | "* La definición de la función.\n", 61 | "* El adecuado llamado de la función previamente definida." 62 | ] 63 | }, 64 | { 65 | "cell_type": "markdown", 66 | "metadata": { 67 | "slideshow": { 68 | "slide_type": "slide" 69 | } 70 | }, 71 | "source": [ 72 | "## Definición de una función" 73 | ] 74 | }, 75 | { 76 | "cell_type": "markdown", 77 | "metadata": { 78 | "slideshow": { 79 | "slide_type": "fragment" 80 | } 81 | }, 82 | "source": [ 83 | "Para definir una función se debe utilizar la palabra reservada `def`, seguida de la siguiente sintaxis:" 84 | ] 85 | }, 86 | { 87 | "cell_type": "markdown", 88 | "metadata": { 89 | "slideshow": { 90 | "slide_type": "fragment" 91 | } 92 | }, 93 | "source": [ 94 | "\n", 95 | "`def` nombre_funcion**(parametro1, parametro2, ...):**" 96 | ] 97 | }, 98 | { 99 | "cell_type": "markdown", 100 | "metadata": { 101 | "slideshow": { 102 | "slide_type": "slide" 103 | } 104 | }, 105 | "source": [ 106 | "Toda función definida debe tener un nombre luego de la palabra `def`. Este nombre cumple las mismas restricciones de nombres de variables." 107 | ] 108 | }, 109 | { 110 | "cell_type": "markdown", 111 | "metadata": { 112 | "slideshow": { 113 | "slide_type": "fragment" 114 | } 115 | }, 116 | "source": [ 117 | "Los parámetros de entradas entre paréntesis redondos `( )`. Estos parámetros deben ir separados por comas y pueden ser una cantidad variable. Se termina al final con el caracter dos puntos `:`." 118 | ] 119 | }, 120 | { 121 | "cell_type": "markdown", 122 | "metadata": { 123 | "slideshow": { 124 | "slide_type": "slide" 125 | } 126 | }, 127 | "source": [ 128 | "## Definición de una función" 129 | ] 130 | }, 131 | { 132 | "cell_type": "markdown", 133 | "metadata": { 134 | "slideshow": { 135 | "slide_type": "fragment" 136 | } 137 | }, 138 | "source": [ 139 | "Después de escribir la primera línea de código de la función, se deben escribir todas las instrucciones. Estas instrucciones deben estar indentadas de tal manera que todas esten dentro de la función" 140 | ] 141 | }, 142 | { 143 | "cell_type": "markdown", 144 | "metadata": { 145 | "slideshow": { 146 | "slide_type": "fragment" 147 | } 148 | }, 149 | "source": [ 150 | "En la mayoria de los casos, las funciones tienen una instrucción especial representada por la palabra reservada **return**. Esta instrucción especial nos indica el momento en que nos salimos de la función, retornando algun valor de interes. " 151 | ] 152 | }, 153 | { 154 | "cell_type": "markdown", 155 | "metadata": { 156 | "slideshow": { 157 | "slide_type": "slide" 158 | } 159 | }, 160 | "source": [ 161 | "En trinket, una función es:" 162 | ] 163 | }, 164 | { 165 | "cell_type": "code", 166 | "execution_count": 1, 167 | "metadata": { 168 | "slideshow": { 169 | "slide_type": "fragment" 170 | } 171 | }, 172 | "outputs": [ 173 | { 174 | "data": { 175 | "text/html": [ 176 | "\n", 177 | " \n", 184 | " " 185 | ], 186 | "text/plain": [ 187 | "" 188 | ] 189 | }, 190 | "execution_count": 1, 191 | "metadata": {}, 192 | "output_type": "execute_result" 193 | } 194 | ], 195 | "source": [ 196 | "from IPython.display import IFrame\n", 197 | "IFrame(\"https://trinket.io/embed/blocks/0cda3d2969?hideGeneratedCode=true\", width=\"100%\", height=\"400\")" 198 | ] 199 | }, 200 | { 201 | "cell_type": "markdown", 202 | "metadata": { 203 | "slideshow": { 204 | "slide_type": "slide" 205 | } 206 | }, 207 | "source": [ 208 | "Un ejemplo de la misma función en Python es:" 209 | ] 210 | }, 211 | { 212 | "cell_type": "code", 213 | "execution_count": 2, 214 | "metadata": { 215 | "collapsed": true, 216 | "slideshow": { 217 | "slide_type": "fragment" 218 | } 219 | }, 220 | "outputs": [], 221 | "source": [ 222 | "def discriminante(a,b,c):\n", 223 | " resultado = b**2-4*a*c\n", 224 | " return resultado" 225 | ] 226 | }, 227 | { 228 | "cell_type": "markdown", 229 | "metadata": { 230 | "slideshow": { 231 | "slide_type": "fragment" 232 | } 233 | }, 234 | "source": [ 235 | "Con esto, ya hemos desarrollado nuestra primera función, pero ahora nos hace falta poder utilizarla." 236 | ] 237 | }, 238 | { 239 | "cell_type": "markdown", 240 | "metadata": { 241 | "slideshow": { 242 | "slide_type": "slide" 243 | } 244 | }, 245 | "source": [ 246 | "## Llamado de la función" 247 | ] 248 | }, 249 | { 250 | "cell_type": "markdown", 251 | "metadata": { 252 | "slideshow": { 253 | "slide_type": "fragment" 254 | } 255 | }, 256 | "source": [ 257 | "Una vez la función es creada, como en el ejemplo anterior, podemos utilizarla. A este proceso comunmente se le llama: **llamar la función**." 258 | ] 259 | }, 260 | { 261 | "cell_type": "markdown", 262 | "metadata": { 263 | "slideshow": { 264 | "slide_type": "fragment" 265 | } 266 | }, 267 | "source": [ 268 | "Para llamar a una función, se debe saber el nombre de esta y los parámetros que recibe. Es importante respetar el número de parámetros. " 269 | ] 270 | }, 271 | { 272 | "cell_type": "markdown", 273 | "metadata": { 274 | "slideshow": { 275 | "slide_type": "slide" 276 | } 277 | }, 278 | "source": [ 279 | "En Trinket, una función puede ser llamada al usar su bloque respectivo e ingresando los parámetros requeridos." 280 | ] 281 | }, 282 | { 283 | "cell_type": "code", 284 | "execution_count": 3, 285 | "metadata": { 286 | "slideshow": { 287 | "slide_type": "fragment" 288 | } 289 | }, 290 | "outputs": [ 291 | { 292 | "data": { 293 | "text/html": [ 294 | "\n", 295 | " \n", 302 | " " 303 | ], 304 | "text/plain": [ 305 | "" 306 | ] 307 | }, 308 | "execution_count": 3, 309 | "metadata": {}, 310 | "output_type": "execute_result" 311 | } 312 | ], 313 | "source": [ 314 | "from IPython.display import IFrame\n", 315 | "IFrame(\"https://trinket.io/embed/blocks/1b661715ca?hideGeneratedCode=true\", width=\"100%\", height=\"400\")" 316 | ] 317 | }, 318 | { 319 | "cell_type": "markdown", 320 | "metadata": { 321 | "slideshow": { 322 | "slide_type": "slide" 323 | } 324 | }, 325 | "source": [ 326 | "Siguiendo el ejemplo anterior, llamar a una función en Python consiste en lo siguiente:" 327 | ] 328 | }, 329 | { 330 | "cell_type": "code", 331 | "execution_count": 4, 332 | "metadata": { 333 | "slideshow": { 334 | "slide_type": "fragment" 335 | } 336 | }, 337 | "outputs": [], 338 | "source": [ 339 | "var_resultado = discriminante(1,4,2)" 340 | ] 341 | }, 342 | { 343 | "cell_type": "markdown", 344 | "metadata": { 345 | "slideshow": { 346 | "slide_type": "fragment" 347 | } 348 | }, 349 | "source": [ 350 | "Con lo anterior, guardamos el dato que calcula la función (variable `resultado`) en la variable `var_resultado`. Veamos que nos entrega:" 351 | ] 352 | }, 353 | { 354 | "cell_type": "code", 355 | "execution_count": 5, 356 | "metadata": { 357 | "slideshow": { 358 | "slide_type": "fragment" 359 | } 360 | }, 361 | "outputs": [ 362 | { 363 | "data": { 364 | "text/plain": [ 365 | "8" 366 | ] 367 | }, 368 | "execution_count": 5, 369 | "metadata": {}, 370 | "output_type": "execute_result" 371 | } 372 | ], 373 | "source": [ 374 | "var_resultado" 375 | ] 376 | }, 377 | { 378 | "cell_type": "markdown", 379 | "metadata": { 380 | "slideshow": { 381 | "slide_type": "fragment" 382 | } 383 | }, 384 | "source": [ 385 | "Recuerde utilizar una variable para guardar lo que entrega la función. " 386 | ] 387 | }, 388 | { 389 | "cell_type": "markdown", 390 | "metadata": { 391 | "slideshow": { 392 | "slide_type": "slide" 393 | } 394 | }, 395 | "source": [ 396 | "Si quisieramos hacer un programa que nos pudiera resolver las ecuaciones de segundo grado, nuestro código podría ser:" 397 | ] 398 | }, 399 | { 400 | "cell_type": "code", 401 | "execution_count": 6, 402 | "metadata": { 403 | "slideshow": { 404 | "slide_type": "fragment" 405 | } 406 | }, 407 | "outputs": [ 408 | { 409 | "name": "stdout", 410 | "output_type": "stream", 411 | "text": [ 412 | "Ingrese el valor a:1\n", 413 | "Ingrese el valor b:-1\n", 414 | "Ingrese el valor c:-12\n", 415 | "Las soluciones son:\n", 416 | "sol= -3.0\n", 417 | "sol2= 4.0\n" 418 | ] 419 | } 420 | ], 421 | "source": [ 422 | "def discriminante(a,b,c):\n", 423 | " resultado = b**2-4*a*c\n", 424 | " return resultado\n", 425 | "\n", 426 | "p1 = float(input('Ingrese el valor a:'))\n", 427 | "p2 = float(input('Ingrese el valor b:'))\n", 428 | "p3 = float(input('Ingrese el valor c:'))\n", 429 | "\n", 430 | "var_resultado = discriminante(p1,p2,p3)\n", 431 | "\n", 432 | "if var_resultado < 0:\n", 433 | " print('La ecuacion no tiene solucion real')\n", 434 | "elif var_resultado == 0:\n", 435 | " sol = -p2 / (2*p1) \n", 436 | " print('La solucion es unica y es sol=', sol)\n", 437 | "else:\n", 438 | " sol = (-p2 - (var_resultado**0.5))/(2*p1)\n", 439 | " sol2 = (-p2 + (var_resultado**0.5))/(2*p1)\n", 440 | " print('Las soluciones son:')\n", 441 | " print('sol=', sol)\n", 442 | " print('sol2=', sol2)" 443 | ] 444 | }, 445 | { 446 | "cell_type": "markdown", 447 | "metadata": { 448 | "slideshow": { 449 | "slide_type": "slide" 450 | } 451 | }, 452 | "source": [ 453 | "## Diferencia entre `print()` y `return`" 454 | ] 455 | }, 456 | { 457 | "cell_type": "markdown", 458 | "metadata": { 459 | "slideshow": { 460 | "slide_type": "fragment" 461 | } 462 | }, 463 | "source": [ 464 | "`print()` y `return` pueden tener un comportamiento muy parecido, pero no se les debe confundir, ya que son instrucciones **completamente** diferentes." 465 | ] 466 | }, 467 | { 468 | "cell_type": "markdown", 469 | "metadata": { 470 | "slideshow": { 471 | "slide_type": "fragment" 472 | } 473 | }, 474 | "source": [ 475 | "* `return` es el **resultado de una funcion**, por lo tanto solo debe ir dentro de una función.\n", 476 | "* `print()` es una **salida de un programa**, puede ir tanto en una función (aunque no es tan común) como en el código de un programa principal (el main).\n", 477 | "* `return` se comporta muy parecido al `print()` cuando a la función se le llama de la consola (shell).\n", 478 | "* Lo anterior cambia cuando el codigo se ejecuta desde el archivo." 479 | ] 480 | }, 481 | { 482 | "cell_type": "markdown", 483 | "metadata": { 484 | "slideshow": { 485 | "slide_type": "slide" 486 | } 487 | }, 488 | "source": [ 489 | "Recordemos la función, la cual estará guardada en un archivo llamado `prueba.py`:" 490 | ] 491 | }, 492 | { 493 | "cell_type": "code", 494 | "execution_count": 7, 495 | "metadata": { 496 | "collapsed": true, 497 | "slideshow": { 498 | "slide_type": "fragment" 499 | } 500 | }, 501 | "outputs": [], 502 | "source": [ 503 | "def discriminante(a,b,c):\n", 504 | " resultado = b**2-4*a*c\n", 505 | " return resultado" 506 | ] 507 | }, 508 | { 509 | "cell_type": "markdown", 510 | "metadata": { 511 | "slideshow": { 512 | "slide_type": "fragment" 513 | } 514 | }, 515 | "source": [ 516 | "Al ejecutar el archivo `prueba.py` no nos mostrará ningun resultado por pantalla, ya que el `return` no se comporta como un `print()` cuando se ejecuta desde un archivo." 517 | ] 518 | }, 519 | { 520 | "cell_type": "markdown", 521 | "metadata": { 522 | "slideshow": { 523 | "slide_type": "slide" 524 | } 525 | }, 526 | "source": [ 527 | "Para obtener resultado por pantalla, se debe llamar la función:" 528 | ] 529 | }, 530 | { 531 | "cell_type": "code", 532 | "execution_count": 8, 533 | "metadata": { 534 | "slideshow": { 535 | "slide_type": "fragment" 536 | } 537 | }, 538 | "outputs": [ 539 | { 540 | "data": { 541 | "text/plain": [ 542 | "-12" 543 | ] 544 | }, 545 | "execution_count": 8, 546 | "metadata": {}, 547 | "output_type": "execute_result" 548 | } 549 | ], 550 | "source": [ 551 | "discriminante(1,2,4)" 552 | ] 553 | }, 554 | { 555 | "cell_type": "markdown", 556 | "metadata": { 557 | "slideshow": { 558 | "slide_type": "slide" 559 | } 560 | }, 561 | "source": [ 562 | "Si queremos que al ejecutar el archivo `prueba.py` muestre inmediatamente el resultado de la función, debemos llamar a la función incluyendo un `print()`. \n", 563 | "\n", 564 | "Nuestro archivo `prueba.py` entonces quedaria como:" 565 | ] 566 | }, 567 | { 568 | "cell_type": "code", 569 | "execution_count": 9, 570 | "metadata": { 571 | "slideshow": { 572 | "slide_type": "fragment" 573 | } 574 | }, 575 | "outputs": [ 576 | { 577 | "name": "stdout", 578 | "output_type": "stream", 579 | "text": [ 580 | "-12\n" 581 | ] 582 | } 583 | ], 584 | "source": [ 585 | "def discriminante(a,b,c):\n", 586 | " resultado = b**2-4*a*c\n", 587 | " return resultado\n", 588 | "\n", 589 | "print(discriminante(1,2,4))" 590 | ] 591 | }, 592 | { 593 | "cell_type": "markdown", 594 | "metadata": { 595 | "slideshow": { 596 | "slide_type": "fragment" 597 | } 598 | }, 599 | "source": [ 600 | "Debemos ejecutar la función desde la consola para que nos entregue el resultado. Y al llamarla, debemos entregarle los valores de los parámetros. NO OLVIDAR!!" 601 | ] 602 | }, 603 | { 604 | "cell_type": "markdown", 605 | "metadata": { 606 | "slideshow": { 607 | "slide_type": "fragment" 608 | } 609 | }, 610 | "source": [ 611 | "Lo que hace python es cargar la función en memoria y luego mostrar por pantalla (gracias al `print()`) el resultado de llamarla." 612 | ] 613 | }, 614 | { 615 | "cell_type": "markdown", 616 | "metadata": { 617 | "slideshow": { 618 | "slide_type": "slide" 619 | } 620 | }, 621 | "source": [ 622 | "## Ejercicios" 623 | ] 624 | }, 625 | { 626 | "cell_type": "markdown", 627 | "metadata": { 628 | "slideshow": { 629 | "slide_type": "slide" 630 | } 631 | }, 632 | "source": [ 633 | "**1.-** Escriba la función `promedio(n1, n2, n3)` que reciba las notas de los 3 certámenes de la asignatura y retorne el valor del promedio." 634 | ] 635 | }, 636 | { 637 | "cell_type": "code", 638 | "execution_count": 10, 639 | "metadata": { 640 | "collapsed": true, 641 | "slideshow": { 642 | "slide_type": "fragment" 643 | } 644 | }, 645 | "outputs": [], 646 | "source": [ 647 | "def promedio(n1, n2, n3):\n", 648 | " suma = p1 + p2 + p3\n", 649 | " prom = suma/3\n", 650 | " return prom" 651 | ] 652 | }, 653 | { 654 | "cell_type": "markdown", 655 | "metadata": { 656 | "slideshow": { 657 | "slide_type": "slide" 658 | } 659 | }, 660 | "source": [ 661 | "**2.-** El riesgo de que una persona sufra enfermedades coronarias depende de su edad y su índice de masa corporal.\n", 662 | "\n", 663 | "El Indice de masa corporal (IMC) es el cociente entre el peso del individuo en kilos y el cuadrado de su estatura en metros.\n", 664 | "\n", 665 | "Escriba una función que reciba como parámetros la estatura, el peso y la edad de la persona , y le entregue su condición de riesgo.\n", 666 | "\n", 667 | "\n", 668 | " \n", 669 | " \n", 670 | " \n", 671 | " \n", 672 | " \n", 673 | " \n", 674 | " \n", 675 | " \n", 676 | " \n", 677 | " \n", 678 | " \n", 679 | " \n", 680 | " \n", 681 | " \n", 682 | " \n", 683 | "
edad < 45edad ≥ 45
IMC < 22bajomedio
IMC ≥ 22medioalto
" 684 | ] 685 | }, 686 | { 687 | "cell_type": "code", 688 | "execution_count": 11, 689 | "metadata": { 690 | "collapsed": true, 691 | "slideshow": { 692 | "slide_type": "slide" 693 | } 694 | }, 695 | "outputs": [], 696 | "source": [ 697 | "def IMC(est, peso, edad):\n", 698 | " indice = peso/(est**2)\n", 699 | " if edad < 45:\n", 700 | " if indice < 22.0:\n", 701 | " condicion = 'bajo'\n", 702 | " else:\n", 703 | " condicion = 'medio'\n", 704 | " else:\n", 705 | " if indice < 22.0:\n", 706 | " condicion = 'medio'\n", 707 | " else:\n", 708 | " condicion = 'alto'\n", 709 | " return condicion" 710 | ] 711 | }, 712 | { 713 | "cell_type": "markdown", 714 | "metadata": { 715 | "slideshow": { 716 | "slide_type": "slide" 717 | } 718 | }, 719 | "source": [ 720 | "**3.-** Un viajero desea saber cuánto tiempo tomó un viaje que realizó. Él conoce la duración (en minutos) de cada uno de los tramos del viaje por separado.\n", 721 | "\n", 722 | "Desarrolle un programa, **que contenga al menos una función**, que permita ingresar los tiempos de viaje de los tramos y entregue como resultado el tiempo total de viaje en formato: `horas` horas con `minutos` minutos\n", 723 | "\n", 724 | "El programa deja de pedir tiempos de viaje cuando se ingresa un **0**.\n", 725 | "\n", 726 | "**Ejemplo:**\n", 727 | "* Duración del tramo: **15**\n", 728 | "* Duración del tramo: **30**\n", 729 | "* Duración del tramo: **87**\n", 730 | "* Duración del tramo: **0**\n", 731 | "* Tiempo total de viaje : 2 horas con 12 minutos" 732 | ] 733 | }, 734 | { 735 | "cell_type": "code", 736 | "execution_count": 12, 737 | "metadata": { 738 | "slideshow": { 739 | "slide_type": "slide" 740 | } 741 | }, 742 | "outputs": [ 743 | { 744 | "name": "stdout", 745 | "output_type": "stream", 746 | "text": [ 747 | "Duracion del tramo: 40\n", 748 | "Duracion del tramo: 30\n", 749 | "Duracion del tramo: 60\n", 750 | "Duracion del tramo: 70\n", 751 | "Duracion del tramo: 0\n", 752 | "Tiempo total de viaje: 3 horas con 20 minutos\n" 753 | ] 754 | } 755 | ], 756 | "source": [ 757 | "def transformacion(total_min):\n", 758 | " horas = total_min/60\n", 759 | " return int(horas)\n", 760 | "\n", 761 | "def transformacion2(total_min):\n", 762 | " minutos = total_min%60\n", 763 | " return minutos\n", 764 | "\n", 765 | "flag = True\n", 766 | "total_min = 0\n", 767 | "while flag:\n", 768 | " minutos = int(input('Duracion del tramo: '))\n", 769 | " if minutos == 0:\n", 770 | " flag = False\n", 771 | " else:\n", 772 | " total_min = total_min + minutos\n", 773 | "\n", 774 | "horas = transformacion(total_min)\n", 775 | "minutos = transformacion2(total_min)\n", 776 | "print('Tiempo total de viaje:', horas, 'horas con', minutos, 'minutos')" 777 | ] 778 | }, 779 | { 780 | "cell_type": "markdown", 781 | "metadata": { 782 | "slideshow": { 783 | "slide_type": "slide" 784 | } 785 | }, 786 | "source": [ 787 | "**4.-** Realice el ruteo del problema anterior con las siguientes duraciones de tramos: 40, 35, 60, 70." 788 | ] 789 | }, 790 | { 791 | "cell_type": "code", 792 | "execution_count": null, 793 | "metadata": { 794 | "collapsed": true 795 | }, 796 | "outputs": [], 797 | "source": [] 798 | } 799 | ], 800 | "metadata": { 801 | "celltoolbar": "Slideshow", 802 | "kernelspec": { 803 | "display_name": "Python 3", 804 | "language": "python", 805 | "name": "python3" 806 | }, 807 | "language_info": { 808 | "codemirror_mode": { 809 | "name": "ipython", 810 | "version": 3 811 | }, 812 | "file_extension": ".py", 813 | "mimetype": "text/x-python", 814 | "name": "python", 815 | "nbconvert_exporter": "python", 816 | "pygments_lexer": "ipython3", 817 | "version": "3.5.2" 818 | } 819 | }, 820 | "nbformat": 4, 821 | "nbformat_minor": 2 822 | } 823 | -------------------------------------------------------------------------------- /Clase08_Funciones_Ciclos_2019.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": { 6 | "slideshow": { 7 | "slide_type": "slide" 8 | } 9 | }, 10 | "source": [ 11 | "\"\"\n", 12 | "\"\"\n", 13 | "\n", 14 | "
\n", 15 | "
\n", 16 | "

IWI131 Programación


\n", 17 | "

Descomposición en Funciones y Ciclos Anidados

\n", 18 | "

\n", 19 | "Departamento de Informática
\n", 20 | "Universidad Técnica Federico Santa María\n", 21 | "
" 22 | ] 23 | }, 24 | { 25 | "cell_type": "markdown", 26 | "metadata": { 27 | "slideshow": { 28 | "slide_type": "slide" 29 | } 30 | }, 31 | "source": [ 32 | "# Descomposición en Funciones" 33 | ] 34 | }, 35 | { 36 | "cell_type": "markdown", 37 | "metadata": { 38 | "slideshow": { 39 | "slide_type": "fragment" 40 | } 41 | }, 42 | "source": [ 43 | "Como dice el refrán: **Divide y Vencerás**... Es posible resolver un problema difícil, dividiéndolo en subproblemas más simples (en la medida de lo posible). La idea es resolver el problema principal, utilizando las soluciones de los\n", 44 | "subproblemas." 45 | ] 46 | }, 47 | { 48 | "cell_type": "markdown", 49 | "metadata": { 50 | "slideshow": { 51 | "slide_type": "slide" 52 | } 53 | }, 54 | "source": [ 55 | "En el mundo de la informática, es muy frecuente que se resuelvan los problemas de esta forma, siendo uno de los paradigmas más importantes en el diseño de algoritmos. Un pequeño esquema podría ser:\n", 56 | "\n", 57 | "```\n", 58 | "Problema:\n", 59 | " Subproblema 1\n", 60 | " Subproblema 2\n", 61 | " ...\n", 62 | " Subproblema N\n", 63 | "```" 64 | ] 65 | }, 66 | { 67 | "cell_type": "markdown", 68 | "metadata": { 69 | "slideshow": { 70 | "slide_type": "slide" 71 | } 72 | }, 73 | "source": [ 74 | "## Subproblema a Función" 75 | ] 76 | }, 77 | { 78 | "cell_type": "markdown", 79 | "metadata": { 80 | "slideshow": { 81 | "slide_type": "fragment" 82 | } 83 | }, 84 | "source": [ 85 | "Recordando los contenidos vistos en clases anteriores, podríamos relacionar cada subproblema a una función. De esta forma el esquema anterior quedaría más o menos así:" 86 | ] 87 | }, 88 | { 89 | "cell_type": "markdown", 90 | "metadata": { 91 | "slideshow": { 92 | "slide_type": "slide" 93 | } 94 | }, 95 | "source": [ 96 | "```python\n", 97 | "# Inicio de mi algoritmo (problema):\n", 98 | "def funcion1(...):\n", 99 | " Instrucciones\n", 100 | "def funcion2(...):\n", 101 | " Instrucciones\n", 102 | "....\n", 103 | "Instrucciones\n", 104 | "funcion1(...)\n", 105 | "Instrucciones\n", 106 | "funcion2(...)\n", 107 | "...\n", 108 | "# Fin de mi algoritmo```" 109 | ] 110 | }, 111 | { 112 | "cell_type": "markdown", 113 | "metadata": { 114 | "slideshow": { 115 | "slide_type": "slide" 116 | } 117 | }, 118 | "source": [ 119 | "En resumen, buscamos descomponer nuestro algoritmo en funciones, integrar estas funciones y finalmente obtener nuestra solución." 120 | ] 121 | }, 122 | { 123 | "cell_type": "markdown", 124 | "metadata": { 125 | "slideshow": { 126 | "slide_type": "fragment" 127 | } 128 | }, 129 | "source": [ 130 | "Ahora el problema está en la capacidad de encontrar los subproblemas... Pero generalmente son bastante simples de identificar :)" 131 | ] 132 | }, 133 | { 134 | "cell_type": "markdown", 135 | "metadata": { 136 | "slideshow": { 137 | "slide_type": "slide" 138 | } 139 | }, 140 | "source": [ 141 | "## Variables Globales y Locales" 142 | ] 143 | }, 144 | { 145 | "cell_type": "markdown", 146 | "metadata": { 147 | "slideshow": { 148 | "slide_type": "fragment" 149 | } 150 | }, 151 | "source": [ 152 | "Si bien hay una definición mucho más completa de los tipos de variables *Globales* y *Locales*, para nosotros bastará diferenciarlas de la siguiente manera:\n", 153 | "* **Variable local**: es una variable que sólo se usa dentro del código de una función. \n", 154 | "* **Variable global**: es una variable que se puede utilizar en cualquier parte del programa, inclusive al interior de una función.\n", 155 | "\n", 156 | "A continuación un pequeño ejemplo..." 157 | ] 158 | }, 159 | { 160 | "cell_type": "markdown", 161 | "metadata": { 162 | "slideshow": { 163 | "slide_type": "slide" 164 | } 165 | }, 166 | "source": [ 167 | "**Ejemplo**\n", 168 | "\n", 169 | "La fuerza de atracción gravitacional entre dos planetas de masas $m_1$ y $m_2$ separados por una distancia de $r$\n", 170 | "kilómetros está dada por la fórmula:\n", 171 | "\n", 172 | "$$\n", 173 | "F = \\frac{G\\,m_1\\,m_2}{r^2},\n", 174 | "$$\n", 175 | "\n", 176 | "donde $G = 6,67428\\times 10^{−11}$ [m$^3$ kg$^{−1}$ s$^{−2}$] es la constante de gravitación universal.\n", 177 | "\n", 178 | "Escriba un programa que pregunte las masas de los planetas y su distancia, y entregue la fuerza de atracción entre ellos." 179 | ] 180 | }, 181 | { 182 | "cell_type": "markdown", 183 | "metadata": { 184 | "slideshow": { 185 | "slide_type": "slide" 186 | } 187 | }, 188 | "source": [ 189 | "Opción 1, utilizando $G$ como variable **global**." 190 | ] 191 | }, 192 | { 193 | "cell_type": "code", 194 | "execution_count": 1, 195 | "metadata": { 196 | "slideshow": { 197 | "slide_type": "fragment" 198 | } 199 | }, 200 | "outputs": [ 201 | { 202 | "name": "stdout", 203 | "output_type": "stream", 204 | "text": [ 205 | "m1: 5\n", 206 | "m2: 1000\n", 207 | "Distancia: 10\n", 208 | "La fuerza de atraccion es 3.3371399999999995e-09\n" 209 | ] 210 | } 211 | ], 212 | "source": [ 213 | "G = 6.67428e-11 # Variable global. Puede ser utilizada en cualquier parte del código\n", 214 | "\n", 215 | "def cgu(masa1, masa2, radio):\n", 216 | " # La variable fuerza se comporta como variable local, \n", 217 | " # solo se conoce dentro de la función cgu\n", 218 | " fuerza = G * masa1 * masa2 / (radio ** 2) \n", 219 | " return fuerza\n", 220 | "\n", 221 | "m1 = float(input('m1: '))\n", 222 | "m2 = float(input('m2: '))\n", 223 | "r = float(input('Distancia: '))\n", 224 | "print('La fuerza de atraccion es', cgu(m1, m2, r))" 225 | ] 226 | }, 227 | { 228 | "cell_type": "markdown", 229 | "metadata": { 230 | "slideshow": { 231 | "slide_type": "slide" 232 | } 233 | }, 234 | "source": [ 235 | "Opción 2, utilizando $G$ como variable **local**." 236 | ] 237 | }, 238 | { 239 | "cell_type": "code", 240 | "execution_count": 11, 241 | "metadata": { 242 | "slideshow": { 243 | "slide_type": "fragment" 244 | } 245 | }, 246 | "outputs": [ 247 | { 248 | "name": "stdout", 249 | "output_type": "stream", 250 | "text": [ 251 | "m1: 1\n", 252 | "m2: 1\n", 253 | "Distancia: 1\n", 254 | "La fuerza de atraccion es 6.67428e-11\n" 255 | ] 256 | } 257 | ], 258 | "source": [ 259 | "def cgu(masa1, masa2, radio):\n", 260 | " # Tanto fuerza como G son variables locales que solo se conocen en cgu.\n", 261 | " G = 6.67428e-11\n", 262 | " fuerza = G * masa1 * masa2 / (radio ** 2) \n", 263 | " return fuerza\n", 264 | "\n", 265 | "m1 = float(input('m1: '))\n", 266 | "m2 = float(input('m2: '))\n", 267 | "r = float(input('Distancia: '))\n", 268 | "print('La fuerza de atraccion es', cgu(m1, m2, r))" 269 | ] 270 | }, 271 | { 272 | "cell_type": "markdown", 273 | "metadata": { 274 | "slideshow": { 275 | "slide_type": "slide" 276 | } 277 | }, 278 | "source": [ 279 | "# Ciclos Anidados" 280 | ] 281 | }, 282 | { 283 | "cell_type": "markdown", 284 | "metadata": { 285 | "slideshow": { 286 | "slide_type": "fragment" 287 | } 288 | }, 289 | "source": [ 290 | "Como su nombre lo dice, hay problemas en los cuales es necesario utilizar una estructura repetitiva dentro de otra estructura repetiva. Sintaxis general:\n", 291 | "\n", 292 | "```\n", 293 | "ciclo:\n", 294 | " ciclo:\n", 295 | " ciclo:\n", 296 | " ...\n", 297 | "```" 298 | ] 299 | }, 300 | { 301 | "cell_type": "markdown", 302 | "metadata": { 303 | "slideshow": { 304 | "slide_type": "slide" 305 | } 306 | }, 307 | "source": [ 308 | "Y en Python:\n", 309 | "\n", 310 | "```python\n", 311 | "while condicion:\n", 312 | " while condicion:\n", 313 | " while condicion:\n", 314 | " instrucciones\n", 315 | " ...\n", 316 | "```" 317 | ] 318 | }, 319 | { 320 | "cell_type": "markdown", 321 | "metadata": { 322 | "slideshow": { 323 | "slide_type": "slide" 324 | } 325 | }, 326 | "source": [ 327 | "**Pequeño Ejemplo**\n", 328 | "\n", 329 | "Escriba un programa que muestre todas las combinaciones de dos dados que entreguen un puntaje mayor que siete." 330 | ] 331 | }, 332 | { 333 | "cell_type": "code", 334 | "execution_count": 2, 335 | "metadata": { 336 | "slideshow": { 337 | "slide_type": "fragment" 338 | } 339 | }, 340 | "outputs": [ 341 | { 342 | "name": "stdout", 343 | "output_type": "stream", 344 | "text": [ 345 | "2 6\n", 346 | "3 5\n", 347 | "3 6\n", 348 | "4 4\n", 349 | "4 5\n", 350 | "4 6\n", 351 | "5 3\n", 352 | "5 4\n", 353 | "5 5\n", 354 | "5 6\n", 355 | "6 2\n", 356 | "6 3\n", 357 | "6 4\n", 358 | "6 5\n", 359 | "6 6\n" 360 | ] 361 | } 362 | ], 363 | "source": [ 364 | "dado_1 = 1\n", 365 | "while dado_1 <= 6:\n", 366 | " dado_2 = 1\n", 367 | " while dado_2 <= 6:\n", 368 | " if dado_1 + dado_2 > 7:\n", 369 | " print(dado_1, dado_2)\n", 370 | " dado_2 += 1\n", 371 | " dado_1 += 1" 372 | ] 373 | }, 374 | { 375 | "cell_type": "markdown", 376 | "metadata": { 377 | "slideshow": { 378 | "slide_type": "slide" 379 | } 380 | }, 381 | "source": [ 382 | "Y para que el puntaje sea mayor a 12?" 383 | ] 384 | }, 385 | { 386 | "cell_type": "markdown", 387 | "metadata": { 388 | "slideshow": { 389 | "slide_type": "slide" 390 | } 391 | }, 392 | "source": [ 393 | "**Otro ejemplo**\n", 394 | "\n", 395 | "Imprimir (mostrar) todos los números primos en un rango particular recibido como entrada." 396 | ] 397 | }, 398 | { 399 | "cell_type": "code", 400 | "execution_count": 3, 401 | "metadata": { 402 | "slideshow": { 403 | "slide_type": "slide" 404 | } 405 | }, 406 | "outputs": [ 407 | { 408 | "name": "stdout", 409 | "output_type": "stream", 410 | "text": [ 411 | "Ingrese a: 0\n", 412 | "Ingrese b: 10\n", 413 | "0\n", 414 | "1\n", 415 | "2\n", 416 | "3\n", 417 | "5\n", 418 | "7\n" 419 | ] 420 | } 421 | ], 422 | "source": [ 423 | "# Suponiendo que el rango es siempre correcto (no hay que verificar)\n", 424 | "a = int(input(\"Ingrese a: \"))\n", 425 | "b = int(input(\"Ingrese b: \"))\n", 426 | "\n", 427 | "# Variable que utilizaremos para probar si es primo\n", 428 | "n = a\n", 429 | "\n", 430 | "while n <= b:\n", 431 | " d = 2 # Variable para buscar divisores\n", 432 | " n_divisores = 0 # Contador para numero de divisores\n", 433 | " while d <= n/2:\n", 434 | " if n % d == 0:\n", 435 | " n_divisores += 1\n", 436 | " d += 1\n", 437 | " \n", 438 | " # Mostramos el numero si es primo\n", 439 | " if n_divisores == 0:\n", 440 | " print(n)\n", 441 | " \n", 442 | " # Seguimos con el proximo numero\n", 443 | " n += 1" 444 | ] 445 | }, 446 | { 447 | "cell_type": "markdown", 448 | "metadata": { 449 | "slideshow": { 450 | "slide_type": "slide" 451 | } 452 | }, 453 | "source": [ 454 | "# Ejercicios" 455 | ] 456 | }, 457 | { 458 | "cell_type": "markdown", 459 | "metadata": { 460 | "slideshow": { 461 | "slide_type": "fragment" 462 | } 463 | }, 464 | "source": [ 465 | "Apliquemos los conceptos revisados en esta clase." 466 | ] 467 | }, 468 | { 469 | "cell_type": "markdown", 470 | "metadata": { 471 | "slideshow": { 472 | "slide_type": "slide" 473 | } 474 | }, 475 | "source": [ 476 | "1. Aproxime la función $e^x$ utilizando *Serie de Taylor*:\n", 477 | "\n", 478 | "\\begin{equation}\n", 479 | " e^x \\approx \\sum_{n=0}^{N} \\frac{x^n}{n!}, \\quad \\forall x \\in \\mathbb{R}, \\, n\\in\\mathbb{N}_0\n", 480 | "\\end{equation}" 481 | ] 482 | }, 483 | { 484 | "cell_type": "code", 485 | "execution_count": 17, 486 | "metadata": { 487 | "slideshow": { 488 | "slide_type": "slide" 489 | } 490 | }, 491 | "outputs": [ 492 | { 493 | "name": "stdout", 494 | "output_type": "stream", 495 | "text": [ 496 | "Ingrese N: 10\n", 497 | "Ingrese x: 5\n", 498 | "Valor aproximacion: 146.38060102513225\n" 499 | ] 500 | } 501 | ], 502 | "source": [ 503 | "N = int(input(\"Ingrese N: \"))\n", 504 | "x = float(input(\"Ingrese x: \"))\n", 505 | "\n", 506 | "n = 0\n", 507 | "exp = 0\n", 508 | "while n <= N:\n", 509 | " \n", 510 | " # Calculo de factorial\n", 511 | " prod = 1\n", 512 | " i = 1\n", 513 | " while i <= n:\n", 514 | " prod *= i\n", 515 | " i += 1\n", 516 | " \n", 517 | " # Actualizar acumulador\n", 518 | " exp = exp + (x ** n) / prod\n", 519 | " \n", 520 | " n += 1 \n", 521 | " \n", 522 | "print(\"Valor aproximacion: \", exp)" 523 | ] 524 | }, 525 | { 526 | "cell_type": "markdown", 527 | "metadata": { 528 | "slideshow": { 529 | "slide_type": "slide" 530 | } 531 | }, 532 | "source": [ 533 | "Resolvamos el mismo ejercicio pero descomponiendo el problema." 534 | ] 535 | }, 536 | { 537 | "cell_type": "code", 538 | "execution_count": 4, 539 | "metadata": { 540 | "slideshow": { 541 | "slide_type": "slide" 542 | } 543 | }, 544 | "outputs": [], 545 | "source": [ 546 | "def factorial(n):\n", 547 | " prod = 1\n", 548 | " i = 1\n", 549 | " while i <= n:\n", 550 | " prod *= i\n", 551 | " i += 1\n", 552 | " return prod" 553 | ] 554 | }, 555 | { 556 | "cell_type": "code", 557 | "execution_count": 5, 558 | "metadata": { 559 | "slideshow": { 560 | "slide_type": "slide" 561 | } 562 | }, 563 | "outputs": [], 564 | "source": [ 565 | "def aproximacion(N, x):\n", 566 | " n = 0\n", 567 | " exp = 0\n", 568 | " while n <= N:\n", 569 | " exp += (x ** n) / factorial(n)\n", 570 | " n += 1\n", 571 | " return exp" 572 | ] 573 | }, 574 | { 575 | "cell_type": "code", 576 | "execution_count": 6, 577 | "metadata": { 578 | "slideshow": { 579 | "slide_type": "slide" 580 | } 581 | }, 582 | "outputs": [ 583 | { 584 | "name": "stdout", 585 | "output_type": "stream", 586 | "text": [ 587 | "Ingrese N: 100\n", 588 | "Ingrese x: 1\n", 589 | "Valor aproximacion: 2.7182818284590455\n" 590 | ] 591 | } 592 | ], 593 | "source": [ 594 | "N = int(input(\"Ingrese N: \"))\n", 595 | "x = float(input(\"Ingrese x: \"))\n", 596 | "\n", 597 | "exp_aprox = aproximacion(N, x)\n", 598 | "\n", 599 | "print(\"Valor aproximacion: \", exp_aprox)" 600 | ] 601 | }, 602 | { 603 | "cell_type": "markdown", 604 | "metadata": { 605 | "slideshow": { 606 | "slide_type": "slide" 607 | } 608 | }, 609 | "source": [ 610 | "2. Basándose en el ejercicio anterior. Calcule la aproximación de $e^x$ hasta que la diferencia entre dos sumandos sucesivos sea menor a un $\\varepsilon$." 611 | ] 612 | }, 613 | { 614 | "cell_type": "code", 615 | "execution_count": 29, 616 | "metadata": { 617 | "slideshow": { 618 | "slide_type": "slide" 619 | } 620 | }, 621 | "outputs": [ 622 | { 623 | "name": "stdout", 624 | "output_type": "stream", 625 | "text": [ 626 | "Ingrese x: 5\n", 627 | "Ingrese epsilon: 1e-14\n", 628 | "Aproximacion: 148.41315910257657\n", 629 | "Numero de terminos: 32\n" 630 | ] 631 | } 632 | ], 633 | "source": [ 634 | "x = float(input(\"Ingrese x: \"))\n", 635 | "eps = float(input(\"Ingrese epsilon: \"))\n", 636 | "\n", 637 | "flag = True\n", 638 | "\n", 639 | "n = 1\n", 640 | "while flag:\n", 641 | " aprox_1 = aproximacion(n, x)\n", 642 | " aprox_2 = aproximacion(n+1, x)\n", 643 | " \n", 644 | " if abs(aprox_1 - aprox_2) < eps:\n", 645 | " flag = False\n", 646 | " else:\n", 647 | " n += 1\n", 648 | " \n", 649 | "print(\"Aproximacion: \", aprox_2)\n", 650 | "print(\"Numero de terminos: \", n)" 651 | ] 652 | }, 653 | { 654 | "cell_type": "markdown", 655 | "metadata": { 656 | "slideshow": { 657 | "slide_type": "slide" 658 | } 659 | }, 660 | "source": [ 661 | "Solo por curiosidad..." 662 | ] 663 | }, 664 | { 665 | "cell_type": "code", 666 | "execution_count": 31, 667 | "metadata": { 668 | "slideshow": { 669 | "slide_type": "fragment" 670 | } 671 | }, 672 | "outputs": [ 673 | { 674 | "name": "stdout", 675 | "output_type": "stream", 676 | "text": [ 677 | "148.4131591025766\n" 678 | ] 679 | } 680 | ], 681 | "source": [ 682 | "from math import exp\n", 683 | "print(exp(x))" 684 | ] 685 | }, 686 | { 687 | "cell_type": "markdown", 688 | "metadata": { 689 | "slideshow": { 690 | "slide_type": "slide" 691 | } 692 | }, 693 | "source": [ 694 | "3. En cada ronda del juego del cachipún, los dos competidores deben elegir entre jugar tijera, papel o piedra. Las reglas para decidir quién gana la ronda son: tijera le gana a papel, papel le gana a piedra, piedra le gana a tijera, y todas las demás combinaciones son empates. \n", 695 | "\n", 696 | "El ganador del juego es el primero que gane tres rondas.\n", 697 | "\n", 698 | "Escriba un programa que pregunte a cada jugador cuál es su jugada, muestre cuál es el marcador después de cada ronda, y termine cuando uno de ellos haya ganado tres rondas. Los jugadores deben indicar su jugada escribiendo tijera, papel o piedra." 699 | ] 700 | }, 701 | { 702 | "cell_type": "code", 703 | "execution_count": 11, 704 | "metadata": { 705 | "slideshow": { 706 | "slide_type": "slide" 707 | } 708 | }, 709 | "outputs": [], 710 | "source": [ 711 | "def cachipun(j1, j2):\n", 712 | " gana = 0 # Para manejar el empate\n", 713 | " if j1 == 'piedra':\n", 714 | " if j2 == 'papel':\n", 715 | " gana = 0\n", 716 | " elif j2 == 'tijera':\n", 717 | " gana = 1\n", 718 | " elif j1 == 'papel':\n", 719 | " if j2 == 'piedra':\n", 720 | " gana = 1\n", 721 | " elif j2 == 'tijera':\n", 722 | " gana = 0\n", 723 | " else:\n", 724 | " if j2 == 'piedra':\n", 725 | " gana = 0\n", 726 | " elif j2 == 'papel':\n", 727 | " gana = 1\n", 728 | " return gana" 729 | ] 730 | }, 731 | { 732 | "cell_type": "code", 733 | "execution_count": 12, 734 | "metadata": { 735 | "slideshow": { 736 | "slide_type": "slide" 737 | } 738 | }, 739 | "outputs": [ 740 | { 741 | "name": "stdout", 742 | "output_type": "stream", 743 | "text": [ 744 | "Jugador 1: papel\n", 745 | "Jugador 2: tijera\n", 746 | "Marcador: 0 - 1\n", 747 | "Jugador 1: tijera\n", 748 | "Jugador 2: papel\n", 749 | "Marcador: 1 - 1\n", 750 | "Jugador 1: piedra\n", 751 | "Jugador 2: piedra\n", 752 | "Marcador: 1 - 1\n", 753 | "Jugador 1: piedra\n", 754 | "Jugador 2: tijera\n", 755 | "Marcador: 2 - 1\n", 756 | "Jugador 1: tijera\n", 757 | "Jugador 2: papel\n", 758 | "Marcador: 3 - 1\n", 759 | "Gana jugador 1\n" 760 | ] 761 | } 762 | ], 763 | "source": [ 764 | "p1 = 0\n", 765 | "p2 = 0\n", 766 | "\n", 767 | "while p1 < 3 and p2 < 3:\n", 768 | " jug_1 = input(\"Jugador 1: \")\n", 769 | " jug_2 = input(\"Jugador 2: \")\n", 770 | " \n", 771 | " if jug_1 != jug_2:\n", 772 | " res = cachipun(jug_1, jug_2)\n", 773 | " p1 += res\n", 774 | " p2 += (1 - res)\n", 775 | " \n", 776 | " print(\"Marcador: \", p1, \" - \", p2)\n", 777 | " \n", 778 | "if p1 > p2:\n", 779 | " print(\"Gana jugador 1\")\n", 780 | "else:\n", 781 | " print(\"Gana jugador 2\")" 782 | ] 783 | }, 784 | { 785 | "cell_type": "markdown", 786 | "metadata": { 787 | "slideshow": { 788 | "slide_type": "slide" 789 | } 790 | }, 791 | "source": [ 792 | "4. El **método de Newton** es un algoritmo para encontrar aproximaciones de los ceros o raíces de una función real.\n", 793 | "\n", 794 | "\\begin{equation}\n", 795 | " x_{n+1} = x_n - \\frac{f(x_n)}{f'(x_n)}.\n", 796 | "\\end{equation}\n", 797 | "\n", 798 | "Calcule $\\sqrt{2}$, sabiendo que $f(x)=x^2-2$, $f'(x)=2x$. El número máximo de iteraciones $N$ y $x_0$ son entradas del programa." 799 | ] 800 | }, 801 | { 802 | "cell_type": "code", 803 | "execution_count": 11, 804 | "metadata": { 805 | "slideshow": { 806 | "slide_type": "slide" 807 | } 808 | }, 809 | "outputs": [ 810 | { 811 | "name": "stdout", 812 | "output_type": "stream", 813 | "text": [ 814 | "Ingrese valor inicial: 1000\n", 815 | "Ingrese numero de iteraciones: 10\n", 816 | "La raiz de 2 es aproximadamente: 1.5795487524060154\n" 817 | ] 818 | } 819 | ], 820 | "source": [ 821 | "def f(x):\n", 822 | " return x**2 - 2\n", 823 | "\n", 824 | "def df(x):\n", 825 | " return 2*x\n", 826 | "\n", 827 | "def metodo_newton(x_0, N):\n", 828 | " n = 1\n", 829 | " x = x_0 # Valor inicial\n", 830 | " while n <= N:\n", 831 | " x = x - f(x) / df(x)\n", 832 | " n += 1\n", 833 | " return x\n", 834 | "\n", 835 | "x_0 = float(input(\"Ingrese valor inicial: \"))\n", 836 | "N = int(input(\"Ingrese numero de iteraciones: \"))\n", 837 | "\n", 838 | "sol = metodo_newton(x_0, N)\n", 839 | "\n", 840 | "print(\"La raiz de 2 es aproximadamente: \", sol)" 841 | ] 842 | }, 843 | { 844 | "cell_type": "markdown", 845 | "metadata": { 846 | "slideshow": { 847 | "slide_type": "slide" 848 | } 849 | }, 850 | "source": [ 851 | "Nuevamente por curiosidad..." 852 | ] 853 | }, 854 | { 855 | "cell_type": "code", 856 | "execution_count": 12, 857 | "metadata": { 858 | "slideshow": { 859 | "slide_type": "fragment" 860 | } 861 | }, 862 | "outputs": [ 863 | { 864 | "name": "stdout", 865 | "output_type": "stream", 866 | "text": [ 867 | "1.4142135623730951\n" 868 | ] 869 | } 870 | ], 871 | "source": [ 872 | "from math import sqrt\n", 873 | "print(sqrt(2))" 874 | ] 875 | }, 876 | { 877 | "cell_type": "code", 878 | "execution_count": 13, 879 | "metadata": { 880 | "slideshow": { 881 | "slide_type": "fragment" 882 | } 883 | }, 884 | "outputs": [ 885 | { 886 | "name": "stdout", 887 | "output_type": "stream", 888 | "text": [ 889 | "0.1653351900329203\n" 890 | ] 891 | } 892 | ], 893 | "source": [ 894 | "print(abs(sol-sqrt(2)))" 895 | ] 896 | } 897 | ], 898 | "metadata": { 899 | "celltoolbar": "Slideshow", 900 | "kernelspec": { 901 | "display_name": "Python 3", 902 | "language": "python", 903 | "name": "python3" 904 | }, 905 | "language_info": { 906 | "codemirror_mode": { 907 | "name": "ipython", 908 | "version": 3 909 | }, 910 | "file_extension": ".py", 911 | "mimetype": "text/x-python", 912 | "name": "python", 913 | "nbconvert_exporter": "python", 914 | "pygments_lexer": "ipython3", 915 | "version": "3.7.2" 916 | } 917 | }, 918 | "nbformat": 4, 919 | "nbformat_minor": 2 920 | } 921 | -------------------------------------------------------------------------------- /Clase01_Intro_Programacion_2019.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": { 6 | "colab_type": "text", 7 | "id": "KnAJIAL4sqXc", 8 | "slideshow": { 9 | "slide_type": "slide" 10 | } 11 | }, 12 | "source": [ 13 | "\"\"\n", 14 | "\"\"\n", 15 | "\n", 16 | "
\n", 17 | "
\n", 18 | "

IWI131 Programación


\n", 19 | "

Introducción a la Programación

\n", 20 | "

\n", 21 | "Departamento de Informática
\n", 22 | "Universidad Técnica Federico Santa María\n", 23 | "
" 24 | ] 25 | }, 26 | { 27 | "cell_type": "markdown", 28 | "metadata": { 29 | "colab_type": "text", 30 | "id": "wfwZI3GxsqXe", 31 | "slideshow": { 32 | "slide_type": "slide" 33 | } 34 | }, 35 | "source": [ 36 | "# Algoritmos" 37 | ] 38 | }, 39 | { 40 | "cell_type": "markdown", 41 | "metadata": { 42 | "colab_type": "text", 43 | "id": "6JfAj5z7sqXf", 44 | "slideshow": { 45 | "slide_type": "fragment" 46 | } 47 | }, 48 | "source": [ 49 | "Un algoritmo es una **secuencia** finita y **precisa** de pasos para resolver un **problema**." 50 | ] 51 | }, 52 | { 53 | "cell_type": "markdown", 54 | "metadata": { 55 | "colab_type": "text", 56 | "id": "QhnyucxOsqXg", 57 | "slideshow": { 58 | "slide_type": "fragment" 59 | } 60 | }, 61 | "source": [ 62 | "Entonces, ¿qué es un problema?" 63 | ] 64 | }, 65 | { 66 | "cell_type": "markdown", 67 | "metadata": { 68 | "colab_type": "text", 69 | "id": "LpdzdfGisqXh", 70 | "slideshow": { 71 | "slide_type": "slide" 72 | } 73 | }, 74 | "source": [ 75 | "# Problemas" 76 | ] 77 | }, 78 | { 79 | "cell_type": "markdown", 80 | "metadata": { 81 | "colab_type": "text", 82 | "id": "IjQ6NX7esqXj", 83 | "slideshow": { 84 | "slide_type": "fragment" 85 | } 86 | }, 87 | "source": [ 88 | "Un problema es la necesidad de transformar un **estado inicial** en un **estado final**, respetando ciertas restricciones. " 89 | ] 90 | }, 91 | { 92 | "cell_type": "markdown", 93 | "metadata": { 94 | "colab_type": "text", 95 | "id": "ED3wwIivsqXk", 96 | "slideshow": { 97 | "slide_type": "fragment" 98 | } 99 | }, 100 | "source": [ 101 | "Los problemas involucran **datos de entrada** en el estado inical y la solución contiene **datos de salida** en el estado final. Además, probablemente involucre otros datos intermedios que son relevantes." 102 | ] 103 | }, 104 | { 105 | "cell_type": "markdown", 106 | "metadata": { 107 | "colab_type": "text", 108 | "id": "-C_p38u9sqXl", 109 | "slideshow": { 110 | "slide_type": "slide" 111 | } 112 | }, 113 | "source": [ 114 | "## Ejemplos de Problemas" 115 | ] 116 | }, 117 | { 118 | "cell_type": "markdown", 119 | "metadata": { 120 | "colab_type": "text", 121 | "id": "3U8aykZzsqXn", 122 | "slideshow": { 123 | "slide_type": "fragment" 124 | } 125 | }, 126 | "source": [ 127 | "- Dado un conjunto de números, determinar los números ordenados de menor a mayor\n", 128 | "- Dado un conjunto de ciudades, encontrar el camino más corto que recorre las ciudades.\n", 129 | "- Dado un mensaje email, encontrar la probabilidad de que sea spam\n", 130 | "- ..." 131 | ] 132 | }, 133 | { 134 | "cell_type": "markdown", 135 | "metadata": { 136 | "colab_type": "text", 137 | "id": "m4euBKGZsqXo", 138 | "slideshow": { 139 | "slide_type": "slide" 140 | } 141 | }, 142 | "source": [ 143 | "## El problema de la ambigüedad" 144 | ] 145 | }, 146 | { 147 | "cell_type": "markdown", 148 | "metadata": { 149 | "colab_type": "text", 150 | "id": "QQsArLKBsqXo", 151 | "slideshow": { 152 | "slide_type": "fragment" 153 | } 154 | }, 155 | "source": [ 156 | "
\n", 157 | "
\n", 158 | " \"\"\n", 159 | "
\n", 160 | "
\n", 161 | "Mi madre dice:
\n", 162 | "''Cariño, anda al súper y me traes una botella de leche, y si tienen huevos, compra seis\"

\n", 163 | "Cuando vuelvo me pregunta
\n", 164 | "\"¿Por qué trajiste seis botellas de leche?\"

\n", 165 | "Respondo
\n", 166 | "\"Porque había huevos\"\n", 167 | "
\n", 168 | "
" 169 | ] 170 | }, 171 | { 172 | "cell_type": "markdown", 173 | "metadata": { 174 | "colab_type": "text", 175 | "id": "Qz8NBr-hsqXq", 176 | "slideshow": { 177 | "slide_type": "slide" 178 | } 179 | }, 180 | "source": [ 181 | "## Comprensión del Problema" 182 | ] 183 | }, 184 | { 185 | "cell_type": "markdown", 186 | "metadata": { 187 | "colab_type": "text", 188 | "id": "XUS-LjgpsqXr", 189 | "slideshow": { 190 | "slide_type": "fragment" 191 | } 192 | }, 193 | "source": [ 194 | "Para poder resolver un problema se debe **comprenderlo bien**, y ser capaces de formalizarlo de alguna manera. De lo contrario, corremos el riesgo de terminar **resolviendo el problema equivocado**." 195 | ] 196 | }, 197 | { 198 | "cell_type": "markdown", 199 | "metadata": { 200 | "colab_type": "text", 201 | "id": "bK6ikuhosqXs", 202 | "slideshow": { 203 | "slide_type": "slide" 204 | } 205 | }, 206 | "source": [ 207 | "## Formalización del Problema" 208 | ] 209 | }, 210 | { 211 | "cell_type": "markdown", 212 | "metadata": { 213 | "colab_type": "text", 214 | "id": "4IhsiRQhsqXt", 215 | "slideshow": { 216 | "slide_type": "fragment" 217 | } 218 | }, 219 | "source": [ 220 | "En este proceso se debe **definir el estado final al que se quiere llegar**. Esto se logra pensando cómo se vería una solución." 221 | ] 222 | }, 223 | { 224 | "cell_type": "markdown", 225 | "metadata": { 226 | "colab_type": "text", 227 | "id": "dDFcd28DsqXu", 228 | "slideshow": { 229 | "slide_type": "fragment" 230 | } 231 | }, 232 | "source": [ 233 | "En esta etapa es importante concentrarse en el **qué** y no en el **cómo**." 234 | ] 235 | }, 236 | { 237 | "cell_type": "markdown", 238 | "metadata": { 239 | "colab_type": "text", 240 | "id": "e6if_zGxsqXv", 241 | "slideshow": { 242 | "slide_type": "slide" 243 | } 244 | }, 245 | "source": [ 246 | "**Volviendo a los algoritmos...**
\n", 247 | "Un algoritmo es una **secuencia** finita y **precisa** de pasos para resolver un **problema**." 248 | ] 249 | }, 250 | { 251 | "cell_type": "markdown", 252 | "metadata": { 253 | "colab_type": "text", 254 | "id": "uTvSglUpsqXw", 255 | "slideshow": { 256 | "slide_type": "fragment" 257 | } 258 | }, 259 | "source": [ 260 | "Una vez especificado el problema, hay que tratar de resoverlo pero ¿de qué manera se puede expresar la secuencia de instrucciones?" 261 | ] 262 | }, 263 | { 264 | "cell_type": "markdown", 265 | "metadata": { 266 | "colab_type": "text", 267 | "id": "RiQKbWCtsqXx", 268 | "slideshow": { 269 | "slide_type": "fragment" 270 | } 271 | }, 272 | "source": [ 273 | "- Lenguaje natural\n", 274 | "- Pseudocódigo\n", 275 | "- Diagramas de Flujo\n", 276 | "- Lenguajes de Bloques" 277 | ] 278 | }, 279 | { 280 | "cell_type": "markdown", 281 | "metadata": { 282 | "colab_type": "text", 283 | "id": "ugZznpBmsqXy", 284 | "slideshow": { 285 | "slide_type": "slide" 286 | } 287 | }, 288 | "source": [ 289 | "## Problema Ejemplo:\n", 290 | "\n", 291 | "Determine si un número es **primo** o **compuesto**." 292 | ] 293 | }, 294 | { 295 | "cell_type": "markdown", 296 | "metadata": { 297 | "colab_type": "text", 298 | "id": "cEuwiaMAsqX0", 299 | "slideshow": { 300 | "slide_type": "fragment" 301 | } 302 | }, 303 | "source": [ 304 | "**Definición:** un número natural `n` es primo si tiene solamente como divisores a 1 y a si mismo. En caso contrario es un número compuesto." 305 | ] 306 | }, 307 | { 308 | "cell_type": "markdown", 309 | "metadata": { 310 | "colab_type": "text", 311 | "id": "ZODRvYZRsqX2", 312 | "slideshow": { 313 | "slide_type": "slide" 314 | } 315 | }, 316 | "source": [ 317 | "### Lenguaje natural" 318 | ] 319 | }, 320 | { 321 | "cell_type": "markdown", 322 | "metadata": { 323 | "colab_type": "text", 324 | "id": "YpBKNCsOsqX3", 325 | "slideshow": { 326 | "slide_type": "fragment" 327 | } 328 | }, 329 | "source": [ 330 | "Buscar algún valor `d` que esté entre `2` y `n-1` que sea divisor de `n`.\n", 331 | "\n", 332 | "Si existe por lo menos uno de estos valores, entonces `n` es compuesto; en caso contrario, es primo." 333 | ] 334 | }, 335 | { 336 | "cell_type": "markdown", 337 | "metadata": { 338 | "colab_type": "text", 339 | "id": "xOAOrl9isqX4", 340 | "slideshow": { 341 | "slide_type": "slide" 342 | } 343 | }, 344 | "source": [ 345 | "### Pseudocódigo\n", 346 | "```\n", 347 | "leer n\n", 348 | "es_primo = verdadero\n", 349 | "d = 2\n", 350 | "```\n", 351 | "```\n", 352 | "mientras d sea menor que n:\n", 353 | " si n es divisible por d:\n", 354 | " es_primo = falso\n", 355 | " d = d + 1\n", 356 | "```\n", 357 | "```\n", 358 | "si es_primo es verdadero:\n", 359 | " escribir \"n es primo\"\n", 360 | "si no:\n", 361 | " escribir \"n es compuesto\"\n", 362 | "```\n" 363 | ] 364 | }, 365 | { 366 | "cell_type": "markdown", 367 | "metadata": { 368 | "colab_type": "text", 369 | "id": "QrhzTF0MsqX6", 370 | "slideshow": { 371 | "slide_type": "slide" 372 | } 373 | }, 374 | "source": [ 375 | "### Diagramas de Flujo\n", 376 | "\"\"/" 377 | ] 378 | }, 379 | { 380 | "cell_type": "markdown", 381 | "metadata": { 382 | "colab_type": "text", 383 | "id": "3iJlUTjqsqX6", 384 | "slideshow": { 385 | "slide_type": "slide" 386 | } 387 | }, 388 | "source": [ 389 | "### Lenguajes de Bloques" 390 | ] 391 | }, 392 | { 393 | "cell_type": "code", 394 | "execution_count": 14, 395 | "metadata": { 396 | "colab": {}, 397 | "colab_type": "code", 398 | "id": "wjtS8_8qsqX7", 399 | "outputId": "c53d4d1b-9fa4-4b8a-c939-057ce8deca64", 400 | "slideshow": { 401 | "slide_type": "fragment" 402 | } 403 | }, 404 | "outputs": [ 405 | { 406 | "data": { 407 | "text/html": [ 408 | "" 409 | ], 410 | "text/plain": [ 411 | "" 412 | ] 413 | }, 414 | "execution_count": 14, 415 | "metadata": {}, 416 | "output_type": "execute_result" 417 | } 418 | ], 419 | "source": [ 420 | "from IPython.display import HTML\n", 421 | "HTML('')" 422 | ] 423 | }, 424 | { 425 | "cell_type": "markdown", 426 | "metadata": { 427 | "colab_type": "text", 428 | "id": "NPhOhoOysqYA", 429 | "slideshow": { 430 | "slide_type": "slide" 431 | } 432 | }, 433 | "source": [ 434 | "## Estructura de un algoritmo" 435 | ] 436 | }, 437 | { 438 | "cell_type": "markdown", 439 | "metadata": { 440 | "colab_type": "text", 441 | "id": "JtJKTzJ6sqYA", 442 | "slideshow": { 443 | "slide_type": "fragment" 444 | } 445 | }, 446 | "source": [ 447 | "Las instrucciones del algoritmo pueden expresarse:\n", 448 | "- **Secuencialmente**\n", 449 | "- Tomando **decisiones**\n", 450 | "- En **repeticiones** o **ciclos**" 451 | ] 452 | }, 453 | { 454 | "cell_type": "markdown", 455 | "metadata": { 456 | "colab_type": "text", 457 | "id": "35vtupd6sqYC", 458 | "slideshow": { 459 | "slide_type": "slide" 460 | } 461 | }, 462 | "source": [ 463 | "## Usando un Lenguaje de Bloques" 464 | ] 465 | }, 466 | { 467 | "cell_type": "markdown", 468 | "metadata": { 469 | "colab_type": "text", 470 | "id": "JWTq9mUssqYC", 471 | "slideshow": { 472 | "slide_type": "fragment" 473 | } 474 | }, 475 | "source": [ 476 | "### Trinket\n", 477 | "- https://trinket.io/\n", 478 | "- Posee un entorno de diseño de algoritmos por medio de bloques" 479 | ] 480 | }, 481 | { 482 | "cell_type": "markdown", 483 | "metadata": { 484 | "colab_type": "text", 485 | "id": "MJ94_LApsqYD", 486 | "slideshow": { 487 | "slide_type": "fragment" 488 | } 489 | }, 490 | "source": [ 491 | "**Dos bloques de Trinket:**\n", 492 | "- move (mover)\n", 493 | "- turn (girar)" 494 | ] 495 | }, 496 | { 497 | "cell_type": "markdown", 498 | "metadata": { 499 | "colab_type": "text", 500 | "id": "xLtZlBF9sqYF", 501 | "slideshow": { 502 | "slide_type": "slide" 503 | } 504 | }, 505 | "source": [ 506 | "### Bloque `move` (mover)\n", 507 | "- Permite mover un cursor tantas unidades como sean indicadas por un valor numérico.\n", 508 | "- Puede mover hacia adelante (`move forward`) o mover hacia atrás (`move backward`)." 509 | ] 510 | }, 511 | { 512 | "cell_type": "markdown", 513 | "metadata": { 514 | "colab_type": "text", 515 | "id": "lIGtKolJsqYG", 516 | "slideshow": { 517 | "slide_type": "slide" 518 | } 519 | }, 520 | "source": [ 521 | "#### `move forward` (mover hacia adelante)" 522 | ] 523 | }, 524 | { 525 | "cell_type": "code", 526 | "execution_count": 15, 527 | "metadata": { 528 | "colab": {}, 529 | "colab_type": "code", 530 | "id": "n4BPwX35sqYH", 531 | "outputId": "de412a9a-c985-4dc3-f7f0-c76d6465fb42", 532 | "slideshow": { 533 | "slide_type": "fragment" 534 | } 535 | }, 536 | "outputs": [ 537 | { 538 | "data": { 539 | "text/html": [ 540 | "" 541 | ], 542 | "text/plain": [ 543 | "" 544 | ] 545 | }, 546 | "execution_count": 15, 547 | "metadata": {}, 548 | "output_type": "execute_result" 549 | } 550 | ], 551 | "source": [ 552 | "HTML('')" 553 | ] 554 | }, 555 | { 556 | "cell_type": "markdown", 557 | "metadata": { 558 | "colab_type": "text", 559 | "id": "Kp3PrcATsqYL", 560 | "slideshow": { 561 | "slide_type": "slide" 562 | } 563 | }, 564 | "source": [ 565 | "#### `move backward` (mover hacia atrás)" 566 | ] 567 | }, 568 | { 569 | "cell_type": "code", 570 | "execution_count": 16, 571 | "metadata": { 572 | "colab": {}, 573 | "colab_type": "code", 574 | "id": "USLxHJmysqYM", 575 | "outputId": "7334c254-aa75-4c77-8ae9-f8cb9aeee443", 576 | "slideshow": { 577 | "slide_type": "fragment" 578 | } 579 | }, 580 | "outputs": [ 581 | { 582 | "data": { 583 | "text/html": [ 584 | "" 585 | ], 586 | "text/plain": [ 587 | "" 588 | ] 589 | }, 590 | "execution_count": 16, 591 | "metadata": {}, 592 | "output_type": "execute_result" 593 | } 594 | ], 595 | "source": [ 596 | "HTML('')" 597 | ] 598 | }, 599 | { 600 | "cell_type": "markdown", 601 | "metadata": { 602 | "colab_type": "text", 603 | "id": "nYroxHEWsqYP", 604 | "slideshow": { 605 | "slide_type": "slide" 606 | } 607 | }, 608 | "source": [ 609 | "### Bloque `turn` (girar)\n", 610 | "- Permite girar un cursor en tantos grados como sean indicados por un valor numérico.\n", 611 | "- Se puede girar hacia la derecha (`turn right by`) o en sentido horario. \n", 612 | "- Se puede girar hacia la izquierda (`turn left by`) o en sentido anti-horario." 613 | ] 614 | }, 615 | { 616 | "cell_type": "markdown", 617 | "metadata": { 618 | "colab_type": "text", 619 | "id": "2ECxqo3YsqYR", 620 | "slideshow": { 621 | "slide_type": "slide" 622 | } 623 | }, 624 | "source": [ 625 | "#### `turn right by` (girar hacia la derecha)" 626 | ] 627 | }, 628 | { 629 | "cell_type": "code", 630 | "execution_count": 17, 631 | "metadata": { 632 | "colab": {}, 633 | "colab_type": "code", 634 | "id": "7f-10pC0sqYS", 635 | "outputId": "8be43b6d-1fa8-467a-be34-c7958a2bedf1", 636 | "slideshow": { 637 | "slide_type": "fragment" 638 | } 639 | }, 640 | "outputs": [ 641 | { 642 | "data": { 643 | "text/html": [ 644 | "" 645 | ], 646 | "text/plain": [ 647 | "" 648 | ] 649 | }, 650 | "execution_count": 17, 651 | "metadata": {}, 652 | "output_type": "execute_result" 653 | } 654 | ], 655 | "source": [ 656 | "HTML('')" 657 | ] 658 | }, 659 | { 660 | "cell_type": "markdown", 661 | "metadata": { 662 | "colab_type": "text", 663 | "collapsed": true, 664 | "id": "LuxgLER-sqYY", 665 | "slideshow": { 666 | "slide_type": "slide" 667 | } 668 | }, 669 | "source": [ 670 | "#### `turn left by` (girar hacia la izquierda)" 671 | ] 672 | }, 673 | { 674 | "cell_type": "code", 675 | "execution_count": 18, 676 | "metadata": { 677 | "colab": {}, 678 | "colab_type": "code", 679 | "id": "6iJ_ijAdsqYZ", 680 | "outputId": "b31b8651-376d-45a0-fa15-b0f0b7626e46", 681 | "slideshow": { 682 | "slide_type": "fragment" 683 | } 684 | }, 685 | "outputs": [ 686 | { 687 | "data": { 688 | "text/html": [ 689 | "" 690 | ], 691 | "text/plain": [ 692 | "" 693 | ] 694 | }, 695 | "execution_count": 18, 696 | "metadata": {}, 697 | "output_type": "execute_result" 698 | } 699 | ], 700 | "source": [ 701 | "HTML('')" 702 | ] 703 | }, 704 | { 705 | "cell_type": "markdown", 706 | "metadata": { 707 | "colab_type": "text", 708 | "id": "Myes1I31sqYc", 709 | "slideshow": { 710 | "slide_type": "slide" 711 | } 712 | }, 713 | "source": [ 714 | "## Usando un Lenguaje de Bloques" 715 | ] 716 | }, 717 | { 718 | "cell_type": "markdown", 719 | "metadata": { 720 | "colab_type": "text", 721 | "id": "JmLm5SLvsqYc", 722 | "slideshow": { 723 | "slide_type": "fragment" 724 | } 725 | }, 726 | "source": [ 727 | "La idea de un leguaje de bloques es poder **conectar los bloques** para diseñar un algoritmo que resuelva un problema. ¿Qué ocurre en el siguiente ejemplo?" 728 | ] 729 | }, 730 | { 731 | "cell_type": "code", 732 | "execution_count": 19, 733 | "metadata": { 734 | "colab": {}, 735 | "colab_type": "code", 736 | "id": "tBYyw6MlsqYd", 737 | "outputId": "845309b6-87be-4a25-d344-814f0f798331", 738 | "slideshow": { 739 | "slide_type": "fragment" 740 | } 741 | }, 742 | "outputs": [ 743 | { 744 | "data": { 745 | "text/html": [ 746 | "" 747 | ], 748 | "text/plain": [ 749 | "" 750 | ] 751 | }, 752 | "execution_count": 19, 753 | "metadata": {}, 754 | "output_type": "execute_result" 755 | } 756 | ], 757 | "source": [ 758 | "HTML('')" 759 | ] 760 | }, 761 | { 762 | "cell_type": "markdown", 763 | "metadata": { 764 | "colab_type": "text", 765 | "id": "2wRNysmVsqYg", 766 | "slideshow": { 767 | "slide_type": "slide" 768 | } 769 | }, 770 | "source": [ 771 | "## Ejercicio 1\n", 772 | "\n", 773 | "Diseñar un algoritmo que dibuje un cuadrado.\n" 774 | ] 775 | }, 776 | { 777 | "cell_type": "code", 778 | "execution_count": 7, 779 | "metadata": { 780 | "colab": {}, 781 | "colab_type": "code", 782 | "id": "2AKT1W_usqYg", 783 | "outputId": "232fd211-1447-4c2f-f099-1b806e119c49", 784 | "slideshow": { 785 | "slide_type": "fragment" 786 | } 787 | }, 788 | "outputs": [ 789 | { 790 | "data": { 791 | "text/html": [ 792 | "" 793 | ], 794 | "text/plain": [ 795 | "" 796 | ] 797 | }, 798 | "execution_count": 7, 799 | "metadata": {}, 800 | "output_type": "execute_result" 801 | } 802 | ], 803 | "source": [ 804 | "HTML('')" 805 | ] 806 | }, 807 | { 808 | "cell_type": "markdown", 809 | "metadata": { 810 | "colab_type": "text", 811 | "id": "C2W_Lo3WsqYi", 812 | "slideshow": { 813 | "slide_type": "slide" 814 | } 815 | }, 816 | "source": [ 817 | "## Ejercicio 2\n", 818 | "\n", 819 | "Diseñar un algoritmo que dibuje otra figura geométrica distinta al cuadrado." 820 | ] 821 | }, 822 | { 823 | "cell_type": "code", 824 | "execution_count": 8, 825 | "metadata": { 826 | "colab": {}, 827 | "colab_type": "code", 828 | "id": "e0lMs3J1sqYk", 829 | "outputId": "254f2004-5dad-485c-d39c-bca40354b953", 830 | "slideshow": { 831 | "slide_type": "fragment" 832 | } 833 | }, 834 | "outputs": [ 835 | { 836 | "data": { 837 | "text/html": [ 838 | "" 839 | ], 840 | "text/plain": [ 841 | "" 842 | ] 843 | }, 844 | "execution_count": 8, 845 | "metadata": {}, 846 | "output_type": "execute_result" 847 | } 848 | ], 849 | "source": [ 850 | "HTML('')" 851 | ] 852 | }, 853 | { 854 | "cell_type": "code", 855 | "execution_count": null, 856 | "metadata": { 857 | "colab": {}, 858 | "colab_type": "code", 859 | "collapsed": true, 860 | "id": "oFvikT3usqYn", 861 | "slideshow": { 862 | "slide_type": "skip" 863 | } 864 | }, 865 | "outputs": [], 866 | "source": [] 867 | } 868 | ], 869 | "metadata": { 870 | "colab": { 871 | "collapsed_sections": [], 872 | "name": "Clase01_Intro_Programación_2019.ipynb", 873 | "provenance": [], 874 | "version": "0.3.2" 875 | }, 876 | "kernelspec": { 877 | "display_name": "Python 3", 878 | "language": "python", 879 | "name": "python3" 880 | }, 881 | "language_info": { 882 | "codemirror_mode": { 883 | "name": "ipython", 884 | "version": 3 885 | }, 886 | "file_extension": ".py", 887 | "mimetype": "text/x-python", 888 | "name": "python", 889 | "nbconvert_exporter": "python", 890 | "pygments_lexer": "ipython3", 891 | "version": "3.5.2" 892 | } 893 | }, 894 | "nbformat": 4, 895 | "nbformat_minor": 1 896 | } 897 | -------------------------------------------------------------------------------- /Clase03_Algoritmos_Trinket_2019.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": { 6 | "colab_type": "text", 7 | "id": "_rPxQN5ys4D7", 8 | "slideshow": { 9 | "slide_type": "slide" 10 | } 11 | }, 12 | "source": [ 13 | "\"\"\n", 14 | "\"\"\n", 15 | "\n", 16 | "
\n", 17 | "
\n", 18 | "

IWI131 Programación


\n", 19 | "

Algoritmos Generales con Trinket

\n", 20 | "

\n", 21 | "Departamento de Informática
\n", 22 | "Universidad Técnica Federico Santa María\n", 23 | "
" 24 | ] 25 | }, 26 | { 27 | "cell_type": "markdown", 28 | "metadata": { 29 | "colab_type": "text", 30 | "id": "sXKOzmjBs4EE", 31 | "slideshow": { 32 | "slide_type": "slide" 33 | } 34 | }, 35 | "source": [ 36 | "# Algoritmos" 37 | ] 38 | }, 39 | { 40 | "cell_type": "markdown", 41 | "metadata": { 42 | "colab_type": "text", 43 | "id": "x5ewA5fls4Eh", 44 | "slideshow": { 45 | "slide_type": "slide" 46 | } 47 | }, 48 | "source": [ 49 | "## Decisiones" 50 | ] 51 | }, 52 | { 53 | "cell_type": "markdown", 54 | "metadata": { 55 | "colab_type": "text", 56 | "id": "DZNN_h-m2Uyf", 57 | "slideshow": { 58 | "slide_type": "fragment" 59 | } 60 | }, 61 | "source": [ 62 | "Existen problemas en los cuales nuestros algoritmos toman decisiones o se bifurcan, por ejemplo: \n", 63 | "\n", 64 | "\n", 65 | "1. Saber si un número es par.\n", 66 | "2. Verificar que un número sea positivo e impar.\n", 67 | "3. La definición del valor absoluto.\n", 68 | "\\begin{equation}\n", 69 | " |x|=\n", 70 | " \\begin{cases}\n", 71 | " \\hfill x, & \\text{si } x \\geq 0 \\\\ \n", 72 | " -x, & \\text{si } x < 0 \\\\ \n", 73 | " \\end{cases}\n", 74 | "\\end{equation}" 75 | ] 76 | }, 77 | { 78 | "cell_type": "markdown", 79 | "metadata": { 80 | "colab_type": "text", 81 | "id": "OG4mRCRAs4ES", 82 | "slideshow": { 83 | "slide_type": "slide" 84 | } 85 | }, 86 | "source": [ 87 | "## Repeticiones o Ciclos\n" 88 | ] 89 | }, 90 | { 91 | "cell_type": "markdown", 92 | "metadata": { 93 | "colab_type": "text", 94 | "id": "TSmSZlq-s4EW", 95 | "slideshow": { 96 | "slide_type": "fragment" 97 | } 98 | }, 99 | "source": [ 100 | "Hay veces que notamos ciertos patrones que se repiten dentro de un algoritmo, por ejemplo:\n", 101 | "\n", 102 | "\n", 103 | "1. Obtener el promedio de $N$ elementos.\n", 104 | "2. Dado un conjunto de números, obtener el mayor/menor.\n", 105 | "3. Buscar los divisores de un número.\n", 106 | "\n" 107 | ] 108 | }, 109 | { 110 | "cell_type": "markdown", 111 | "metadata": { 112 | "colab_type": "text", 113 | "id": "A_eoh8gsxrtR", 114 | "slideshow": { 115 | "slide_type": "skip" 116 | } 117 | }, 118 | "source": [ 119 | "## Lenguaje de bloques" 120 | ] 121 | }, 122 | { 123 | "cell_type": "markdown", 124 | "metadata": { 125 | "colab_type": "text", 126 | "id": "hwZsbrT2xuxC", 127 | "slideshow": { 128 | "slide_type": "slide" 129 | } 130 | }, 131 | "source": [ 132 | "### Bloque `print`\n", 133 | "\n", 134 | "***Imprime*** un mensaje" 135 | ] 136 | }, 137 | { 138 | "cell_type": "code", 139 | "execution_count": 1, 140 | "metadata": { 141 | "colab": { 142 | "base_uri": "https://localhost:8080/", 143 | "height": 620 144 | }, 145 | "colab_type": "code", 146 | "executionInfo": { 147 | "elapsed": 552, 148 | "status": "ok", 149 | "timestamp": 1551157554990, 150 | "user": { 151 | "displayName": "Daniel San Martín", 152 | "photoUrl": "https://lh4.googleusercontent.com/-xj_b6QASR9g/AAAAAAAAAAI/AAAAAAAAABc/MAAqQCVKo5I/s64/photo.jpg", 153 | "userId": "16014787961842903941" 154 | }, 155 | "user_tz": 180 156 | }, 157 | "id": "BVVrly4g2Ykz", 158 | "outputId": "cff7eafb-99ca-4e2f-b9ce-25bd5366275f", 159 | "scrolled": true, 160 | "slideshow": { 161 | "slide_type": "fragment" 162 | } 163 | }, 164 | "outputs": [ 165 | { 166 | "data": { 167 | "text/html": [ 168 | "" 169 | ], 170 | "text/plain": [ 171 | "" 172 | ] 173 | }, 174 | "metadata": {}, 175 | "output_type": "display_data" 176 | } 177 | ], 178 | "source": [ 179 | "from IPython.core.display import display, HTML\n", 180 | "display(HTML(''))" 181 | ] 182 | }, 183 | { 184 | "cell_type": "markdown", 185 | "metadata": { 186 | "colab_type": "text", 187 | "id": "MvB8m6IGz7CP", 188 | "slideshow": { 189 | "slide_type": "slide" 190 | } 191 | }, 192 | "source": [ 193 | "### Bloque `if-else`\n", 194 | "\n", 195 | "Permite bifurcar un algoritmo. ***Si*** se cumple la condición realiza una acción, ***sino*** realiza la otra." 196 | ] 197 | }, 198 | { 199 | "cell_type": "code", 200 | "execution_count": 2, 201 | "metadata": { 202 | "colab": { 203 | "base_uri": "https://localhost:8080/", 204 | "height": 620 205 | }, 206 | "colab_type": "code", 207 | "executionInfo": { 208 | "elapsed": 549, 209 | "status": "ok", 210 | "timestamp": 1551157466116, 211 | "user": { 212 | "displayName": "Daniel San Martín", 213 | "photoUrl": "https://lh4.googleusercontent.com/-xj_b6QASR9g/AAAAAAAAAAI/AAAAAAAAABc/MAAqQCVKo5I/s64/photo.jpg", 214 | "userId": "16014787961842903941" 215 | }, 216 | "user_tz": 180 217 | }, 218 | "id": "sf4X5epL4RNi", 219 | "outputId": "ae25bbe9-30d9-4b54-faff-b37de29bd48e", 220 | "slideshow": { 221 | "slide_type": "fragment" 222 | } 223 | }, 224 | "outputs": [ 225 | { 226 | "data": { 227 | "text/html": [ 228 | "" 229 | ], 230 | "text/plain": [ 231 | "" 232 | ] 233 | }, 234 | "metadata": {}, 235 | "output_type": "display_data" 236 | } 237 | ], 238 | "source": [ 239 | "display(HTML(''))" 240 | ] 241 | }, 242 | { 243 | "cell_type": "markdown", 244 | "metadata": { 245 | "colab_type": "text", 246 | "id": "q50tIB5H0hgg", 247 | "slideshow": { 248 | "slide_type": "slide" 249 | } 250 | }, 251 | "source": [ 252 | "### Operadores de comparación\n", 253 | "\n", 254 | "Nos permite hacer comparación de variables para utilizarlas dentro de nuestro bloque `if-else`. Podemos realizar comparaciones aritméticas: $=, \\neq, <, \\leq, >, \\geq$ y lógicas como: `and`, `or`.\n", 255 | "\n" 256 | ] 257 | }, 258 | { 259 | "cell_type": "code", 260 | "execution_count": 3, 261 | "metadata": { 262 | "colab": { 263 | "base_uri": "https://localhost:8080/", 264 | "height": 620 265 | }, 266 | "colab_type": "code", 267 | "executionInfo": { 268 | "elapsed": 588, 269 | "status": "ok", 270 | "timestamp": 1551157422362, 271 | "user": { 272 | "displayName": "Daniel San Martín", 273 | "photoUrl": "https://lh4.googleusercontent.com/-xj_b6QASR9g/AAAAAAAAAAI/AAAAAAAAABc/MAAqQCVKo5I/s64/photo.jpg", 274 | "userId": "16014787961842903941" 275 | }, 276 | "user_tz": 180 277 | }, 278 | "id": "IW--zy2A54AX", 279 | "outputId": "9b174b66-af9f-4573-f7db-7568dbae6d97", 280 | "slideshow": { 281 | "slide_type": "fragment" 282 | } 283 | }, 284 | "outputs": [ 285 | { 286 | "data": { 287 | "text/html": [ 288 | "" 289 | ], 290 | "text/plain": [ 291 | "" 292 | ] 293 | }, 294 | "metadata": {}, 295 | "output_type": "display_data" 296 | } 297 | ], 298 | "source": [ 299 | "display(HTML(''))" 300 | ] 301 | }, 302 | { 303 | "cell_type": "markdown", 304 | "metadata": { 305 | "colab_type": "text", 306 | "id": "IoaCQANC0ltV", 307 | "slideshow": { 308 | "slide_type": "slide" 309 | } 310 | }, 311 | "source": [ 312 | "### Bloque `repeat-while`\n", 313 | "\n", 314 | "***Repetir*** una sección de código ***mientras*** se cumple una condición." 315 | ] 316 | }, 317 | { 318 | "cell_type": "code", 319 | "execution_count": 4, 320 | "metadata": { 321 | "colab": { 322 | "base_uri": "https://localhost:8080/", 323 | "height": 620 324 | }, 325 | "colab_type": "code", 326 | "executionInfo": { 327 | "elapsed": 587, 328 | "status": "ok", 329 | "timestamp": 1551157365424, 330 | "user": { 331 | "displayName": "Daniel San Martín", 332 | "photoUrl": "https://lh4.googleusercontent.com/-xj_b6QASR9g/AAAAAAAAAAI/AAAAAAAAABc/MAAqQCVKo5I/s64/photo.jpg", 333 | "userId": "16014787961842903941" 334 | }, 335 | "user_tz": 180 336 | }, 337 | "id": "DtVA4tPQ7_1P", 338 | "outputId": "7844ab1f-0f2f-49b9-dbf1-add41718d9f3", 339 | "slideshow": { 340 | "slide_type": "fragment" 341 | } 342 | }, 343 | "outputs": [ 344 | { 345 | "data": { 346 | "text/html": [ 347 | "" 348 | ], 349 | "text/plain": [ 350 | "" 351 | ] 352 | }, 353 | "metadata": {}, 354 | "output_type": "display_data" 355 | } 356 | ], 357 | "source": [ 358 | "display(HTML(''))" 359 | ] 360 | }, 361 | { 362 | "cell_type": "markdown", 363 | "metadata": { 364 | "colab_type": "text", 365 | "id": "hW6byiSZ0uTF", 366 | "slideshow": { 367 | "slide_type": "slide" 368 | } 369 | }, 370 | "source": [ 371 | "### Bloque `remainder`\n", 372 | "\n", 373 | "Calcula el ***resto*** de una división." 374 | ] 375 | }, 376 | { 377 | "cell_type": "code", 378 | "execution_count": 5, 379 | "metadata": { 380 | "colab": { 381 | "base_uri": "https://localhost:8080/", 382 | "height": 620 383 | }, 384 | "colab_type": "code", 385 | "executionInfo": { 386 | "elapsed": 507, 387 | "status": "ok", 388 | "timestamp": 1551157303076, 389 | "user": { 390 | "displayName": "Daniel San Martín", 391 | "photoUrl": "https://lh4.googleusercontent.com/-xj_b6QASR9g/AAAAAAAAAAI/AAAAAAAAABc/MAAqQCVKo5I/s64/photo.jpg", 392 | "userId": "16014787961842903941" 393 | }, 394 | "user_tz": 180 395 | }, 396 | "id": "JbEkr5Ei_4Nz", 397 | "outputId": "b0a89886-9f9b-4324-f905-edd799efbee3", 398 | "slideshow": { 399 | "slide_type": "fragment" 400 | } 401 | }, 402 | "outputs": [ 403 | { 404 | "data": { 405 | "text/html": [ 406 | "" 407 | ], 408 | "text/plain": [ 409 | "" 410 | ] 411 | }, 412 | "metadata": {}, 413 | "output_type": "display_data" 414 | } 415 | ], 416 | "source": [ 417 | "display(HTML(''))" 418 | ] 419 | }, 420 | { 421 | "cell_type": "markdown", 422 | "metadata": { 423 | "colab_type": "text", 424 | "id": "2OAst5vO00W1", 425 | "slideshow": { 426 | "slide_type": "slide" 427 | } 428 | }, 429 | "source": [ 430 | "### Bloque `is-even`\n", 431 | "\n", 432 | "Verifica si un número es ***par***." 433 | ] 434 | }, 435 | { 436 | "cell_type": "code", 437 | "execution_count": 6, 438 | "metadata": { 439 | "colab": { 440 | "base_uri": "https://localhost:8080/", 441 | "height": 620 442 | }, 443 | "colab_type": "code", 444 | "executionInfo": { 445 | "elapsed": 539, 446 | "status": "ok", 447 | "timestamp": 1551157250992, 448 | "user": { 449 | "displayName": "Daniel San Martín", 450 | "photoUrl": "https://lh4.googleusercontent.com/-xj_b6QASR9g/AAAAAAAAAAI/AAAAAAAAABc/MAAqQCVKo5I/s64/photo.jpg", 451 | "userId": "16014787961842903941" 452 | }, 453 | "user_tz": 180 454 | }, 455 | "id": "wxggKegz_5QY", 456 | "outputId": "86334a60-a3a9-495e-dd16-b5238f608c5b", 457 | "slideshow": { 458 | "slide_type": "fragment" 459 | } 460 | }, 461 | "outputs": [ 462 | { 463 | "data": { 464 | "text/html": [ 465 | "" 466 | ], 467 | "text/plain": [ 468 | "" 469 | ] 470 | }, 471 | "metadata": {}, 472 | "output_type": "display_data" 473 | } 474 | ], 475 | "source": [ 476 | "display(HTML(''))" 477 | ] 478 | }, 479 | { 480 | "cell_type": "markdown", 481 | "metadata": { 482 | "colab_type": "text", 483 | "id": "7zlVouJp1HEE", 484 | "slideshow": { 485 | "slide_type": "slide" 486 | } 487 | }, 488 | "source": [ 489 | "### Valores booleanos (`true-false`)\n", 490 | "\n", 491 | "Valores lógicos ***verdadero*** y ***falso***." 492 | ] 493 | }, 494 | { 495 | "cell_type": "code", 496 | "execution_count": 7, 497 | "metadata": { 498 | "colab": { 499 | "base_uri": "https://localhost:8080/", 500 | "height": 620 501 | }, 502 | "colab_type": "code", 503 | "executionInfo": { 504 | "elapsed": 578, 505 | "status": "ok", 506 | "timestamp": 1551157164781, 507 | "user": { 508 | "displayName": "Daniel San Martín", 509 | "photoUrl": "https://lh4.googleusercontent.com/-xj_b6QASR9g/AAAAAAAAAAI/AAAAAAAAABc/MAAqQCVKo5I/s64/photo.jpg", 510 | "userId": "16014787961842903941" 511 | }, 512 | "user_tz": 180 513 | }, 514 | "id": "pah_TSEb_6PP", 515 | "outputId": "4644821e-0430-4524-866a-31a438780f9d", 516 | "slideshow": { 517 | "slide_type": "fragment" 518 | } 519 | }, 520 | "outputs": [ 521 | { 522 | "data": { 523 | "text/html": [ 524 | "" 525 | ], 526 | "text/plain": [ 527 | "" 528 | ] 529 | }, 530 | "metadata": {}, 531 | "output_type": "display_data" 532 | } 533 | ], 534 | "source": [ 535 | "display(HTML(''))" 536 | ] 537 | }, 538 | { 539 | "cell_type": "markdown", 540 | "metadata": { 541 | "colab_type": "text", 542 | "id": "kBOIP0wL1oiC", 543 | "slideshow": { 544 | "slide_type": "slide" 545 | } 546 | }, 547 | "source": [ 548 | "### Bloque `create-text`\n", 549 | "\n", 550 | "Permite ***Crear un texto***." 551 | ] 552 | }, 553 | { 554 | "cell_type": "code", 555 | "execution_count": 8, 556 | "metadata": { 557 | "colab": { 558 | "base_uri": "https://localhost:8080/", 559 | "height": 620 560 | }, 561 | "colab_type": "code", 562 | "executionInfo": { 563 | "elapsed": 628, 564 | "status": "ok", 565 | "timestamp": 1551157069411, 566 | "user": { 567 | "displayName": "Daniel San Martín", 568 | "photoUrl": "https://lh4.googleusercontent.com/-xj_b6QASR9g/AAAAAAAAAAI/AAAAAAAAABc/MAAqQCVKo5I/s64/photo.jpg", 569 | "userId": "16014787961842903941" 570 | }, 571 | "user_tz": 180 572 | }, 573 | "id": "VcF3gOYa_68P", 574 | "outputId": "05d9953a-0bb8-4be5-a2ac-0afe93c31375", 575 | "slideshow": { 576 | "slide_type": "fragment" 577 | } 578 | }, 579 | "outputs": [ 580 | { 581 | "data": { 582 | "text/html": [ 583 | "" 584 | ], 585 | "text/plain": [ 586 | "" 587 | ] 588 | }, 589 | "metadata": {}, 590 | "output_type": "display_data" 591 | } 592 | ], 593 | "source": [ 594 | "display(HTML(''))" 595 | ] 596 | }, 597 | { 598 | "cell_type": "markdown", 599 | "metadata": { 600 | "colab_type": "text", 601 | "id": "po7bnOzVv21F", 602 | "slideshow": { 603 | "slide_type": "slide" 604 | } 605 | }, 606 | "source": [ 607 | "# Ejemplos" 608 | ] 609 | }, 610 | { 611 | "cell_type": "markdown", 612 | "metadata": { 613 | "colab_type": "text", 614 | "id": "bkhgNHXRwukX", 615 | "slideshow": { 616 | "slide_type": "slide" 617 | } 618 | }, 619 | "source": [ 620 | "## Conjetura de Ulam\n", 621 | "\n", 622 | "A partir de un número cualquiera (entrada) es posible hacer una sucesión de números que termina en 1.\n", 623 | "- Si el número es par, se debe dividir por 2.\n", 624 | "- Si el número es impar, se debe multiplicar por 3 y sumarle 1.\n", 625 | "\n", 626 | "Con esto se obtiene el siguiente número de la sucesión, al cual se le deben aplicar las mismas operaciones. La sucesión de números termina cuando el número obtenido por medio de las operaciones es 1.\n" 627 | ] 628 | }, 629 | { 630 | "cell_type": "code", 631 | "execution_count": 9, 632 | "metadata": { 633 | "colab": { 634 | "base_uri": "https://localhost:8080/", 635 | "height": 621 636 | }, 637 | "colab_type": "code", 638 | "executionInfo": { 639 | "elapsed": 977, 640 | "status": "ok", 641 | "timestamp": 1551060020237, 642 | "user": { 643 | "displayName": "Sergio Campos", 644 | "photoUrl": "", 645 | "userId": "12155360713523385064" 646 | }, 647 | "user_tz": 180 648 | }, 649 | "id": "w8YUiyfHvrUS", 650 | "outputId": "fd74cf90-a798-4733-917c-4029b907186f", 651 | "slideshow": { 652 | "slide_type": "slide" 653 | } 654 | }, 655 | "outputs": [ 656 | { 657 | "data": { 658 | "text/html": [ 659 | "" 660 | ], 661 | "text/plain": [ 662 | "" 663 | ] 664 | }, 665 | "metadata": {}, 666 | "output_type": "display_data" 667 | } 668 | ], 669 | "source": [ 670 | "display(HTML(''))" 671 | ] 672 | }, 673 | { 674 | "cell_type": "markdown", 675 | "metadata": { 676 | "colab_type": "text", 677 | "id": "XMuV6acNxMCN", 678 | "slideshow": { 679 | "slide_type": "slide" 680 | } 681 | }, 682 | "source": [ 683 | "## Número Mágico\n", 684 | "\n", 685 | "Diseñe un algoritmo para determinar si un número natural $n$ es mágico o no.\n", 686 | "\n", 687 | "Un número se dice mágico cuando la suma de sus divisores es igual al número. En la suma no se debe considerar al mismo número como un divisor.\n", 688 | "\n", 689 | "***Ejemplos:***\n", 690 | "\n", 691 | "* 28 = 1+2+4+7+14 es un número mágico\n", 692 | "* 32 != 1+2+4+8+16 no es un número mágico\n", 693 | "\n" 694 | ] 695 | }, 696 | { 697 | "cell_type": "code", 698 | "execution_count": 10, 699 | "metadata": { 700 | "colab": { 701 | "base_uri": "https://localhost:8080/", 702 | "height": 621 703 | }, 704 | "colab_type": "code", 705 | "executionInfo": { 706 | "elapsed": 912, 707 | "status": "ok", 708 | "timestamp": 1551060020241, 709 | "user": { 710 | "displayName": "Sergio Campos", 711 | "photoUrl": "", 712 | "userId": "12155360713523385064" 713 | }, 714 | "user_tz": 180 715 | }, 716 | "id": "IsHR-W0ZvzXh", 717 | "outputId": "4af94687-043d-4435-ad74-9878aafd69fd", 718 | "slideshow": { 719 | "slide_type": "slide" 720 | } 721 | }, 722 | "outputs": [ 723 | { 724 | "data": { 725 | "text/html": [ 726 | "" 727 | ], 728 | "text/plain": [ 729 | "" 730 | ] 731 | }, 732 | "metadata": {}, 733 | "output_type": "display_data" 734 | } 735 | ], 736 | "source": [ 737 | "display(HTML(''))" 738 | ] 739 | }, 740 | { 741 | "cell_type": "markdown", 742 | "metadata": { 743 | "colab_type": "text", 744 | "id": "uaaL_yRJ0lJE", 745 | "slideshow": { 746 | "slide_type": "slide" 747 | } 748 | }, 749 | "source": [ 750 | "## Adivinar un Número\n", 751 | "\n", 752 | "Diseñe un algoritmo que intente adivinar un número entre 1 y 10." 753 | ] 754 | }, 755 | { 756 | "cell_type": "code", 757 | "execution_count": 11, 758 | "metadata": { 759 | "colab": { 760 | "base_uri": "https://localhost:8080/", 761 | "height": 621 762 | }, 763 | "colab_type": "code", 764 | "executionInfo": { 765 | "elapsed": 861, 766 | "status": "ok", 767 | "timestamp": 1551060020243, 768 | "user": { 769 | "displayName": "Sergio Campos", 770 | "photoUrl": "", 771 | "userId": "12155360713523385064" 772 | }, 773 | "user_tz": 180 774 | }, 775 | "id": "Ecmzqv5h0Z3k", 776 | "outputId": "11c0ba4b-19ca-4c60-9467-f22289c0af14", 777 | "slideshow": { 778 | "slide_type": "slide" 779 | } 780 | }, 781 | "outputs": [ 782 | { 783 | "data": { 784 | "text/html": [ 785 | "" 786 | ], 787 | "text/plain": [ 788 | "" 789 | ] 790 | }, 791 | "metadata": {}, 792 | "output_type": "display_data" 793 | } 794 | ], 795 | "source": [ 796 | "display(HTML(''))" 797 | ] 798 | }, 799 | { 800 | "cell_type": "code", 801 | "execution_count": null, 802 | "metadata": { 803 | "colab": {}, 804 | "colab_type": "code", 805 | "id": "I0eZE80v2JiP", 806 | "slideshow": { 807 | "slide_type": "skip" 808 | } 809 | }, 810 | "outputs": [], 811 | "source": [] 812 | } 813 | ], 814 | "metadata": { 815 | "celltoolbar": "Slideshow", 816 | "colab": { 817 | "collapsed_sections": [], 818 | "name": "Clase03_Algoritmos_Trinket_2019.ipynb", 819 | "provenance": [], 820 | "version": "0.3.2" 821 | }, 822 | "kernelspec": { 823 | "display_name": "Python 3", 824 | "language": "python", 825 | "name": "python3" 826 | }, 827 | "language_info": { 828 | "codemirror_mode": { 829 | "name": "ipython", 830 | "version": 3 831 | }, 832 | "file_extension": ".py", 833 | "mimetype": "text/x-python", 834 | "name": "python", 835 | "nbconvert_exporter": "python", 836 | "pygments_lexer": "ipython3", 837 | "version": "3.6.8" 838 | } 839 | }, 840 | "nbformat": 4, 841 | "nbformat_minor": 1 842 | } 843 | -------------------------------------------------------------------------------- /Clase06_Ciclos_2019.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": { 6 | "colab_type": "text", 7 | "id": "myM2e0xjJFKK", 8 | "slideshow": { 9 | "slide_type": "slide" 10 | } 11 | }, 12 | "source": [ 13 | "\"\"\n", 14 | "\"\"\n", 15 | "\n", 16 | "
\n", 17 | "
\n", 18 | "

IWI131 Programación


\n", 19 | "

Estructuras Repetitivas y Ciclos

\n", 20 | "

\n", 21 | "Departamento de Informática
\n", 22 | "Universidad Técnica Federico Santa María\n", 23 | "
" 24 | ] 25 | }, 26 | { 27 | "cell_type": "markdown", 28 | "metadata": { 29 | "slideshow": { 30 | "slide_type": "slide" 31 | } 32 | }, 33 | "source": [ 34 | "## Sentencias Cíclicas\n", 35 | "\n", 36 | "Permiten realizar un conjunto instrucciones reiterativamente. Esta reiteración puede:\n", 37 | "- Ser una cantidad de terminada de veces.\n", 38 | "- Hasta que una condición se cumpla.\n", 39 | "\n", 40 | "**OJO**: Notése que una cantidad finita de veces puede ser representada como condición." 41 | ] 42 | }, 43 | { 44 | "cell_type": "markdown", 45 | "metadata": { 46 | "colab_type": "text", 47 | "id": "8F0jSoc0JFN1", 48 | "slideshow": { 49 | "slide_type": "slide" 50 | } 51 | }, 52 | "source": [ 53 | "### Ciclo while\n", 54 | "El ciclo `while` ejecuta una secuencia de instrucciones mientras una condición sea verdadera. " 55 | ] 56 | }, 57 | { 58 | "cell_type": "markdown", 59 | "metadata": { 60 | "slideshow": { 61 | "slide_type": "fragment" 62 | } 63 | }, 64 | "source": [ 65 | "**Sintaxis:**\n", 66 | "```python\n", 67 | "while cond:\n", 68 | " sentencias mientras la cond sea verdadera\n", 69 | "```" 70 | ] 71 | }, 72 | { 73 | "cell_type": "markdown", 74 | "metadata": { 75 | "colab_type": "text", 76 | "id": "b6t437drJFN2", 77 | "slideshow": { 78 | "slide_type": "fragment" 79 | } 80 | }, 81 | "source": [ 82 | "La **Indentación** después de la instrucción `while` indica que cosas se realizarán reiterativamente si se cumple la condición." 83 | ] 84 | }, 85 | { 86 | "cell_type": "markdown", 87 | "metadata": { 88 | "slideshow": { 89 | "slide_type": "slide" 90 | } 91 | }, 92 | "source": [ 93 | "### Recordatorio/Reminder\n", 94 | "\n", 95 | "La instrucción `while` equivalente al bloque `repeat-while` de trinket." 96 | ] 97 | }, 98 | { 99 | "cell_type": "markdown", 100 | "metadata": { 101 | "slideshow": { 102 | "slide_type": "fragment" 103 | } 104 | }, 105 | "source": [ 106 | "La **indentación** es equivalente a utilizar el espacio de rompecabezas interno en bloque `repeat-while` de *Trinket* (después de `do`)." 107 | ] 108 | }, 109 | { 110 | "cell_type": "code", 111 | "execution_count": 23, 112 | "metadata": { 113 | "slideshow": { 114 | "slide_type": "fragment" 115 | } 116 | }, 117 | "outputs": [ 118 | { 119 | "data": { 120 | "text/html": [ 121 | "\n", 122 | " \n", 129 | " " 130 | ], 131 | "text/plain": [ 132 | "" 133 | ] 134 | }, 135 | "execution_count": 23, 136 | "metadata": {}, 137 | "output_type": "execute_result" 138 | } 139 | ], 140 | "source": [ 141 | "from IPython.display import IFrame\n", 142 | "IFrame('https://trinket.io/embed/blocks/773558e03a?hideGeneratedCode=true', width=\"75%\", height=250)" 143 | ] 144 | }, 145 | { 146 | "cell_type": "markdown", 147 | "metadata": { 148 | "colab_type": "text", 149 | "id": "lpZbiw8JJFN3", 150 | "slideshow": { 151 | "slide_type": "slide" 152 | } 153 | }, 154 | "source": [ 155 | "## Ciclo while: Diagrama de flujo explicativo\n", 156 | "
\n", 157 | "\n", 158 | "
" 159 | ] 160 | }, 161 | { 162 | "cell_type": "markdown", 163 | "metadata": { 164 | "slideshow": { 165 | "slide_type": "slide" 166 | } 167 | }, 168 | "source": [ 169 | "## Conceptos y detalles importantes\n", 170 | "\n", 171 | "**Sintaxis:**\n", 172 | "```python\n", 173 | "while cond:\n", 174 | " sentencias mientras la cond sea verdadera\n", 175 | "```" 176 | ] 177 | }, 178 | { 179 | "cell_type": "markdown", 180 | "metadata": { 181 | "colab_type": "text", 182 | "id": "Ag0bnV_TJFN5", 183 | "slideshow": { 184 | "slide_type": "fragment" 185 | } 186 | }, 187 | "source": [ 188 | "- **Iteración:** es una ejecución del cuerpo del ciclo. Cada vez que se ejecuten las sentencias del ciclo se habla de iteración.\n", 189 | "- La condición es evaluada **antes** de cada iteración.\n", 190 | "- Si la condición es *inicialmente falsa*, el ciclo **no se ejecutará**." 191 | ] 192 | }, 193 | { 194 | "cell_type": "markdown", 195 | "metadata": { 196 | "slideshow": { 197 | "slide_type": "slide" 198 | } 199 | }, 200 | "source": [ 201 | "## ¿Entendemos `while`?\n", 202 | "\n", 203 | "* ¿Qué realiza el siguiente ejemplo?" 204 | ] 205 | }, 206 | { 207 | "cell_type": "code", 208 | "execution_count": 2, 209 | "metadata": { 210 | "colab": {}, 211 | "colab_type": "code", 212 | "id": "jD-W65DVJFN7", 213 | "outputId": "ca1f5719-bfed-4d6d-9f66-efd7e0915819", 214 | "slideshow": { 215 | "slide_type": "fragment" 216 | } 217 | }, 218 | "outputs": [ 219 | { 220 | "name": "stdout", 221 | "output_type": "stream", 222 | "text": [ 223 | "m: 3\n", 224 | "n: 4\n", 225 | "El producto de m y n es: 12\n" 226 | ] 227 | } 228 | ], 229 | "source": [ 230 | "m = int(input(\"m: \"))\n", 231 | "n = int(input(\"n: \"))\n", 232 | "k = 0\n", 233 | "\n", 234 | "while m > 0:\n", 235 | " m = m - 1 \n", 236 | " k = k + n\n", 237 | "\n", 238 | "print(\"El producto de m y n es:\",k)" 239 | ] 240 | }, 241 | { 242 | "cell_type": "markdown", 243 | "metadata": { 244 | "colab_type": "text", 245 | "id": "OHZpLYfIJFOC", 246 | "slideshow": { 247 | "slide_type": "fragment" 248 | } 249 | }, 250 | "source": [ 251 | "* ¿Cómo realiza la operación?\n", 252 | "* ¿Cómo se asegura que en algún momento se termine el ciclo?" 253 | ] 254 | }, 255 | { 256 | "cell_type": "markdown", 257 | "metadata": { 258 | "colab_type": "text", 259 | "id": "nNFC14zaJFOE", 260 | "slideshow": { 261 | "slide_type": "slide" 262 | } 263 | }, 264 | "source": [ 265 | "## Uso de Ciclos\n", 266 | "\n", 267 | "¿Necesito usar un ciclo?

\n", 268 | "\n", 269 | "Evaluar si en la siguiente situación deberíamos usar un ciclo. " 270 | ] 271 | }, 272 | { 273 | "cell_type": "markdown", 274 | "metadata": { 275 | "colab_type": "text", 276 | "id": "kOnhFeo9JFOH", 277 | "slideshow": { 278 | "slide_type": "slide" 279 | } 280 | }, 281 | "source": [ 282 | "**1.** Escriba un programa que calcule el promedio de sus notas de certamenes de programación (IWI131)." 283 | ] 284 | }, 285 | { 286 | "cell_type": "code", 287 | "execution_count": 3, 288 | "metadata": { 289 | "colab": {}, 290 | "colab_type": "code", 291 | "id": "mr0DGQJ0JFOJ", 292 | "outputId": "6cb141ea-14b8-4d5c-c56f-0c4bc1dbbfb1", 293 | "slideshow": { 294 | "slide_type": "fragment" 295 | } 296 | }, 297 | "outputs": [ 298 | { 299 | "name": "stdout", 300 | "output_type": "stream", 301 | "text": [ 302 | "Ingrese nota C1: 70\n", 303 | "Ingrese nota C2: 50\n", 304 | "Ingrese nota C3: 60\n", 305 | "Su promedio es: 60\n" 306 | ] 307 | } 308 | ], 309 | "source": [ 310 | "n1 = int(input('Ingrese nota C1: '))\n", 311 | "n2 = int(input('Ingrese nota C2: '))\n", 312 | "n3 = int(input('Ingrese nota C3: '))\n", 313 | "print(\"Su promedio es:\", int(round((n1+n2+n3)/3)))" 314 | ] 315 | }, 316 | { 317 | "cell_type": "markdown", 318 | "metadata": { 319 | "colab_type": "text", 320 | "id": "kOnhFeo9JFOH", 321 | "slideshow": { 322 | "slide_type": "slide" 323 | } 324 | }, 325 | "source": [ 326 | "**1b.** Escriba un programa que calcule el promedio las notas del certamen 1 de un paralelo de IWI131. (Nótese que generalmente los paralelos no tienen la misma cantidad de alumnos)" 327 | ] 328 | }, 329 | { 330 | "cell_type": "code", 331 | "execution_count": 4, 332 | "metadata": { 333 | "colab": {}, 334 | "colab_type": "code", 335 | "id": "mr0DGQJ0JFOJ", 336 | "outputId": "6cb141ea-14b8-4d5c-c56f-0c4bc1dbbfb1", 337 | "slideshow": { 338 | "slide_type": "fragment" 339 | } 340 | }, 341 | "outputs": [ 342 | { 343 | "name": "stdout", 344 | "output_type": "stream", 345 | "text": [ 346 | "Ingrese la cantidad de alumnos: 4\n", 347 | "Ingrese nota: 70\n", 348 | "Ingrese nota: 50\n", 349 | "Ingrese nota: 60\n", 350 | "Ingrese nota: 60\n", 351 | "El promedio del paralelo es: 60\n" 352 | ] 353 | } 354 | ], 355 | "source": [ 356 | "cant = int(input(\"Ingrese la cantidad de alumnos: \"))\n", 357 | "\n", 358 | "cont = 0 #contador de alumnos/notas ingresadas\n", 359 | "suma = 0 #notas acumuladas\n", 360 | "\n", 361 | "while cont < cant:\n", 362 | " nota = int(input(\"Ingrese nota: \"))\n", 363 | " suma = suma + nota\n", 364 | " cont = cont + 1\n", 365 | " \n", 366 | "print(\"El promedio del paralelo es:\", int(round(suma/cont)))" 367 | ] 368 | }, 369 | { 370 | "cell_type": "markdown", 371 | "metadata": { 372 | "colab_type": "text", 373 | "id": "kOnhFeo9JFOH", 374 | "slideshow": { 375 | "slide_type": "slide" 376 | } 377 | }, 378 | "source": [ 379 | "**1c.** Escriba un programa que calcule el promedio las notas de varios alumnos. Se ingresarán notas hasta que se ingrese el valor **-1**." 380 | ] 381 | }, 382 | { 383 | "cell_type": "code", 384 | "execution_count": 5, 385 | "metadata": { 386 | "colab": {}, 387 | "colab_type": "code", 388 | "id": "mr0DGQJ0JFOJ", 389 | "outputId": "6cb141ea-14b8-4d5c-c56f-0c4bc1dbbfb1", 390 | "slideshow": { 391 | "slide_type": "fragment" 392 | } 393 | }, 394 | "outputs": [ 395 | { 396 | "name": "stdout", 397 | "output_type": "stream", 398 | "text": [ 399 | "Ingrese nota: 40\n", 400 | "Ingrese nota: 50\n", 401 | "Ingrese nota: 60\n", 402 | "Ingrese nota: -1\n", 403 | "El promedio es: 50\n" 404 | ] 405 | } 406 | ], 407 | "source": [ 408 | "cont=0 #contador de cantidad notas ingresadas\n", 409 | "suma=0 #notas acumuladas\n", 410 | "\n", 411 | "nota = int(input(\"Ingrese nota: \"))\n", 412 | "\n", 413 | "while nota != -1:\n", 414 | " suma = suma + nota\n", 415 | " cont += 1 #cont = cont + 1\n", 416 | " nota = int(input(\"Ingrese nota: \"))\n", 417 | " \n", 418 | "print(\"El promedio es:\", int(round(suma/cont)))" 419 | ] 420 | }, 421 | { 422 | "cell_type": "markdown", 423 | "metadata": { 424 | "colab_type": "text", 425 | "id": "kOnhFeo9JFOH", 426 | "slideshow": { 427 | "slide_type": "slide" 428 | } 429 | }, 430 | "source": [ 431 | "**1c.** Escriba un programa que calcule el promedio las notas de varios alumnos. Se ingresarán notas hasta que se ingrese el valor **-1**." 432 | ] 433 | }, 434 | { 435 | "cell_type": "code", 436 | "execution_count": 6, 437 | "metadata": { 438 | "colab": {}, 439 | "colab_type": "code", 440 | "id": "mr0DGQJ0JFOJ", 441 | "outputId": "6cb141ea-14b8-4d5c-c56f-0c4bc1dbbfb1", 442 | "slideshow": { 443 | "slide_type": "fragment" 444 | } 445 | }, 446 | "outputs": [ 447 | { 448 | "name": "stdout", 449 | "output_type": "stream", 450 | "text": [ 451 | "Ingrese nota: 40\n", 452 | "Ingrese nota: 50\n", 453 | "Ingrese nota: 60\n", 454 | "Ingrese nota: -1\n", 455 | "El promedio es: 50\n" 456 | ] 457 | } 458 | ], 459 | "source": [ 460 | "flag = True # bandera que indica si condicion se cumple\n", 461 | "cont=0 #contador de cantidad notas ingresadas\n", 462 | "suma=0 #notas acumuladas\n", 463 | "\n", 464 | "while flag: #flag==True\n", 465 | " nota = int(input(\"Ingrese nota: \"))\n", 466 | " if nota==-1:\n", 467 | " flag=False\n", 468 | " else:\n", 469 | " suma += nota #suma = suma + nota\n", 470 | " cont += 1 #cont = cont + 1\n", 471 | "\n", 472 | "print(\"El promedio es:\", int(round(suma/cont)))" 473 | ] 474 | }, 475 | { 476 | "cell_type": "markdown", 477 | "metadata": { 478 | "slideshow": { 479 | "slide_type": "slide" 480 | } 481 | }, 482 | "source": [ 483 | "## Patrones Comunes\n", 484 | "\n", 485 | "**Patrón**: Solución aplicable a un prolema que ocurre a menudo." 486 | ] 487 | }, 488 | { 489 | "cell_type": "markdown", 490 | "metadata": { 491 | "slideshow": { 492 | "slide_type": "fragment" 493 | } 494 | }, 495 | "source": [ 496 | "1. Sumar cosas\n", 497 | "2. Multiplicar cosas\n", 498 | "3. Contar cosas\n", 499 | "4. Encontrar el máximo\n", 500 | "5. Encontrar el mínimo\n", 501 | "6. Generar pares de cosas" 502 | ] 503 | }, 504 | { 505 | "cell_type": "markdown", 506 | "metadata": { 507 | "slideshow": { 508 | "slide_type": "slide" 509 | } 510 | }, 511 | "source": [ 512 | "### 1. Sumar cosas" 513 | ] 514 | }, 515 | { 516 | "cell_type": "markdown", 517 | "metadata": { 518 | "slideshow": { 519 | "slide_type": "fragment" 520 | } 521 | }, 522 | "source": [ 523 | "Escriba un programa que reciba como entrada un número entero. El programa debe mostrar el resultado de la suma de los números al cuadrado desde el 1 hasta el valor ingresado.\n", 524 | "$$\n", 525 | "1^2+2^2+\\ldots+(n-1)^2+n^2\n", 526 | "$$" 527 | ] 528 | }, 529 | { 530 | "cell_type": "code", 531 | "execution_count": 7, 532 | "metadata": { 533 | "slideshow": { 534 | "slide_type": "fragment" 535 | } 536 | }, 537 | "outputs": [ 538 | { 539 | "name": "stdout", 540 | "output_type": "stream", 541 | "text": [ 542 | "Ingrese n: 4\n", 543 | "La suma de los numeros al cuadrado es: 30\n" 544 | ] 545 | } 546 | ], 547 | "source": [ 548 | "n = int(input(\"Ingrese n: \"))\n", 549 | "suma = 0\n", 550 | "cont = 1\n", 551 | "\n", 552 | "while cont <= n:\n", 553 | " d = cont**2\n", 554 | " #print(\"d\", d)\n", 555 | " suma = suma + d\n", 556 | " #print(\"suma\", suma)\n", 557 | " cont += 1\n", 558 | "\n", 559 | "print(\"La suma de los numeros al cuadrado es:\", suma)" 560 | ] 561 | }, 562 | { 563 | "cell_type": "markdown", 564 | "metadata": { 565 | "slideshow": { 566 | "slide_type": "slide" 567 | } 568 | }, 569 | "source": [ 570 | "**Sintaxis sumar cosas:**\n", 571 | "```Python\n", 572 | "suma = 0\n", 573 | "ciclo:\n", 574 | " n = calcular()\n", 575 | " suma = suma + n\n", 576 | "```" 577 | ] 578 | }, 579 | { 580 | "cell_type": "markdown", 581 | "metadata": { 582 | "slideshow": { 583 | "slide_type": "fragment" 584 | } 585 | }, 586 | "source": [ 587 | "¿Cuáles son los elementos de este patrón?" 588 | ] 589 | }, 590 | { 591 | "cell_type": "markdown", 592 | "metadata": { 593 | "slideshow": { 594 | "slide_type": "slide" 595 | } 596 | }, 597 | "source": [ 598 | "### 2. Multiplicar cosas" 599 | ] 600 | }, 601 | { 602 | "cell_type": "markdown", 603 | "metadata": { 604 | "slideshow": { 605 | "slide_type": "fragment" 606 | } 607 | }, 608 | "source": [ 609 | "Escriba una programa que calcule el factorial de un número $n$ ingresada como entrada:\n", 610 | "$3! = 1\\cdot 2 \\cdot 3$" 611 | ] 612 | }, 613 | { 614 | "cell_type": "code", 615 | "execution_count": 8, 616 | "metadata": { 617 | "slideshow": { 618 | "slide_type": "fragment" 619 | } 620 | }, 621 | "outputs": [ 622 | { 623 | "name": "stdout", 624 | "output_type": "stream", 625 | "text": [ 626 | "Ingrese n: 4\n", 627 | "El factorial de 4 es: 24\n" 628 | ] 629 | } 630 | ], 631 | "source": [ 632 | "n = int(input(\"Ingrese n: \"))\n", 633 | "\n", 634 | "if n < 0:\n", 635 | " print(\"El factorial está definido sólo para números naturales mayores o igual que 0.\")\n", 636 | "else:\n", 637 | " prod = 1\n", 638 | " cont = 1\n", 639 | " \n", 640 | " while cont <= n:\n", 641 | " prod = prod * cont #prod *= cont\n", 642 | " cont += 1 #cont = cont + 1\n", 643 | " \n", 644 | " print(\"El factorial de\", n, \"es:\", prod)" 645 | ] 646 | }, 647 | { 648 | "cell_type": "markdown", 649 | "metadata": { 650 | "slideshow": { 651 | "slide_type": "slide" 652 | } 653 | }, 654 | "source": [ 655 | "**Sintaxis multiplicar cosas:**\n", 656 | "```Python\n", 657 | "producto = 1\n", 658 | "ciclo:\n", 659 | " n = calcular()\n", 660 | " producto = producto * n\n", 661 | "```" 662 | ] 663 | }, 664 | { 665 | "cell_type": "markdown", 666 | "metadata": { 667 | "slideshow": { 668 | "slide_type": "fragment" 669 | } 670 | }, 671 | "source": [ 672 | "¿Cuáles son los elementos de este patrón?" 673 | ] 674 | }, 675 | { 676 | "cell_type": "markdown", 677 | "metadata": { 678 | "slideshow": { 679 | "slide_type": "slide" 680 | } 681 | }, 682 | "source": [ 683 | "### 3. Contar cosas" 684 | ] 685 | }, 686 | { 687 | "cell_type": "markdown", 688 | "metadata": { 689 | "slideshow": { 690 | "slide_type": "fragment" 691 | } 692 | }, 693 | "source": [ 694 | "Escriba un programa que solicite el ingreso de $n$ números, luego entregue la cantidad de números pares ingresados." 695 | ] 696 | }, 697 | { 698 | "cell_type": "code", 699 | "execution_count": 9, 700 | "metadata": { 701 | "slideshow": { 702 | "slide_type": "fragment" 703 | } 704 | }, 705 | "outputs": [ 706 | { 707 | "name": "stdout", 708 | "output_type": "stream", 709 | "text": [ 710 | "Ingrese n: 5\n", 711 | "Ingrese numero: 1\n", 712 | "pares = 0\n", 713 | "Ingrese numero: 4\n", 714 | "pares = 1\n", 715 | "Ingrese numero: 2\n", 716 | "pares = 2\n", 717 | "Ingrese numero: 6\n", 718 | "pares = 3\n", 719 | "Ingrese numero: 3\n", 720 | "pares = 3\n", 721 | "La cantidad de pares ingresados es: 3\n" 722 | ] 723 | } 724 | ], 725 | "source": [ 726 | "n = int(input(\"Ingrese n: \"))\n", 727 | "pares = 0 #contador de pares\n", 728 | "cont = 0 #contador de numeros\n", 729 | "\n", 730 | "while cont < n:\n", 731 | " num = int(input(\"Ingrese numero: \"))\n", 732 | "\n", 733 | " if num % 2 == 0: #si es divisible por 2\n", 734 | " pares += 1 #pares = pares + 1\n", 735 | " \n", 736 | " print(\"pares =\", pares)\n", 737 | " cont += 1 #cont = cont + 1 \n", 738 | "\n", 739 | "print(\"La cantidad de pares ingresados es:\", pares)" 740 | ] 741 | }, 742 | { 743 | "cell_type": "markdown", 744 | "metadata": { 745 | "slideshow": { 746 | "slide_type": "slide" 747 | } 748 | }, 749 | "source": [ 750 | "**Sintaxis contar cosas:**\n", 751 | "```Python\n", 752 | "cuenta = 0\n", 753 | "ciclo:\n", 754 | " if condicion:\n", 755 | " cuenta = cuenta + 1\n", 756 | "```" 757 | ] 758 | }, 759 | { 760 | "cell_type": "markdown", 761 | "metadata": { 762 | "slideshow": { 763 | "slide_type": "fragment" 764 | } 765 | }, 766 | "source": [ 767 | "¿Cuáles son los elementos de este patrón?" 768 | ] 769 | }, 770 | { 771 | "cell_type": "markdown", 772 | "metadata": { 773 | "slideshow": { 774 | "slide_type": "slide" 775 | } 776 | }, 777 | "source": [ 778 | "### 4. Encontrar el máximo" 779 | ] 780 | }, 781 | { 782 | "cell_type": "markdown", 783 | "metadata": { 784 | "slideshow": { 785 | "slide_type": "fragment" 786 | } 787 | }, 788 | "source": [ 789 | "Escribir un programa que solicite n números y luego muestre el número mayor que haya sido ingresado." 790 | ] 791 | }, 792 | { 793 | "cell_type": "markdown", 794 | "metadata": { 795 | "slideshow": { 796 | "slide_type": "fragment" 797 | } 798 | }, 799 | "source": [ 800 | "**Opción 1:** usando un número muy pequeño para comparar." 801 | ] 802 | }, 803 | { 804 | "cell_type": "code", 805 | "execution_count": 13, 806 | "metadata": { 807 | "slideshow": { 808 | "slide_type": "fragment" 809 | } 810 | }, 811 | "outputs": [ 812 | { 813 | "name": "stdout", 814 | "output_type": "stream", 815 | "text": [ 816 | "Ingrese n: 6\n", 817 | "Ingrese numero: 7.5\n", 818 | "mayor temp = 7.5\n", 819 | "Ingrese numero: 3.1\n", 820 | "mayor temp = 7.5\n", 821 | "Ingrese numero: 2\n", 822 | "mayor temp = 7.5\n", 823 | "Ingrese numero: 9.0\n", 824 | "mayor temp = 9.0\n", 825 | "Ingrese numero: 8.5\n", 826 | "mayor temp = 9.0\n", 827 | "Ingrese numero: 2.5\n", 828 | "mayor temp = 9.0\n", 829 | "El numero mayor es: 9.0\n" 830 | ] 831 | } 832 | ], 833 | "source": [ 834 | "n = int(input(\"Ingrese n: \"))\n", 835 | "i = 1\n", 836 | "mayor = float(\"-inf\")\n", 837 | "\n", 838 | "while i <= n:\n", 839 | " mensaje = \"Ingrese numero: \"\n", 840 | " numero = float(input(mensaje))\n", 841 | "\n", 842 | " if mayor < numero:\n", 843 | " mayor = numero\n", 844 | " \n", 845 | " print(\"mayor temp =\", mayor)\n", 846 | " i += 1\n", 847 | "\n", 848 | "print(\"El numero mayor es:\", mayor)" 849 | ] 850 | }, 851 | { 852 | "cell_type": "markdown", 853 | "metadata": { 854 | "slideshow": { 855 | "slide_type": "slide" 856 | } 857 | }, 858 | "source": [ 859 | "**Opción 2:** sin usar número muy pequeño para comparar." 860 | ] 861 | }, 862 | { 863 | "cell_type": "code", 864 | "execution_count": 14, 865 | "metadata": { 866 | "slideshow": { 867 | "slide_type": "fragment" 868 | } 869 | }, 870 | "outputs": [ 871 | { 872 | "name": "stdout", 873 | "output_type": "stream", 874 | "text": [ 875 | "Ingrese n: 5\n", 876 | "Ingrese numero: 1.1\n", 877 | "Ingrese numero: 3.5\n", 878 | "Ingrese numero: 4.23\n", 879 | "Ingrese numero: 2.5\n", 880 | "Ingrese numero: 2.3\n", 881 | "El numero mayor es 4.23\n" 882 | ] 883 | } 884 | ], 885 | "source": [ 886 | "n = int(input(\"Ingrese n: \"))\n", 887 | "i = 1\n", 888 | "\n", 889 | "while i <= n:\n", 890 | " mensaje = \"Ingrese numero: \"\n", 891 | " numero = float(input(mensaje))\n", 892 | "\n", 893 | " if i == 1:\n", 894 | " mayor = numero\n", 895 | " elif mayor < numero:\n", 896 | " mayor = numero\n", 897 | " i += 1\n", 898 | "\n", 899 | "print(\"El numero mayor es\", mayor)" 900 | ] 901 | }, 902 | { 903 | "cell_type": "markdown", 904 | "metadata": { 905 | "slideshow": { 906 | "slide_type": "slide" 907 | } 908 | }, 909 | "source": [ 910 | "### **Sintaxis encontrar el máximo:**\n", 911 | "```Python\n", 912 | "mayor = numero_muy_chico\n", 913 | "ciclo:\n", 914 | " n = calcular()\n", 915 | " if n > mayor:\n", 916 | " mayor = n\n", 917 | "```" 918 | ] 919 | }, 920 | { 921 | "cell_type": "markdown", 922 | "metadata": { 923 | "slideshow": { 924 | "slide_type": "fragment" 925 | } 926 | }, 927 | "source": [ 928 | "¿Cuáles son los elementos de este patrón?" 929 | ] 930 | }, 931 | { 932 | "cell_type": "markdown", 933 | "metadata": { 934 | "slideshow": { 935 | "slide_type": "slide" 936 | } 937 | }, 938 | "source": [ 939 | "### 5. Encontrar el mínimo" 940 | ] 941 | }, 942 | { 943 | "cell_type": "markdown", 944 | "metadata": { 945 | "slideshow": { 946 | "slide_type": "fragment" 947 | } 948 | }, 949 | "source": [ 950 | "¿Cómo cambia el patrón anterior si ahora se quiere encontrar el mínimo?" 951 | ] 952 | }, 953 | { 954 | "cell_type": "code", 955 | "execution_count": 15, 956 | "metadata": { 957 | "slideshow": { 958 | "slide_type": "fragment" 959 | } 960 | }, 961 | "outputs": [ 962 | { 963 | "name": "stdout", 964 | "output_type": "stream", 965 | "text": [ 966 | "Ingrese n: 6\n", 967 | "Ingrese numero: 10\n", 968 | "Ingrese numero: 4.3\n", 969 | "Ingrese numero: 5.3\n", 970 | "Ingrese numero: 6.3\n", 971 | "Ingrese numero: 5.1\n", 972 | "Ingrese numero: 1.5\n", 973 | "El numero menor es: 1.5\n" 974 | ] 975 | } 976 | ], 977 | "source": [ 978 | "n = int(input(\"Ingrese n: \"))\n", 979 | "i = 1\n", 980 | "menor = float(\"inf\")\n", 981 | "\n", 982 | "while i <= n:\n", 983 | " mensaje = \"Ingrese numero: \"\n", 984 | " numero = float(input(mensaje))\n", 985 | "\n", 986 | " if menor > numero:\n", 987 | " menor = numero\n", 988 | " i += 1\n", 989 | "\n", 990 | "print(\"El numero menor es:\", menor)" 991 | ] 992 | }, 993 | { 994 | "cell_type": "markdown", 995 | "metadata": { 996 | "slideshow": { 997 | "slide_type": "slide" 998 | } 999 | }, 1000 | "source": [ 1001 | "**Sintaxis encontrar el mínimo:**\n", 1002 | "```Python\n", 1003 | "menor = numero_muy_grande\n", 1004 | "ciclo:\n", 1005 | " n = calcular()\n", 1006 | " if n < menor:\n", 1007 | " menor = n\n", 1008 | "```" 1009 | ] 1010 | }, 1011 | { 1012 | "cell_type": "markdown", 1013 | "metadata": { 1014 | "slideshow": { 1015 | "slide_type": "slide" 1016 | } 1017 | }, 1018 | "source": [ 1019 | "### 6. Generar Pares de cosas" 1020 | ] 1021 | }, 1022 | { 1023 | "cell_type": "markdown", 1024 | "metadata": { 1025 | "slideshow": { 1026 | "slide_type": "fragment" 1027 | } 1028 | }, 1029 | "source": [ 1030 | "Escribir un programa que muestre todas las combinaciones posibles al lanzar 2 dados." 1031 | ] 1032 | }, 1033 | { 1034 | "cell_type": "code", 1035 | "execution_count": 17, 1036 | "metadata": { 1037 | "scrolled": false, 1038 | "slideshow": { 1039 | "slide_type": "fragment" 1040 | } 1041 | }, 1042 | "outputs": [ 1043 | { 1044 | "name": "stdout", 1045 | "output_type": "stream", 1046 | "text": [ 1047 | "1 1\n", 1048 | "1 2\n", 1049 | "1 3\n", 1050 | "1 4\n", 1051 | "1 5\n", 1052 | "1 6\n", 1053 | "2 1\n", 1054 | "2 2\n", 1055 | "2 3\n", 1056 | "2 4\n", 1057 | "2 5\n", 1058 | "2 6\n", 1059 | "3 1\n", 1060 | "3 2\n", 1061 | "3 3\n", 1062 | "3 4\n", 1063 | "3 5\n", 1064 | "3 6\n", 1065 | "4 1\n", 1066 | "4 2\n", 1067 | "4 3\n", 1068 | "4 4\n", 1069 | "4 5\n", 1070 | "4 6\n", 1071 | "5 1\n", 1072 | "5 2\n", 1073 | "5 3\n", 1074 | "5 4\n", 1075 | "5 5\n", 1076 | "5 6\n", 1077 | "6 1\n", 1078 | "6 2\n", 1079 | "6 3\n", 1080 | "6 4\n", 1081 | "6 5\n", 1082 | "6 6\n" 1083 | ] 1084 | } 1085 | ], 1086 | "source": [ 1087 | "n = 6\n", 1088 | "m = 6\n", 1089 | "i = 0\n", 1090 | "contador = 0\n", 1091 | "while i < n:\n", 1092 | " j = 0\n", 1093 | " i += 1\n", 1094 | " while j < m:\n", 1095 | " j += 1\n", 1096 | " contador +=1\n", 1097 | " print(i,j)" 1098 | ] 1099 | }, 1100 | { 1101 | "cell_type": "markdown", 1102 | "metadata": { 1103 | "colab_type": "text", 1104 | "id": "aw-tGZ5uJFOq", 1105 | "slideshow": { 1106 | "slide_type": "slide" 1107 | } 1108 | }, 1109 | "source": [ 1110 | "## Conclusiones" 1111 | ] 1112 | }, 1113 | { 1114 | "cell_type": "markdown", 1115 | "metadata": { 1116 | "colab_type": "text", 1117 | "id": "vmEYcAQmJFOs", 1118 | "slideshow": { 1119 | "slide_type": "fragment" 1120 | } 1121 | }, 1122 | "source": [ 1123 | "- Depende. A veces hay operaciones que se deben hacer **muchas veces**.\n", 1124 | "- Un ciclo es **recomendado** cuando una misma operación se debe repetir, pero cambiando algo ligeramente.\n", 1125 | "- Los ciclos son útiles, pero peligrosos si no se tiene cuidado de la condición " 1126 | ] 1127 | }, 1128 | { 1129 | "cell_type": "markdown", 1130 | "metadata": { 1131 | "slideshow": { 1132 | "slide_type": "slide" 1133 | } 1134 | }, 1135 | "source": [ 1136 | "## Ejercicio 1\n", 1137 | "\n", 1138 | "### Conjetura de Ulam\n", 1139 | "\n", 1140 | "A partir de un número cualquiera (entrada) es posible hacer una sucesión de números que termina en 1.\n", 1141 | "- Si el número es par, se debe dividir por 2.\n", 1142 | "- Si el número es impar, se debe multiplicar por 3 y sumarle 1.\n", 1143 | "\n", 1144 | "Con esto se obtiene el siguiente número de la sucesión, al cual se le deben aplicar las mismas operaciones. La sucesión de números termina cuando el número obtenido por medio de las operaciones es 1." 1145 | ] 1146 | }, 1147 | { 1148 | "cell_type": "code", 1149 | "execution_count": 24, 1150 | "metadata": { 1151 | "slideshow": { 1152 | "slide_type": "slide" 1153 | } 1154 | }, 1155 | "outputs": [ 1156 | { 1157 | "data": { 1158 | "text/html": [ 1159 | "\n", 1160 | " \n", 1167 | " " 1168 | ], 1169 | "text/plain": [ 1170 | "" 1171 | ] 1172 | }, 1173 | "execution_count": 24, 1174 | "metadata": {}, 1175 | "output_type": "execute_result" 1176 | } 1177 | ], 1178 | "source": [ 1179 | "from IPython.display import IFrame\n", 1180 | "IFrame(\"https://trinket.io/embed/blocks/06947cd48d?hideGeneratedCode=true\", width=\"100%\", height=500)" 1181 | ] 1182 | }, 1183 | { 1184 | "cell_type": "code", 1185 | "execution_count": 19, 1186 | "metadata": { 1187 | "slideshow": { 1188 | "slide_type": "slide" 1189 | } 1190 | }, 1191 | "outputs": [ 1192 | { 1193 | "name": "stdout", 1194 | "output_type": "stream", 1195 | "text": [ 1196 | "Inicio: 120\n", 1197 | "120\n", 1198 | "60\n", 1199 | "30\n", 1200 | "15\n", 1201 | "46\n", 1202 | "23\n", 1203 | "70\n", 1204 | "35\n", 1205 | "106\n", 1206 | "53\n", 1207 | "160\n", 1208 | "80\n", 1209 | "40\n", 1210 | "20\n", 1211 | "10\n", 1212 | "5\n", 1213 | "16\n", 1214 | "8\n", 1215 | "4\n", 1216 | "2\n", 1217 | "1\n" 1218 | ] 1219 | } 1220 | ], 1221 | "source": [ 1222 | "t= int(input('Inicio: '))\n", 1223 | "\n", 1224 | "while t != 1:\n", 1225 | " print(int(t))\n", 1226 | " if t % 2 == 0:\n", 1227 | " t = t/2\n", 1228 | " else: \n", 1229 | " t = (3*t) + 1\n", 1230 | " \n", 1231 | "print(int(t))" 1232 | ] 1233 | }, 1234 | { 1235 | "cell_type": "markdown", 1236 | "metadata": { 1237 | "slideshow": { 1238 | "slide_type": "slide" 1239 | } 1240 | }, 1241 | "source": [ 1242 | "## Ejercicio 2\n", 1243 | "\n", 1244 | "Escriba un programa que determine si un número es **primo** o **compuesto**." 1245 | ] 1246 | }, 1247 | { 1248 | "cell_type": "code", 1249 | "execution_count": 25, 1250 | "metadata": { 1251 | "colab": {}, 1252 | "colab_type": "code", 1253 | "id": "j-MwSyKmJFOt", 1254 | "slideshow": { 1255 | "slide_type": "fragment" 1256 | } 1257 | }, 1258 | "outputs": [ 1259 | { 1260 | "data": { 1261 | "text/html": [ 1262 | "\n", 1263 | " \n", 1270 | " " 1271 | ], 1272 | "text/plain": [ 1273 | "" 1274 | ] 1275 | }, 1276 | "execution_count": 25, 1277 | "metadata": {}, 1278 | "output_type": "execute_result" 1279 | } 1280 | ], 1281 | "source": [ 1282 | "from IPython.display import IFrame\n", 1283 | "IFrame('https://trinket.io/embed/blocks/f1d62613e6?hideGeneratedCode=true', width=\"100%\", height=500)" 1284 | ] 1285 | }, 1286 | { 1287 | "cell_type": "code", 1288 | "execution_count": 21, 1289 | "metadata": { 1290 | "slideshow": { 1291 | "slide_type": "slide" 1292 | } 1293 | }, 1294 | "outputs": [ 1295 | { 1296 | "name": "stdout", 1297 | "output_type": "stream", 1298 | "text": [ 1299 | "n: 37\n", 1300 | "Es primo\n" 1301 | ] 1302 | } 1303 | ], 1304 | "source": [ 1305 | "n=int(input(\"n: \"))\n", 1306 | "es_primo = True\n", 1307 | "d = 2\n", 1308 | "\n", 1309 | "while d\n", 12 | "\"\"\n", 13 | "\n", 14 | "
\n", 15 | "
\n", 16 | "

IWI131 Programación


\n", 17 | "

Estructuras de Datos: Tuplas

\n", 18 | "

\n", 19 | "Departamento de Informática
\n", 20 | "Universidad Técnica Federico Santa María\n", 21 | "
" 22 | ] 23 | }, 24 | { 25 | "cell_type": "markdown", 26 | "metadata": { 27 | "collapsed": true, 28 | "slideshow": { 29 | "slide_type": "slide" 30 | } 31 | }, 32 | "source": [ 33 | "# Tuplas" 34 | ] 35 | }, 36 | { 37 | "cell_type": "markdown", 38 | "metadata": { 39 | "slideshow": { 40 | "slide_type": "fragment" 41 | } 42 | }, 43 | "source": [ 44 | "- Una tupla es una secuencia de valores agrupados.\n", 45 | "- Pueden contener básicamente cualquier cosa.\n", 46 | "- Una tupla sirve para agrupar, como si fueran un único valor, varios valores que por su naturaleza deben ir juntos.\n", 47 | "- Una tupla es inmutable, es decir, no puede ser modificada una vez que ha sido creada." 48 | ] 49 | }, 50 | { 51 | "cell_type": "markdown", 52 | "metadata": { 53 | "slideshow": { 54 | "slide_type": "slide" 55 | } 56 | }, 57 | "source": [ 58 | "## Creación de Tuplas\n", 59 | "- Usando paréntesis ()\n", 60 | "- Usando la función `tuple()`" 61 | ] 62 | }, 63 | { 64 | "cell_type": "markdown", 65 | "metadata": { 66 | "slideshow": { 67 | "slide_type": "slide" 68 | } 69 | }, 70 | "source": [ 71 | "### Tupla Vacía\n", 72 | "\n", 73 | "Aunque no tiene mucha utilidad. ¿Por qué?" 74 | ] 75 | }, 76 | { 77 | "cell_type": "code", 78 | "execution_count": 1, 79 | "metadata": { 80 | "slideshow": { 81 | "slide_type": "fragment" 82 | } 83 | }, 84 | "outputs": [ 85 | { 86 | "name": "stdout", 87 | "output_type": "stream", 88 | "text": [ 89 | "()\n", 90 | "()\n" 91 | ] 92 | } 93 | ], 94 | "source": [ 95 | "a = ()\n", 96 | "b = tuple()\n", 97 | "print(a)\n", 98 | "print(b)" 99 | ] 100 | }, 101 | { 102 | "cell_type": "markdown", 103 | "metadata": { 104 | "slideshow": { 105 | "slide_type": "slide" 106 | } 107 | }, 108 | "source": [ 109 | "### Tupla con elementos" 110 | ] 111 | }, 112 | { 113 | "cell_type": "code", 114 | "execution_count": 4, 115 | "metadata": { 116 | "slideshow": { 117 | "slide_type": "fragment" 118 | } 119 | }, 120 | "outputs": [ 121 | { 122 | "name": "stdout", 123 | "output_type": "stream", 124 | "text": [ 125 | "(1, 2, 3, 4)\n", 126 | "('a', 1, True, [1, 2])\n" 127 | ] 128 | } 129 | ], 130 | "source": [ 131 | "a = (1,2,3,4)\n", 132 | "b = tuple(['a', 1, True, [1, 2]])\n", 133 | "print(a)\n", 134 | "print(b)" 135 | ] 136 | }, 137 | { 138 | "cell_type": "code", 139 | "execution_count": 5, 140 | "metadata": { 141 | "slideshow": { 142 | "slide_type": "fragment" 143 | } 144 | }, 145 | "outputs": [ 146 | { 147 | "name": "stdout", 148 | "output_type": "stream", 149 | "text": [ 150 | "(1, 2, 3, 4)\n", 151 | "(1, 2, 3, 4)\n" 152 | ] 153 | } 154 | ], 155 | "source": [ 156 | "c = tuple([1, 2, 3, 4])\n", 157 | "d = tuple((1, 2, 3, 4))\n", 158 | "print(c)\n", 159 | "print(d)" 160 | ] 161 | }, 162 | { 163 | "cell_type": "markdown", 164 | "metadata": { 165 | "slideshow": { 166 | "slide_type": "slide" 167 | } 168 | }, 169 | "source": [ 170 | "La función `tuple(iterable)` convierte a tupla el tipo de dato dado por la variable `iterable`. Cada elemento de `iterable` es agregado a una tupla." 171 | ] 172 | }, 173 | { 174 | "cell_type": "code", 175 | "execution_count": 8, 176 | "metadata": { 177 | "slideshow": { 178 | "slide_type": "fragment" 179 | } 180 | }, 181 | "outputs": [ 182 | { 183 | "name": "stdout", 184 | "output_type": "stream", 185 | "text": [ 186 | "('a', 'b', 'c')\n" 187 | ] 188 | } 189 | ], 190 | "source": [ 191 | "tup = tuple(\"abc\")\n", 192 | "print(tup)" 193 | ] 194 | }, 195 | { 196 | "cell_type": "markdown", 197 | "metadata": { 198 | "slideshow": { 199 | "slide_type": "slide" 200 | } 201 | }, 202 | "source": [ 203 | "## Desempaquetado de Tuplas" 204 | ] 205 | }, 206 | { 207 | "cell_type": "markdown", 208 | "metadata": { 209 | "slideshow": { 210 | "slide_type": "fragment" 211 | } 212 | }, 213 | "source": [ 214 | "Los valores individuales de una tupla pueden ser recuperados asignando la tupla a las variables respectivas. Esto se llama desempaquetar la tupla." 215 | ] 216 | }, 217 | { 218 | "cell_type": "code", 219 | "execution_count": 19, 220 | "metadata": {}, 221 | "outputs": [ 222 | { 223 | "name": "stdout", 224 | "output_type": "stream", 225 | "text": [ 226 | "(1, 2, 3)\n", 227 | "1 2 3\n", 228 | "1\n", 229 | "2\n", 230 | "3\n" 231 | ] 232 | } 233 | ], 234 | "source": [ 235 | "tupla = (1, 2, 3)\n", 236 | "a, b, c = tupla\n", 237 | "print(tupla)\n", 238 | "print(a, b, c)\n", 239 | "print(a)\n", 240 | "print(b)\n", 241 | "print(c)" 242 | ] 243 | }, 244 | { 245 | "cell_type": "markdown", 246 | "metadata": { 247 | "slideshow": { 248 | "slide_type": "slide" 249 | } 250 | }, 251 | "source": [ 252 | "Para desempaquetar correctamente debe utilizar tantas variables como elementos posee la tupla." 253 | ] 254 | }, 255 | { 256 | "cell_type": "code", 257 | "execution_count": 20, 258 | "metadata": { 259 | "slideshow": { 260 | "slide_type": "fragment" 261 | } 262 | }, 263 | "outputs": [ 264 | { 265 | "ename": "ValueError", 266 | "evalue": "too many values to unpack (expected 2)", 267 | "output_type": "error", 268 | "traceback": [ 269 | "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", 270 | "\u001b[1;31mValueError\u001b[0m Traceback (most recent call last)", 271 | "\u001b[1;32m\u001b[0m in \u001b[0;36m\u001b[1;34m\u001b[0m\n\u001b[0;32m 1\u001b[0m \u001b[0mtupla\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;33m(\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;36m2\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;36m3\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 2\u001b[1;33m \u001b[0ma\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mb\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mtupla\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m", 272 | "\u001b[1;31mValueError\u001b[0m: too many values to unpack (expected 2)" 273 | ] 274 | } 275 | ], 276 | "source": [ 277 | "tupla = (1, 2, 3)\n", 278 | "a, b = tupla" 279 | ] 280 | }, 281 | { 282 | "cell_type": "markdown", 283 | "metadata": { 284 | "slideshow": { 285 | "slide_type": "slide" 286 | } 287 | }, 288 | "source": [ 289 | "Además, también es posible extraer los valores usando su índice, al igual que con las listas:" 290 | ] 291 | }, 292 | { 293 | "cell_type": "code", 294 | "execution_count": 30, 295 | "metadata": { 296 | "slideshow": { 297 | "slide_type": "fragment" 298 | } 299 | }, 300 | "outputs": [ 301 | { 302 | "name": "stdout", 303 | "output_type": "stream", 304 | "text": [ 305 | "2\n", 306 | "3\n", 307 | "(1, 2, 3)\n", 308 | "(3,)\n", 309 | "(2, 3)\n" 310 | ] 311 | } 312 | ], 313 | "source": [ 314 | "tupla = (1, 2, 3)\n", 315 | "print(tupla[1])\n", 316 | "print(tupla[2])\n", 317 | "print(tupla[:])\n", 318 | "print(tupla[2:])\n", 319 | "print(tupla[1:])" 320 | ] 321 | }, 322 | { 323 | "cell_type": "markdown", 324 | "metadata": { 325 | "slideshow": { 326 | "slide_type": "slide" 327 | } 328 | }, 329 | "source": [ 330 | "A diferencia de las listas, los elementos de una tupla no se pueden modificar:" 331 | ] 332 | }, 333 | { 334 | "cell_type": "code", 335 | "execution_count": 39, 336 | "metadata": { 337 | "slideshow": { 338 | "slide_type": "fragment" 339 | } 340 | }, 341 | "outputs": [ 342 | { 343 | "ename": "TypeError", 344 | "evalue": "'tuple' object does not support item assignment", 345 | "output_type": "error", 346 | "traceback": [ 347 | "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", 348 | "\u001b[1;31mTypeError\u001b[0m Traceback (most recent call last)", 349 | "\u001b[1;32m\u001b[0m in \u001b[0;36m\u001b[1;34m\u001b[0m\n\u001b[0;32m 1\u001b[0m \u001b[0mtupla\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;33m(\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;36m2\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;36m3\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 2\u001b[1;33m \u001b[0mtupla\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m0\u001b[0m\u001b[1;33m]\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;36m100\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m 3\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 4\u001b[0m \u001b[1;31m#tupla = tuple([100])+tupla[1:]\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 5\u001b[0m \u001b[1;31m#print(tupla)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", 350 | "\u001b[1;31mTypeError\u001b[0m: 'tuple' object does not support item assignment" 351 | ] 352 | } 353 | ], 354 | "source": [ 355 | "tupla = (1, 2, 3)\n", 356 | "tupla[0] = 100\n", 357 | "\n", 358 | "#tupla = tuple([100])+tupla[1:]\n", 359 | "#print(tupla)" 360 | ] 361 | }, 362 | { 363 | "cell_type": "markdown", 364 | "metadata": { 365 | "slideshow": { 366 | "slide_type": "slide" 367 | } 368 | }, 369 | "source": [ 370 | "## Usos recomendados" 371 | ] 372 | }, 373 | { 374 | "cell_type": "markdown", 375 | "metadata": { 376 | "slideshow": { 377 | "slide_type": "fragment" 378 | } 379 | }, 380 | "source": [ 381 | "Las tuplas se usan siempre que es necesario agrupar valores. Generalmente, conceptos del mundo real son representados como tuplas que agrupan información sobre ellos. " 382 | ] 383 | }, 384 | { 385 | "cell_type": "code", 386 | "execution_count": 44, 387 | "metadata": { 388 | "slideshow": { 389 | "slide_type": "slide" 390 | } 391 | }, 392 | "outputs": [], 393 | "source": [ 394 | "posicion_alfil = (7, 6)\n", 395 | "alumno = ('Fulano', 'De Tal', '201199001-1') \n", 396 | "carta = (5, 'corazones')\n", 397 | "fecha = (2011, 4, 12)\n", 398 | "triangulo = ((5, 1), (2, 4), (-2, 0))\n", 399 | "personaje = ('Arturo Prat', (1848, 4, 3),\n", 400 | " (1879, 5, 21))\n", 401 | "\n" 402 | ] 403 | }, 404 | { 405 | "cell_type": "code", 406 | "execution_count": 45, 407 | "metadata": { 408 | "slideshow": { 409 | "slide_type": "fragment" 410 | } 411 | }, 412 | "outputs": [ 413 | { 414 | "name": "stdout", 415 | "output_type": "stream", 416 | "text": [ 417 | "6.6\n" 418 | ] 419 | } 420 | ], 421 | "source": [ 422 | "punto = (6.6, -2.4, 3.7)\n", 423 | "x, y, z = punto\n", 424 | "print(x)" 425 | ] 426 | }, 427 | { 428 | "cell_type": "code", 429 | "execution_count": 46, 430 | "metadata": { 431 | "slideshow": { 432 | "slide_type": "fragment" 433 | } 434 | }, 435 | "outputs": [ 436 | { 437 | "name": "stdout", 438 | "output_type": "stream", 439 | "text": [ 440 | "64\n" 441 | ] 442 | } 443 | ], 444 | "source": [ 445 | "personaje = (\"Bernardo O'Higgins\", (1778, 8, 20), (1842, 10, 24))\n", 446 | "nombre, nacimiento, defuncion = personaje\n", 447 | "an, mn, dn = nacimiento\n", 448 | "ad, md, dd = defuncion\n", 449 | "print(ad - an)" 450 | ] 451 | }, 452 | { 453 | "cell_type": "markdown", 454 | "metadata": { 455 | "slideshow": { 456 | "slide_type": "slide" 457 | } 458 | }, 459 | "source": [ 460 | "## Comparación de Tuplas\n" 461 | ] 462 | }, 463 | { 464 | "cell_type": "markdown", 465 | "metadata": { 466 | "slideshow": { 467 | "slide_type": "fragment" 468 | } 469 | }, 470 | "source": [ 471 | "Dos tuplas son iguales cuando tienen el mismo tamaño y cada uno de sus elementos correspondientes tienen el mismo valor:" 472 | ] 473 | }, 474 | { 475 | "cell_type": "code", 476 | "execution_count": 47, 477 | "metadata": { 478 | "slideshow": { 479 | "slide_type": "fragment" 480 | } 481 | }, 482 | "outputs": [ 483 | { 484 | "data": { 485 | "text/plain": [ 486 | "True" 487 | ] 488 | }, 489 | "execution_count": 47, 490 | "metadata": {}, 491 | "output_type": "execute_result" 492 | } 493 | ], 494 | "source": [ 495 | "(1, 2) == (3 // 2, 1 + 1)" 496 | ] 497 | }, 498 | { 499 | "cell_type": "code", 500 | "execution_count": 48, 501 | "metadata": { 502 | "slideshow": { 503 | "slide_type": "fragment" 504 | } 505 | }, 506 | "outputs": [ 507 | { 508 | "data": { 509 | "text/plain": [ 510 | "False" 511 | ] 512 | }, 513 | "execution_count": 48, 514 | "metadata": {}, 515 | "output_type": "execute_result" 516 | } 517 | ], 518 | "source": [ 519 | "(6, 1) == (6, 2)" 520 | ] 521 | }, 522 | { 523 | "cell_type": "code", 524 | "execution_count": 49, 525 | "metadata": { 526 | "slideshow": { 527 | "slide_type": "fragment" 528 | } 529 | }, 530 | "outputs": [ 531 | { 532 | "data": { 533 | "text/plain": [ 534 | "False" 535 | ] 536 | }, 537 | "execution_count": 49, 538 | "metadata": {}, 539 | "output_type": "execute_result" 540 | } 541 | ], 542 | "source": [ 543 | "(6, 1) == (6, 1, 0)" 544 | ] 545 | }, 546 | { 547 | "cell_type": "markdown", 548 | "metadata": { 549 | "slideshow": { 550 | "slide_type": "slide" 551 | } 552 | }, 553 | "source": [ 554 | "Para determinar si una tupla es menor que otra, se utiliza lo que se denomina orden **lexicográfico**. Si los elementos en la primera posición de ambas tuplas son distintos, ellos determinan el ordenamiento de las tuplas:" 555 | ] 556 | }, 557 | { 558 | "cell_type": "code", 559 | "execution_count": 50, 560 | "metadata": { 561 | "slideshow": { 562 | "slide_type": "fragment" 563 | } 564 | }, 565 | "outputs": [ 566 | { 567 | "data": { 568 | "text/plain": [ 569 | "True" 570 | ] 571 | }, 572 | "execution_count": 50, 573 | "metadata": {}, 574 | "output_type": "execute_result" 575 | } 576 | ], 577 | "source": [ 578 | "(1, 4, 7) < (2, 0, 0, 1)" 579 | ] 580 | }, 581 | { 582 | "cell_type": "code", 583 | "execution_count": 51, 584 | "metadata": { 585 | "slideshow": { 586 | "slide_type": "fragment" 587 | } 588 | }, 589 | "outputs": [ 590 | { 591 | "data": { 592 | "text/plain": [ 593 | "False" 594 | ] 595 | }, 596 | "execution_count": 51, 597 | "metadata": {}, 598 | "output_type": "execute_result" 599 | } 600 | ], 601 | "source": [ 602 | "(1, 9, 10) < (0, 5)" 603 | ] 604 | }, 605 | { 606 | "cell_type": "markdown", 607 | "metadata": { 608 | "slideshow": { 609 | "slide_type": "slide" 610 | } 611 | }, 612 | "source": [ 613 | "La primera comparación es True porque `1 < 2`. La segunda comparación es False porque `1 > 0`. No importa el valor que tengan los siguientes valores, o si una tupla tiene más elementos que la otra." 614 | ] 615 | }, 616 | { 617 | "cell_type": "markdown", 618 | "metadata": { 619 | "slideshow": { 620 | "slide_type": "slide" 621 | } 622 | }, 623 | "source": [ 624 | "Si los elementos en la primera posición son iguales, entonces se usa el valor siguiente para hacer la comparación:" 625 | ] 626 | }, 627 | { 628 | "cell_type": "code", 629 | "execution_count": 52, 630 | "metadata": { 631 | "slideshow": { 632 | "slide_type": "fragment" 633 | } 634 | }, 635 | "outputs": [ 636 | { 637 | "data": { 638 | "text/plain": [ 639 | "True" 640 | ] 641 | }, 642 | "execution_count": 52, 643 | "metadata": {}, 644 | "output_type": "execute_result" 645 | } 646 | ], 647 | "source": [ 648 | "(6, 1, 8) < (6, 2, 8)" 649 | ] 650 | }, 651 | { 652 | "cell_type": "code", 653 | "execution_count": 55, 654 | "metadata": { 655 | "slideshow": { 656 | "slide_type": "fragment" 657 | } 658 | }, 659 | "outputs": [ 660 | { 661 | "data": { 662 | "text/plain": [ 663 | "False" 664 | ] 665 | }, 666 | "execution_count": 55, 667 | "metadata": {}, 668 | "output_type": "execute_result" 669 | } 670 | ], 671 | "source": [ 672 | "(6, 1, 8) <(6, 0)\n", 673 | "#(6, 1, 8) <=(6, 0)" 674 | ] 675 | }, 676 | { 677 | "cell_type": "markdown", 678 | "metadata": { 679 | "slideshow": { 680 | "slide_type": "slide" 681 | } 682 | }, 683 | "source": [ 684 | "La primera comparación es True porque `6 == 6` y `1 < 2`. La segunda comparación es False porque `6 == 6` y `1 > 0`\n", 685 | "." 686 | ] 687 | }, 688 | { 689 | "cell_type": "markdown", 690 | "metadata": { 691 | "slideshow": { 692 | "slide_type": "slide" 693 | } 694 | }, 695 | "source": [ 696 | "Si los elementos respectivos siguen siendo iguales, entonces se sigue probando con los siguientes uno por uno, hasta encontrar dos distintos. Si a una tupla se le acaban los elementos para comparar antes que a la otra, entonces es considerada menor que la otra:" 697 | ] 698 | }, 699 | { 700 | "cell_type": "code", 701 | "execution_count": 59, 702 | "metadata": { 703 | "slideshow": { 704 | "slide_type": "fragment" 705 | } 706 | }, 707 | "outputs": [ 708 | { 709 | "data": { 710 | "text/plain": [ 711 | "True" 712 | ] 713 | }, 714 | "execution_count": 59, 715 | "metadata": {}, 716 | "output_type": "execute_result" 717 | } 718 | ], 719 | "source": [ 720 | "(1, 2) < (1, 2, 0)" 721 | ] 722 | }, 723 | { 724 | "cell_type": "code", 725 | "execution_count": 60, 726 | "metadata": { 727 | "slideshow": { 728 | "slide_type": "fragment" 729 | } 730 | }, 731 | "outputs": [ 732 | { 733 | "data": { 734 | "text/plain": [ 735 | "False" 736 | ] 737 | }, 738 | "execution_count": 60, 739 | "metadata": {}, 740 | "output_type": "execute_result" 741 | } 742 | ], 743 | "source": [ 744 | "(1, 3) < (1, 2, 4)" 745 | ] 746 | }, 747 | { 748 | "cell_type": "markdown", 749 | "metadata": { 750 | "slideshow": { 751 | "slide_type": "slide" 752 | } 753 | }, 754 | "source": [ 755 | "La primera compación es `True` porque `1 == 1`, `2 == 2`, y ahí se acaban los elementos de la primera tupla. La segunda comparación es False porque `1 == 1` y `3 < 2`; en este caso sí se alcanza a determinar el resultado antes que se acaben los elementos de la primera tupla." 756 | ] 757 | }, 758 | { 759 | "cell_type": "markdown", 760 | "metadata": { 761 | "slideshow": { 762 | "slide_type": "slide" 763 | } 764 | }, 765 | "source": [ 766 | "## Algunas operaciones sobre tuplas" 767 | ] 768 | }, 769 | { 770 | "cell_type": "markdown", 771 | "metadata": { 772 | "slideshow": { 773 | "slide_type": "slide" 774 | } 775 | }, 776 | "source": [ 777 | "### Verificar si elemento se encuentra en una tupla\n", 778 | "\n", 779 | "La instrucción `in` permite verificar si un elemento está contenido en una tupla." 780 | ] 781 | }, 782 | { 783 | "cell_type": "code", 784 | "execution_count": 61, 785 | "metadata": { 786 | "slideshow": { 787 | "slide_type": "fragment" 788 | } 789 | }, 790 | "outputs": [], 791 | "source": [ 792 | "t = (1, 5, 6)" 793 | ] 794 | }, 795 | { 796 | "cell_type": "code", 797 | "execution_count": 65, 798 | "metadata": { 799 | "slideshow": { 800 | "slide_type": "fragment" 801 | } 802 | }, 803 | "outputs": [ 804 | { 805 | "data": { 806 | "text/plain": [ 807 | "True" 808 | ] 809 | }, 810 | "execution_count": 65, 811 | "metadata": {}, 812 | "output_type": "execute_result" 813 | } 814 | ], 815 | "source": [ 816 | "1 in t" 817 | ] 818 | }, 819 | { 820 | "cell_type": "code", 821 | "execution_count": 63, 822 | "metadata": { 823 | "slideshow": { 824 | "slide_type": "fragment" 825 | } 826 | }, 827 | "outputs": [ 828 | { 829 | "data": { 830 | "text/plain": [ 831 | "True" 832 | ] 833 | }, 834 | "execution_count": 63, 835 | "metadata": {}, 836 | "output_type": "execute_result" 837 | } 838 | ], 839 | "source": [ 840 | "3 not in t" 841 | ] 842 | }, 843 | { 844 | "cell_type": "markdown", 845 | "metadata": { 846 | "slideshow": { 847 | "slide_type": "slide" 848 | } 849 | }, 850 | "source": [ 851 | "## Funciones que aceptan tuplas como parámetros" 852 | ] 853 | }, 854 | { 855 | "cell_type": "markdown", 856 | "metadata": { 857 | "slideshow": { 858 | "slide_type": "fragment" 859 | } 860 | }, 861 | "source": [ 862 | "### Longitud de una tupla\n", 863 | "La función `len(tupla)` entrega la cantidad de elementos de la tupla ingresada como parámetro." 864 | ] 865 | }, 866 | { 867 | "cell_type": "code", 868 | "execution_count": 66, 869 | "metadata": { 870 | "slideshow": { 871 | "slide_type": "fragment" 872 | } 873 | }, 874 | "outputs": [ 875 | { 876 | "name": "stdout", 877 | "output_type": "stream", 878 | "text": [ 879 | "La cantidad de elementos en la tupla es 6\n" 880 | ] 881 | } 882 | ], 883 | "source": [ 884 | "t = (1,2,3,4,8,10)\n", 885 | "print(\"La cantidad de elementos en la tupla es\", len(t))" 886 | ] 887 | }, 888 | { 889 | "cell_type": "markdown", 890 | "metadata": { 891 | "slideshow": { 892 | "slide_type": "slide" 893 | } 894 | }, 895 | "source": [ 896 | "### Suma de los valores de una tupla\n", 897 | "Usando la función `sum(tupla)`, se puede determinar la suma de los elementos de una tupla." 898 | ] 899 | }, 900 | { 901 | "cell_type": "code", 902 | "execution_count": 67, 903 | "metadata": { 904 | "slideshow": { 905 | "slide_type": "fragment" 906 | } 907 | }, 908 | "outputs": [ 909 | { 910 | "data": { 911 | "text/plain": [ 912 | "28" 913 | ] 914 | }, 915 | "execution_count": 67, 916 | "metadata": {}, 917 | "output_type": "execute_result" 918 | } 919 | ], 920 | "source": [ 921 | "t = (1,2,3,4,8,10)\n", 922 | "sum(t)" 923 | ] 924 | }, 925 | { 926 | "cell_type": "markdown", 927 | "metadata": { 928 | "slideshow": { 929 | "slide_type": "slide" 930 | } 931 | }, 932 | "source": [ 933 | "### Mínimo y Máximo en una tupla de elementos\n", 934 | "La función `min(tupla)` y `max(tupla)` entrega el valor mínimo y máximo de la `tupla` ingresada como parámetro." 935 | ] 936 | }, 937 | { 938 | "cell_type": "code", 939 | "execution_count": 68, 940 | "metadata": { 941 | "slideshow": { 942 | "slide_type": "fragment" 943 | } 944 | }, 945 | "outputs": [ 946 | { 947 | "name": "stdout", 948 | "output_type": "stream", 949 | "text": [ 950 | "1 10\n" 951 | ] 952 | } 953 | ], 954 | "source": [ 955 | "t = (1,2,3,4,8,10)\n", 956 | "print(min(t), max(t))" 957 | ] 958 | }, 959 | { 960 | "cell_type": "markdown", 961 | "metadata": { 962 | "slideshow": { 963 | "slide_type": "slide" 964 | } 965 | }, 966 | "source": [ 967 | "## Ciclo `for` en tuplas\n", 968 | "- Un ciclo `for` puede ser usado para iterar sobre tuplas." 969 | ] 970 | }, 971 | { 972 | "cell_type": "code", 973 | "execution_count": 70, 974 | "metadata": { 975 | "slideshow": { 976 | "slide_type": "fragment" 977 | } 978 | }, 979 | "outputs": [ 980 | { 981 | "name": "stdout", 982 | "output_type": "stream", 983 | "text": [ 984 | "(0, 1, 2, 3, 4, 5, 6, 7, 8, 9)\n", 985 | "0\n", 986 | "1\n", 987 | "2\n", 988 | "3\n", 989 | "4\n", 990 | "5\n", 991 | "6\n", 992 | "7\n", 993 | "8\n", 994 | "9\n" 995 | ] 996 | } 997 | ], 998 | "source": [ 999 | "tt = tuple(range(10))\n", 1000 | "print(tt)\n", 1001 | "for e in tt:\n", 1002 | " print(e)" 1003 | ] 1004 | }, 1005 | { 1006 | "cell_type": "markdown", 1007 | "metadata": { 1008 | "slideshow": { 1009 | "slide_type": "slide" 1010 | } 1011 | }, 1012 | "source": [ 1013 | "### Iterables (hasta el momento):\n", 1014 | "- Strings\n", 1015 | "- Listas\n", 1016 | "- `range`\n", 1017 | "- Tuplas" 1018 | ] 1019 | }, 1020 | { 1021 | "cell_type": "markdown", 1022 | "metadata": { 1023 | "slideshow": { 1024 | "slide_type": "slide" 1025 | } 1026 | }, 1027 | "source": [ 1028 | "## Mezcla de Estructuras: Lista de Tuplas\n", 1029 | "\n", 1030 | "Algunas veces es necesario integrar varias estructuras para resolver ciertos problemas." 1031 | ] 1032 | }, 1033 | { 1034 | "cell_type": "code", 1035 | "execution_count": 71, 1036 | "metadata": { 1037 | "slideshow": { 1038 | "slide_type": "slide" 1039 | } 1040 | }, 1041 | "outputs": [ 1042 | { 1043 | "name": "stdout", 1044 | "output_type": "stream", 1045 | "text": [ 1046 | "Progra tiene 3 creditos\n", 1047 | "Mate tiene 5 creditos\n", 1048 | "Física tiene 3 creditos\n", 1049 | "Ed.Fisica tiene 1 creditos\n", 1050 | "Inmanente tiene 2 creditos\n" 1051 | ] 1052 | } 1053 | ], 1054 | "source": [ 1055 | "# Opcion 1\n", 1056 | "\n", 1057 | "ramos = [\n", 1058 | " ('Progra', 'IWI-131', 3),\n", 1059 | " ('Mate', 'MAT-021', 5), \n", 1060 | " ('Física', 'FIS-100', 3),\n", 1061 | " ('Ed.Fisica', 'DEW-100', 1), \n", 1062 | " ('Inmanente', 'HRW-102', 2)\n", 1063 | "]\n", 1064 | "\n", 1065 | "# Iterar sobre la lista de tuplas\n", 1066 | "for ramo in ramos:\n", 1067 | " nombre, sigla, c = ramo\n", 1068 | " print(nombre, 'tiene', c, 'creditos')" 1069 | ] 1070 | }, 1071 | { 1072 | "cell_type": "code", 1073 | "execution_count": 77, 1074 | "metadata": { 1075 | "slideshow": { 1076 | "slide_type": "slide" 1077 | } 1078 | }, 1079 | "outputs": [ 1080 | { 1081 | "name": "stdout", 1082 | "output_type": "stream", 1083 | "text": [ 1084 | "Progra tiene 3 creditos\n", 1085 | "Mate tiene 5 creditos\n", 1086 | "Física tiene 3 creditos\n", 1087 | "Ed.Fisica tiene 1 creditos\n", 1088 | "Inmanente tiene 2 creditos\n" 1089 | ] 1090 | } 1091 | ], 1092 | "source": [ 1093 | "# Opcion 2\n", 1094 | "ramos = [\n", 1095 | " ('Progra', 'IWI-131', 3),\n", 1096 | " ('Mate', 'MAT-021', 5), \n", 1097 | " ('Física', 'FIS-100', 3),\n", 1098 | " ('Ed.Fisica', 'DEW-100', 1), \n", 1099 | " ('Inmanente', 'HRW-102', 2)\n", 1100 | "]\n", 1101 | "\n", 1102 | "# Iterar sobre la lista de tuplas\n", 1103 | "for nombre, sigla, c in ramos:\n", 1104 | " print(nombre, 'tiene', c, 'creditos')" 1105 | ] 1106 | }, 1107 | { 1108 | "cell_type": "markdown", 1109 | "metadata": { 1110 | "slideshow": { 1111 | "slide_type": "slide" 1112 | } 1113 | }, 1114 | "source": [ 1115 | "### Ordenar una lista de tuplas" 1116 | ] 1117 | }, 1118 | { 1119 | "cell_type": "code", 1120 | "execution_count": 83, 1121 | "metadata": { 1122 | "slideshow": { 1123 | "slide_type": "fragment" 1124 | } 1125 | }, 1126 | "outputs": [ 1127 | { 1128 | "data": { 1129 | "text/plain": [ 1130 | "[(4, 'Una nueva Esperanza'),\n", 1131 | " (5, 'El Imperio Contraataca'),\n", 1132 | " (6, 'El Retorno del Jedi'),\n", 1133 | " (1, 'La Amenaza Fantasma'),\n", 1134 | " (2, 'El Ataque de los Clones'),\n", 1135 | " (3, 'La Venganza de los Siths'),\n", 1136 | " (7, 'El Despertar de la Fuerza'),\n", 1137 | " (8, 'Los Ultimos Jedi')]" 1138 | ] 1139 | }, 1140 | "execution_count": 83, 1141 | "metadata": {}, 1142 | "output_type": "execute_result" 1143 | } 1144 | ], 1145 | "source": [ 1146 | "star_wars = [\n", 1147 | " (4, 'Una nueva Esperanza'),\n", 1148 | " (5, 'El Imperio Contraataca'),\n", 1149 | " (6, 'El Retorno del Jedi'),\n", 1150 | " (1, 'La Amenaza Fantasma'),\n", 1151 | " (2, 'El Ataque de los Clones'),\n", 1152 | " (3, 'La Venganza de los Siths'),\n", 1153 | " (7, 'El Despertar de la Fuerza'),\n", 1154 | " (8, 'Los Ultimos Jedi')\n", 1155 | "]\n", 1156 | "\n", 1157 | "star_wars\n", 1158 | "#nueva_lista =[]\n", 1159 | "#for elem in star_wars:\n", 1160 | "# num, nombre = elem\n", 1161 | "# nueva_lista.append(tuple([nombre,num]))\n", 1162 | "\n", 1163 | "#nueva_lista" 1164 | ] 1165 | }, 1166 | { 1167 | "cell_type": "code", 1168 | "execution_count": 84, 1169 | "metadata": { 1170 | "slideshow": { 1171 | "slide_type": "slide" 1172 | } 1173 | }, 1174 | "outputs": [ 1175 | { 1176 | "data": { 1177 | "text/plain": [ 1178 | "[(1, 'La Amenaza Fantasma'),\n", 1179 | " (2, 'El Ataque de los Clones'),\n", 1180 | " (3, 'La Venganza de los Siths'),\n", 1181 | " (4, 'Una nueva Esperanza'),\n", 1182 | " (5, 'El Imperio Contraataca'),\n", 1183 | " (6, 'El Retorno del Jedi'),\n", 1184 | " (7, 'El Despertar de la Fuerza'),\n", 1185 | " (8, 'Los Ultimos Jedi')]" 1186 | ] 1187 | }, 1188 | "execution_count": 84, 1189 | "metadata": {}, 1190 | "output_type": "execute_result" 1191 | } 1192 | ], 1193 | "source": [ 1194 | "star_wars.sort()\n", 1195 | "star_wars" 1196 | ] 1197 | }, 1198 | { 1199 | "cell_type": "code", 1200 | "execution_count": 85, 1201 | "metadata": { 1202 | "slideshow": { 1203 | "slide_type": "slide" 1204 | } 1205 | }, 1206 | "outputs": [ 1207 | { 1208 | "data": { 1209 | "text/plain": [ 1210 | "[(1, 4), (1, 2), (1, 1), (1, 10)]" 1211 | ] 1212 | }, 1213 | "execution_count": 85, 1214 | "metadata": {}, 1215 | "output_type": "execute_result" 1216 | } 1217 | ], 1218 | "source": [ 1219 | "nums = [(1, 4), (1, 2), (1, 1), (1, 10)]\n", 1220 | "nums" 1221 | ] 1222 | }, 1223 | { 1224 | "cell_type": "code", 1225 | "execution_count": 89, 1226 | "metadata": { 1227 | "slideshow": { 1228 | "slide_type": "fragment" 1229 | } 1230 | }, 1231 | "outputs": [ 1232 | { 1233 | "data": { 1234 | "text/plain": [ 1235 | "[(1, 1), (1, 2), (1, 4), (1, 10)]" 1236 | ] 1237 | }, 1238 | "execution_count": 89, 1239 | "metadata": {}, 1240 | "output_type": "execute_result" 1241 | } 1242 | ], 1243 | "source": [ 1244 | "nums.sort()\n", 1245 | "nums" 1246 | ] 1247 | }, 1248 | { 1249 | "cell_type": "markdown", 1250 | "metadata": { 1251 | "slideshow": { 1252 | "slide_type": "fragment" 1253 | } 1254 | }, 1255 | "source": [ 1256 | "Para ordenar una lista de tuplas, utiliza el criterio de comparación de tuplas utilizando un orden ascendente." 1257 | ] 1258 | }, 1259 | { 1260 | "cell_type": "markdown", 1261 | "metadata": { 1262 | "slideshow": { 1263 | "slide_type": "slide" 1264 | } 1265 | }, 1266 | "source": [ 1267 | "## Ejercicios" 1268 | ] 1269 | }, 1270 | { 1271 | "cell_type": "markdown", 1272 | "metadata": { 1273 | "slideshow": { 1274 | "slide_type": "fragment" 1275 | } 1276 | }, 1277 | "source": [ 1278 | "**1.** Escriba una función `distancia(p1, p2)` que retorne la distancia entre los puntos `p1` y `p2`:\n", 1279 | "\n", 1280 | "```\n", 1281 | ">>> a = (5.1, 7.3, 2.4)\n", 1282 | ">>> b = (1.1, 2.8, 4.9)\n", 1283 | ">>> distancia(a, b)\n", 1284 | "6.5192024052026492\n", 1285 | "```" 1286 | ] 1287 | }, 1288 | { 1289 | "cell_type": "code", 1290 | "execution_count": null, 1291 | "metadata": { 1292 | "slideshow": { 1293 | "slide_type": "slide" 1294 | } 1295 | }, 1296 | "outputs": [], 1297 | "source": [ 1298 | "def distancia(p1, p2):\n", 1299 | " x1, y1, z1 = p1\n", 1300 | " x2, y2, z2 = p2\n", 1301 | " dx = x2 - x1\n", 1302 | " dy = y2 - y1\n", 1303 | " dz = z2 - z1\n", 1304 | " return (dx ** 2 + dy ** 2 + dz ** 2) ** 0.5" 1305 | ] 1306 | }, 1307 | { 1308 | "cell_type": "code", 1309 | "execution_count": null, 1310 | "metadata": { 1311 | "slideshow": { 1312 | "slide_type": "slide" 1313 | } 1314 | }, 1315 | "outputs": [], 1316 | "source": [ 1317 | "a = (5.1, 7.3, 2.4)\n", 1318 | "b = (1.1, 2.8, 4.9)\n", 1319 | "distancia(a, b)" 1320 | ] 1321 | }, 1322 | { 1323 | "cell_type": "markdown", 1324 | "metadata": { 1325 | "slideshow": { 1326 | "slide_type": "slide" 1327 | } 1328 | }, 1329 | "source": [ 1330 | "**2.** Un polígono está determinado por la lista de sus vértices. Escriba una función `perimetro(vertices)` que entregue el perímetro del polígono definido por la lista vertices:\n", 1331 | "\n", 1332 | "```\n", 1333 | ">>> p = [(4, 1), (7, 2), (7, 4), (5, 9)]\n", 1334 | ">>> perimetro(p)\n", 1335 | "18.609700215601432\n", 1336 | "```" 1337 | ] 1338 | }, 1339 | { 1340 | "cell_type": "code", 1341 | "execution_count": null, 1342 | "metadata": { 1343 | "slideshow": { 1344 | "slide_type": "slide" 1345 | } 1346 | }, 1347 | "outputs": [], 1348 | "source": [ 1349 | "# Distancia para puntos en R^2\n", 1350 | "def distancia(p1, p2):\n", 1351 | " (x1, y1), (x2, y2) = p1, p2\n", 1352 | " dx, dy = x2 - x1, y2 - y1\n", 1353 | " return (dx ** 2 + dy ** 2) ** .5" 1354 | ] 1355 | }, 1356 | { 1357 | "cell_type": "code", 1358 | "execution_count": null, 1359 | "metadata": { 1360 | "slideshow": { 1361 | "slide_type": "fragment" 1362 | } 1363 | }, 1364 | "outputs": [], 1365 | "source": [ 1366 | "# Propuesta 1\n", 1367 | "def perimetro(vertices): \n", 1368 | " n = len(vertices) \n", 1369 | " suma = 0.0\n", 1370 | " for i in range(n):\n", 1371 | " a = vertices[i]\n", 1372 | " b = vertices[(i + 1) % n] \n", 1373 | " suma += distancia(a, b)\n", 1374 | " return suma" 1375 | ] 1376 | }, 1377 | { 1378 | "cell_type": "code", 1379 | "execution_count": null, 1380 | "metadata": { 1381 | "slideshow": { 1382 | "slide_type": "fragment" 1383 | } 1384 | }, 1385 | "outputs": [], 1386 | "source": [ 1387 | "p = [(4, 1), (7, 2), (7, 4), (5, 9)]\n", 1388 | "perimetro(p)" 1389 | ] 1390 | }, 1391 | { 1392 | "cell_type": "code", 1393 | "execution_count": null, 1394 | "metadata": { 1395 | "slideshow": { 1396 | "slide_type": "slide" 1397 | } 1398 | }, 1399 | "outputs": [], 1400 | "source": [ 1401 | "# Propuesta 2\n", 1402 | "def perimetro(vertices):\n", 1403 | " n = len(vertices)\n", 1404 | " actual = vertices[0:n]\n", 1405 | " sgte = vertices[1:n] + [vertices[0]] \n", 1406 | " distancias = []\n", 1407 | " for i in range(n):\n", 1408 | " d = distancia(actual[i], sgte[i]) \n", 1409 | " distancias.append(d)\n", 1410 | " return sum(distancias)" 1411 | ] 1412 | }, 1413 | { 1414 | "cell_type": "code", 1415 | "execution_count": null, 1416 | "metadata": { 1417 | "slideshow": { 1418 | "slide_type": "fragment" 1419 | } 1420 | }, 1421 | "outputs": [], 1422 | "source": [ 1423 | "p = [(4, 1), (7, 2), (7, 4), (5, 9)]\n", 1424 | "perimetro(p)" 1425 | ] 1426 | }, 1427 | { 1428 | "cell_type": "code", 1429 | "execution_count": null, 1430 | "metadata": {}, 1431 | "outputs": [], 1432 | "source": [] 1433 | } 1434 | ], 1435 | "metadata": { 1436 | "anaconda-cloud": {}, 1437 | "celltoolbar": "Slideshow", 1438 | "kernelspec": { 1439 | "display_name": "Python 3", 1440 | "language": "python", 1441 | "name": "python3" 1442 | }, 1443 | "language_info": { 1444 | "codemirror_mode": { 1445 | "name": "ipython", 1446 | "version": 3 1447 | }, 1448 | "file_extension": ".py", 1449 | "mimetype": "text/x-python", 1450 | "name": "python", 1451 | "nbconvert_exporter": "python", 1452 | "pygments_lexer": "ipython3", 1453 | "version": "3.7.1" 1454 | } 1455 | }, 1456 | "nbformat": 4, 1457 | "nbformat_minor": 1 1458 | } 1459 | --------------------------------------------------------------------------------