Saltar navegación

20251024 Bucles_1 - Contenido educativo

Ajuste de pantalla

El ajuste de pantalla se aprecia al ver el vídeo en pantalla completa. Elige la presentación que más te guste:

Subido el 26 de octubre de 2025 por Raquel G.

7 visualizaciones

Más información Transcripción

Descargar la transcripción

así que no pasa nada 00:00:00
vale, lo que sí que 00:00:02
no se nos ha olvidado ninguno 00:00:05
es que seguimos con programación 00:00:06
estructurada, aquí todavía no tenemos 00:00:09
ni clases, ni objetos 00:00:10
con lo cual todo ese maravilloso 00:00:12
mundo de posibilidades 00:00:15
que nos habla programación estructurada de objetos 00:00:16
todavía no lo tenemos, pero 00:00:18
poquito a poco, en breve lo tendremos 00:00:20
¿vale? en cuanto acabemos esto de los bucles 00:00:22
lo tendremos 00:00:24
todavía estamos, por tanto, con programación estructurada 00:00:25
Y la programación estructurada ya sabemos que está basada en construir programas que sean una secuencia de sentencias, finita por supuesto, una tras otra, y esas sentencias son exclusivamente asignaciones a variables para incorporar datos, operaciones por supuesto también, 00:00:30
es decir, asignaciones a variables en general 00:00:56
me da igual que venga 00:00:58
que yo los leo del teclado o que yo hago una operación 00:00:59
asignaciones a variables 00:01:02
decisiones para permitir 00:01:03
que mi programa haga una cosa 00:01:06
u otra en función de condiciones 00:01:08
sobre los datos de entrada 00:01:10
normalmente 00:01:12
y nos falta una última sentencia 00:01:12
y ya está, ya no hay más en la aprobación estructurada 00:01:16
que es la sentencia 00:01:18
iterativa 00:01:20
la otra 00:01:21
era la sentencia de decisión 00:01:24
Y la sentencia iterativa que nos permite 00:01:26
Nos permite un bloque de código 00:01:31
Un bloque de código 00:01:35
Hacerlo varias veces 00:01:39
Ejecutar varias veces el mismo bloque de código 00:01:42
Esto hasta ahora no lo podíamos hacer, era imposible 00:01:47
Cada bloque de código, cada sentencia 00:01:51
se ejecutaba solo una vez 00:01:55
o ninguna 00:01:57
ninguna si estaba en una rama de una decisión 00:01:58
que no se cumplía 00:02:01
pero el mayor número de veces que se podría 00:02:02
ejecutar un bloque de código 00:02:05
con lo que nosotros sabemos hasta ahora es una vez 00:02:07
si cae dentro de la rama 00:02:09
cuya condición se hace cierta 00:02:11
si no, cero veces 00:02:13
pero que un mismo bloque de código se ejecute 00:02:15
varias veces, no lo podíamos hacer 00:02:17
¿es interesante 00:02:19
poder hacerlo? 00:02:22
Pues por supuesto que es interesante 00:02:22
¿Vale? Porque hay muchísimos programas 00:02:25
Que no son planteables 00:02:28
Si no tenemos un bucle 00:02:30
Por ejemplo 00:02:32
Ejemplo típico 00:02:34
Nos plantean un programa 00:02:37
Que ya directamente me dicen 00:02:39
Solicita un número 00:02:41
Pero ahora ya sí que nos van a pedir 00:02:43
Que validemos 00:02:45
Si el número 00:02:46
Tiene que ser positivo 00:02:49
Si no es positivo, el programa lo vuelve a solicitar una y otra vez. Ejemplito, programa cualquiera que hemos hecho que incorpore ahora una validación de los datos. Una validación en el sentido de que si el usuario no ha introducido un dato válido, te lo está pidiendo una y otra vez. 00:02:51
¿Cómo podemos hacer eso sin bucles? 00:03:13
Es imposible, ¿no? 00:03:16
No podemos hacer una sentencia de if uno tras otro. 00:03:17
Introduzca dato. 00:03:19
Si dato no válido, anidamos. 00:03:21
Eso no tendría ningún sentido. 00:03:23
Es decir, le diríamos al tío, introduzca el dato. 00:03:26
Leemos el dato, bla, bla, bla. 00:03:32
Si el dato no es válido, lo que sea, 00:03:35
pues entonces 00:03:39
otra vez introduzca 00:03:42
dato, si el 00:03:44
dato no es válido 00:03:48
otra vez introduzca dato 00:03:50
esto cuando acaba, este programa 00:03:51
es implanteable, así es que no se puede resolver 00:03:53
se puede resolver 00:03:56
¿vale? no se trata de que 00:03:57
un bucle nos permita 00:04:00
repetir un código varias veces 00:04:01
pero si yo no tengo bucles 00:04:03
no pasa nada porque lo que hago es poner 00:04:06
eso varias veces y listo, no 00:04:07
es que de partida, ya por el planteamiento 00:04:09
de los programas, es que hay cosas 00:04:12
que no se pueden hacer si yo no lo hago con un bucle 00:04:14
por ejemplo, esta situación 00:04:16
sencilla, de solicitar 00:04:18
un dato de entrada 00:04:20
y mientras ese dato no sea 00:04:21
válido, pedirlo otra vez 00:04:24
pedirlo otra vez, entonces si yo me olvido 00:04:25
de los bucles, con lo que sabemos ahora 00:04:28
esto me 00:04:29
¿hasta dónde escribo if? 00:04:31
es imposible, escribiría if hasta el infinito 00:04:33
¿verdad? no puedo hacer un programa 00:04:36
con infinitos ir, pero tendrían 00:04:38
que tener infinito. 00:04:41
¿Vale? Entonces, lógicamente 00:04:43
hay muchas cosas que 00:04:44
no se pueden hacer con las sentencias de decisión 00:04:46
exclusivamente, con las sentencias 00:04:48
exclusivamente de decisión. Como este ejemplo 00:04:50
que hemos dicho, ¿verdad? 00:04:53
Es un ejemplito sin más, para motivarlo. 00:05:02
Vale, pues entonces, vamos a asumir 00:05:08
que ahora sí que tenemos un bucle. ¿Cómo podríamos hacer eso? 00:05:09
Pues una vez que yo he 00:05:12
identificado que mi 00:05:13
problema necesita resolverse 00:05:15
haciendo algo muchas veces, pues ya me he dado cuenta 00:05:17
de que es un núcleo lo que necesito. 00:05:21
Primero, como siempre decimos, uno se mira bien su enunciado, 00:05:24
entiende lo que hay que hacer, 00:05:28
si no, se vuelve a reunir con aquel que se lo planteó, 00:05:30
pero tiene que tener muy claro lo que tiene que hacer. 00:05:35
Una vez que lo tenemos claro, ya empezamos a hacer 00:05:37
un diseño mental en la cabeza. 00:05:40
Pues en este caso, solamente esta parte, 00:05:42
introducir un número, 00:05:45
por ejemplo, y mientras ese número no sea positivo, 00:05:47
volverlo a pedir una y otra vez. 00:05:52
Entonces, introduce número, es negativo, vuelve a introducir. 00:05:54
Introduce número, es negativo, vuelve a introducir. 00:05:59
Introduce número, es negativo, vuelve a introducir. 00:06:01
Ese es el problema que nos han planteado. 00:06:04
Entonces, una vez que ya hemos entendido lo que hay que hacer, 00:06:06
ya vamos a este primer diseño mental. 00:06:09
Dicimos, bueno, esto es hacer algo un montón de veces. 00:06:11
Es hacer algo muchas veces. 00:06:16
¿Cuántas? No lo sé, ese es un segundo problema que ya resolveré, pero por lo menos ya me he dado cuenta de la primera parte importante, que es que este programa consiste en hacer algo muchas veces. 00:06:17
¿Cuántas? Repito, eso ya es una segunda pregunta, pero la primera es que me identifica que mi programa va a necesitar un bucle, porque voy a hacer algo muchas veces. 00:06:29
Bueno, pues aquí hay algo que voy a hacer un montón de veces 00:06:42
En este caso, ¿qué voy a hacer un montón de veces? 00:06:45
Pedir el número, ¿vale? 00:06:50
Con el mensajito 00:06:52
Y leerlo 00:06:53
Leer el número 00:06:54
Esto lo voy a hacer un montón de veces 00:06:56
Leer el número, leer el número, leer el número 00:06:58
Un montón de veces, ¿vale? 00:07:01
Luego esto se va a convertir en un programa 00:07:02
Que va a estar todo el rato haciendo esto 00:07:05
Esto por aquí 00:07:07
Y otra vez, y otra vez, y otra vez 00:07:09
Esto es un bucle, un trozo de código que yo he identificado que se va a hacer muchas veces y otra y otra y otra, muchas veces. Vale, gracias a que tenemos los bucles, por tanto, no tendré que escribir esto dentro de mis ifelse y ifelse porque no tenía sentido. 00:07:12
Luego, mi programa, mi primera arquitectura mental de programa es esto 00:07:27
Leer el número un montón de veces, un montón de veces 00:07:31
Pero claro, ningún programa puede ser infinito 00:07:33
Entonces, esto no puede ser dar vueltas al lazo todo el rato 00:07:37
¿Vale? Esto no puede ser dar vueltas al lazo 00:07:41
¿Vale? ¿Cuándo voy a dejar yo de dar vueltas al lazo? 00:07:44
Bueno, pues en algún sitio tendré que, tendrá que haber 00:07:48
En algún sitio tendrá que estar recogida 00:07:51
una condición, vamos a poner las condiciones 00:07:54
como las ponemos siempre, de alguna manera 00:08:00
tendrá que estar recogida sintácticamente 00:08:05
ahora veremos cómo será la sintaxis 00:08:07
de alguna manera tendrá que estar recogida una condición 00:08:09
que me va a fijar si el bucle 00:08:13
se vuelve a repetir y se vuelve a repetir 00:08:17
y se vuelve a repetir y se vuelve a repetir, de alguna manera tendrá que estar fijada 00:08:19
vale, pues ahora ya me hago la segunda parte 00:08:22
de mi diseño mental, la primera es identificar 00:08:25
que hay algo que lo voy a hacer muchas veces. 00:08:28
Esa es la primera. 00:08:31
La segunda es, ¿y qué es lo que voy a hacer muchas veces? 00:08:32
Pedir el número. 00:08:36
Un montón de veces. 00:08:36
Pedir el número, pedir el número, pedir el número. 00:08:37
Un montón de veces. 00:08:39
Vale, pues ya está. 00:08:39
Un montón de veces. 00:08:40
Y ya la tercera. 00:08:41
¿De qué depende que yo vuelva una y otra vez a dar la vuelta? 00:08:44
¿De qué depende de que este círculo se haga otra vez 00:08:49
y otra vez y otra vez? 00:08:52
Depende de una condición. 00:08:54
Bueno, pues ahora ya pienso en la condición. 00:08:56
¿Qué va a hacer que yo dé otra vuelta más y dé otra vuelta más? 00:08:59
Pues me han dicho que mientras que el número sea negativo, 00:09:02
porque el válido es el positivo, 00:09:06
entonces que yo dé otra vuelta y que dé otra vuelta y que dé otra vuelta 00:09:08
va a depender de que este número sea negativo. 00:09:12
Bueno, pues ya he fijado una condición. 00:09:15
Entonces, cuando el número sea negativo, 00:09:18
Efectivamente yo 00:09:22
Entraré aquí otra vez 00:09:24
¿Vale? 00:09:26
Y luego volveré a preguntarme la condición 00:09:28
Luego si el número es negativo 00:09:31
Me vendré por aquí 00:09:33
Y volveré a preguntarme la condición 00:09:35
Si sigue siendo negativo 00:09:37
Entraré por aquí 00:09:39
Y volveré a preguntarme la condición 00:09:40
Si sigue siendo negativo 00:09:42
Entraré por aquí y volveré a preguntármela 00:09:44
Pero claro, habrá alguna vez 00:09:46
Que el programa 00:09:49
que el usuario ya meta el número positivo 00:09:50
bueno, pues si 00:09:53
esta condición tiene 00:09:55
dos posibilidades, que se cumpla 00:09:57
o que no se cumpla 00:09:59
si se cumple ya sabemos que 00:10:00
otra vez, otra vez 00:10:03
y si no se cumple, ya el programa 00:10:05
ya sigue, ya el dato está válido 00:10:07
y ya pues lo que sea 00:10:09
la condición es 00:10:11
la contraria 00:10:17
a la que permite la salida 00:10:20
¿vale? la condición 00:10:22
es condición que mientras se cumpla 00:10:24
vuelves a entrar, vuelves a entrar 00:10:25
luego es la contraria de la salida 00:10:27
la contraria de la que fije 00:10:30
la salida 00:10:32
¿vale? 00:10:32
entonces, así más o menos es un diagramita 00:10:36
de lo que es un bucle 00:10:38
lo que pasa es que esto, puesto en diagrama de flujo 00:10:39
que es esa herramienta gráfica 00:10:42
que dijimos en su momento 00:10:44
que nos es de ayuda para entender el flujo 00:10:45
de un programa, en diagrama de 00:10:48
flujo, esto se queda un poco 00:10:50
más bonito. Un bucle en diagrama de flujo 00:10:52
sería esto. Mi programita viene 00:10:54
por aquí, haciendo las intenciones que sea. 00:10:56
Aquí tiene una condición. 00:10:58
¿El número 00:11:01
es menor que cero? 00:11:02
Sí, es menor que cero. 00:11:04
Entro en el bucle 00:11:06
y hago lo que tenga que hacer. En este 00:11:07
caso, pues por ejemplo, 00:11:10
el si soy, leer en. 00:11:12
Y vuelvo otra vez 00:11:14
aquí arriba. 00:11:16
a preguntarme la condición, que no, hemos terminado y el programa ya sigue por aquí 00:11:18
haciendo lo que tenga que hacer, mostrando dato válido, lo que sea, esto ya sí es la 00:11:24
foto de un diagrama de flujo de un bucle, ¿vale? Una condición, si se cumple hago 00:11:33
esto y si no he terminado y sigo, pero claro se distingue mucho de un if, porque hay veces 00:11:42
en algunos casos que 00:11:50
confundís los if y los while 00:11:51
y no, ah bueno 00:11:53
que esto es más fácil así 00:11:58
un if 00:11:59
ya sabemos que es esto 00:12:05
empieza igual, empieza con una condición 00:12:08
la que sea 00:12:11
si se cumple, hago una cosa 00:12:11
lo que sea 00:12:15
si no se cumple, hago otra 00:12:16
o no hago nada 00:12:19
tengo una rama vacía 00:12:21
pero en ambos casos el programa termina 00:12:22
Me da igual en una sentencia de decisión haber ido por esta rama que haber ido por esta, que una vez completado lo que haya que hacer, que podría no ser nada, podría aquí haber nada o podría aquí haber nada, pero sea lo que sea, una vez completado lo que haya que hacer, ya está. 00:12:25
sin embargo el while 00:12:43
también es una condición 00:12:45
el bucle es una condición 00:12:47
que como todas las condiciones 00:12:49
hay dos posibilidades, o se cumple o no, no hay más 00:12:51
si se cumple, hago algo 00:12:53
y a diferencia 00:12:55
del if, que ya me piro 00:12:57
de ahí y se acabó y continuo 00:12:59
con el programa, a diferencia 00:13:01
del if, el bucle 00:13:03
vuelve otra vez a preguntarse 00:13:04
la misma condición, que sigue siendo 00:13:07
cierta, repito esto 00:13:09
una segunda vez y vuelvo 00:13:11
otra vez a preguntármela. ¿Que sigue siendo cierta? 00:13:13
Ejecuto de nuevo 00:13:16
esta y vuelvo otra vez. 00:13:17
Luego esa es la diferencia, que aquí la rama del 00:13:19
sí no vuelve arriba. Se va 00:13:21
y listo. Y la rama 00:13:23
del no, si es que no, se 00:13:25
acabó. Continúo con el resto 00:13:27
del programa. Ya está. No hay más que hacer. 00:13:29
¿Vale? Entonces 00:13:31
esto nos permite, esta estructura 00:13:35
nos permite algo que yo he 00:13:37
identificado que tengo que hacer varias veces 00:13:39
que realmente se haga muchas veces. 00:13:41
¿Cuántas? Pues depende 00:13:43
En este ejemplo en concreto 00:13:46
¿Cuántas? Depende 00:13:47
De las que tarde el usuario meter un número positivo 00:13:49
En una ejecución 00:13:52
Igual lo hace solo una vez 00:13:54
Pero a lo mejor dentro de tres ejecuciones 00:13:55
Tarda siete veces en meter el positivo 00:13:58
Pues siete veces 00:14:00
Que va a estar ahí dando vueltas 00:14:02
¿Vale? 00:14:04
Cada una de las vueltas 00:14:06
Es lo que llamamos, es una iteración 00:14:08
Del bucle, cada una de las vueltas 00:14:10
es una iteración 00:14:12
y por eso esta es la sentencia 00:14:13
iterativa 00:14:17
que se llama, porque va haciendo iteraciones 00:14:18
esta es la sentencia 00:14:20
iterativa o repetitiva 00:14:23
iterativa 00:14:25
y la programación estructurada 00:14:25
no necesita nada más que esto 00:14:31
las variables 00:14:33
con sus operaciones 00:14:34
esto y esto 00:14:36
ya está, nada más 00:14:38
todo lo demás 00:14:40
son añadidos 00:14:42
para que el programa sea 00:14:45
más bonito, más reutilizable 00:14:46
separarlo en partes 00:14:49
porque si no el programa es 00:14:51
inmanejable, todo lo demás de la 00:14:53
programación está orientado 00:14:55
a esto que os digo, para la algoritmia 00:14:57
ya no hace falta nada más 00:14:59
para cualquier algoritmo 00:15:01
que yo tenga que hacer 00:15:02
lo voy a poder resolver con lo que 00:15:04
hemos visto hasta ahora 00:15:06
incluyendo el bucle, ya está 00:15:08
todo lo demás ya compete 00:15:10
a cómo almaceno los datos, 00:15:12
cómo organizo el programa, 00:15:15
qué variables declaro, 00:15:17
a conocimientos en relación a eso 00:15:20
para que mi programa se convierta en algo 00:15:22
realmente manejable, útil, escalable, modificable, etc. 00:15:24
¿Vale? 00:15:29
Bueno, pues entonces, ¿cómo ahora ya? 00:15:31
¿Cómo programamos esto? 00:15:34
Esto ya tiene una sintaxis, lógicamente. 00:15:35
Tiene una sintaxis, pues vamos ya 00:15:38
a verlo 00:15:40
ahí que 00:15:42
se queda más claro y más bonito 00:15:44
ahí, vale 00:15:46
venga 00:15:55
vale 00:16:00
vale, y vosotros decís entonces 00:16:17
si lo decís de verdad 00:16:20
este ejemplo, nos ha quedado 00:16:21
a todos claro que no hay otra forma 00:16:24
de hacerlo que no sea un bucle 00:16:25
¿vale? porque hombre 00:16:27
un programa que me dicen, lee 10 00:16:29
números, luego haz no sé qué 00:16:32
pues yo podría hacer las 00:16:33
10 lecturas una tras otra, me queda muy feo 00:16:36
si tengo un bucle, pues no lo hago 00:16:37
así, pero podría hacerlo sin bucles 00:16:40
es que este ni siquiera 00:16:42
no podemos 00:16:43
entonces, ah, ya que hemos entendido 00:16:44
que no podemos y que 00:16:47
estructura tendríamos que hacer 00:16:49
pues ahora ya podemos programarlo 00:16:51
venga 00:16:53
el que se ha hecho automáticamente 00:17:07
hay una pestañita 00:17:11
abajo 00:17:15
que puedes marcar 00:17:16
pero mira, gracias a que no lo he descubierto hasta ahora 00:17:18
se lo sabe de memoria seguro perfectísimamente 00:17:21
claro, vale, pues entonces 00:17:23
vamos a hacer este ejemplo 00:17:26
Tenemos nuestro numerito, nuestro escáner para leer del teclado y aquí nuestro numerito N, ¿vale? 00:17:27
Entonces, ¿qué vamos a hacer aquí? Pues vamos a solicitar número hasta que se introduzca uno positivo. 00:17:49
Esto es lo que queremos hacer, ¿vale? 00:18:09
Pues entonces 00:18:17
Ya hemos identificado 00:18:19
Que sentencias queremos hacer un montón de veces 00:18:21
Un montón de veces 00:18:23
Ler número, ler número, ler número 00:18:24
Entonces un montón de veces 00:18:26
Vamos a 00:18:28
Querer hacer esto 00:18:30
Introduzca número 00:18:32
Y ahora 00:18:38
Un montón de veces queremos hacer esto 00:18:40
Vale 00:18:46
Luego esto va a estar dentro del bucle 00:18:46
La sintaxis del bucle 00:18:50
¿Cuál es? 00:18:55
empieza una de las posibles 00:18:56
la primera que vamos a ver 00:19:00
empieza con while 00:19:01
mientras como no podía ser de otra manera 00:19:04
y aquí es donde va esa condición 00:19:06
que tenemos que seguir perfilando 00:19:09
entonces 00:19:13
todo el código que se repite 00:19:15
dentro del bucle 00:19:19
todo el código que se repite 00:19:21
va entre llaves después del while 00:19:22
Ahí entre llaves 00:19:25
Ahora 00:19:27
¿Vale? 00:19:28
De nuevo con el mismo matiz de leave 00:19:31
Si lo que se repite fuera solo una sentencia 00:19:33
Puedo quitar las llaves 00:19:36
¿Vale? 00:19:38
Si lo que se va a repetir es solo una sentencia 00:19:39
Puedo quitarlas 00:19:41
Lo podemos poner aquí 00:19:42
Pesarias 00:19:45
Pesarias 00:19:49
Llaves 00:19:51
Si dentro del bucle 00:19:53
solo hay una sentencia 00:19:56
¿vale? en este caso hay dos 00:19:59
luego en este caso 00:20:04
obligatorio poner las llaves 00:20:06
de nuevo 00:20:08
sigamos las pautas de 00:20:09
sigamos las pautas de estilo 00:20:11
el while es una sentencia más 00:20:14
que empieza al mismo nivel que están 00:20:16
las otras, como esta de declaración de variables 00:20:18
la llave 00:20:22
que abre el código que va dentro del bucle 00:20:23
la pongo justo después del while, la pongo aquí 00:20:26
Y todo lo que va tabulado, no es obligatorio, repito, es una cuestión de estilo, todo lo que va dentro, perdón, lo tabulo por estilo para que se vea claro qué es lo que va dentro del while, para que se vea claro. 00:20:28
Una vez que ya he terminado todo lo que va dentro del bucle, cierro la llave y esa llave la cierro a la misma altura que se abrió el while, porque así queda claro esa llave que código cierra. 00:20:42
como pauta de estilo, repito 00:20:55
vale, entonces 00:20:58
parte de este programa 00:21:03
está hecho, estamos aquí 00:21:05
un montón de veces pidiendo 00:21:07
número, pidiendo número, pidiendo número 00:21:09
y ahora os hacemos la pregunta, me han dicho 00:21:10
que salga cuando 00:21:13
se introduce un número positivo 00:21:15
luego la condición que pongo aquí efectivamente es 00:21:16
la contraria a la 00:21:19
de salida, es decir 00:21:21
la condición que si se cumple 00:21:22
tengo que volver a repetir, tengo que volver a repetir 00:21:24
Aquí pongo la condición que me obliga a repetir 00:21:27
En este caso la condición que me obliga a repetir 00:21:30
¿Cuál sería? 00:21:33
N menor que 0, el número negativo 00:21:36
¿Vale? 00:21:38
Luego este programa estaría casi hecho 00:21:40
¿Vale? 00:21:42
Casi 00:21:44
Solo le falta un matiz 00:21:44
De hecho aquí estamos viendo un error de compilación 00:21:46
¿Vale? 00:21:49
Claro, tiene sentido 00:21:50
Ahora ya esto se empieza a ejecutar 00:21:51
¿Y cómo se ejecuta esto ya? 00:21:53
Pues la máquina virtual viene por aquí, variable n, estupendo, le creo un espacio en memoria para n, ahí se queda con valor indefinido porque no le has asignado nada. 00:21:57
Ahora empiezo, lo primero que haces es evaluar la condición, lo primero, si la condición fuera falsa de partida, es que jamás nunca se haría esto, 00:22:05
porque si la condición ya la primera vez que llegamos por aquí ya es falsa, es que ni se haría, saltaríamos por aquí. 00:22:17
Vamos a poner aquí una sentencia, el número introducido es n, ¿vale? Es decir, saldríamos por aquí, si el número ya de partida fuera, si esta condición de partida fuera falsa. 00:22:24
pero si es cierta, entramos 00:22:47
entramos una primera vez 00:22:50
pedimos el número 00:22:51
si el número es negativo 00:22:53
lo pedimos una segunda vez 00:22:56
entonces, ¿cómo se os ocurre 00:22:57
que podemos arreglar este programa? 00:23:00
porque una primera vez queremos entrar sí o sí 00:23:01
la primera petición queremos hacerla 00:23:04
por ejemplo, podríamos 00:23:06
hacer la primera petición 00:23:11
fuera, esta sería una posibilidad 00:23:13
pido el primer número fuera 00:23:14
introduzca número 00:23:17
si el número es negativo 00:23:19
Ya me va a pedir el segundo otra vez 00:23:20
Si el número es positivo 00:23:23
Ya de partida no entra 00:23:25
Luego este arreglo está bien 00:23:26
¿Vale? 00:23:28
De hecho si lo ejecutamos 00:23:30
Pues aquí se queda 00:23:31
Menos 6, menos 6 00:23:36
Menos 3, 4 00:23:40
Ahí se queda 00:23:41
Bla, bla, bla, encajado 00:23:43
Vale, este sería un arreglo 00:23:44
Aquí lo único, está bien 00:23:46
Lo único es que estamos duplicando código 00:23:49
Escribiendo esto dos veces 00:23:51
Si os ocurre algún otro arreglo 00:23:53
Claro, vamos a inicializar n 00:23:57
Con un número negativo cualquiera 00:24:04
Entonces, con un número negativo cualquiera 00:24:06
De partida esta condición es falsa 00:24:10
De partida es falsa 00:24:13
Con lo cual la primera vez va a entrar sí o sí 00:24:15
La primera vez va a entrar 00:24:18
Y ya las siguientes dependerá 00:24:19
De si el número es positivo o no 00:24:23
Sí, puedes meter aquí un if 00:24:24
Y cambiar salir a true o false 00:24:38
Claro, sí, pero esa variable booleana 00:24:41
Si tú pones aquí, tú te refieres a esto 00:24:45
Poner aquí un boolean 00:24:47
Salir, que de partida es false 00:24:49
Y ahora aquí 00:24:53
A este boolean 00:24:55
Sí, ya, pero lo tendrías que cambiar 00:24:56
De valor dentro 00:24:59
Salir, y ahora aquí salir 00:25:00
Y tendrás que volverla a actualizar. 00:25:03
Número mayor o igual que cero. 00:25:06
¿Vale? 00:25:12
Te refieres a esto. 00:25:12
¿No? 00:25:13
Sí. 00:25:14
Pero bueno, que si algún código es largo, 00:25:15
necesitas dejar más claro. 00:25:20
Pero aquí en realidad estamos añadiendo una complejidad. 00:25:22
Hacer un boolean. 00:25:25
Para poner aquí el boolean y aquí actualizarlo cada vez. 00:25:26
Estamos añadiendo que quizá en este caso es innecesaria. 00:25:28
¿Vale? 00:25:31
o sea, guardar la condición en un boolean aparte siempre 00:25:31
a veces puede dejar el programa más claro 00:25:34
si este bucle, por ejemplo, es larguísimo 00:25:37
puedes perder la noción de por qué necesitas 00:25:40
que esto sea menor que cero, entonces pues le puedes dar 00:25:44
pero si no, aparte que 00:25:46
de esta manera enmascaras parte de la información 00:25:49
porque yo veo este código de partida, yo estoy viendo el programa de otro 00:25:52
y veo while salir 00:25:56
y para entender por qué este código sale 00:25:57
tengo que mirar todo dentro del while 00:26:01
a ver qué valor le doy a salir 00:26:02
sin embargo, si pongo aquí la condición 00:26:05
yo de partida veo este bucle 00:26:07
cuándo va a salir y cuándo no 00:26:10
entonces, bueno, dependiendo de la situación 00:26:11
pues a lo mejor puede ser más claro, más legible 00:26:14
¿vale? depende de la situación 00:26:16
ahora mismo en particular, para no complicarlo 00:26:18
pues no vamos a... 00:26:21
¿vale? 00:26:24
vale 00:26:33
vale 00:26:34
bueno, pues entonces 00:26:39
podemos poner un valor negativo 00:26:41
y ya está, forzamos la primera iteración 00:26:44
vale 00:26:47
luego, el bucle 00:26:48
es única y exclusivamente 00:26:50
esto 00:26:52
el while con la condición 00:26:53
de la contraria 00:26:56
a la salida, o lo que es lo mismo 00:26:58
la condición que hace que vuelvas 00:27:00
que puede ser muy pequeña o puede ser muy grande 00:27:01
depende de lo que haga mi programa 00:27:04
¿vale? y luego ya 00:27:05
dentro lo que yo quiero que se repita 00:27:08
cuando la condición se hace 00:27:10
falsa, se acabó 00:27:12
y ya está 00:27:13
en este 00:27:15
en este caso en particular sí, porque 00:27:21
así no duplico código 00:27:23
aquí arriba, ¿vale? todo depende 00:27:25
de la situación, una vez que conocemos las herramientas 00:27:27
yo en este caso la inicializaría 00:27:30
a un número que ya fuerza la primera 00:27:32
claro, porque en este 00:27:34
ejemplo en particular, yo una primera 00:27:35
vez tengo que entrar sí o sí, ¿vale? Tengo que entrar. Vale, entonces, ¿por qué he puesto este 00:27:37
ejemplo? Para comparar esta versión de bucle con otra sintaxis posible que tiene, que es muy 00:27:46
parecida pero es igual, que es la sintaxis do while. Vale, entonces, esta sintaxis y lo que 00:27:53
hace, está entendida, ¿no? 00:28:00
Y este 00:28:03
bucle, si de partida 00:28:04
la condición fuera falsa, 00:28:06
que podría ocurrir, 00:28:09
esto nunca se ejecutaría. Luego 00:28:10
un bucle while puede ocurrir que lo que tenga dentro 00:28:12
nunca se haga, ¿vale? Puede ocurrir que 00:28:14
nunca se haga. De hecho, 00:28:16
en esta solución que teníamos aquí, sacando 00:28:18
este código fuera, 00:28:20
si metemos el número positivo 00:28:22
de partida, lo que hay aquí 00:28:24
dentro no se va a ejecutar jamás. 00:28:26
luego lo que hay dentro de un while puede que no se ejecute nunca 00:28:27
si la primera vez esta condición es falsa 00:28:30
vale, pero 00:28:35
hay programas, situaciones 00:28:37
hay mil posibilidades de programas a solucionar 00:28:40
en los cuales por la naturaleza del problema 00:28:42
resolver nosotros queremos que una primera vez 00:28:47
se haga sí o sí 00:28:50
incondicionalmente, sí o sí 00:28:51
sin mirar condición ni historias 00:28:54
y luego ya las siguientes dependiendo de la condición. 00:28:57
Es una situación típica. 00:29:01
Por ejemplo, en casos como este. 00:29:02
Cuando hacemos un menú de datos de entrada, 00:29:04
mostrar el menú y leer la opción, 00:29:08
una primera vez la queremos sí o sí. 00:29:09
¿Vale? 00:29:13
Entonces, vamos a ponerlo aquí. 00:29:13
Hay situaciones, problemas o programas 00:29:21
en las cuales necesitamos 00:29:23
Necesitamos 00:29:27
Que la 00:29:31
Primera 00:29:33
Ejecución 00:29:35
Se haga 00:29:37
Incondicionalmente 00:29:39
Que se haga sí o sí 00:29:42
Que se haga siempre 00:29:46
La primera ejecución del bucle 00:29:47
Y ya las demás dependiendo 00:29:49
La primera se haga sí o sí 00:29:51
si, ahora vemos la sintaxis 00:29:54
¿vale? pero por ejemplo 00:30:00
podría ser como esta, en este 00:30:02
bucle de pedir datos 00:30:04
sabemos que es un bucle, tiene que ser un bucle porque se va a hacer 00:30:05
varias veces, ¿vale? pero 00:30:08
también hemos visto que la primera vez 00:30:10
de la 00:30:12
primera vez, esto se 00:30:14
tiene que hacer, esta se tiene 00:30:16
que hacer, porque el primer 00:30:18
número lo tienes que pedir 00:30:20
entonces, para 00:30:21
forzar a que la primera vez se haga, hemos tenido 00:30:24
que hacer la trampa, entre comillas, 00:30:26
de por esto negativo. Hemos tenido que 00:30:29
hacer esa trampa, entre comillas, 00:30:30
para forzar la primera iteración. 00:30:32
¿Vale? Que no pasa nada, 00:30:35
no pasa nada, es lo más natural del mundo y lo más 00:30:36
habitual. Fuerzo la primera iteración. 00:30:38
Y a las segundas 00:30:41
vendrán dadas, por si este numerito 00:30:42
ya es negativo o no. 00:30:44
Vale, pero, bueno, 00:30:47
precisamente, para no tener 00:30:49
que hacer estas trampitas, 00:30:50
existe otra sintaxis del while 00:30:52
otra sintaxis del bucle 00:30:56
que fuerza a que la primera 00:30:57
iteración se haga sí o sí 00:31:00
que es la sintaxis do while 00:31:01
¿cómo es la sintaxis del bucle 00:31:04
do while? primero se escribe 00:31:11
do, se abren ahí 00:31:13
las llavecitas 00:31:15
y la condición se pone después 00:31:15
al final 00:31:18
y ya terminamos aquí en punto y coma 00:31:20
y ahora esto que 00:31:26
tenía que hacer lo meto aquí dentro 00:31:29
Vale, pues esto es un bucle igualmente 00:31:31
Esto es una sintaxis 00:31:37
De bucle igual 00:31:44
¿Qué es lo que se repite? Esto 00:31:45
¿Qué es lo único que cambia? 00:31:48
Lo único que cambia es que 00:31:51
La máquina virtual viene por aquí, pam, pam 00:31:52
Lo primero que hace es 00:31:54
Hacer una ejecución, sí o sí 00:31:56
Es lo primero que hace 00:31:58
Y a partir de ahí ya empieza a mirar la condición 00:31:59
¿Esto es negativo? 00:32:02
Vuelvo arriba y ejecuto 00:32:05
¿Sigue siendo negativo? 00:32:07
vuelvo arriba y ejecuto 00:32:08
pero la primera se hace sí o sí 00:32:10
y las siguientes ya 00:32:12
depende de la condición 00:32:14
aquí se termina con un punto y coma, etc. 00:32:18
entonces 00:32:26
el bucle do while se prestaría mejor 00:32:26
a este ejemplito nuestro 00:32:29
porque la primera petición 00:32:30
la va a hacer sí o sí 00:32:33
y ya las siguientes 00:32:34
pues dependerá 00:32:37
dependerá de si el número es negativo o no 00:32:38
vale, entonces yo aquí la variable 00:32:41
n, no tendría 00:32:57
por qué inicializarla 00:32:59
vale, o sea 00:33:01
de hecho voy a comentar todo lo anterior 00:33:03
aunque para 00:33:05
comprobarlo 00:33:07
comento aquí 00:33:08
la inicialización de la n 00:33:11
y comento este código 00:33:13
vale 00:33:18
vale, entonces tengo 00:33:20
mi variable n sin inicializar 00:33:23
limpia 00:33:25
y el do while no me da ningún error de compilación 00:33:26
¿por qué? 00:33:30
porque la primera vez que llega la condición 00:33:32
ha llegado después de una primera ejecución 00:33:34
esta ejecución se ha hecho una primera vez 00:33:37
con lo cual obligatoriamente la variable n tiene que tener un valor 00:33:39
porque eso se ha hecho una vez obligatorio 00:33:44
con lo cual la primera vez que evalúo la condición 00:33:46
n ya tiene algo seguro 00:33:50
luego esto pega muchísimo más 00:33:52
Para programas 00:33:58
Que te muestren un menú de opciones 00:34:01
Pega mucho más 00:34:02
Voy a dejarlo como estaba 00:34:05
¿Vale? 00:34:14
Podemos hacer la parte del while 00:34:18
Ese sería el do while 00:34:20
¿Y la variable, la n, la has declarado? 00:34:25
La n la he declarado antes 00:34:28
Y puede no tener valor 00:34:30
Tú prueba a hacer este programa 00:34:33
Con una n delante 00:34:36
sin ningún valor inicializado 00:34:37
y no hay ningún problema 00:34:39
porque como lo primero que hace es esto 00:34:41
ya aquí recibe su primer valor 00:34:43
claro, la inicialización de n 00:34:45
se hace en la primera 00:34:47
iteración del bucle, en la primera 00:34:49
y como esa primera 00:34:51
iteración se hace sí o sí 00:34:53
pues no hay duda, vamos a llegar 00:34:55
a la condición con n con un primer 00:34:57
valor, el de la primera lectura 00:34:59
¿vale? 00:35:01
esto 00:35:10
Un segundito y paramos 00:35:10
Vale 00:35:26
Es decir, el while es esto 00:35:31
Yo tengo mi condición 00:35:38
Que es lo primero que se hace 00:35:41
Si se cumple 00:35:43
Hago el código que sea 00:35:45
Y vuelvo arriba otra vez 00:35:47
Que no se cumple 00:35:49
Me voy 00:35:54
este es el while a secas 00:35:56
que hemos visto 00:36:00
el while condición 00:36:01
sentencias 00:36:03
y el do 00:36:05
sentencias while condición 00:36:06
esta es la condición que sea 00:36:10
la condición que sea, sería esto 00:36:13
primero 00:36:16
ejecuto el código que sea 00:36:17
lo primero de todo 00:36:20
y ahora ya 00:36:21
me planteo la condición 00:36:22
que se cumple 00:36:25
me voy 00:36:27
arriba 00:36:30
que no se cumple 00:36:30
sigo por abajo 00:36:33
luego ese es el while 00:36:34
y este es el do while 00:36:37
que no funcionan exactamente 00:36:38
igual, los dos son bucles 00:36:43
que hacen muchas veces algo 00:36:45
tienen una pequeña diferencia 00:36:46
que en el do while 00:36:49
lo que se ejecuta una primera 00:36:50
vez se hace sí o sí 00:36:53
y ya las siguientes dependen de la condición 00:36:55
porque si la condición la primera vez es falsa 00:36:57
solo se ejecuta una vez y luego ya me piro 00:37:00
se ejecuta una vez y me piro 00:37:02
pero en este bucle 00:37:04
si la condición es falsa 00:37:06
ya es que no se va a ejecutar nunca 00:37:08
ninguna 00:37:11
si es falsa como es lo primero que miro 00:37:11
al ser lo primero 00:37:14
si es falsa nunca se va a ejecutar esto 00:37:15
sin embargo en este caso 00:37:18
si la condición es falsa 00:37:20
la primera vez se ejecuta 00:37:21
y ya las siguientes no 00:37:23
Entonces dependiendo de mi funcionamiento 00:37:24
De programa, lo que yo quiera hacer 00:37:27
Pues pega más una o pega más la otra 00:37:29
¿Vale? 00:37:31
Queda más bonito uno o la otra 00:37:33
Todo lo podemos hacer con las dos 00:37:34
Pero habrá que hacer retoques 00:37:36
Lo que hemos hecho antes del menú 00:37:38
Se adaptaba mejor esto 00:37:40
Muestro menú, leo opción 00:37:44
No es válida 00:37:45
Muestro menú, leo opción 00:37:47
No es válida 00:37:48
Muestro menú, leo opción 00:37:49
Es válida, se acabó 00:37:50
Con esta 00:37:51
hemos tenido que hacer una trampa 00:37:52
para forzar a que la condición 00:37:56
sea falsa de partida 00:37:58
y hacerlo una primera vez 00:38:00
¿vale? 00:38:01
podemos hacer todo con cualquiera de los dos 00:38:04
pero entonces tendremos que hacer 00:38:06
los retoques correspondientes 00:38:07
para que haga exactamente lo que queremos que se haga 00:38:10
¿verdad? 00:38:12
vale, vamos a parar unos minutos 00:38:14
¿no? 00:38:18
Materias:
Programación
Niveles educativos:
▼ Mostrar / ocultar niveles
  • Formación Profesional
    • Ciclo formativo de grado superior
      • Segundo Curso
Subido por:
Raquel G.
Licencia:
Todos los derechos reservados
Visualizaciones:
7
Fecha:
26 de octubre de 2025 - 17:10
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
38′ 20″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
1.06

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid