1
00:00:05,060 --> 00:00:10,900
Bueno y continuamos con el curso vamos a ver ahora estructuras de iteración son las estructuras más

2
00:00:10,900 --> 00:00:11,630
usadas.

3
00:00:11,680 --> 00:00:17,980
Las estructuras de iteración nos van a permitir ejecutar una serie de instrucciones mientras se cumpla

4
00:00:17,980 --> 00:00:18,840
una condición.

5
00:00:19,000 --> 00:00:23,260
Entonces entra como una especie de loop de iteración.

6
00:00:23,260 --> 00:00:29,410
Por eso se le dice iteración donde se van a repetir pasos hasta que se cumple una condición llevado

7
00:00:29,410 --> 00:00:31,960
al día a día nuestro nosotros.

8
00:00:32,200 --> 00:00:38,980
De hecho cuando nos trasladamos de un lugar al otro y tenemos que llegar a una calle determinada a nuestro

9
00:00:38,980 --> 00:00:46,450
trabajo repetimos pasos y repetimos operaciones hasta que se cumple la condición de cuál es la condición

10
00:00:46,690 --> 00:00:49,480
que hemos llegado a nuestro lugar de trabajo.

11
00:00:49,480 --> 00:00:55,300
Cuando comemos repetimos las operaciones hasta que ya no tenemos más comida.

12
00:00:55,300 --> 00:01:00,550
Cuando leemos un libro lo leemos hasta que ya lo hemos terminado.

13
00:01:00,550 --> 00:01:08,290
Siempre estamos repitiendo tareas hasta que se cumple una condición o mientras se cumple una condición

14
00:01:08,590 --> 00:01:11,740
vamos a saber qué distintos tipos de iteración.

15
00:01:11,740 --> 00:01:21,610
Muy bien para eso tenemos que ir a loops loops nos permite usar unas estructuras vamos a empezar con

16
00:01:21,730 --> 00:01:28,720
ésta que es la estructura que teníamos cuando comenzamos con blocking y la van a ver la vamos a colocar

17
00:01:28,720 --> 00:01:37,990
aquí dentro Heldu y vamos a meter el print a introducir el print dentro de esta estructura de repetición

18
00:01:38,240 --> 00:01:39,160
o iteración.

19
00:01:39,220 --> 00:01:49,060
Fíjense que aquí me aparece una condición mientras o hasta esto significa repetí estás o repite estas

20
00:01:49,060 --> 00:01:55,910
instrucciones mientras ocurra una condición o hasta que se dé una condición.

21
00:01:56,050 --> 00:02:00,940
Entonces lo que va a hacer es repetir hasta que encuentra que la condición es verdadera.

22
00:02:00,940 --> 00:02:08,470
Muy bien vamos a ir por la primera lo que vamos a hacer aquí vamos a salir de vamos a sacar esto vamos

23
00:02:08,470 --> 00:02:16,420
a sacarlo de Count es menor temperatura no lo vamos a dejar lo que vamos a sacar aquí es esto aquí al

24
00:02:16,420 --> 00:02:22,990
no tener ninguna condición me dices si es verdadero lo va a ejecutar siempre no importa en realidad

25
00:02:22,990 --> 00:02:28,420
tendría que cambiar de estructura para que no tenga ni hablar ni Elan ni melhor pero no importa los

26
00:02:28,420 --> 00:02:36,490
efectos va a funcionar igual lo que vamos a hacer es que si count es menor a temperatura va a repetir

27
00:02:36,510 --> 00:02:43,600
es ahora qué es lo que va a hacer aquí vamos a hacer que esta instrucción esta condición la vamos a

28
00:02:43,600 --> 00:02:51,070
pasar al Huay aquí lo que vamos a colocar vamos a copiar esto para que nuestro IFF tenga algo y le vamos

29
00:02:51,070 --> 00:02:59,380
a decir que si count es igual a vamos a quitar esto lo quiero hacer en tiempo real no quiero que aparezcan

30
00:02:59,380 --> 00:03:05,230
en un capítulo donde ya está todo armado porque quiero que vean y no se pierdan ningún paso muy bien

