"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Profesores"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"* Alvaro Montenegro, PhD, \n",
"* Campo Elías Pardo, PhD, \n",
"* Daniel Montenegro, Msc, \n",
"* Camilo José Torres Jiménez, Msc, "
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Asesora Medios y Marketing digital"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"* Maria del Pilar Montenegro, pmontenegro88@gmail.com\n",
"* Jessica López Mejía, jelopezme@unal.edu.co"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Jefe Jurídica"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"* Paula Andrea Guzmán, guzmancruz.paula@gmail.com"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Coordinador Jurídico"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"* David Fuentes, fuentesd065@gmail.com"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Desarrolladores Principales"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"* Dairo Moreno, damoralesj@unal.edu.co\n",
"* Joan Castro, jocastroc@unal.edu.co\n",
"* Bryan Riveros, briveros@unal.edu.co\n",
"* Rosmer Vargas, rovargasc@unal.edu.co\n",
"* Venus Puertas, vpuertasg@unal.edu.co"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Expertos en Bases de Datos"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"* Giovvani Barrera, udgiovanni@gmail.com\n",
"* Camilo Chitivo, cchitivo@unal.edu.co"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Introducción"
]
},
{
"cell_type": "markdown",
"metadata": {
"colab_type": "text",
"id": "qAqnr4i70sLy"
},
"source": [
"En la mayoría de lenguajes de programación, que soportan el paradigma imperativo, existen tres estructuras de control básicas:\n",
"\n",
"- Secuencia\n",
"- Selección (o decisión)\n",
"- Iteración (o repetición)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Secuencia"
]
},
{
"cell_type": "markdown",
"metadata": {
"colab_type": "text",
"id": "qAqnr4i70sLy"
},
"source": [
"La ejecución del programa (algoritmo codificado en el lenguaje de programación) se realiza en orden de aparición de las sentencias. Una `sentencia` puede ser *simple* (solamente una instrucción) o *compuesta* (varias instrucciones que siguen un orden y que fueron agrupadas)."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Ejemplo\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"colab_type": "text",
"id": "qAqnr4i70sLy"
},
"source": [
"Observe el siguiente código Python"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"x = 1\n",
"y = 2\n",
"print(x, y)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"En el ejemplo hay tres sentencias. Dos sentencias de asignación de valores y una sentencia de impresión. Se ejecuta una después de la otra."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Selección"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Las estructuras de selección permiten al programa validar una condición, y ejecutar una serie de sentencias diferentes, dependiendo del valor que toma la condición. Por ejemplo, permite realizar unas sentencias si la condición es verdadero u otras distintas en caso de que la condición sea falsa."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Estructura if\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Esta estructura de control está diseñada para que un programa pueda seguir diferentes caminos de ejecución, dependiendo de la evaluación de una expresión lógica. Observe el siguiente ejemplo."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"x = 5\n",
"y = 3\n",
"if x > y:\n",
" print(\"x es mayor que y\")\n",
" print(\"Este texto se imprimirá únicamente si x es mayor que y\")\n",
"print(\"Este texto se imprimirá sin que ello dependa de si x es mayor que y\")"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"La estructura empieza con la palabra clave **if**. Luego aparece una condición lógica que es evaluada (`x > y`). Si la condición es verdadera, como en este caso, se ejecutan las instrucciones escritas con *indentación* o *indentado* (anglicismos, que en español corresponderían a: con sangrado o sangría. Ver RAE).\n",
"\n",
"Ahora observe el siguiente cambio"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"x = 3\n",
"y = 5\n",
"if x > y:\n",
" print(\"x es mayor que y\")\n",
" print(\"Este texto se imprimirá únicamente si x es mayor que y\")\n",
"print(\"Este texto se imprimirá sin que ello dependa de si x es mayor que y\")"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"En este caso, no se ejecutan los `print` indentados, debido a que la condición es falsa. "
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Estructura if- else"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Cuando hay dos alternativas de ejecución, dependiendo de la evaluación de una condición, se puede emplear la estructura `if-else`. Ahora observe el siguiente ejemplo."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"x = 3\n",
"y = 5\n",
"if x > y:\n",
" print(\"La condición es verdadera\")\n",
" print(\"Este texto se imprimirá únicamente si x es mayor que y\")\n",
"else:\n",
" print('La condición es falsa')\n",
" print(\"Este texto se imprimirá únicamente si x NO es mayor que y\")\n",
"print(\"Este texto se imprimirá sin que ello dependa de si x es mayor que y\")"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Lo que se agregó aquí fue un `else`. Este debe ir después de un `if` y se ejecuta cuando la condicion del `if` no se cumple, es decir cuando su valor lógico es: `False`."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Estructura elif\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Usaremos la estructura `elif` (forma corta de \"else if\") si queremos evaluar más de una condición separada dentro de la estructura de la selección. Hagamos el anterior ejemplo más complejo"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"a = 3\n",
"b = 5\n",
"c = 5\n",
"if a > c:\n",
" print(\"a es mayor que c\")\n",
"elif b > c:\n",
" print('b es mayor que c')\n",
"else:\n",
" print(\"c es mayor o igual que a y mayor o igual que b\")"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Lo que ocurre es lo siguiente:\n",
"\n",
"* En este último ejemplo, se evalúa primero la condición `a > c`. Si la evaluación de la condición es `True` se ejecuta `print(\"a es mayor que c\")` y se termina la ejecución de toda la estructura de control. En ejemplo, el resultado de la evaluación de la condición es `False`, por lo que se salta a la siguiente parte de la estructura, es decir a la parte `elif`. \n",
"* En este caso, la evaluación de la condición `b > c` es `False`, por lo que se salta a la parte `else`, se ejecuta `print(\"c es mayor o igual que a y mayor o igual que b\")` y termina la ejecución de la estructura de decisión."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Ejercicio\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"colab_type": "text",
"id": "qA6o2ObtUzVC"
},
"source": [
"El siguiente código calcula la longitud del nombre y escribe una frase acorde a la longitud. Observe que en el comando `print()`, `sep = ` es un parámetro que separa los valores ingresados dentro de la función `print()`. Como vemos, escribimos `N = 'Tu_nombre'` eso asigna a la variable `N` el texto *Tu_nombre*. La función `len` devuelve la longitud de la cadena."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"colab": {},
"colab_type": "code",
"id": "P41c3wWHUzVI"
},
"outputs": [],
"source": [
"N = \n",
"if len(N) > 10:\n",
" A=\"es un nombre largo\"\n",
"else:\n",
" A=\"es un nombre corto\"\n",
"\n",
"print(N, A, sep=\" ... \")"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Estructura de decisión múltiple Match. Python 3.10\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**Esto solo es posible desde la versión 3.10 de Python.**\n",
"\n",
"Durante muchos años, los usuarios de Python pidieron incluir una estructura de selección que existe en otros lenguajes de programación. En C existe la estructura de selección llamada \"switch\", la cual se usa para cuando la condición puede tener otros valores aparte de los valores lógicos asociados a verdadero y falso. En estos casos hacer `if elif else` no es tan práctico.\n",
" \n",
"En C/C++ la estructura `switch` se ve así:\n",
"\n",
"```\n",
"switch(variable_a_evaluar):\n",
" case valor1:\n",
" sentencias1\n",
" break:\n",
" case valor2:\n",
" sentencias2\n",
" break:\n",
" case valor3:\n",
" sentencias3\n",
" break:\n",
" default:\n",
" otras_sentencias\n",
"```\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"En Python no existía nada parecido, hasta la versión 3.10 donde se creó `match`.\n",
"\n",
"Hagamos un ejemplo básico:"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# Este código se ejecutará y funcionará únicamente bajo Python 3.10\n",
"quit = True\n",
"match quit:\n",
" case True:\n",
" print(\"Cerrando\")\n",
" case False:\n",
" print(\"Sistema prendido\")"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Dentro del `match` también sucede el caso \"default\", que se cumple cuando los otros casos no, en Python esto se toma con un `_`"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"status = 401\n",
"\n",
"match status:\n",
" case 400:\n",
" print('Mala solicitud')\n",
" case 401:\n",
" print('No autorizado')\n",
" case 402:\n",
" print('Pago necesario')\n",
" case 403:\n",
" print('Prohibido')\n",
" case 404:\n",
" print('No encontrado')\n",
" case _:\n",
" print('código no reconocido')"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"En Python es posible aplicar una acción a varios casos"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"status = 403\n",
"\n",
"match status:\n",
" case 400:\n",
" print('Mala solicitud') \n",
" case 401 | 403: # es la operación lógica: o\n",
" print('Error de Autenticación')\n",
" case 404:\n",
" print('No encontrado')\n",
" case _:\n",
" print('otro tipo de código')"
]
},
{
"cell_type": "markdown",
"metadata": {
"colab_type": "text",
"id": "qAqnr4i70sLy"
},
"source": [
"## Alcance de las estructuras. Indentación en Python"
]
},
{
"cell_type": "markdown",
"metadata": {
"colab_type": "text",
"id": "oMyFFHSjlj9J"
},
"source": [
"Indentar significa **mover un bloque de texto hacia la derecha**, dejando una serie de espacios o un tabulador para distinguirlo del texto alineado a la izquierda. \n",
"\n",
"Por ejemplo:\n",
"\n",
"> Este texto está indentado.\n",
"\n",
"En Python, la indentación es obligatoria para indicar el alcance de una estructura. Además, solamente debe usarse para tal fin.\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Ejemplo: Indentación en Python\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"colab_type": "text",
"id": "OqFH478Xza5l"
},
"source": [
"En este ejemplo"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"colab": {},
"colab_type": "code",
"id": "ie3nUgSszhve"
},
"outputs": [],
"source": [
"x = 3\n",
"y = 5\n",
"if x > y:\n",
" print(\"Instrucción 1\")\n",
" print(\"Instrucción 2\")\n",
"print(\"Instrucción 3\")"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"x = 3\n",
"y = 5\n",
"if x > y:\n",
" print(\"Instrucción 1\")\n",
"print(\"Instrucción 2\")\n",
"print(\"Instrucción 3\")"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Si no se indenta al menos una instrucción despues de la estructura, entonces se produce un error."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"x = 3\n",
"y = 5\n",
"if x > y:\n",
"print(\"Instrucción 1\")\n",
"print(\"Instrucción 2\")\n",
"print(\"Instrucción 3\")"
]
},
{
"cell_type": "markdown",
"metadata": {
"colab_type": "text",
"id": "h_FUae2V1Dfu"
},
"source": [
"### Número de espacios al indentar"
]
},
{
"cell_type": "markdown",
"metadata": {
"colab_type": "text",
"id": "h_FUae2V1Dfu"
},
"source": [
"No importa cuántos espacios en blanco se dejen, siempre y cuando sea *al menos uno*. Revise el siguiente ejemplo."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"colab": {},
"colab_type": "code",
"id": "8shIg71S1KOI"
},
"outputs": [],
"source": [
"# la indentación con 2 espacios\n",
"if 5 > 3:\n",
" print(\"Five is greater than Three\") \n",
"# la indentación con 6 espacios\n",
"if 5 > 3:\n",
" print(\"Five is greater than Three\")"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Observe que el número de espacios en la identación no afectó la salida."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Ejercicio\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Verifique que entiende qué hace el siguiente código. ¿Cuál es la salida?"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"edad = 15\n",
"estado = None\n",
"if (edad > 12) and (edad < 20):\n",
" estado = 'adolescente'\n",
"else:\n",
" estado = 'no adolescente'\n",
"print('estado =', estado)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Estructuras de repetición (iteración, ciclos o bucles)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Este tercer tipo de estructura de control se usa para los casos en los cuales es necesario ejecutar un conjunto de instrucciones varias veces consecutivas."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Ciclo while\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Al comienzo se evalúa una condición. Si la condición es verdadera, se realiza una nueva iteración o ciclo. En otro caso, termina. Analice el siguiente código."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"contador = 0\n",
"print('¡Empezando!')\n",
"while contador < 10:\n",
" print(contador, ' ', end = '')\n",
" contador = contador + 1\n",
"print()\n",
"print('¡Hecho!')"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Ejercicio\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"¿Qué hace `end = ''` en el `print()` anterior? "
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Ciclo for\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"En este caso se usa una variable de salto que va recorriendo un conjunto de valores hasta terminar. Revise el siguiente fragmento de código."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"print('\\nInicio:')\n",
"for i in range(20):\n",
" print(i, ' ', end='')\n",
"print('\\nHecho.')"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Ejercicio"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"1. Discuta, ¿cuál es la diferencia entre la estructuras `while` y `for`?\n",
"2. Reescriba los dos ejemplos anteriores cambiado de `while` a `for` y viceversa, según el caso."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# Consigne aquí sus respuestas\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Sentencia break\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Esta sentencia se usa para terminar la ejecución de un `while` o `for`. Corra el siguiente ejemplo dando diferentes valores para el rango de valores, digamos 3, 5, 10."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"for i in range(10):\n",
" print(i)\n",
" if i == 5:\n",
" break"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Estructuras de control anidadas"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Es posible incluir (o anidar) estructuras de control, unas dentro de otras. Esto es de gran utilidad para realizar programas de mayor complejidad."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Ejemplo"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"A continuación tenemos una estructura `for` **anidada** dentro de una estructura `if`. Si la condición en la estructura `if` es `True`, como en el ejemplo, se ejecutan las siguientes tres sentencias: `print`, `for`, y asignación. La últimas dos sentencias al final de código siempre se ejecutan, porque están por fuera de la estructura `if`."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"colab": {},
"colab_type": "code",
"id": "Q6UM2ujoztla"
},
"outputs": [],
"source": [
"x = 5\n",
"y = 3\n",
"print(\"x =\", x, \", y =\", y)\n",
"if x > y:\n",
" print(\"Cinco es mayor que tres\")\n",
" for i in range(10):\n",
" print(i, end=\", \")\n",
" x = 9.9\n",
"y = 2\n",
"print(\"\\nx =\", x, \". y =\", y)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Ciclos anidados\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Un ejemplo de ciclos anidados, puede ser de gran utilidad para realizar procesos iterativos. Por ejemplo crear las tablas de multiplicar."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Ejemplo de la tablas multiplicar"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"En el siguiente fragmento imprimimos las tablas de multiplicar hasta 4, con multiplicadores hasta 12. Veámos."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"print(\"\\nAlgunas Tablas de Multiplicar:\")\n",
"for i in range(6, 9): # i va aumentado desde 1, luego va a 2,3,...\n",
" print(f'\\nTabla del {i}\\n')\n",
" for j in range(1, 11): # Recorre desde el 1 hasta el 12\n",
" print(i, \"x\", j, \" = \", i*j, sep='')"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Ejemplo de una sucesión creciente de asteríscos"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# Sucesión creciente de asteríscos\n",
"num_lineas = 11\n",
"for i in range(0, num_lineas): \n",
" for j in range(i): \n",
" print('*', end='') \n",
" print('') "
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Buscando una letra en una cadena (string) con un ciclo for"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"También es posible aplicar un `else` a las estructuras `for` y `while`. Lo que se ponga en este se va a ejecutar al final del ciclo a menos que se use una claúsula `break`. En el siguiente ejemplo se busca determinar si una letra esta dentro de un texto. Investigamos si la letra u está o no en el texto. Observe el uso de la claúsula `in` (en) para recorrer el texto. "
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# en este caso no está la letra u en el texto\n",
"texto = \"Esta frase no tiene cierta letra\"\n",
"\n",
"for letra in texto:\n",
" if letra == \"u\" or letra == \"U\":\n",
" print(\"Letra U encontrada\")\n",
" break\n",
"else:\n",
" print(\"Letra U no encontrada\")"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# en este caso si está la letra u en el texto\n",
"texto = \"la letra 'u' está en la frase\"\n",
"\n",
"for letra in texto:\n",
" if letra == \"u\":\n",
" print(\"Letra U encontrada\")\n",
" break\n",
"else:\n",
" print(\"Letra U no encontrada\")"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Cláusula `in` en un ciclo for"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Como se observa en el ejemplo previo, la cláusula `in` se ha usado para recorrer el texto completo. Esta cláusula es muy importante para recorrer estructuras de datos, que llamaremos iterables y que estudiaremos en otra lección. Básicamente si un objeto tiene varios elementos que pueden ser visitados individualmente (`objeto iterable`), la cláusula `in` se usa para recorrer el objeto, sin tener que indicar una posición específica en el objeto.\n",
" \n",
"En el ejemplo hemos recorrido *texto* que es una cadena (string). Toda cadena está conformada por caracteres, y es posible recorrer la cadena y usar cada caracter. No podemos modificar individualmente cada caracter. Veamos el siguiente ejemplo.\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Ejemplo de recorrer una cadena exhaustivamente "
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"En este ejemplo recorremos la cadena e imprimimos cada caracter de la cadena individualmente."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"texto = \"Esta es una cadena\"\n",
"\n",
"for char in texto:\n",
" print(char, end=' ')"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Ejemplo ciclo infinito"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"En este ejemplo empezamos imprimiendo números de forma secuencial. Observe que la condición evaluada por la estructura `while` es `True`, por lo que el ciclo no puede terminar sin interrumpirlo con la cláusula `break`."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"count = 0\n",
"fin = 3\n",
"while True:\n",
" print(count)\n",
" if count >= fin:\n",
" break\n",
" count += 1"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"La clausula `break` debe usarse responsablemente, y de hecho su uso no es necesariamente obligatorio, siempre hay alternativas como veremos a continuación. Pero noten que debemos introducir una variable adicional."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"count = 0\n",
"fin = 3\n",
"flag1 = True\n",
"while flag1:\n",
" print(count)\n",
" if count >= fin:\n",
" flag1 = False\n",
" count += 1"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Ejercicio\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"colab_type": "text",
"id": "NTTmenRR162S"
},
"source": [
"Escriba un código que le diga al computador que devuelva los textos \"*Estoy listo para codificar!*\" si su nombre tiene más de diez caracteres u \"*Hola mundo!*\" si pasa lo contrario. Para medir la longitud de su nombre utilice la función `len()`."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Manejo de excepciones. Estructura try - except "
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Como habrá observado hasta ahora, cuando se produce un error, Python termina la ejecución y hace una traza de la ejecución hasta que se produjo el error e indica el tipo de error. Ya hemos visto que sucede cuando por ejemplo llamamos una variable a la cual no se la ha asignado nada.\n",
"\n",
"Para cambiar este comportamiento, los errores pueden ser capturados con `excepciones` para ser procesados y evitar que el programa termine por causa del error. Siempre que se produce un error, Python genera una excepción (que puede imaginar como un mensaje) que el programador puede capturar.\n",
"\n",
"Lo que podemos hacer es \"intentar\" ejecutar algo, y si se tiene un problema de error ejecutamos otra sección de código. De esta forma no se detiene todo el código. Observemos el siguiente ejemplo."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# se genera error y termina la ejecución\n",
"print(no_variable)\n",
"print('Aqui sigue la ejecución...')"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# captura el error\n",
"try:\n",
" print(no_variable)\n",
"except:\n",
" print(\"variable no encontrada\")\n",
" \n",
"print('Aqui sigue la ejecución...')"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Si en el bloque `try` se genera un error, se ejecuta el bloque `except` en su lugar\n",
"\n",
"Podemos ser específicos con el tipo de errores que obtenemos y ejecutar cosas distintas respecto a esto."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"try:\n",
" print(no_variable+2)\n",
"except NameError:\n",
" print(\"Variable no definida\")\n",
"except:\n",
" print(\"Otro problema encontrado\")"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Podemos agregar otros tipos de bloques para manejar errores\n",
"- `else` correrá si no se encuentran errores\n",
"- `finally` corre al final del bloque, sin importar si se encontraron errores o no"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"try:\n",
" print(\"imprimiendo linea\")\n",
"except:\n",
" print(\"encontramos un problema\")\n",
"else:\n",
" print(\"no se encontraron problemas\")\n",
"finally:\n",
" print(\"código terminado, que tenga un buen día!\")"
]
}
],
"metadata": {
"celltoolbar": "Tags",
"kernelspec": {
"display_name": "Python 3 (ipykernel)",
"language": "python",
"name": "python3"
},
"language_info": {
"codemirror_mode": {
"name": "ipython",
"version": 3
},
"file_extension": ".py",
"mimetype": "text/x-python",
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
"version": "3.11.3"
},
"vscode": {
"interpreter": {
"hash": "cf92aa13fedf815d5c8dd192b8d835913fde3e8bc926b2a0ad6cc74ef2ba3ca2"
}
}
},
"nbformat": 4,
"nbformat_minor": 4
}
![](\"../Imagenes/logo-final-ap.png\"){kind=logo}
\n",
"![](\"https://raw.githubusercontent.com/AprendizajeProfundo/Alejandria/main/Archivos_Generales/Imagenes/Carretera.jpg\")
\n",
"