Bucles (for)
Contents
Bucles (for)#
Important
¿Cómo vamos?
Hasta el momento debemos tener claro lo siguiente:
La iteración que veremos hoy es la iteración definida, en esta se repite un proceso para elementos alojados en una colección de objetos. El bucle que lo permite es for y funciona de la siguiente manera:
for objeto in colección_de_objetos:
instrucción_1
instrucción_2
...
instrucción_n
otras instrucciones
otras instrucciones
otras instrucciones
En las instrucciones dentro de for el valor de objeto varía conforme se vaya recorriendo la colección. Un ejemplo muy sencillo puede ser:
Lista=['Elemento_1','Elemento_2','Elemento_3']
print('Sentencia previa a iniciar el bucle.\n')
for Elemento in Lista:
print(' -> Instrucción inicial dentro del bucle para el:')
print(' ->',Elemento)
print(' ')
print(' -> Fin de la iteración\n\n')
print('Fin del bucle')
Sentencia previa a iniciar el bucle.
-> Instrucción inicial dentro del bucle para el:
-> Elemento_1
-> Fin de la iteración
-> Instrucción inicial dentro del bucle para el:
-> Elemento_2
-> Fin de la iteración
-> Instrucción inicial dentro del bucle para el:
-> Elemento_3
-> Fin de la iteración
Fin del bucle
La colección que recorre el for debe ser un elemento iterable. Hay elementos iterables que no son tan evidentes. Por ejemplo:
for i in 'Hola Mundo':
print(i)
H
o
l
a
M
u
n
d
o
El ejemplo anterior recorrió cada caracter de la cadena de caractéres, esta cadena se reconoce como elemento iterable, al respecto tenemos los siguientes tipos de datos:
Cadenas de caracteres
Listas
Tuplas
Conjuntos
Diccionarios
para saber si son iterables podemos utilizar la función iter():
iter('Hola')
<str_iterator at 0x7fca25f3b7c0>
si el resultado es de la forma <str_iterator at *****> el objeto es iterable. En otro caso obtenemos una excepción:
iter(20)
---------------------------------------------------------------------------
TypeError Traceback (most recent call last)
Input In [4], in <cell line: 1>()
----> 1 iter(20)
TypeError: 'int' object is not iterable
Aparte de los tipos de datos mencionados anteriormente en Python hay una gran cantidad de datos iterables, el método mencionado iter sobre el objeto lista es el que permite recorrer los elementos de una lista. De hecho podemos utilizarla de nuestra parte usando su complemento next(). Veamos:
Lista=['Elemento_1','Elemento_2','Elemento_3']
iterable=iter(Lista)
print(next(iterable))
print(next(iterable))
print(next(iterable))
Elemento_1
Elemento_2
Elemento_3
Si hacemos el siguiente next tendremos un problema:
next(iterable)
---------------------------------------------------------------------------
StopIteration Traceback (most recent call last)
/tmp/ipykernel_52973/1608679135.py in <module>
----> 1 next(iterable)
StopIteration:
print(iterable)
<list_iterator object at 0x7efcc26b9280>
Observemos el siguiente código, salvo por la excepción ¿Qué podríamos estar viendo?
Lista=['Elemento_1','Elemento_2','Elemento_3','Elemento_4','Elemento_5']
iterable=iter(Lista)
while True:
elemento=next(iterable)
print(elemento)
Elemento_1
Elemento_2
Elemento_3
Elemento_4
Elemento_5
---------------------------------------------------------------------------
StopIteration Traceback (most recent call last)
/tmp/ipykernel_52973/1291867402.py in <module>
2 iterable=iter(Lista)
3 while True:
----> 4 elemento=next(iterable)
5 print(elemento)
StopIteration:
Indiscutiblemente for recorre las listas ayudandose del iterador y la función next. StopIteration muestra el final del camino del for. Veremos a continuación unos elementos que son extremadamente útiles para trabajar con for.
Funciones útiles para trabajar con for#
range()#
range()es una función de Python que genera un elemento iterable que recorre un rango numérico, tenemos:
range(start, stop, step) ## start hace referencia al inicio del rango numérico,
## por defecto es 0.
##
## stop hace referencia el límite final del
## rango numérico, no se toca por el rango.
##
## step hace referencia al paso del rango,
##por defecto es 1.
Así si quiero la lista de los números del 1 al 10 escribo:
range(1,11)
range(1, 11)
para verificarlo, sabiendo que el rango numérico es iterable, escribimos:
for i in range(1,11):
print(i)
1
2
3
4
5
6
7
8
9
10
Si quiero la lista de los pares menores o iguales a 10 y mayores o iguales a 2 escribimos:
lista=range(2,11,2)
for i in lista:
print(i)
2
4
6
8
10
Si utilizamos help para entender como funcione range()tenemos:
help(range)
Help on class range in module builtins:
class range(object)
| range(stop) -> range object
| range(start, stop[, step]) -> range object
|
| Return an object that produces a sequence of integers from start (inclusive)
| to stop (exclusive) by step. range(i, j) produces i, i+1, i+2, ..., j-1.
| start defaults to 0, and stop is omitted! range(4) produces 0, 1, 2, 3.
| These are exactly the valid indices for a list of 4 elements.
| When step is given, it specifies the increment (or decrement).
|
| Methods defined here:
|
| __bool__(self, /)
| self != 0
|
| __contains__(self, key, /)
| Return key in self.
|
| __eq__(self, value, /)
| Return self==value.
|
| __ge__(self, value, /)
| Return self>=value.
|
| __getattribute__(self, name, /)
| Return getattr(self, name).
|
| __getitem__(self, key, /)
| Return self[key].
|
| __gt__(self, value, /)
| Return self>value.
|
| __hash__(self, /)
| Return hash(self).
|
| __iter__(self, /)
| Implement iter(self).
|
| __le__(self, value, /)
| Return self<=value.
|
| __len__(self, /)
| Return len(self).
|
| __lt__(self, value, /)
| Return self<value.
|
| __ne__(self, value, /)
| Return self!=value.
|
| __reduce__(...)
| Helper for pickle.
|
| __repr__(self, /)
| Return repr(self).
|
| __reversed__(...)
| Return a reverse iterator.
|
| count(...)
| rangeobject.count(value) -> integer -- return number of occurrences of value
|
| index(...)
| rangeobject.index(value) -> integer -- return index of value.
| Raise ValueError if the value is not present.
|
| ----------------------------------------------------------------------
| Static methods defined here:
|
| __new__(*args, **kwargs) from builtins.type
| Create and return a new object. See help(type) for accurate signature.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| start
|
| step
|
| stop
enumerate()#
enumerate() crea una lista a partir del argumento que puede ser un elemento iterable en el cual cada elemento corresponde a una tupla que contiene un índice para el elemento y el elemento al que alude. En el siguiente script vemos como for permite desentrañar la función:
Lista=['Elemento_1','Elemento_2','Elemento_3','Elemento_4','Elemento_5']
for i in enumerate(Lista):
print(i)
(0, 'Elemento_1')
(1, 'Elemento_2')
(2, 'Elemento_3')
(3, 'Elemento_4')
(4, 'Elemento_5')
Podemos referenciar los elementos por separado desde el mismo for:
for i,j in enumerate(Lista):
print('El índice de', j, 'es', i,'\n')
El índice de Elemento_1 es 0
El índice de Elemento_2 es 1
El índice de Elemento_3 es 2
El índice de Elemento_4 es 3
El índice de Elemento_5 es 4
Es una herramienta muy útil cuando requerimos la posición del elemento.
break y continue en for#
Como en while podemos interrumpir el ciclo en for, usamos break y continue:
Lista=['Elemento_1','Elemento_2','Elemento_3','Elemento_4','Elemento_5']
for i in Lista:
if 'Elemento_3'==i:
break
print(i)
print('Bucle terminado.')
Elemento_1
Elemento_2
Bucle terminado.
Lista=['Elemento_1','Elemento_2','Elemento_3','Elemento_4','Elemento_5']
for i in Lista:
if 'Elemento_3'==i:
continue
print(i)
print('Bucle terminado.')
Elemento_1
Elemento_2
Elemento_4
Elemento_5
Bucle terminado.
else en for#
Igual que en while for puede trabajarse con else, su interpretación es similar:
FV = ['Papa', 'Limón', 'Cebolla', 'Arroz']
s = 'Chocolate'
for i in FV:
if i == s:
print(s, 'fue encontrado en la lista.')
break
else:
print(s, 'no fue encontrado en la lista.')
Chocolate no fue encontrado en la lista.
FV = ['Papa', 'Limón', 'Cebolla', 'Arroz','Chocolate']
s = 'Chocolate'
for i in FV:
if i == s:
print(s, 'fue encontrado en la lista.')
break
else:
print(s, 'no fue encontrado en la lista.')
Chocolate fue encontrado en la lista.
Cierre#
Hemos visto la iteración definida en Python, acabamos de recorrer listas y abrimos los ojos a nuevos algoritmos y formas de trabajar. Con eso completamos la revisión de estructuras de control fundamentales y según el teorema de Böhm–Jacopini ya podemos crear cualquier función computable.
Ejercicio 1#
Defina una lista con los días de este mes. Utilice el paquete datetime. Defina un algoritmo para determinar cuales de esos días hacen referencia a días de fin de semana.
Ejercicio 2#
Haga un algoritmo que identifoque los primeros 100 números primos.