31
00:03:05,440 --> 00:03:07,920
esto lo voy a duplicar y lo voy a colocar aquí.

32
00:03:08,050 --> 00:03:15,250
Entonces CTO Count en dos y luego preguntó si countless igualados va a ejecutar todo esto lo hago para

33
00:03:15,250 --> 00:03:18,210
que ahora ejecute siempre esto muy bien.

34
00:03:18,310 --> 00:03:27,340
Entonces lo que vamos a hacer aquí es además vamos a sacar esto vamos a venir a texto y le vamos a decir

35
00:03:27,460 --> 00:03:34,270
que me muestre la variable vamos a volver a nuestro programa y aquí lo que voy a hacer es arrastrar

36
00:03:34,750 --> 00:03:38,620
vamos a duplicar y le voy a decir que muestre.

37
00:03:38,890 --> 00:03:44,500
No quiero que muestre un texto quiero que muestre el valor de Kawa muy bien aquí va a repetir esto va

38
00:03:44,500 --> 00:03:50,980
a mostrarme siempre mientras sea menor a temperatura si yo ejecuto esto ahora voy a entrar en lo que

39
00:03:50,980 --> 00:03:57,500
se llama En programación un loop un loop es una iteración una repetición de la que no puedo salir nunca.

40
00:03:57,550 --> 00:03:58,360
Por qué.

41
00:03:58,360 --> 00:04:02,720
Porque va a estar evaluando siempre la condición y Koum siempre va a valer lo mismo.

42
00:04:02,720 --> 00:04:07,360
Bueno entonces para no entrar en loop qué es lo que voy a hacer voy a hacer que Koum se vaya incrementando

43
00:04:07,360 --> 00:04:13,840
en 1 para que en algún momento Koum no va a ser menor a temperatura porque va a empezar en dos.

44
00:04:13,840 --> 00:04:21,400
Luego va a ser 3 en algún momento va a pasar los 30 aquí vamos a colocar el valor de 10 por ejemplo

45
00:04:21,720 --> 00:04:26,490
para qué para que ahora cuando lo corra no esté tirando 30 veces.

46
00:04:26,500 --> 00:04:33,810
Muy bien vamos a colocar aquí antes o después del print la instrucción que me va a ir incrementando.

47
00:04:34,090 --> 00:04:41,470
Qué es lo que tengo que hacer vengo a variables elijo la del set set significa aceptar el valor de que

48
00:04:41,670 --> 00:04:43,310
Decoud en cuanto.

49
00:04:43,320 --> 00:04:52,480
Bueno aquí vengo a operación matemática y le digo que esto va a ser Knet agarrar Count lo voy a duplicar.

50
00:04:52,600 --> 00:04:58,930
Entonces voy a sestear Counts con qué valor con el valor que ya tenga Knet y le voy a agregar 1 sino

51
00:04:59,120 --> 00:05:07,390
si vemos aquí a la derecha hace exactamente eso es igual a más muy bien vamos a ejecutarlo me dice que

52
00:05:07,390 --> 00:05:12,070
Count vale 2 porque inicialmente los Septién 2 le doy a aceptar.

53
00:05:12,100 --> 00:05:20,240
Ahora vale 3 4 5 6 y así sucesivamente hasta que supera.

54
00:05:20,240 --> 00:05:28,120
Ahí le di todos los click hasta que supera los 10 que era el valor de temperatura no jebe no me los

55
00:05:28,120 --> 00:05:35,770
aceptó recién ahora ahí ya detectó que cuanto valía 10 Temperatura vale 10 entonces esta condición no

56
00:05:35,770 --> 00:05:37,120
se cumple por qué.

57
00:05:37,140 --> 00:05:44,620
Por qué Coupet no es menor la temperatura es igual a temperatura entonces cuando la variable Count llegó

58
00:05:44,620 --> 00:05:47,400
al número 10 se cae del Wyle.

59
00:05:47,440 --> 00:05:52,870
Y como no tiene ninguna instrucción más para ejecutar terminó en nuestro programa.

60
00:05:52,870 --> 00:05:58,700
Esto es lo que hace la estructura de repetición y es lo mismo que ponerle.

61
00:05:58,780 --> 00:06:04,020
Lo que va a hacer es ejecutar hasta que esta condición sea verdadera.

62
00:06:04,030 --> 00:06:05,620
Qué es lo que va a hacer en este caso.

63
00:06:05,620 --> 00:06:07,600
No no me va a mostrar nada.

64
00:06:07,600 --> 00:06:14,530
Vamos a ver lo ejecuto y no hace nada porque porque cuando ya entró en el repeat Counts ya es menor

65
00:06:14,530 --> 00:06:15,880
a temperatura.

66
00:06:15,880 --> 00:06:23,770
Entonces si evaluamos esto lo que me está diciendo es repita estas instrucciones hasta que CAM sea menor

67
00:06:23,770 --> 00:06:31,450
a temperatura pero cancha es menor a temperatura entonces ya tiene la condición por verdadera antes

68
00:06:31,450 --> 00:06:35,620
de entrar y nunca ejecuta estas instrucciones.

69
00:06:35,650 --> 00:06:39,000
Esto sería el positivo y el negativo.

70
00:06:39,130 --> 00:06:47,500
Muy bien vamos a ver otras estructuras por ejemplo tenemos otras estructuras el loops tenemos esta esta

71
00:06:47,530 --> 00:06:56,710
estructura ustedes la van a ver en algunos lenguajes como el ciclo for o como una hay pocos lenguajes

72
00:06:56,710 --> 00:07:04,360
que tienen esta estructura generalmente la tienen en lenguajes por ejemplo el lenguaje COBOL que tiene

73
00:07:04,360 --> 00:07:08,050
esto de ejecutar una instrucción n veces.

74
00:07:08,050 --> 00:07:11,610
Generalmente lo van a manejar con un con un ciclo for.

75
00:07:11,650 --> 00:07:18,490
Aquí está forma el ciclo Forth tiene tres parámetros primero qué variable va a usar y la inicializar

76
00:07:18,850 --> 00:07:20,810
en el valor que ustedes quieran.

77
00:07:21,010 --> 00:07:27,970
En este caso en cero luego separados por punto y coma hasta cuándo va a ejecutar lo que esté dentro

78
00:07:27,970 --> 00:07:29,240
del foro hasta que Kwame.

79
00:07:29,680 --> 00:07:36,970
Mientras que CAM mientras no hasta mientras que CAM sea menor a 10 y luego lo que tiene como tercer

80
00:07:37,270 --> 00:07:44,120
parámetro es que es lo que tiene que hacer con Count con Count lo tiene que sumar uno atrás del otro.

81
00:07:44,170 --> 00:07:51,550
Entonces va a ejecutar por primera vez Counts vale cero muy bien count es menor a 10 si muy bien va

82
00:07:51,550 --> 00:07:57,910
a ejecutar lo que coloquemos aquí adentro va a venir aquí y va a ejecutar la última parte.

83
00:07:57,910 --> 00:08:02,540
Le va a sumar 1 account vuelve a evaluar count es menor a 10.

84
00:08:02,560 --> 00:08:07,270
Ya esta parte la ejecuta al comienzo del foro y nunca más la ejecuta.

85
00:08:07,270 --> 00:08:07,660
Por qué.

86
00:08:07,650 --> 00:08:11,700
Porque esta es la parte donde inicia Liza la variable.

87
00:08:11,950 --> 00:08:19,930
Luego está siempre evaluando esto y cuando terminó de ejecutar todo ejecuta esto les suma 1 a la variable

88
00:08:19,940 --> 00:08:28,840
con cuánto vale uno es menor a 10 y entonces ejecuto suma 1 Count Count vale 2 es menor a 10 si y así

89
00:08:28,840 --> 00:08:30,700
va a ejecutar 10 veces.

90
00:08:30,700 --> 00:08:37,960
Por eso aquí la instrucción se llama repetir 10 veces qué es lo que voy a hacer.

91
00:08:37,990 --> 00:08:48,640
Voy a colocar esto aquí muy bien vamos a ejecutarlo me dice que vale dos porque porque estoy ejecutando

92
00:08:48,640 --> 00:08:58,600
CAM 3 4 5 6 7 8 9 10 11 y ahí no ejecuta más.

93
00:08:58,600 --> 00:09:07,060
Recuerden que aquí la evaluación era otra si era menor a temperatura nunca veíamos el número 10 nunca

94
00:09:07,060 --> 00:09:10,870
veíamos el número 11 veíamos hasta el número 9 por qué.

95
00:09:10,870 --> 00:09:16,890
Porque cuando CAM era igual a 10 no era menor la temperatura y se caía.

96
00:09:17,020 --> 00:09:21,790
En este caso va a ejecutar siempre 10 veces.

97
00:09:21,790 --> 00:09:26,300
Por eso Count que inician 2 termina mostrando un 11.

98
00:09:26,710 --> 00:09:33,820
Muy bien este es el repetir tantas veces una secuencia de instrucciones.

99
00:09:33,820 --> 00:09:40,780
Vamos a ver otro Loup por ejemplo aquí tenemos el CAM una variante de Count.

100
00:09:40,780 --> 00:09:43,090
Esta es otra variante del foro.

101
00:09:43,480 --> 00:09:50,230
Vamos a colocarlo aquí fíjense que hay dos for y aquí me permite Arlo más en detalle porque en realidad

102
00:09:50,590 --> 00:09:55,990
aquí no tengo ningún ninguna forma de modificar el comportamiento.

103
00:09:55,990 --> 00:09:59,300
Aquí dice ejecutar 10 veces y nada más.

104
00:09:59,440 --> 00:10:06,550
Pero aquí yo tengo forma de decirle por ejemplo cuando voy a sestear CAM le voy a decir que CAM va a

105
00:10:06,550 --> 00:10:12,990
arrancar por el número 5 y va a ir hasta 10 incrementándose en 1.

106
00:10:13,030 --> 00:10:21,250
Si yo quisiera hacer a la inversa quisiera ir que cuando valga primero 10 y vaya que vaya bajando su

107
00:10:21,250 --> 00:10:25,940
valor hasta el número 1 aquí en BAII tendría que poner menos 1.

108
00:10:25,960 --> 00:10:27,660
Entonces qué es lo que hace esto.

109
00:10:27,670 --> 00:10:34,220
Aquí voy a poner un 10 aquí voy a poner un 5 y aquí voy a mostrar esto.

110
00:10:34,330 --> 00:10:41,080
Esta instrucción no hace falta no hace falta porque no tengo que ir incrementando manualmente Count

111
00:10:41,140 --> 00:10:43,800
porque ya lo hace este foro.

112
00:10:43,970 --> 00:10:51,910
Aquí yo ya le voy diciendo que Count arranca valiendo 10 va a terminar valiendo 5 y para que eso ocurra

113
00:10:51,910 --> 00:10:57,670
tengo que ir incrementando lo menos uno o sea bajando su valor en menos 1.

114
00:10:57,790 --> 00:11:04,920
Si yo quisiera ir saltando de 5 en 5 aquí le colocaría al menos cinco y un primero valdría 10.

115
00:11:04,930 --> 00:11:11,830
Luego valdría 5 y luego terminaría la ejecución de esta iteración.

116
00:11:11,830 --> 00:11:23,350
En este caso vamos a ver vamos a ejecutarlo y me dice que primero vale 10 ahora vale 9 ahora 8 7 6 5

117
00:11:23,470 --> 00:11:25,150
y terminó la ejecución.

118
00:11:25,150 --> 00:11:25,600
Por qué.

119
00:11:25,600 --> 00:11:28,830
Por qué le dije que comience con 10.

120
00:11:28,840 --> 00:11:34,400
Pero cuando llegó a 5 ya terminó la ejecución de lo que tengo aquí.

121
00:11:34,660 --> 00:11:41,850
Bueno vamos a ver otra estructura de iteración esta estructura es muy importante y la vamos a ver es

122
00:11:41,850 --> 00:11:50,050
el for each el Fortich me permite iterar por cada elemento que encuentra en una lista de elementos tenemos

123
00:11:50,050 --> 00:11:54,400
que crear nuestra lista para crear nuestra lista primero vamos a ver que es una lista una lista es un

124
00:11:54,400 --> 00:12:01,330
conjunto de elementos un conjunto de elementos en los lenguajes de programación se conocen como vectores

125
00:12:01,630 --> 00:12:09,100
también como listas también se conocen como mapas en realidad pueden haber uno o el otro porque cada

126
00:12:09,100 --> 00:12:12,070
uno tiene su característica determinada.

127
00:12:12,070 --> 00:12:17,800
Vamos a crear una simple lista de elementos por ejemplo de frutas vamos a venir a nuestras variables

128
00:12:17,830 --> 00:12:25,420
vamos a decirle que vamos a sestear una nueva variable esa nueva variable va a ser de tipo lista vamos

129
00:12:25,420 --> 00:12:33,370
a crear una lista con elementos fijense que aquí me crea una variable llamada M la voy a llamar lista

130
00:12:33,640 --> 00:12:41,950
una variable lista que tiene por ahora tres elementos yo voy a agregarle textos a esos elementos voy

131
00:12:41,950 --> 00:12:48,430
a crear uno aquí voy a duplicarlo voy a crear otro elemento de la lista y vamos a agregar tres frutas

132
00:12:49,000 --> 00:12:51,190
aquí lo vamos a llamar peras.

133
00:12:51,190 --> 00:12:55,710
Aquí lo vamos a llamar manzanas y aquí lo vamos a llamar bananas.

134
00:12:55,870 --> 00:13:03,640
Muy bien tenemos aquí nuestra lista de tres frutas y lo que hace esta iteración Fortich es vamos a decirle

135
00:13:03,970 --> 00:13:11,920
que vamos a iterar aquí vamos a duplicar esto lo colocamos aquí aquí en lugar de Count elegimos lista

136
00:13:12,010 --> 00:13:19,000
y le decimos que por cada elemento a cada elemento lo vamos a llamar M es una variable que la crea en

137
00:13:19,000 --> 00:13:27,040
el momento por cada elemento al cual vamos a llamar a ese elemento con el nombre M en la lista llamada

138
00:13:27,040 --> 00:13:34,990
lista vamos a ejecutar una instrucción en este caso vamos a duplicar o vamos a hacer un print por pantalla

139
00:13:35,060 --> 00:13:36,740
y qué es lo que vamos a mostrar.

140
00:13:36,820 --> 00:13:39,670
Vamos a hacer la muestra de M.

141
00:13:39,790 --> 00:13:47,850
Ahora lo voy a acomodar y se los voy a muy bien vamos a repasar creé una lista con tres elementos un

142
00:13:47,840 --> 00:13:51,860
arreglo de tres elementos llamado peras manzanas y bananas.

143
00:13:51,860 --> 00:13:57,010
Muy bien y luego voy a iterar por cada elemento de esa lista.

144
00:13:57,050 --> 00:14:04,220
Como hay tres elementos va a ejecutarlo tres veces si hubiera 20 elementos va a ejecutar 20 veces cada

145
00:14:04,220 --> 00:14:08,360
elemento de mi lista lo va a grabar en una variable.

146
00:14:08,480 --> 00:14:17,510
Fíjense que aquí lo hacen una variable en una variable que la crea dentro del EUFOR llamada M Esa variable

147
00:14:17,750 --> 00:14:25,070
esa variable es elemento me lo va a mostrar por pantalla vamos a correrlo y me muestra primero el elemento

148
00:14:25,070 --> 00:14:30,380
peras luego el elemento manzanas y luego el elemento bananas.

149
00:14:30,380 --> 00:14:35,000
Todo esto conforma las estructuras de iteración.

150
00:14:35,010 --> 00:14:37,150
Espero que lo hayan entendido.

151
00:14:37,160 --> 00:14:43,670
Vamos a ir practicando y sobre todo vuelvo a repetirlo todo esto lo vamos a hacer en lenguajes reales

152
00:14:43,670 --> 00:14:50,560
así que vamos al próximo capítulo y seguimos aprendiendo a programar de manera básica.
