![\"Licencia](\"https://i.creativecommons.org/l/by-sa/4.0/88x31.png\")
Esta obra está bajo una licencia de Creative Commons Reconocimiento-CompartirIgual 4.0 Internacional
Autor: Pablo Cerrillo Ruiz.
Última modificación: 26 de junio de 2019.
Jupyter Notebook es un entorno de trabajo interactivo que permite desarrollar código de manera dinámica. Ahora mismo nos encontramos en el cuaderno UD Estructuras de repetición, cuya finalidad es enseñar al alumno las diferentes estructuras de repetición en Python y la utilidad que éstas tienen en el mundo de la programación.
" }, { "metadata": {}, "cell_type": "markdown", "source": "Recuerde que para ejecutar el contenido de una celda basta con pulsar el botón Run del panel de control. También puede pulsar al mismo tiempo las teclas Mayúsculas+Enter
" }, { "metadata": {}, "cell_type": "markdown", "source": "![](\"./images/menu_superior_jupyter_notebook.png\")
"
},
{
"metadata": {},
"cell_type": "markdown",
"source": "\nVamos a comenzar esta sección realizan un pequeño ejercicio. Vamos a escribir un programa que muestre por pantalla por pantalla la palabra \"Hello World!\" cinco veces.
" }, { "metadata": { "trusted": true }, "cell_type": "code", "source": "# Ejecuta el siguiente código, para ello pulsa el botón Run del panel superior\n\nprint('Hello World!')\nprint('Hello World!')\nprint('Hello World!')\nprint('Hello World!')\nprint('Hello World!')\n", "execution_count": null, "outputs": [] }, { "metadata": {}, "cell_type": "markdown", "source": "Tarea sencilla ¿verdad?. Ahora vamos a realizar el mismo ejercicio pero imprimiendo la palabra \"Hello World!\" 10 veces.
" }, { "metadata": { "trusted": true }, "cell_type": "code", "source": "# Ejecuta el siguiente código, para ello pulsa el botón del panel superior Run\n\nprint('Hello World!')\nprint('Hello World!')\nprint('Hello World!')\nprint('Hello World!')\nprint('Hello World!')\nprint('Hello World!')\nprint('Hello World!')\nprint('Hello World!')\nprint('Hello World!')\nprint('Hello World!')", "execution_count": null, "outputs": [] }, { "metadata": {}, "cell_type": "markdown", "source": "Esto no supone un gran reto pero puede volverse bastante tedioso. \n¿Eres capaz de imaginar como resolver este problema pero imprimiendo la palabra \"Hello World!\" 100 veces? \nEvidentemente una de las opciones sería copiar y pegar la sentencia print('Hello World!') 100 veces, pero no es un trabajo nada práctico. Para resolver ésto, se utilizan lo que se denominan estructuras de repetición.
" }, { "metadata": {}, "cell_type": "markdown", "source": "Las estructuras de repetición, comúnmente conocidas como bucles, son un recurso que permiten al programador indicar que sentencias se van a repetir mientras se cumple una determinada condición. En Python encontramos dos sentencias para implementar estructuras de repetición: for y while.
" }, { "metadata": {}, "cell_type": "markdown", "source": "![](\"./images/ud_estructuras_repeticion/icono_bucles.png\")
"
},
{
"metadata": {},
"cell_type": "markdown",
"source": "\nLa sentencia for permite la ejecución de un código mientras la condición que evalúa sea verdadera. Generalmente, usamos esta sentencia para realizar bucles en la que la condición se ejecutará un número determinado de veces. A continuación mostraremos una imagen que representa el flujo de un programa que utiliza un bucle for.
![](\"./images/ud_estructuras_repeticion/diagrama_flujo_bucle_for.png\")
"
},
{
"metadata": {},
"cell_type": "markdown",
"source": "Como podemos observar en la imagen anterior, una vez que la condición sea evaluada como falsa, el bloque de código del bucle no se ejecutará. Esto implica que puede que un bucle no se ejecuté nunca si su condición desde el primer momento es evaluada como falsa. A continuación especificaremos la sintaxis en Python para la sentencia for:
" }, { "metadata": {}, "cell_type": "markdown", "source": "![](\"./images/ud_estructuras_repeticion/sintaxis_bucle_for.png\")
"
},
{
"metadata": {},
"cell_type": "markdown",
"source": "Donde:
\nEjemplo 1: Vamos a resolver el problema inicial, imprimiremos 10 veces la cadena de texto \"Hello World!\" con el uso de la sentencia iterativa for.
" }, { "metadata": { "trusted": true }, "cell_type": "code", "source": "# Mediante la función range, definimos una lista de números inmutables.\nfor x in range(10): # x es el elemento que irá actualizándose hasta recorrer la lista inmutable proporcionada por range\n print('Hello World!')", "execution_count": null, "outputs": [] }, { "metadata": {}, "cell_type": "markdown", "source": "Como podemos observar, hemos resuelto un problema que nos ocupaba mas 10 líneas de código en 2. De esta forma, el programador puede ahorrar muchas líneas de código. Imagina lo sencillo que sería imprimir ahora la cadena \"Hello World!\" 100 veces. Si observamos el elemento iterable utilizado en el ejemplo 1, hemos utilizado la función range, la cual nos devuelve una lista inmutable de números desde el 0 hasta n-1, incrementando el valor en 1.
" }, { "metadata": {}, "cell_type": "markdown", "source": "Ejemplo 2: Imprimir los número del 0 al 10.
" }, { "metadata": { "trusted": true }, "cell_type": "code", "source": "# Mediante la función range, definimos una lista de números inmutables.\nfor x in range(11): # x es el elemento que irá actualizándose hasta recorrer la lista inmutable proporcionada por range\n print(x)", "execution_count": null, "outputs": [] }, { "metadata": {}, "cell_type": "markdown", "source": "Como podemos observar en el ejemplo anterior, la variable x ha ido tomando los diferentes valores de cada uno de los elementos de la lista. El bucle for acaba cuando la variable x toma el último valor de la lista.
" }, { "metadata": {}, "cell_type": "markdown", "source": "Ésta no es la única forma de llamar a la función range. La función range admite tambien llamadas con dos y tres argumentos
\nEjemplo 3: Diferentes usos de la función range.
" }, { "metadata": { "trusted": true }, "cell_type": "code", "source": "''' En este primer trozo de código, vamos a devolver los números del 1 al 7 incluido '''\nfor x in range(1,8): # x es el elemento que irá actualizándose hasta recorrer la lista inmutable proporcionada por range\n print(x)\n\nprint(\"\\n\")\n\n'''En este segundo trozo de código vamos a imprimir los números impares del 1 al 10 incluido'''\nfor x in range(1,11,2): # x es el elemento que irá actualizándose hasta recorrer la lista inmutable proporcionada por range\n print(x)", "execution_count": null, "outputs": [] }, { "metadata": {}, "cell_type": "markdown", "source": "Vamos a realizar un pequeño ejercicio, de manera que se imprimirán tu nombre y apellidos junto con el valor de los números pares del 0 al 10 incluido. Para ello completa el código con las instrucciones que te se proporcionan.
" }, { "metadata": { "trusted": true }, "cell_type": "code", "source": "''' Completa el código y pulsa sobre el botón run una vez hayas terminado. Observa la salida. '''\n\nnombre = '' # inserta tu nombre entre las comillas.\napellidos = '' # inserta tus apellidos entre las comillas.\n\nfor x in range(): # indica los argumentos de la función range para que aparezcan los número pares\n print(x, nombre, apellidos) # imprimimos el valor de la variable junto con el nombre y apellidos.", "execution_count": null, "outputs": [] }, { "metadata": {}, "cell_type": "markdown", "source": "Otra vez hemos vuelto a utilizar la función range, debido a que permite crear facilmente un elemento iterable, pero no es la única opción disponible. Podemos encontrarnos elementos iterables de diferentes tipos de datos. A continuación enumeraremos los diferentes elementos iterables y mostraremos acerca de como se recorre cada uno de ellos.
" }, { "metadata": {}, "cell_type": "markdown", "source": "\nA continuación vamos a recorrer los diferentes elementos iterables para ver las diferencias entre ambos. Entre los elementos iterables más comunes encontramos: listas, tuplas, conjuntos, diccionarios y cadenas de texto.
" }, { "metadata": {}, "cell_type": "markdown", "source": "![](\"./images/ud_estructuras_repeticion/elemento_iterable.png\")
"
},
{
"metadata": {},
"cell_type": "markdown",
"source": "\nVamos a realizar un ejemplo en el que se definen dos listas y, mediante un bucle for, se recorre cada una de los elementos.
" }, { "metadata": {}, "cell_type": "markdown", "source": "Ejemplo 4: Recorriendo listas con la sentencia de repetición for.
" }, { "metadata": { "trusted": true }, "cell_type": "code", "source": "''' En este ejemplo vamos a definir listas para ver como se recorren mediante un bucle for'''\n\nfrutas = [\"manzana\", \"melón\", \"plátano\", \"fresas\"] # lista con elementos de un mismo tipo de dato\npichichi = [\"CR7\", 15, \"Messi\", 15, \"Luis Suárez\", 13] # lista con elementos de diferentes tipos de dato\n\nfor fruta in frutas: # Declaramos sentencia for, fruta será el elemento que obtenga el valor en cada iteración de un elemento de la lista\n print(fruta)\n\nprint(\"\\n\") # Imprimimos un salto de línea para visualizar de mejor forma la salida de ambos bucles\n\nfor x in pichichi: # Declaramos sentencia for, x será el elemento que obtenga el valor en cada iteración de un elemento de la lista\n print(x)\n", "execution_count": null, "outputs": [] }, { "metadata": {}, "cell_type": "markdown", "source": "Como podemos observar, cuando recorremos los elementos de una lista mediante un bucle for, los elementos se recorren en el orden en el que aparecen dentro de la lista. Respecto al cuerpo del bucle, puede contener un número indeterminado de líneas de código.
" }, { "metadata": {}, "cell_type": "markdown", "source": "Define una lista con los nombres de tus mejores amigos/as e imprime el nombre de cada uno de ellos utilizando la sentencia de repetición for.
" }, { "metadata": { "trusted": true }, "cell_type": "code", "source": "''' Escribe aquí el código del ejercicio '''\n\n# Define una lista\n\n\n# Define el bucle para recorrer cada elemento de la lista e imprímelo por pantalla\n\n", "execution_count": null, "outputs": [] }, { "metadata": {}, "cell_type": "markdown", "source": "\nVamos a realizar un ejemplo en el que se definen dos tuplas y, mediante un bucle for, se recorre cada una de los elementos. Recuerde que para crear tuplas, utilizamos los paréntesis.
" }, { "metadata": {}, "cell_type": "markdown", "source": "Ejemplo 4: Recorriendo listas con la sentencia de repetición for.
" }, { "metadata": { "trusted": true }, "cell_type": "code", "source": "''' En este ejemplo vamos a definir una tupla para ver como se recorren mediante un bucle for '''\n\nfrutas = (\"manzana\", \"melón\", \"plátano\", \"fresas\") # tupla con elementos de un mismo tipo de dato\npichichi = (\"CR7\", 15, \"Messi\", 15, \"Luis Suárez\", 13) # tupla con elementos de diferentes tipos de dato\n\nfor fruta in frutas: # Declaramos sentencia for, fruta será el elemento que obtenga el valor en cada iteración de un elemento de la lista\n print(fruta)\n\nprint(\"\\n\") # Imprimimos un salto de línea para visualizar de mejor forma la salida de ambos bucles\n\nfor x in pichichi: # Declaramos sentencia for, x será el elemento que obtenga el valor en cada iteración de un elemento de la lista\n print(x)", "execution_count": null, "outputs": [] }, { "metadata": {}, "cell_type": "markdown", "source": "Al igual que las listas, cuando recorremos los elementos de una lista mediante un bucle for, los elementos se recorren en el orden en el que aparecen dentro de la lista.
" }, { "metadata": {}, "cell_type": "markdown", "source": "Define una tupla que contenga el día de la semana y a continuación la temperatura de ese día. Después imprime cada uno de ellos utilizando la sentencia de repetición for.
" }, { "metadata": { "trusted": true }, "cell_type": "code", "source": "''' Escribe aquí el código del ejercicio '''\n\n# Define una tupla\n\n\n# Define el bucle para recorrer cada elemento de la tupla e imprímelo por pantalla\n\n", "execution_count": null, "outputs": [] }, { "metadata": {}, "cell_type": "markdown", "source": "\nEn esta ocasión vamos a trabajar con conjuntos. Como recordatorio, decir que podemos crear conjuntos de elementos de diversos tipos de datos insertándolos entre las llaves {}.
" }, { "metadata": { "trusted": true }, "cell_type": "code", "source": "''' En este ejemplo vamos a definir dos conjuntos para ver como se recorren mediante un bucle for '''\n\nasignaturas = {\"Matemáticas\", \"Lengua\", \"Historia\", \"Informática\", \"Gimnasia\", \"Filosofía\"} # conjunto con elementos de un mismo tipo de dato\ncajon = (\"cargador\", 5, True, 7.9, 8 , \"hello world!\") # conjunto con elementos de diferentes tipos de dato\n\nfor asig in asignaturas: # Declaramos sentencia for, asig será el elemento que obtenga el valor en cada iteración de un elemento del conjunto\n print(asig)\n\nprint(\"\\n\") # Imprimimos un salto de línea para visualizar de mejor forma la salida de ambos bucles\n\nfor cosa in cajon: # Declaramos sentencia for, cosa será el elemento que obtenga el valor en cada iteración de un elemento del conjunto\n print(cosa)", "execution_count": null, "outputs": [] }, { "metadata": {}, "cell_type": "markdown", "source": "Como podemos observar, no hay ningún orden en los conjuntos.
" }, { "metadata": {}, "cell_type": "markdown", "source": "Define un conjunto que contenga el nombre de las diferentes redes sociales que conozcas. Después imprime cada uno de ellos utilizando la sentencia de repetición for.
" }, { "metadata": { "trusted": true }, "cell_type": "code", "source": "''' Escribe aquí el código del ejercicio '''\n\n# Define un conjunto\n\n\n# Define el bucle para recorrer cada elemento del conjunto e imprímelo por pantalla\n\n", "execution_count": null, "outputs": [] }, { "metadata": {}, "cell_type": "markdown", "source": "\nUna de las estrucutras de datos más utilizadas son los diccionarios .Vamos a realizar un ejemplo en el que se define un diccionario y se va a utilizar como elemento iterable.
" }, { "metadata": { "trusted": true }, "cell_type": "code", "source": "''' En este ejemplo vamos a definir un diccionario para ver como se recorren mediante un bucle for '''\n\n# Vamos a definir los números de los coches de F1 junto sus pilotos\npiloto = { '14': 'Fernando Alonso', '5': 'Sebastian Vettel', '44': 'Lewis Hamilton', '55': 'Carlos Sainz Jr.' } # diccionario que contine clave valor\n\nfor x in piloto: # Declaramos sentencia for, x será el elemento que obtenga el valor de la clave del diccionario\n print(x)", "execution_count": null, "outputs": [] }, { "metadata": {}, "cell_type": "markdown", "source": "Como vemos en el ejemplo anterior, unicamente se imprimen las claves del diccionario, además sin un orden aparente. Si queremos imprimir tambíen el valor, entonces deberíamos acceder mediante los corchetes y la clave.
" }, { "metadata": { "trusted": true }, "cell_type": "code", "source": "''' En este ejemplo vamos a definir un diccionario para ver como se recorren mediante un bucle for '''\n\n# Vamos a definir los números de los coches de F1 junto sus pilotos\npiloto = { '14': 'Fernando Alonso', '5': 'Sebastian Vettel', '44': 'Lewis Hamilton', '55': 'Carlos Sainz Jr.' } # diccionario que contine clave valor\n\nfor x in piloto: # Declaramos sentencia for, x será el elemento que obtenga el valor de la clave del diccionario\n print(x, piloto[x]) # con la sentencia piloto[x] podemos imprimir el valor. ", "execution_count": null, "outputs": [] }, { "metadata": {}, "cell_type": "markdown", "source": "Ahora obtenemos las claves junto con los valores del diccionario. Aunque pueda parecer que están ordenados no lo están. Python devuelve los valores de los diccionarios en orden aleatorio.
" }, { "metadata": {}, "cell_type": "markdown", "source": "Define un diccionario cuya clave sea el codigo de barras de un producto y como valor el nombre del producto. Después imprime los valores del diccionario utilizando un bucle for.
" }, { "metadata": { "trusted": true }, "cell_type": "code", "source": "''' Escribe aquí el código del ejercicio '''\n\n# Define un diccionario\n\n\n# Define el bucle para recorrer cada elemento del diccionario e imprímelo por pantalla\n\n\n", "execution_count": null, "outputs": [] }, { "metadata": {}, "cell_type": "markdown", "source": "\nUna cadena de texto es tambien un elemento iterable. Vamos a realizar un ejemplo en el que se define una cadena de texto y se va a utilizar como elemento iterable.
" }, { "metadata": {}, "cell_type": "markdown", "source": "Ejemplo : Recorriendo una cadena de caracteres con un bucle for
" }, { "metadata": { "trusted": true }, "cell_type": "code", "source": "''' En este ejemplo vamos a definir una cadena de texto y la recorreremos con un bucle for '''\n\ncadena = 'Ka-me-ha-me-haaaaaaaa!!!!' # cadena de texto\n\nfor x in cadena: # Declaramos sentencia for, x será el elemento que obtenga el valor en cada iteración de un elemento de la cadena\n print(x)", "execution_count": null, "outputs": [] }, { "metadata": {}, "cell_type": "markdown", "source": "Cuando utilizamos una cadena de texto como un elemento iterable, Python la descomponen en cada uno de los caracteres que forman la cadena. Des este modo, la variable del bucle for va tomando el valor de cada uno de los carácteres en el orden que aparece.
" }, { "metadata": {}, "cell_type": "markdown", "source": "Define una cadena de texto con una frase o palabra que conozcas. A continuación, imprimela utilizando el bucle for.
" }, { "metadata": { "trusted": true }, "cell_type": "code", "source": "''' Escribe aquí el código del ejercicio '''\n\n# Define una cadena de texto\n\n\n# Define el bucle para recorrer cada uno de los caracteres de la cadena de texto\n\n", "execution_count": null, "outputs": [] }, { "metadata": {}, "cell_type": "markdown", "source": "\n![](\"./images/ud_estructuras_repeticion/cuerpo_bucle.png\")
"
},
{
"metadata": {},
"cell_type": "markdown",
"source": "Hasta ahora, únicamente hemos estado hablando de los elementos iterables más comunes y como recorrerlos, pero ¿Qué ocurre con el cuerpo del bucle? El cuerpo del bucle admite diferente posibilidades, no únicamente la sentencia print. Veamos un par de ejemplos.
" }, { "metadata": {}, "cell_type": "markdown", "source": "Ejemplo: Sumar los elementos de una lista.
" }, { "metadata": { "trusted": true }, "cell_type": "code", "source": "# Declaramos una lista con números\nmi_lista = [5,2,6,1,3]\n\n# Declaramos una variable suma que almacenara el resultado de sumar \nsuma = 0\n\n# Declaramos el bucle for\nfor x in mi_lista: \n suma = suma + x\n\nprint(\"La suma de los números de la lista es: \",suma)", "execution_count": null, "outputs": [] }, { "metadata": {}, "cell_type": "markdown", "source": "Como podemos observar, hemos realizado operaciones dentro de un bucle. Ahora vamos a ver un ejemplo donde insertaremos dentro del bucle sentencias de decisión.
" }, { "metadata": {}, "cell_type": "markdown", "source": "Ejemplo: Bucle for que recorre los elementos de una lista de palabras e imprime aquellas que empiezan por la letra 'm', En otro caso imprimiremos por pantalla el nombre de la fruta junto con la cadena de texto \"no empieza por la letra m\"
" }, { "metadata": { "trusted": true }, "cell_type": "code", "source": "# Declaramos un array con diferentes frutas\nfruits = [\"manzana\", \"melón\", \"plátano\", \"sandía\", \"melocotón\", \"uvas\", \"mango\", \"fresas\", \"pera\"]\n\n# Declaramos el bucle for\nfor x in fruits:\n if x[0] == 'm' or x[0] == 'M': # Si la primera letra de la palabra almacenada en la variable x es m o M\n print(x)\n else:\n print(x + \" no empieza por la letra m\") \n", "execution_count": null, "outputs": [] }, { "metadata": {}, "cell_type": "markdown", "source": "Completa el siguiente código para indicar que números son pares e impares del 0 al 50. Pista: un número es impar si es resto de la división entre 2 es distinto de cero, en otro caso es par.
" }, { "metadata": { "trusted": true }, "cell_type": "code", "source": "# Declaramos el bucle for\nfor in range(): # Completa la sentencia for y los parámetros de la funcion range para obtener los números del 0 al 50 inclusive\n if : # Completa la sentencia de decisión que permitirá saber si un número es impar.\n print(, \" es un número impar\") \n else:\n print(, \" es un número par\") ", "execution_count": null, "outputs": [] }, { "metadata": {}, "cell_type": "markdown", "source": "Calcula la suma y la media de los elementos de la siguiente lista [1, 3, 9, 10, 12, 17, 7, 13, 5]. Pista: La función len devuelve el número de elementos de una lista.
" }, { "metadata": { "trusted": true }, "cell_type": "code", "source": "''' Escribe aquí el código del ejercicio '''\n\n\n\n", "execution_count": null, "outputs": [] }, { "metadata": {}, "cell_type": "markdown", "source": "\nComo hemos visto anteriormente, dentro de un bucle hemos insertado operadores y sentencias de decisión, pero ¿Se puede insertar un bucle dentro de otro bucle? La respuesta es sí, veamos como funciona.
" }, { "metadata": { "trusted": true }, "cell_type": "code", "source": "for x in range(2):\n print(\"Hola\")\n for y in range(4):\n print(\" Mundo!!\")\n", "execution_count": null, "outputs": [] }, { "metadata": { "trusted": true }, "cell_type": "markdown", "source": "Si observamos con detenimiento, la cadena \"Mundo!!\" se ha ejecutado un total de 8 veces. Esto se debe a que al ser un bucle interno, se repetirá tantas veces la ejecución como indique el bucle externo. En el siguiente ejemplo vamos a imprimir la tabla de multiplicar de los números 2 y 3
" }, { "metadata": {}, "cell_type": "markdown", "source": "Ejemplo 6: Imprimir la tabla de multiplicar del número 2 y 3.
" }, { "metadata": { "trusted": true }, "cell_type": "code", "source": "for x in range(2,4):\n print(\"La tabla de multiplicar del número\", x, \"\\n\")\n for y in range(11):\n print(x, \"x\", y, \"=\", x*y)\n print(\"\")", "execution_count": null, "outputs": [] }, { "metadata": {}, "cell_type": "markdown", "source": "Como podemos observar, para cada número del bucle externo, se ha ido ejecutando al completo el bucle interno. Es por ello que se han imprimido los números del 1 al 10 en las dos ocasiones.
" }, { "metadata": {}, "cell_type": "markdown", "source": "La sentencia While permite la ejecución de un código mientras la condición se evalúe como verdadera. A diferencia del bucle for, nosotros somos los encargados de actualizar la variable o el conjunto de variables utilizadas en la sentencia de decisión. A continuación mostraremos una imagen que representa el flujo de un programa que utiliza un bucle while:
" }, { "metadata": {}, "cell_type": "markdown", "source": "![](\"./images/ud_estructuras_repeticion/diagrama_flujo_bucle_while.png\")
"
},
{
"metadata": {},
"cell_type": "markdown",
"source": "Cabe destacar, que si la condición de inicio se evaluase como falsa, el programa no entraría en el bloque de código del bucle. De este modo, no se ejecutaría ninguna instrucción del bucle y la ejecución del programa continuaría por la instrucción que viene justo después del bucle. A continuación especificaremos la sintaxis en Python para la sentencia while:
" }, { "metadata": {}, "cell_type": "markdown", "source": "![](\"./images/ud_estructuras_repeticion/sintaxis_bucle_while.png\")
"
},
{
"metadata": {},
"cell_type": "markdown",
"source": "Donde:
\nEjemplo 1: Vamos a resolver el problema inicial, imprimiremos 10 veces la cadena de texto \"Hello World!\" usando la sentencia iterativa while.
" }, { "metadata": { "trusted": true }, "cell_type": "code", "source": "# Definimos una variable que nos sirva de contador\nx = 0\nwhile x < 10:\n print('Hello World!') # Imprimimos la cadena Hello World!\n x += 1 # Incrementamos la variable", "execution_count": null, "outputs": [] }, { "metadata": {}, "cell_type": "markdown", "source": "Como podemos observar en el ejemplo anterior, se ejecuta el código hasta que la condición se evalúe como falsa. Vamos a imprimir el valor de la variable x y a mostrar la salida de evaluar la condicion x < 10.
" }, { "metadata": { "trusted": true }, "cell_type": "code", "source": "print(x)\nprint(x < 10)", "execution_count": null, "outputs": [] }, { "metadata": { "trusted": true }, "cell_type": "code", "source": "x = 0\nwhile( x < 10):\n print(x)\n x += 1", "execution_count": null, "outputs": [] }, { "metadata": {}, "cell_type": "markdown", "source": "Tenemos que prestar atención a la condición del bucle, asi como la actualización de las diferentes variables que permiten la detención del bucle en el momento que estimemos oportuno. Si no prestamos atención, podríamos hacer un bucle infinito. En el siguiente ejemplo vamos a utilizar la sentencia break, la cuál permite parar detener la ejecución de un bucle o sentencia de decisión.
" }, { "metadata": {}, "cell_type": "markdown", "source": "Ejemplo: Sentencia while que ejecuta un bucle infinito.Para detener su ejecución, utilizaremos la sentencia break.
" }, { "metadata": { "trusted": true }, "cell_type": "code", "source": "# Definimos una variable que nos sirva de contador\nx = 0\nwhile x >= 0: # Entra en el bucle, ya que cumple la condición en la primera iteración\n print(x, \" \" ,end=\"\")# Imprimimos el valor de la variable sin hacer salto de línea\n x += 1 # actualizamos la variable erróneamente\n if x > 400:\n break", "execution_count": null, "outputs": [] }, { "metadata": {}, "cell_type": "markdown", "source": "Como hemos podido observar, la ejecución del programa se ha detenido gracias a la sentencia break. El bucle no se ha parado por su condición porque se ha producido un bucle infinito, ya que la variable x nunca será menor que cero, simplemente por el hecho de que estamos actualizando la variable erróneamente y siempre estamos incrementando el valor de la variable, en vez de decrementarlo.
" }, { "metadata": {}, "cell_type": "markdown", "source": "Otra de las cosas en las que tenemos que fijarnos a la hora de utilizar bucles son las condiciones de ejecución y el valor antes de entrar por primera vez al bucle. Como se mencionó anteriormente, si la condición de entrada se evalúa como falsa antes de entrar al bucle, no se ejecutará ninguna instrucción ubicada dentro del bucle.
" }, { "metadata": {}, "cell_type": "markdown", "source": "Ejemplo: Sentencia while que no se ejecuta debido a que no cumple la condición.
" }, { "metadata": { "trusted": true }, "cell_type": "code", "source": "# Definimos una variable que nos sirva de contador\nx = 0\nwhile x > 10:\n print('Hello World!') # Imprimimos la cadena Hello World!\n\nprint('No se ejecuta ninguna instrucción del bucle')", "execution_count": null, "outputs": [] }, { "metadata": {}, "cell_type": "markdown", "source": "Esto mismo ocurre con los bucles for, si el elemento iterable no contiene nada, nunca se ejecutará el bloque de código dentro del bucle.
" }, { "metadata": { "trusted": true }, "cell_type": "code", "source": "# Definimos una lista vacía\n\nnumeros = []\n\nfor x in numeros:\n if x > 10 or x < 0:\n print(x, ' es una calificación incorrecta')\n else:\n print(x, 'es una calificación correcta')\n\nprint('No se ejecuta ninguna instrucción del bucle')", "execution_count": null, "outputs": [] }, { "metadata": {}, "cell_type": "markdown", "source": "\n![](\"./images/resumen.jpg\")
"
},
{
"metadata": {},
"cell_type": "markdown",
"source": "Una vez terminado el cuaderno, vamos a realizar un pequeño resumen acerca de lo visto hasta ahora:
\n![](\"./images/ejercicios.png\")
"
},
{
"metadata": {},
"cell_type": "markdown",
"source": "A continuación se presentan una relación de ejercicios para que el alumno/a pueda prácticar los conceptos vistos en este cuaderno."
},
{
"metadata": {},
"cell_type": "markdown",
"source": "EJERCICIO 1: ¿Sabrías decir cuál es la salida del siguiente código sin ejecutarlo?.
" }, { "metadata": { "scrolled": true, "trusted": true }, "cell_type": "code", "source": "## Elimina las comillas para ejercutar el código y comprobar el resultado de salida.\n'''\ncalificaciones = [3,7,4,9,5,6,0]\n\nfor x in calificaciones:\n if x < 5:\n print(\"Has sacado un suspenso\",x)\n elif x >= 5 and x < 6:\n print(\"Has sacado un aprobado\",x)\n elif x >= 6 and x < 7:\n print(\"Has sacado un bien\",x)\n elif x >= 7 and x < 9:\n print(\"Has sacado un notable\",x)\n else:\n print(\"Has sacado un sobresaliente\",x)\n''' ", "execution_count": null, "outputs": [] }, { "metadata": {}, "cell_type": "markdown", "source": "EJERCICIO 2: ¿Sabrías decir cuál es la salida del siguiente código sin ejecutarlo?.
" }, { "metadata": { "trusted": true }, "cell_type": "code", "source": "## Elimina las comillas para ejercutar el código y comprobar el resultado de salida.\n'''\n\ni = 0 \n\nwhile i < 50:\n if i > 20 and i % 5 == 0:\n print(i)\n i = i + 1\n \n'''", "execution_count": null, "outputs": [] }, { "metadata": {}, "cell_type": "markdown", "source": "EJERCICIO 3: ¿Sabrías decir cuál es la salida del siguiente código sin ejecutarlo?.
" }, { "metadata": { "trusted": true }, "cell_type": "code", "source": "## Elimina las comillas para ejercutar el código y comprobar el resultado de salida.\n'''\n\na = 2\nb = 3\n\nfor x in range(1,10):\n if a < b:\n a += 1\n else:\n b += 1\n\nprint(\"El valor de a es: \", a)\nprint(\"El valor de b es: \", b)\n\n'''", "execution_count": null, "outputs": [] }, { "metadata": {}, "cell_type": "markdown", "source": "EJERCICIO 4: ¿Sabrías decir cuál es la salida del siguiente código sin ejecutarlo?.
" }, { "metadata": { "trusted": true }, "cell_type": "code", "source": "## Elimina las comillas para ejercutar el código y comprobar el resultado de salida.\n'''\n\na = 1\nb = 1\ncontador = 0\n\nwhile contador < 11:\n if a > b:\n b = b * 2\n elif b > a:\n a = a + 2\n else:\n a += 1\n \n contador = contador + 1\n \nprint(\"El valor de a es: \", a)\nprint(\"El valor de b es: \", b)\n\n'''", "execution_count": null, "outputs": [] }, { "metadata": {}, "cell_type": "markdown", "source": "EJERCICIO 5: El siguiente código muestra las tablas de multiplicar de los números 2 y 3. Realiza las modificaciones necesarias para que imprima las tablas de multiplicar de los números pares del 2 al 10 inclusive.
" }, { "metadata": { "trusted": true }, "cell_type": "code", "source": "'''\nfor x in range(2,4):\n print(\"La tabla de multiplicar del número\", x, \"\\n\")\n for y in range(11):\n print(x, \"x\", y, \"=\", x*y)\n print(\"\")\n \n'''\n\n### COPIA Y PEGA EL CÓDIGO ANTERIOR PARA MODIFICARLO\n\n\n\n", "execution_count": null, "outputs": [] }, { "metadata": {}, "cell_type": "markdown", "source": "EJERCICIO 6: Escribe un bucle for que imprima todos aquellos número del 0 al 40 inclusive que sean múltiplos de 3 o de 4. Además, junto al número deberá indicarse si es múltiplo de 3, múltiplo de 4 o múltiplo de ambos.
" }, { "metadata": { "trusted": true }, "cell_type": "code", "source": "", "execution_count": null, "outputs": [] } ], "metadata": { "kernelspec": { "name": "python3", "display_name": "Python 3", "language": "python" }, "language_info": { "mimetype": "text/x-python", "nbconvert_exporter": "python", "name": "python", "pygments_lexer": "ipython3", "version": "3.5.4", "file_extension": ".py", "codemirror_mode": { "version": 3, "name": "ipython" } } }, "nbformat": 4, "nbformat_minor": 2 }