Saltar navegación

20251031 BucleFOR - 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 3 de noviembre de 2025 por Raquel G.

4 visualizaciones

Más información Transcripción

Descargar la transcripción

Vale, pues a ver esto. Bueno, pues entonces, el ejemplo que estaba proyectado antes, era un ejemplo en el cual después de denunciado, hemos identificado que hay algo que se tiene que hacer exactamente 10 veces. 00:00:03
no hasta que el usuario 00:00:23
introduzca un cero 00:00:26
o no hasta que ocurra 00:00:27
que la suma me dé positivo 00:00:30
no hasta una condición cualquiera 00:00:31
que hace que el número de veces 00:00:34
que se realice sea indeterminado 00:00:36
no hasta una condición 00:00:37
sino un número exacto de veces 00:00:38
vale, pues esa situación 00:00:40
un número exacto de veces 00:00:43
también 00:00:45
como es un bucle 00:00:46
la resolveríamos con un while 00:00:48
¿verdad? algo que se haga un número exacto de veces 00:00:52
pues podríamos hacer esto 00:00:54
si yo quiero que algo se haga 00:00:55
un número exacto de veces 00:00:58
pues cojo una variable 00:00:59
que me va a servir de contadora 00:01:03
para contar cuantas veces ejecuta eso 00:01:04
me pongo aquí esta condición 00:01:07
aquí hago lo que haya que hacer 00:01:10
lo que sea 00:01:12
y ahora ya incremento 00:01:13
¿vale? entonces repito 00:01:15
si yo quisiera 00:01:18
si yo quisiera un programa 00:01:19
en el que algo, lo que sea 00:01:25
se me haga un número 00:01:27
exacto de veces 00:01:29
n, por ejemplo 00:01:31
pues tendríamos que hacer esto 00:01:32
¿verdad? este bucle 00:01:34
se ejecuta mientras 00:01:37
i sea menor, perdón, menor 00:01:39
exactamente que n, no menor o igual 00:01:41
¿vale? 00:01:43
y empieza valiendo 0 00:01:47
y mientras i sea menor que n 00:01:49
hago lo que tenga que hacer y dejo 00:01:51
incrementada i 00:01:54
entonces esta variable i que yo he puesto ahí 00:01:54
como se puede llamar i, j, h, o la 00:01:57
esa variable me está sirviendo solo 00:02:00
para contar las veces que se ejecuta el bucle 00:02:03
¿vale? 00:02:06
entonces lo que hace el bucle 00:02:08
pues no lo sé, dependerá de mi problema 00:02:09
lo que haga 00:02:11
pero sí que sé que esa estructura de aquí 00:02:12
es una estructura en la cual 00:02:14
esto, sea lo que sea 00:02:17
se hace exactamente n veces 00:02:19
¿vale? 00:02:22
entonces es una situación que se nos puede dar 00:02:23
el tener que hacer un programa 00:02:26
en el que algo se haga 00:02:28
un número de veces que ya conocemos 00:02:30
tal cual, como ese ejemplo 00:02:32
de antes, programa que lee 00:02:34
10 números, pues 10 veces se va a ejecutar 00:02:36
pues lee 20 nombres 00:02:38
pues ese bucle se va a ejecutar 00:02:40
20 veces, entonces cuando tenemos 00:02:42
un programa en el cual algo 00:02:44
ya sabemos de partida 00:02:46
cuantas veces se va a ejecutar 00:02:48
pues con el while podríamos hacer algo así 00:02:50
y listo, ¿vale? 00:02:52
Entonces, recordad que esto 00:02:54
es una situación distinta a 00:02:55
un bucle 00:02:57
que se va a ejecutar 00:02:59
mientras 00:03:02
una condición sea falsa, pero 00:03:04
no sé cuántas veces 00:03:06
va a tardar el bucle en conseguir 00:03:07
que la condición sea falsa. 00:03:10
Es otra situación, ¿no? Como cuando hacemos un programa. 00:03:11
Programa que está todo el rato 00:03:14
introduciendo números hasta que 00:03:15
introduzca uno positivo. 00:03:18
¿No? Un programa de validar que tú estás 00:03:20
metiendo un número todo el rato, mientras el usuario 00:03:22
meta negativo, no te interesa. Hasta 00:03:24
que no meta positivo, no sales del bucle. 00:03:25
Ese bucle, no sabemos cuántas 00:03:28
veces se va a ejecutar. En alguna 00:03:30
ejecución, igual que se ejecuta 5, porque 00:03:31
ha tardado 5 veces en meter el positivo. 00:03:33
Pero en otra ejecución 00:03:36
que hagamos después, a lo mejor se ejecuta 00:03:37
10 veces, porque ha tardado 00:03:39
10 veces en meter el positivo. 00:03:41
Esa sería 00:03:44
otra situación. 00:03:45
Pero una situación muy concreta, 00:03:47
repito, es aquella en la cual 00:03:49
sabemos a priori las veces 00:03:51
que queremos que se ejecute el bucle 00:03:54
lo sabemos a priori, quiero que se ejecute 00:03:56
20, porque es mi problema 00:03:57
y necesita eso 00:04:00
bueno, pues en ese caso 00:04:02
haríamos algo así 00:04:03
pero hay otra sintaxis 00:04:05
para el bucle, hay otra sintaxis 00:04:08
que lo único que aporta 00:04:10
es escribir esto de forma más bonita 00:04:12
nada más 00:04:14
y esa sintaxis 00:04:15
es la sintaxis del bucle for 00:04:17
que la usamos 00:04:20
porque queda más bonito 00:04:22
solo por eso 00:04:24
en situaciones en las cuales yo quiero 00:04:25
que lo que hay dentro del bucle se ejecute 00:04:28
exactamente un número 00:04:30
concreto de veces 00:04:32
¿vale? 00:04:33
¿que es obligatorio usar el for? 00:04:37
pues no, este bucle está muy bien 00:04:39
este bucle 00:04:40
es un bucle que se ejecuta exactamente 00:04:42
n veces 00:04:44
esto está bien 00:04:45
lo que pasa es que, bueno, que he tenido que hacer esta variable aquí fuera, 00:04:46
ahora tengo que incrementarla aquí, que ni siquiera tengo que incrementarla aquí, 00:04:51
podría poner el más más ahí, ¿verdad? 00:04:54
Podría poner ahí el más más, y aquí esto ya no me haría falta, ¿vale? 00:04:57
Que, por tanto, el for no lo necesitamos en realidad. 00:05:04
Es otra herramienta de sintaxis más para que mis códigos queden más bonitos, nada más. 00:05:08
Bueno, pues vamos a ver entonces cuál es esa sintaxis del bucle for, 00:05:14
que nos va a facilitar la escritura del código en algunos casos, simplemente nos va a facilitar la escritura porque es más ágil, pero no aporta nada que no haga un while, ¿vale? 00:05:18
Bueno, pues ¿cuál es la sintaxis del bucle for? Vale, pues la sintaxis es, primero escribimos for, como no podía ser de otra manera, escribimos for. 00:05:31
Y ahora, entre paréntesis, se pone lo que vamos a ver ahora. Y ahora ya aquí lo que se repite, ¿vale? Entre llaves. Que puede ser una sentencia o muchas, como siempre. Si es solo una, de nuevo, las llaves no son obligatorias. Si lo que se repite es solo una sentencia, las llaves no son obligatorias, ¿vale? 00:05:48
vale 00:06:13
ahora, ¿qué se pone 00:06:15
aquí en estos paréntesis? pues tres 00:06:17
cositas, aquí hay espacio 00:06:19
para tres cosas 00:06:22
y cada una de ellas está separada 00:06:23
por el punto y coma, entonces en el 00:06:27
bucle for van tres cosas separadas 00:06:29
por punto y coma, ¿vale? 00:06:31
¿es obligatorio que aparezcan las tres? 00:06:35
no, puede que en alguna yo no quiera poner nada 00:06:37
ahora cuando veamos lo que significa 00:06:39
puede que lleguemos a la conclusión, no 00:06:40
aquí no me interesa poner nada, pues se queda en blanco 00:06:43
da igual, se queda en blanco 00:06:45
pero el espacio tiene que estar 00:06:46
no me refiero al espacio físico 00:06:49
sino que los puntos y comas 00:06:50
separando los campos tienen que estar 00:06:53
aunque uno no tenga nada dentro 00:06:55
vale, pues vamos a ver 00:06:57
que se pone en estas posiciones 00:06:59
en la 1 00:07:00
en la 2 y en la 3 00:07:02
en la posición 1 00:07:04
yo ahí pongo 00:07:08
una sentencia o varias 00:07:11
¿vale? voy a 00:07:14
poner lo que se puede poner ahí 00:07:26
luego otra cosa es el uso habitual que se le dé 00:07:28
una sentencia o varias 00:07:31
y las que yo ponga ahí 00:07:32
sé que se van a ejecutar 00:07:34
en el momento en el que el for 00:07:37
arranca 00:07:38
y solo esa vez, ya nunca más se volverán 00:07:39
a ejecutar, luego 00:07:42
se ejecutan 00:07:44
al comienzo del bucle 00:07:46
pero solo una primera 00:07:51
a ver, es decir, es como unas sentencias que se ejecutan cuando el bucle arranca, ¿vale? 00:07:53
Y solo se ejecutan esa vez. ¿Qué se pone en la posición 2? Ahí hay que poner una 00:08:04
condición, eso es lo que se pone ahí, una condición, muller. Esta condición sería 00:08:23
como la condición del while, tiene el mismo significado, es una condición que si se cumple 00:08:33
entramos y el bucle for vuelve arriba otra vez y vuelve a evaluar condición. Si se cumple 00:08:38
volvemos a entrar y vuelve a evaluar condición. Si se cumple volvemos a entrar. Luego, este 00:08:45
bucle, por ejemplo, este bucle con una condición aquí y este bucle for con esto y esto serían 00:09:03
lo mismo, por ejemplo 00:09:18
yo este campo no lo uso, este campo 00:09:19
que todavía sabemos lo que es, no lo uso, uso solo 00:09:22
la condición, luego 00:09:24
esto y 00:09:26
esto 00:09:28
serían exactamente igual, me da igual 00:09:29
poner una cosa que otra, lo que pasa 00:09:32
es que esta queda muy fea, cuando usamos el 00:09:34
for es porque queremos usar 00:09:36
esta posibilidad y esta 00:09:38
posibilidad, si no quiero 00:09:40
usarlas, para eso pongo un while 00:09:42
que se ve mucho más claro, mientras se cumple 00:09:44
la condición y tera, mientras se cumple y tera 00:09:46
entonces poner esto y poner esto 00:09:48
significa lo mismo 00:09:51
a efectos de lo que va a ejecutar el programa es lo mismo 00:09:52
pero en este caso 00:09:55
esta queda más fea 00:09:57
para qué poner yo ahí unos espacios que no uso 00:09:59
vacíos, pongo lo de arriba y ya está 00:10:01
el for lo usamos 00:10:02
cuando esto nos interesa 00:10:05
vale, pues ya sabemos lo que significa 00:10:06
este segundo campo 00:10:09
y qué significa el tercer campo 00:10:10
qué puedo poner yo ahí si quiero 00:10:13
no es obligatorio poner algo 00:10:15
ahí ponemos de nuevo 00:10:16
una sentencia o varias 00:10:19
una sentencia o varias 00:10:21
¿y cuándo se ejecutan esas? 00:10:32
pues se ejecutan 00:10:34
en cada iteración 00:10:36
y una vez que ha terminado lo que hay dentro 00:10:38
¿vale? o sea el bucle for 00:10:41
tendrá sentencias que son las que se repiten 00:10:43
pues en cada vuelta 00:10:44
se hará lo que hay dentro 00:10:47
y después de hacerse 00:10:49
se hace lo que hay aquí 00:10:51
y volvemos arriba a evaluar condición 00:10:52
si es cierta, se hace lo que hay dentro 00:10:54
y se hace lo que hay aquí 00:10:57
otra vez, luego 00:10:59
esto se hace una vez en cada 00:11:00
iteración 00:11:03
y siempre después de haber terminado 00:11:03
lo que hay escrito dentro 00:11:07
no, solo se hace 00:11:08
al principio cuando arranca el bucle 00:11:23
y ya está 00:11:25
solo esa vez 00:11:27
vale, pues esta es la sintaxis, ahora el tema es 00:11:28
¿en qué me puede 00:11:39
ayudar a mí esto a escribir código? 00:11:42
¿en qué puede ser útil? 00:11:44
¿en qué puede ser práctico? ¿cómo me puede ayudar 00:11:46
a escribir códigos un poquito 00:11:48
más claros? 00:11:49
¿vale? pues si ya entendemos 00:11:53
lo que significa cada cosa, esto se 00:11:54
adapta exactamente 00:11:56
a la situación que hemos escrito antes 00:11:58
para hacer un bucle 00:12:00
que se ejecuta exactamente n veces 00:12:02
¿por qué? vamos a 00:12:04
esto, ah no 00:12:08
¿cómo era lo de, a ver 00:12:14
¿le puedo hacer? 00:12:21
no, no sé cómo se hace pequeño 00:12:28
cómo se hacía pequeño esto, por probar 00:12:30
¿eh? 00:12:32
¿es así? ¿por qué no lo 00:12:34
pero y por qué no me 00:12:35
ah, vale, así sí, vale 00:12:38
vale, pues a ver 00:12:42
vale, pues en qué medida 00:12:45
este for de aquí 00:12:51
este for de aquí 00:12:54
nos puede ser útil para escribir código 00:12:56
ya digo, no es que nos aporte nada 00:12:58
todo lo que hacemos aquí lo pensamos como un while 00:13:00
¿en qué medida? pues por ejemplo 00:13:01
antes hemos dicho, vamos a ver 00:13:03
yo quiero hacer algo exactamente 00:13:05
n mayúscula a veces 00:13:08
pues hemos dicho 00:13:09
pues bueno 00:13:12
tendré yo que hacer una variable 00:13:12
ahora un bucle while 00:13:16
que mientras esa variable sea menor que ese número exactamente de veces 00:13:20
se haga lo que se tiene que hacer 00:13:25
y luego voy a incrementar esta variable en cada iteración 00:13:27
para asegurarme de que se va a ejecutar exactamente n veces 00:13:31
la primera vez que entra i vale 0 00:13:38
y luego sale con i valiendo 1 00:13:40
la siguiente vez i vale 1 00:13:42
y luego sale con i valiendo 2 00:13:45
Mientras sea menor que n sigo entrando, luego con esta estructura está claro que este bucle se ejecuta n veces, ¿vale? 00:13:47
Pero para conseguir que este bucle se ejecute n veces, pues he tenido que hacerme esta sentencia que se ejecuta al principio 00:14:00
y luego he tenido que hacerme esta otra aquí que se va a ejecutar en cada iteración y al finalizar. 00:14:07
pues es que es justo 00:14:15
para lo que sirven los campos 00:14:17
del for, es justo para lo que sirven 00:14:19
entonces el for 00:14:21
aunque se puede usar 00:14:23
poniendo uno aquí lo que le dé la gana 00:14:25
sabiendo lo que hará 00:14:27
la situación típica para la que 00:14:28
encajes en esta 00:14:31
si yo quiero programar esto con un for digo 00:14:32
ah maravilloso, esta sentencia 00:14:35
que quiero que se ejecute una vez 00:14:37
al arrancar, esta sentencia 00:14:39
la coloco aquí 00:14:41
en el 1 00:14:43
aquí pongo la condición 00:14:44
porque es la condición que marca 00:14:46
si yo 00:14:48
sigo iterando o no 00:14:49
y esta otra la pongo 00:14:51
aquí, que está 00:14:54
este campo de aquí tiene la sentencia 00:14:56
que se hace una vez 00:14:59
por iteración 00:15:01
y siempre al acabar 00:15:02
pues justo, en lugar de escribirlo así con el while 00:15:03
que queda más feo 00:15:07
pues lo puedo escribir esto a mismo 00:15:08
con un for 00:15:11
y si lo escribo con un for 00:15:13
pues esto será 00:15:18
en el primer campo esa primera sentencia 00:15:19
luego la condición 00:15:28
y luego esta otra 00:15:30
y ahora aquí ya 00:15:36
lo que sea 00:15:40
luego el código de la izquierda 00:15:41
y el código de la derecha 00:15:48
hacen exactamente lo mismo 00:15:49
hacen lo mismo 00:15:51
pero aquí está como más compacto 00:15:52
está más bonito 00:15:56
y este es el uso habitual 00:15:57
de un bucle for 00:16:02
el uso habitual 00:16:03
escribir un bucle 00:16:06
que sabemos que se va a ejecutar 00:16:10
exactamente lo que yo ponga aquí 00:16:12
que yo quiero un bucle que se ejecute 00:16:14
exactamente 10 veces 00:16:16
pongo esto, con n igual a 10 00:16:17
si quiero un bucle que se ejecute exactamente 15 veces 00:16:20
pongo esto, con n igual a 15 00:16:23
¿el que? 00:16:25
la llave 00:16:27
Bueno, sí, quería ponerla que se abriera 00:16:28
¿Vale? 00:16:31
Dime 00:16:33
No, no es tercera condición, es sentencia 00:16:33
Sí, y más más 00:16:37
Que es esta misma que va aquí 00:16:39
¿Vale? 00:16:40
Pues es el uso habitual 00:16:48
Que programa que lee 00:16:49
30 números 00:16:52
Pues lo metemos en un for desde i igual a 0 00:16:53
Mientras i sea menor que 30, incrementando i 00:16:57
Leo número y hago lo que sea con él 00:16:59
¿Vale? 00:17:01
En lugar de hacer esto 00:17:02
primero hago la sentencia, aquí la voy incrementando 00:17:03
pues escribimos esto y ya está 00:17:06
que es más 00:17:08
cómodo 00:17:10
pero eso sí, el uso que se le 00:17:11
puede hacer de estos campos 00:17:14
es el que a uno le dé la gana 00:17:16
pero claro 00:17:18
la idea es simplificar, o sea no meter aquí 00:17:19
un montón de código que se hacía al principio 00:17:22
lo pongo antes y ya está 00:17:24
o no poner aquí un montón de sentencias 00:17:26
porque eso se me estira y queda un montón de lío 00:17:28
para eso las pongo aquí y se ve más 00:17:30
claro, la idea es no hacer 00:17:32
aquí un lío 00:17:34
este es su uso habitual 00:17:35
pero aquí se puede meter cualquier condición 00:17:37
aquí cualquier 00:17:40
sentencia, aquí también 00:17:41
vale 00:17:43
escribirlo así 00:17:46
en lugar de así 00:17:49
tiene una ventaja añadida 00:17:51
primero lo claro que parece que se ve 00:17:53
¿no? 00:17:56
la ventaja añadida es que mirad 00:17:57
esta declaración 00:17:59
es decir, todo esto 00:18:02
es una declaración 00:18:04
a la vez que una asignación 00:18:06
vale, pero la declaración 00:18:07
está hecha en los paréntesis 00:18:10
¿eso qué significa? 00:18:12
que esta variable i 00:18:15
dura solo 00:18:16
solamente está viva, solo existe 00:18:18
el tiempo que se ejecute este for 00:18:20
sin embargo aquí 00:18:22
esta variable i va a estar 00:18:24
ya viva todo el programa 00:18:26
con lo cual hay un nombre 00:18:28
de variable i 00:18:30
que ya está ahí 00:18:31
molestando para siempre. 00:18:33
¿Vale? Repito. 00:18:38
Un segundo. Cuando declaramos una variable, 00:18:39
por ejemplo, haciendo esto, ya sabemos 00:18:42
lo que pasa. 00:18:44
¿Qué hacemos? Que de repente aparece un espacio en memoria. 00:18:46
¡Pum! Aparece. Del tamaño que toque. 00:18:48
En este caso, 32 bits. 00:18:50
A ese espacio en memoria se le da un nombrecito. 00:18:52
El que yo ya he puesto aquí. 00:18:55
Y luego, además, si hay una asignación, 00:18:56
si además la hay, pues se asigna. 00:18:58
Todo esto pasa. 00:19:00
Vale, pues en esta versión del código, cuando hemos hecho esta declaración, pum, este espacio ha aparecido bajo el nombre i y ese espacio se queda para siempre, ya está, todo el programa ahí se queda, con lo cual este nombrecito i va a estar accesible en cualquier punto del programa, incluso 200 líneas más abajo, donde ya ni nos acordábamos de que había una variable i porque solo servía para esto, que es una cosa muy puntual. 00:19:01
entonces no deja de ser una molestia 00:19:30
el tener esa caja ahí 00:19:32
que yo solamente la quería 00:19:33
como contador de este bucle 00:19:35
no deja de ser una molestia 00:19:37
vale, pues al meterla aquí 00:19:38
en estos paréntesis 00:19:41
esta caja pum 00:19:43
que de repente ha aparecido y se ha abierto 00:19:46
cuando 00:19:48
se ha hecho aquí la declaración 00:19:49
cuando el bucle termina 00:19:51
esta caja desaparece 00:19:53
vale, solo está viva 00:19:56
solo vive y solo está accesible 00:19:58
Dentro del bucle, solo dentro 00:19:59
Solo dentro, fuera ya no 00:20:02
Fuera ya no hay variable ing 00:20:04
Y nada 00:20:06
Porque está declarada aquí dentro 00:20:06
¿Vale? 00:20:09
¿En el while? 00:20:10
¿En el dentro del? 00:20:12
¿Puede declarar dentro del while una variable? 00:20:19
¿Aquí? 00:20:22
No, ¿vale? 00:20:23
No, no, no, eso es 00:20:27
Lo siguiente con lo que a raíz de esto 00:20:29
Me quería meter, el ámbito de variables 00:20:31
Lo que pasa es que en este caso en concreto 00:20:33
no la podrías declarar dentro del este 00:20:35
porque si no la condición no la vería 00:20:37
para esta situación en concreto es que no la podrías 00:20:39
declarar dentro 00:20:41
entonces ahora 00:20:42
vamos por partes 00:20:44
entendéis la diferencia 00:20:46
de situaciones 00:20:49
entonces esto nos lleva 00:20:50
precisamente a lo que apuntas tú 00:20:53
que las variables 00:20:55
nosotros hemos asumido hasta ahora 00:20:56
que desde el momento en que las declaras 00:20:59
aparecen 00:21:01
y ya están ahí 00:21:03
vivas en memoria RAM 00:21:05
para siempre con su nombre, todo el 00:21:06
programa. Eso 00:21:08
podría llegar a ser una molestia porque 00:21:10
las variables a lo mejor yo las uso solo 00:21:13
en un trocito de código 00:21:14
y no quiero esa caja ahí abierta con ese 00:21:16
nombre el resto del programa. Puede ser 00:21:18
una molestia primero de ocupación 00:21:20
de RAM innecesaria 00:21:22
y luego que al final pues hay un montón de nombres 00:21:24
que yo los puedo usar 00:21:26
por error y se refiere a una variable 00:21:28
que he declarado docente a líneas más arriba. 00:21:30
Entonces nos gustaría alguna 00:21:33
manera de acortar 00:21:34
la vida de las variables y que sólo 00:21:36
existan durante el tiempo 00:21:38
el trozo de código en el que me interesa 00:21:40
usarlas. ¿Se puede hacer 00:21:42
eso? Sí. ¿Gracias a qué? 00:21:44
Gracias a la existencia 00:21:47
de lo que 00:21:48
hemos mencionado que se llama 00:21:49
bloques de código, que son 00:21:52
trozos de código entre llaves. 00:21:54
Entonces, esto que voy a 00:21:57
mencionar ahora a raíz de lo del FOR 00:21:58
es lo que llamamos 00:22:00
ámbito 00:22:02
de las variables 00:22:03
el ámbito de las variables 00:22:05
el trozo de código 00:22:10
en el que están vivas y son accesibles 00:22:12
el ámbito de las variables 00:22:14
la porción de código 00:22:20
en el que existen y son accesibles 00:22:23
claro, por su nombre 00:22:32
en el que existen y digamos 00:22:34
que y por tanto 00:22:42
son accesibles, claro 00:22:43
por su nombre 00:22:45
si no existen lógicamente no pueden ser accesibles 00:22:47
bueno pues como controlamos 00:22:50
esto del ámbito de las variables 00:22:55
que ámbito tiene una variable 00:22:57
como sé yo 00:22:59
en que porción de código está viva 00:23:01
y en que porción de código no está viva y por tanto 00:23:03
no es accesible o no existe 00:23:05
bueno pues esto está estrechamente 00:23:07
relacionado con lo que 00:23:10
hemos llamado bloques de código 00:23:12
que son troces de código entre llaves 00:23:13
entonces nosotros ya al hacer 00:23:15
if for while 00:23:17
ya hemos hecho programas 00:23:19
que habrían muchos bloques de código 00:23:21
por ejemplo 00:23:23
nuestro programa 00:23:25
siempre está dentro de un main 00:23:26
eso sí o sí 00:23:28
eso ya lo sabemos 00:23:30
está dentro de un main 00:23:32
pues siempre, obligatoriamente 00:23:33
siempre hay un primer bloque de código gordote 00:23:36
que es 00:23:39
el que engloba todo 00:23:40
este es el primer bloque de código 00:23:42
el más gordo, el que lo engloba todo 00:23:44
¿vale? que es mi programa en sí 00:23:46
mi programa es todo un bloque de código muy grande 00:23:48
que está comprendido 00:23:50
entre las llaves del main, ¿vale? 00:23:52
esto es un bloque de código 00:23:54
por ejemplo, llamémosle bloque 1 00:23:55
es un bloque de código, ¿vale? 00:23:58
ahora, yo aquí 00:24:01
dentro de este bloque, puedo declarar 00:24:02
variables 00:24:04
por ejemplo, int 00:24:04
any, ¿vale? 00:24:08
pues esta variable 00:24:10
por estar declarada 00:24:12
dentro de este bloque de código 00:24:14
va a ser visible, accesible, 00:24:16
va a existir todo el bloque entero. 00:24:20
Es decir, una variable existe 00:24:24
en todo el código, 00:24:26
en todo el bloque, perdón, 00:24:29
en todo el bloque en el cual se ha declarado. 00:24:31
Entonces, como int n se ha declarado en el main, 00:24:33
existe en todo el main. 00:24:37
Si yo hago 10.000 líneas 00:24:39
y ahora en la última de todos hago n igual a 100, 00:24:41
ningún problema porque n sigue existiendo ahí 00:24:44
n existe en todo el bloque 00:24:47
por muy largo que sea 00:24:49
vale, pero ocurre 00:24:50
que dentro de un bloque puede abrirse 00:24:53
otro 00:24:55
por ejemplo, mi programa puede 00:24:56
tener aquí a lo mejor una condición 00:24:59
y aquí en esta condición 00:25:01
se me abre otro bloque 00:25:04
vale, en esta 00:25:05
condición, como 00:25:11
tiene un if con varias sentencias 00:25:13
o solo con una 00:25:15
pero yo le puedo poner llaves 00:25:17
pues aquí 00:25:18
se ha abierto otro bloque 00:25:20
llamémosle a este 00:25:22
bloque 2 00:25:25
entonces los bloques son jerárquicos 00:25:26
unos están contenidos dentro de otros 00:25:29
igual que dentro del if 00:25:31
podría haber otro if 00:25:33
podría haber otro if con otra condición 00:25:35
que abriera otro bloque dentro 00:25:37
podría perfectamente 00:25:40
entonces este programa tendría 00:25:41
tres bloques, el bloque 3 00:25:43
que es el código entre estas llaves 00:25:46
del if, que estaría a su vez 00:25:48
contenido dentro del bloque 2 00:25:50
y el bloque 2 a su vez estaría 00:25:52
contenido en el bloque 1 que es el 00:25:54
grandote 00:25:56
bueno pues 00:25:56
dentro de cada bloque yo puedo 00:25:59
declarar variables, las puedo declarar donde me 00:26:02
dé la gana por supuesto 00:26:04
bueno pues a lo mejor dentro de este bloque yo he declarado 00:26:05
una variable m 00:26:08
bueno pues esta variable m como está 00:26:09
declarada en este bloque con estas 00:26:13
llaves, solo existe 00:26:15
en el trozo 00:26:18
de código correspondiente a este bloque 00:26:19
solo existe ahí 00:26:21
cuando este código 00:26:22
ya ha terminado, porque ya se ha ejecutado 00:26:25
la rama del ir, aquí 00:26:27
ya m no existe, y si yo intentara 00:26:29
después de este bloque, hacer m 00:26:31
igual a 100, me diría 00:26:33
el compilador en particular 00:26:35
me dice m is not visible, me diría 00:26:37
eso, ¿qué significa? m no 00:26:39
existe, ¿quién es m? claro que 00:26:41
no existe, porque m 00:26:43
Al estar declarada, recordad que es tener el tipo puesto delante, que es el momento en el que aparece la variable. 00:26:45
Pues al estar declarada en este bloque, durante todo el bloque yo la puedo usar para hacer cosas. 00:26:52
Pero cuando el bloque ha terminado, esa ha desaparecido. 00:26:59
Entonces, ¿esto qué nomenclatura tiene? 00:27:06
Pues bueno, se dice que esta variable M es local a este bucle. 00:27:12
una variable se dice que es 00:27:16
local a un bloque 00:27:19
es local a un bloque porque 00:27:21
solamente funciona 00:27:23
dentro de ese bloque 00:27:26
es una variable local de ese bloque 00:27:27
está localizada en ese bloque 00:27:29
es una variable local de ese bloque 00:27:31
entonces yo puedo 00:27:33
jugar con donde declaro las variables 00:27:38
podría hacer un código 00:27:41
en el cual todas las declaro aquí arriba 00:27:43
todas, muy bien, no pasa nada 00:27:45
están todas aquí arriba, pero hombre 00:27:47
tengo durante todo el programa 00:27:49
tengo un montón de variables que no estoy 00:27:51
utilizando, entonces lo 00:27:53
ideal es declarar 00:27:55
las variables en el bloque 00:27:56
más pequeño posible 00:27:58
si yo esta variable m 00:28:00
solo la utilizo aquí porque es una variable 00:28:02
para hacer cositas que solo se hace aquí 00:28:05
pues la declaro aquí 00:28:07
¿para qué la voy a declarar aquí arriba? 00:28:08
esta variable 00:28:11
¿para qué la voy a declarar aquí? 00:28:11
si solo la uso en este bloque de list 00:28:14
para que esté ya la m viva 00:28:16
todo el rato ahí ocupando 00:28:18
memoria, pues no, la declaro 00:28:21
aquí dentro y ya está 00:28:23
¿vale? bueno pues 00:28:24
tenemos por tanto 00:28:29
que saber dos cosas, una 00:28:32
principio básico de programación 00:28:33
cuanto más locales 00:28:35
sean las variables mejor, porque van a existir 00:28:37
solo el tiempo que es necesario 00:28:40
¿vale? entonces yo selecciono 00:28:41
el código más pequeño en el que es obligatorio 00:28:44
que estén, claro 00:28:46
eso por un lado, y luego 00:28:46
quedémonos con ese error 00:28:49
cuando el compilador me dice 00:28:52
oye, esta variable no es visible 00:28:53
cuando me diga que esta variable no es visible 00:28:55
rápidamente conectamos 00:28:58
a esto, ah, es que la he declarado 00:29:00
en un bloque pequeño 00:29:02
y la tengo que sacar y declarar al bloque 00:29:04
de arriba, porque la estoy usando 00:29:06
aquí, entonces cuidado 00:29:08
que la he declarado en un bloque demasiado pequeño 00:29:10
saquemosla y declarémosla fuera 00:29:12
para poder acceder yo aquí 00:29:14
esas son las dos cosas esencialmente 00:29:15
con las que tenemos que quedarnos por ahora 00:29:19
en relación con el ámbito de las variables, ¿vale? 00:29:22
Vamos a verlo con ejemplos. 00:29:29
Vale, pues, a ver. 00:29:57
En el proyecto de ejemplo de bucles, 00:30:04
que volveré a subir, 00:30:07
pues vamos a poner ejemplo de for. 00:30:08
Vale, pues, por ejemplo, 00:30:29
Vamos a leer 10 números decimales 00:30:31
Por ejemplo 00:30:38
Podrían decirme leer 10 números decimales 00:30:39
Para hacer lo que sea 00:30:42
Vale, entonces yo tengo que hacer 10 veces 00:30:43
Esto de leer el numerito, ¿verdad? 00:31:05
Tengo que hacer 10 veces esto 00:31:08
Vale, pues entonces 00:31:10
Desde el momento en que sé exactamente 00:31:12
Las veces que tengo que hacer algo 00:31:13
Pues ya me puedo hacer un bucle for directamente 00:31:15
con esta sintaxis 00:31:19
por ejemplo, este podría ser 00:31:20
nuestro numerito 00:31:35
vale, pues ya está 00:31:36
esta es la sintaxis 00:31:53
del for 00:31:55
¿verdad? entonces lo vamos a leer 00:31:57
vale, y esto se ejecutará 00:31:59
a ver, voy a ponerle 3 para no tener que meter 00:32:21
10 números 00:32:23
le pongo 3 00:32:24
y este bucle 00:32:27
se va a ejecutar exactamente 3 veces 00:32:29
esto ya es que 00:32:32
la lectura ya no es muy natural 00:32:33
porque esto significará, arrancando con i igual a 0 00:32:35
y mientras i sea menor que 3 00:32:40
e incrementando i en una unidad cada vez 00:32:42
pues hace esto, eso que significa 00:32:45
ejecútate 3 veces, si empiezas en 0 00:32:48
te incrementas en una unidad cada vez y mientras i sea menor que 3 00:32:51
pues se ejecutará 00:32:55
para i igual a 0, 1 y 2 00:32:58
¿vale? entonces 00:33:00
aquí dentro 00:33:03
podemos mostrar 00:33:09
la variable i tranquilamente si queremos 00:33:11
porque la variable i 00:33:15
la hemos declarado aquí dentro 00:33:17
y es una variable que existe y es accesible 00:33:20
dentro de este código sin ningún problema 00:33:23
¿no? por ejemplo este for me va a decir 00:33:25
número 0 00:33:29
y luego me pide el número 00:33:31
número 1, número 2 00:33:33
porque irá valiendo primero 0 00:33:35
luego 1 y luego 2 00:33:37
¿verdad? mi variable i 00:33:38
la primera vez vale 0, la siguiente vale 1 00:33:40
la siguiente vale 2 00:33:43
y mi variable i yo la podría 00:33:43
tocar aquí dentro y hacer con ellas 00:33:47
mil cosas, bueno primero vamos a 00:33:48
probar esto por si 00:33:51
hemos escrito algo mal 00:33:53
el número 0, pues este 00:33:54
el número 1, este 00:34:00
el número 2, este y ya está 00:34:02
tres veces y acabó 00:34:04
tres veces y acabó 00:34:08
vale 00:34:09
la variable i 00:34:10
yo aquí puedo hacer con ella lo que me dé la gana 00:34:13
es una variable más que está declarada 00:34:15
en este bloque 00:34:17
es una variable más 00:34:17
por ejemplo 00:34:20
¿qué podríamos hacer aquí para convertir a este 00:34:23
bucle en un bucle infinito que no acabará nunca? 00:34:26
¿qué sentencia puedo poner ahí? 00:34:29
no, aquí mismo 00:34:34
en donde yo estoy situada en este 00:34:35
¿qué sentencia me sugerís 00:34:36
para convertir este bucle en infinito? 00:34:39
aquí, como última línea de código 00:34:41
aquí 00:34:43
¿qué podría escribir? 00:34:44
claro, si la vuelvo a bajar otra vez 00:34:50
entonces no avanzo 00:34:52
porque i se va incrementando 00:34:53
en cada iteración, pero yo aquí la vuelvo 00:34:56
a bajar, con lo cual i no avanza 00:34:58
jamás va a llegar a 3 00:35:00
entonces este bucle 00:35:01
se convertiría en un bucle 00:35:02
ah bueno, es que le he metido 00:35:05
una letra en vez de un número 00:35:08
ahí se me queda hasta el infinito 00:35:10
¿vale? 00:35:14
entonces lo paro 00:35:17
Cuando tenéis un programa que no para, acordaos que el proceso lo podéis detener aquí, ¿vale? Porque hay veces que habéis lanzado un programa un montón de veces porque no le funciona y lo volvéis a lanzar, no lo volvéis a lanzar y tenéis un montón de procesos ejecutándose. 00:35:20
habéis lanzado un programa un montón de veces 00:35:38
y que el programa no termina 00:35:40
entonces 00:35:41
cuidado 00:35:43
para ver uno 00:35:45
los programas que tiene lanzados 00:35:47
si le dais aquí 00:35:50
por ejemplo 00:35:53
voy a lanzar 00:35:55
este no ha terminado porque es imposible 00:35:56
y sé que no ha terminado porque me aparece 00:35:58
esto en rojo 00:36:01
y podría lanzar otra vez 00:36:01
este 00:36:04
ala, otro lanjao que tengo aquí 00:36:04
Y digo, uy, he cambiado una cosa 00:36:08
He cambiado una cosa 00:36:12
Voy a poner dos puntos 00:36:14
Voy a volver a probarlo 00:36:15
Y lo lanzo otra vez 00:36:17
Otro, un tercer proceso que se está ejecutando 00:36:18
Hombre, evitemos esto 00:36:23
Vale, ahora mismo tengo tres procesos lanzados 00:36:26
¿Cómo podemos pararlos? 00:36:30
Este lo puedo parar así 00:36:33
Pero, si le vais dando aquí 00:36:34
A estas dos X de aquí 00:36:37
te van resucitando los otros que tenías ahí parados 00:36:39
o sea, que tenías ahí lanzados 00:36:42
ahora voy a parar este 00:36:44
¿tengo algún otro? uy, sí, tengo otro 00:36:45
ahora lo voy a parar 00:36:47
¿tengo algún otro? no, ya no tengo nada 00:36:49
¿vale? cuidado con cuando lanzáis 00:36:51
programas que tienen bucles infinitos 00:36:54
o lecturas a menú 00:36:56
y siguen ahí esperando 00:36:57
no tengáis mil ejecuciones lanzadas a la vez 00:36:58
porque llega un momento en que no sabéis en qué ejecución estáis 00:37:02
y creéis que estáis ejecutando 00:37:04
un código y estáis ejecutando otro 00:37:06
¿vale? 00:37:07
Entonces, dime, ¿puede haber cualquier cosa que sea una condición? Por ejemplo, imaginaos que el programa se modifica y me dicen ahora, introduce 10 números decimales, pero cuidado, si el número es 0, para. 00:37:11
No hagas más, o sea, 10 siempre y cuando sean diferentes de 0 00:37:59
¿Vale? Vamos a ponerlo aquí 00:38:02
Versión en la que introduzco 3 números 00:38:04
3 números decimales, pero si se introduce 0 se para 00:38:20
¿Vale? Entonces aquí van a ser 10, pero si es 0 para 00:38:29
Entonces podemos meter esto en esta condición 00:38:39
Entonces, por ejemplo, esta versión 00:38:41
Pues la podríamos hacer 00:38:47
con esto leemos los tres números 00:38:50
está claro, pero espérate 00:38:54
si el número 00:38:56
es cero 00:38:57
quiero parar, entonces la condición 00:39:00
para seguir, ahora la puedo 00:39:02
modificar para que sea 00:39:04
no solo si es menor que tres, sino que 00:39:06
tiene que ser menor que tres 00:39:08
y además 00:39:09
el número leído 00:39:11
que sea diferente de 00:39:13
cero 00:39:17
vale 00:39:18
entonces 00:39:20
aquí esta condición es más compleja 00:39:24
este bucle 00:39:28
se va a ejecutar 00:39:30
una vez, otra vez, otra vez 00:39:31
y así, mientras si sea menor que 3 00:39:34
pero también es obligatorio 00:39:36
que num sea diferente de 0 00:39:38
si en algún momento yo meto el número 0 ya se para 00:39:39
vale 00:39:42
aquí claro me sale el error 00:39:43
de compilación que me dice, oye num podría no tener 00:39:46
nada, no pasa nada 00:39:48
Lo vamos a inicializar a un valor cualquiera 00:39:50
Para forzarle a entrar en el bucle 00:39:52
Lo inicializamos a un valor cualquiera 00:39:56
Y así entra en el bucle 00:39:59
Entra la primera vez 00:40:01
Si no hemos terminado todavía 00:40:02
Y además num no es cero 00:40:07
Entra la segunda 00:40:09
Si todavía no hemos terminado 00:40:10
Y num sigue sin ser cero 00:40:14
Entra la tercera 00:40:16
Luego efectivamente en estos campos de aquí 00:40:17
Uno puede poner cualquier cosa que le interese 00:40:25
Para hacer lo que tiene que hacer 00:40:29
Por ejemplo, muchos de los enunciados que hemos hecho 00:40:31
Pues habrían sido a lo mejor más legibles 00:40:46
Más claros de hacer con un for 00:40:50
Pero en lugar de volver a hacer esos 00:40:52
Vamos a buscar alguno para hacerlo con un for 00:40:56
vale, por ejemplo 00:41:00
el 10 00:41:09
esto, el 9 y el 10 00:41:12
tenían ya que ver 00:41:14
con el concepto de acumulador, ¿verdad? 00:41:15
estos dos 00:41:19
estos tres primeros 00:41:20
eran una suma acumulativa 00:41:21
y este será 00:41:24
un producto acumulativo, que es lo que 00:41:26
dijimos ayer, que fuerais haciendo 00:41:28
vale, pues este primero 00:41:30
esto se tiene que hacer exactamente 00:41:32
10 veces, ¿el qué? el ir multiplicando 00:41:36
por un acumulador 00:41:38
pues venga, tratad de pensar el 10 00:41:39
de hacer el 10 con un 00:41:42
con un for, en lugar de, no sé si 00:41:44
lo habéis hecho o no, pero si 00:41:46
no lo habéis hecho, hacedlo 00:41:48
y en lugar de con un while, con un for 00:41:50
¿vale? idealmente 00:41:52
tanto el 9 como el 10, el que no lo haya hecho 00:41:54
que lo trate de hacer 00:41:56
pero en lugar de con un while, con un for 00:41:58
¿vale? el 9 y el 10, y ahora 00:42:00
antes de irnos lo... 00:42:02
Materias:
Programación
Niveles educativos:
▼ Mostrar / ocultar niveles
  • Formación Profesional
    • Ciclo formativo de grado superior
      • Primer Curso
Subido por:
Raquel G.
Licencia:
Todos los derechos reservados
Visualizaciones:
4
Fecha:
3 de noviembre de 2025 - 10:26
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
42′ 04″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
1.55

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid