Estructuras de control selectivo y repetitivo

(programación estructurada)

Operaciones o expresiones lógicas:

Una operación o expresión lógica es aquella que al ser evaluada su resultado será un valor
booleano ( Verdadero (True) o Falso (False)). En python las expresion lógicas se construyen
usando operadores relacionales y operadores o conectores lógicos.

operadores relacionales:
mayor: >

menor: <

mayor o igual: >=

menor o igual: <=

comparacion: ==

diferente: !=

operadores lógicos:
Y: and

O: or

NO: not

#ejemplos de expresiones lógicas:

exp1= 5>6 #5 es mayor a 6

print(exp1)

exp2= 2==2 #2 es igual a 2

print(exp2)

exp3= 3>=4 and 3<=10 #3 es mayor o igual a 4 y 3 es menor o igual a

10
print(exp3)

exp4= 4<=10 or 20<90 #4 es menor o igual a 10 o 20 es menor a 90

print(exp4)

exp5= not(5!=6) #no es cierto que 5 sea diferente de 6

print(exp5)

False
True
False
True
False

El resultado de una expresión lógica es un valor de tipo booleano:

print(type(3>8))

x= 4!=5 and 7>9

print(type(x))

<class 'bool'>
<class 'bool'>

Estructura de control: if... elif... else

En programación, una estructura de control selectivo permite controlar el flujo de un programa
en función de una condición. Esta condición se realiza combinando la instrucción if con
expresiones u operaciones lógicas.

Sintaxis de una estructura de decisión simple:

if expresion:
bloque de instrucciones

La instrucción if evalua la expresión, la cual retornará True o False. Si el resultado es True, se

ejecutará el bloque definido debajo de los : , dicho bloque debe estar sangrado a la derecha
(segun el estandar, 4 espacios (un TAB)).

#ejemplo: usando estructuras de decisión simple:

num = int(input("Ingrese un número: "))

# Operador de relación (>)

if num>5:
print(f"{num} es mayor que 5")

# Operador aritmetico (%) y operador lógico (==)

if num%2==0:
print("{} es par".format(num))
Ingrese un número: 34
34 es mayor que 5
34 es par

Importante recalcar que el bloque de instrucciones que se va a ejecutar debajo de los : debe
estar sangrado a la derecha. Si una de las instrucciones del bloque no esta sangrada, se
considerará fuera del bloque.

Ejecute la siguiente celda y observe la excepción generada (IdentationError).

num = int(input("Ingrese un número: "))

if num % 5 == 0:
if num >6:
print("{} esta en el rango 0 a 25")
print("{} es multiplo de 5".format(num))
print("Fin de programa")

Cell In[7], line 4

if num >6:
^
IndentationError: expected an indented block after 'if' statement on
line 3

Se puede incluir la instrucción else para considerar la opción caso contario o sino en la
estructura de control: (estructura de decisión doble)

if expresion:
bloque de instrucciones
else:
bloque de instrucciones

#ejemplo: usando estructuras de decisión doble:

num = int(input("Ingrese un numero entero: "))

if num < 5:
print(f"{num} es menor que 5")
else:
print(f"{num} es mayor que 5")

if num % 2 == 0:
print(f"{num} es par")
else:
print(f"{num} es impar")

Ingrese un numero entero: 2

2 es menor que 5
2 es par
La función instance() permite evaluar si un dato es de un determinado tipo o no.
Dependiendo de la evaluación retornará True o False:

#ejemplos:

var1 = 12.5
print("¿var1 es de tipo float?:",isinstance(var1,float))

var2 = 100
print("¿var2 es de tipo str?:",isinstance(var2,str))

var3 = 2.6
print("¿var3 es de tipo int?:",isinstance(var3,int))

¿var1 es de tipo float?: True

¿var2 es de tipo str?: False
¿var3 es de tipo int?: False

#ejemplo: usando isinstance junto a la estructura if-else:

x = 3.45

if isinstance(x,int):
print("x es entero")
else:
print("x es no entero")

x es no entero

Así también, se puede incluir la instrucción elif para considerar otras posibles condiciones a
evaluar (estructura de decisión múltiple)

if expresion 1:
bloque de instrucciones
elif expresión 2:
bloque de instrucciones
elif expresión 3:
bloque de instrucciones
.
.
.
else:
bloque de instrucciones

#usando una estructura de decisión múltiple:

num = int(input("Ingrese un número entero: "))

if num < 0:
print("El número ingresado es negativo")
elif num < 10:
 print("El número ingresado es positivo de 1 dígito")
elif num < 100:
print("El número ingresado es positivo de 2 dígitos")
else:
print("El número ingresado es positivo de mas de 2 dígitos")

Ingrese un número entero: 44444

El número ingresado es positivo de mas de 2 dígitos

Como en cualquier lenguaje de programación se pueden incluír instrucciones if anidadas:

edad = int(input("Ingrese su edad: "))

if edad > 0:
if edad < 100:
if edad < 18:
print("Ud. es menor de edad")
else:
print("Ud. es mayor de edad")
else:
print("Edad no válida")
else:
print("Edad no válida")

Ingrese su edad: 909

Edad no válida

También se pueden combinar distintas formas de estructuras selectivas:

num = int(input("Ingrese un número entero: "))

print(f"\nPropiedades del número {num}:") if num < 0: print(f"* {num} es un número negativo")
else: print(f"* {num} es número positivo")

if num % 2 == 0: print(f"* {num} es un número par",end='') else: print(f"* {num} es un número

impar",end='')

if num % 3 == 0: print(" múltiplo de 3") elif num % 5 == 0: print(" múltiplo de 5") elif num % 7 ==
0: print(" múltiplo de 7")

if anidados versus if planos

Como se ha visto en los ejemplos anteriores, una estructura de control anidada consiste en una
cascada de condiciones, una dentro de la otra. De ser preferible y convenga, esta práctica se
debe evitar para mantener el código simple, utilizando conectores lógicos (and, or, not) entre
condiciones:
#ejemplo: evaluando si un número pertenece a un intervalo

num = float(input("Ingrese un número: "))

if num>=10:
if num<=20:
print("El número pertenece al intervalo [10,20]")
else:
print("El número no pertenece al intervalo [10,20]")
else:
print("El numero no pertenece al intervalo [10,20]")

Ingrese un número: 12.6

El número pertenece al intervalo [10,20]

También (para este caso) se puede obviar el conector and:

Ahora, usando conectores lógicos:

ejemplo: evaluando si un número pertenece a

un intervalo
num = float(input("Ingrese un número: "))

if num>=10 and num<=20: #se usa el conector lógico and print("El numero pertenece al
intervalo [10,20]") else: print("El numero no pertenece al intervalo [10,20]")

num = float(input("Ingrese un número: "))

if 10<=num<=20:
print("El numero pertenece al intervalo [10,20]")
else:
print("El numero no pertenece al intervalo [10,20]")

Ingrese un número: 56
El numero no pertenece al intervalo [10,20]

Otro ejemplo: Considere la evaluación de un año es bisiesto:

"Año bisiesto es el divisible entre 4 pero no entre 100, a excepción que sea divisible entre 400 "

Esto se puede expresar de la siguiente forma:

#usando if anidados:

año = int(input("Ingrese un año: "))

if año%4==0:
 if(año%100!=0):
print("El año es bisiesto")
else:
if(año%400==0):
print("El año es bisiesto")
else:
print("El año no es bisiesto")
else:
print("El año no es bisiesto")

Compare el programa anterior con el siguiente:

#ahora usando if plano:

anio = int(input("Ingrese un año: "))

#usando operadores lógicos: and, or

if anio%4==0 and (anio%100!=0 or anio%400==0):
print("El año es bisiesto")
else:
print("El año no es bisiesto")

Ingrese un año: 2024

El año es bisiesto

Plano es mejor que anidado...

Palabras reservada pass

numero=0

if numero == 0:
pass

Esto no hará absolutamente nada. La instruccion pass es simplemente un "continuar". Sin

embargo,el compilador no ignora esta sentencia como si lo hace con los comentarios. La palabra
pass sirve para marcar algo que se quiere hacer posteriormente en el programa.

#otro ejemplo:

num = 82

if num < 0:
#quite el pass y coloque la instrucción adecuada
pass
elif num > 100:
#quite el pass y coloque la instrucción adecuada
pass
elif num % 2 == 0:
 print("{} es par".format(num))
else:
print("{} es impar".format(num))

83 es impar

Si se retiran las instrucciones pass del programa anterior y no se reemplazan por ninguna
instrucción, dejará de funcionar (saldrá error). La instrucción pass por lo tanto permite ir
construyendo los bloques de decisión e ir resolviendo cada una de las condiciones poco a poco.

Función range
La función range genera un rango de datos enteros. Formalmente hablando, genera una
construcción conocida como generador, es decir algo que genera valores en línea que puede ser
iterado por un lazo de repetición (al respecto, más adelante). Tiene la siguiente sintaxis:
range(start, end, step):

• range(10) genera el rango de valores: 0, 1, 2, 3, 4, 5, 6, 7, 8, 9

(start=0,end=10,step=1)

• range(1, 10) genera el rango de valores: 1, 2, 3, 4, 5, 6, 7, 8, 9

(start=1,end=10,step=1)

• range(1, 10, 2) genera el rango de valores: 1, 3, 5, 7, 9

(start=1,end=10,step=2)

• range(1, 10, 4) genera el rango de valores: 1, 5, 9 (start=1,end=10,step=4)

• range(7, 1,-1) genera el rango de valores: 7, 6, 5, 4, 3, 2

(start=7,end=1,step=-1)

• range(8, 1, -2) genera el rango de valores: 8, 6, 4, 2 (start=8,end=1,step=-

2)
Note que se genera un rango de números que empieza en start, no se llega a tomar end , con
pasos de step. Si step es positivo el rango es creciente, caso contrario es decreciente.

Tenga en cuenta que la función range genera el tipo de dato range:

x=range(1,20) #x representa al rango 1,2,3,4,5,6,7,9,.......,19

print("valor de x:",x)
print("Tipo de x:",type(x))

valor de x: range(1, 20)

Tipo de x: <class 'range'>

r=range(10,100,10) #r representa al rango 10,20,30,40,50,60,70,80,90

print("valor de r:",r)
print("Tipo de r:",type(r))
valor de r: range(10, 100, 10)
Tipo de r: <class 'range'>

Palabra reservada in
La palabra reservada in se utiliza en Python para verificar si un elemento es parte de un
conjunto de datos o no, por ejemplo de un rango:

print("¿5 esta en el rango del 1 al 10?",5 in range(1,11))

print("¿8 esta en el rango del 1 al 7?",8 in range(1,8))
print("¿17 esta en el rango x?",17 in x)
print("¿0 está en el rango r?", 0 in r)

¿5 esta en el rango del 1 al 10? True

¿8 esta en el rango del 1 al 7? False
¿17 esta en el rango x? True
¿0 está en el rango r? False

Uso de la estructura try...except

Como se sabe, cuando se produce un error en la ejecución de alguna instrucción se generará una
excepción:

#ejemplo:

int("HOLA")

----------------------------------------------------------------------
-----
ValueError Traceback (most recent call
last)
Cell In[34], line 3
1 #ejemplo:
----> 3 int("HOLA")

ValueError: invalid literal for int() with base 10: 'HOLA'

Según el resultado anterior, dado que no se puede convertir "HOLA" a entero, saldrá una
excepción llamada ValueError

Por lo tanto, en el siguiente programa, si el usuario ingresa HOLA se producirá la excepción

ValueError en la línea 1, deteníendose la ejecución:

edad = int(input("Ingresa tu edad: "))

if edad>=0:
if edad<18:
print("Eres menor de edad")
else:
 print("Eres mayor de edad")
else:
print("La edad debe ser positiva")

Ingresa tu edad: 13
Eres menor de edad

Esta situación se puede controlar utilizando la estructura try...except:

try:
edad = int(input("Ingresa tu edad: "))
if edad<18:
print("Eres menor de edad")
else:
print("Eres mayor de edad")
except:
print("La edad debe ser un valor entero")

Ingresa tu edad: 245

Eres mayor de edad

En el programa anterior, al ingresarse el texto HOLA, se produce la excepción ValueError en la

línea 2, dicha excepción es capturada por el bloque try pasándose a ejecutar la instrucción del
bloque except (instrucción de la línea 8)

#otro ejemplo (la división entre 0):

5/0

----------------------------------------------------------------------
-----
ZeroDivisionError Traceback (most recent call
last)
Cell In[37], line 3
1 #otro ejemplo (la división entre 0):
----> 3 5/0

ZeroDivisionError: division by zero

Según el resultado anterior, dado que no se puede dividir entre 0, saldrá una excepción llamada
ZeroDivisionError

Observe ahora el siguiente programa:

try:
num = int(input("Ingrese un numero: "))
r = num/0 #acá se produce la excepción de ZeroDivisionError
print("r: {:.2f}".format(r))
except ValueError:
 print("El numero debe ser entero")
except ZeroDivisionError:
print("No se puede dividir entre 0")

Ingrese un numero: 67
No se puede dividir entre 0

En el programa anterior, si se produce un error (excepción) en alguna instrucción del bloque try
dicha excepción es capturada pasándose a ejecutar las instrucciónes del bloque except según
el tipo de la excepción. Si se utiliza la instrucción except sin especificar el tipo de excepción se
estaría definiendo un caso de error genérico.

Hay varias excepciones estandar usadas comunmente:

• IOError: Error al tratar de acceder a un archivo

• ValueError: Error durante la conversión de un tipo a otro
• EOFError: Error con el manejo de archivos (End Of File)
• ImportError: Error al momento de importar un modulo
• KeyboardInterrupt: Error por cancelar una operacion
• ZeroDivisionError: Error de división entre 0
• TypeError: Error en el tipo de dato durante una operación

El uso típico de un bloque try...except es el manejo de los errores en un programa sin tener que
recurrír a operaciones condicionales que evaluen todos los posibles casos de error. Si sucede un
error, la ejecución del programa irá directamente al bloque except: y aqui se pueden evaluar
directamente todos los errores posibles, lo que hace que el programa se vea ordenado y
robusto.

Estructura de control (lazo) for

La estructura for se conoce como un iterador: esto es, una construcción que toma un objeto
iterable y extrae los elementos que lo conforman uno a uno. Considere el código de la siguiente
celda:

print("Impresion de números pares: ")

for num in range(2,21,2): # para num: 2,4,6,8,......20, ejecuta:

print("* {}".format(num))

Impresion de números pares:

* 2
* 4
* 6
* 8
* 10
* 12
* 14
* 16
* 18
* 20

Como se observa en el resultado anterior, la instrucción for va extrayendo los datos del rango
(un iterable) y para cada valor ejecuta el bloque de instrucciones colocado debajo de los :. Esta
forma de operar de un lazo for permite tener un código legible ya que la lectura del código es
clara.

#otro ejemplo (lazos for anidados):

for j in range(1,11): #para j:1,2,3,4,5,6,7,8,9,10, ejecuta:

if j%2!=0:
car='-'
else:
car='*'
for i in range(1,j): #para i:1,....j, ejecuta:
print(car,end='')
print()

*
--
***
----
*****
------
*******
--------
*********

Estructura de control (lazo) while

La estructura while permite establecer un proceso repetitivo mientras una condición se
mantenga como verdadera. Por ejemplo:

a=1

while a<10: #mientras a sea menor a 10, ejecuta:

print(a)
a = a+2 #actualiza el valor de la vble. a

1
3
5
7
9
¿Qué sucederá si se elimina la línea a+=2?

Al ejecutar la celda el indicador de la misma mostrará [*] y el programa entrará en un "bucle

infinito" ya que la condición siempre será verdadera (el valor de a nunca será mayor o igual a 10).
En caso esto suceda, se debe reiniciar el "kernel", es decir, el núcleo de ejecución de Python,
seleccionando la opción Kernel > Restart en la barra de menús (parte de arriba)

Simulación del funcionamiento de un while:

Otro ejemplo:

a=1

while a<7:
if(a%2==0):
print("a","is even")
else:
print("a","is odd")
a+=1 #a=a+1

a is odd
a is even
a is odd
a is even
a is odd
a is even
Importante: Las estructuras while son ideales para establecer un lazo del que no se conoce el
número de iteraciones que se van a suceder, pero se conoce la condición que hará que este
proceso se mantenga. En cambio los lazos for son mas usados cuando de antemano se conoce el
número de iteraciones que se desea hacer.

La instrucción break
Las instrucción break permite alterar la ejecución de un lazo (detiene su ejecución de forma
inmediata). Considere el siguiente programa:

for num in range(1,20):

if(num%7==0):
print("{} es multiplo de 7".format(num))
break
else:
print("{} no es multiplo de 7".format(num))

1 no es multiplo de 7
2 no es multiplo de 7
3 no es multiplo de 7
4 no es multiplo de 7
5 no es multiplo de 7
6 no es multiplo de 7
7 es multiplo de 7

Podemos usar break junto a un while infinito para hacer una validación. El siguiente programa
pide un valor entre 1 y 10. Si se ingresa un valor fuera de este rango el programa continua
pidiendo el valor hasta que esté en el rango esperado:
while True: #se forma un lazo infinito
num = int(input("Ingrese un numero entre 1 y 10: "))

if num<1 or num>10:
print("Debe ingresar un numero entre 1 y 10")
else:
print("Dato correcto")
break

La instrucción continue
Las instrucción continue también permite alterar la ejecución de un lazo. Observe el siguiente
ejemplo:

for num in range(10,31):

if num%5==0:
continue
print(num)

11
12
13
14
16
17
18
19
21
22
23
24
26
27
28
29

El programa anterior imprime todos aquellos números de la serie del 10 al 30 pero que no son
múltiplos de 5. En la línea 2 se evalúa si num es múltiplo de 5, si es verdad se ejecuta continue
por lo que la variable de iteración num continua con su siguiente valor especificado en el for (la
ejecución de la línea 4 se obvia)

Importación de módulos:
Como se sabe, Python posee varias funciones BIF como print, input, type ... etc. Sin embargo, no
son suficientes para realizar ciertas tareas más complejas, por ejemplo, en caso que se quieran
aplicar funciones matemáticas, generar valores aleatorios, etc.

Entonces, será necesario importar módulos o librerías utilizando la instrucción import.

El módulo math:
Podemos importar el módulo math para acceder a las funciones matemáticas:

import math

La instrucción anterior agrega el módulo math al sistema. Si quiere verificar esto puede
visualizar el directorio del sistema:

dir()

Se puede notar del resultado anterior que en la lista está presente el módulo math.

Verifiquemos que funciones disponibles se encuentran en math:

dir(math)

Las funciones a las que se pueden acceder son aquellas cuyos nombres No estan rodeados de
__.

Si la importación del módulo math se hizo con la instrucción import math, entonces para usar
una función matemática se aplica el formato math.nombre_de la función¨. Por ejemplo, si se
desea calcular la raíz cuadrada de un número:

math.sqrt(8)

Si se quiere calcular el seno de un ángulo (en radianes) y revisando el listado disponible hay una
función prometedora llamada sin:

help(sin)

¿Por qué el error?

Porque sin no es una función BIF (sino, estaria incluída en el directorio de builtins). Para conocer
la ayuda de la función sin hay que especificar el módulo math:

help(math.sin) #recuerde que también puede usar la instrucción:

math.sin?

#ejemplo:

math.sin(30) #ojo se calcula el seno de 30 radianes (como indica el

help)

Otros ejemplos de funciones matemáticas:

print(f"La tangente de pi/4 es: {math.tan(pi/4):.4f}")

print(f"La exponencial de 10.45 es: {math.exp(10.45):.3f}")
print(f"El factorial de 7 es: {math.factorial(7)}")
print(f"El valor de 3.003 redondeado a la derecha es:
{math.ceil(3.003)}")
print(f"El valor de 7.993 redondeado a la izquierda es:
{math.floor(7.993)}")

El módulo random:
Podemos importar el módulo random para acceder a las funciones que generan números
aleatorios:

import random

Verifiquemos nuevamente el directorio del sistema (notará que está presente el módulo
random):

dir()

Verifiquemos ahora todas las funciones disponibles en el módulo random:

Recuerde que las funciones a las que se pueden acceder son aquellas cuyos nombres No estan
rodeados de __.

dir(random)

Revisemos que es lo que hace la función random del módulo random:

help(random.random) #recuerde que también puede usar la instrucción

random.random?

Como puede observar en el resultado anterior, la función random retorna una valor aleatorio
real entre 0 y 0.99999....

#ejemplo:

print(f"Aleatorio real en el intervalo [0,1>: {random.random():.3f}")

Otros ejemplos de funciones para generar números aleatorios:

print(f"Aleatorio entero en el intervalo [1,9]: {random.randint(1,

9)}")
print(f"Aleatorio entero en el intervalo [10,100>:
{random.randrange(10,100)}")
print(f"Aleatorio real en el intervalo [5,30>:
{random.uniform(5,30):.3f}")
El módulo time:
import time

Verifiquemos ahora todas las funciones disponibles en el módulo time:

dir(time)

Veamos algunas funciones interesantes de este módulo time:

time.asctime() #retorna una cadena especificando la información de la

fecha y hora actual

#La función sleep detiene la ejecución una cantidad de segundos

for i in range(10,-1,-1):
print(i)
time.sleep(1) #detiene la ejecución 1 segundo

print("Despegue!!")

Otras formas de importar los módulos

#importa el módulo math con el alias mate:
import math as mate
print(f"El coseo de pi/4 es: {mate.cos(mate.pi/4):.2f}")

#importa el módulo random con el alias alea:

import random as alea
print(f"Resultado de arrojar un dado: {alea.randint(1,6)}")

#importa el módulo time con el alias temp:

import time as temp
temp.asctime()

#del módulo math importa solamente a la función cos y al valor de pi

#(se agregan cos y pi al sistema)
from math import cos,pi

#no se debe anteponer math.

print(f"El coseno de pi/5 es: {cos(pi/5):.2f}")

#del módulo random importa solamente a la función randint (se agrega

randint al sistema)
from random import randint

#no se debe anteponer random

print(f"Número aleatorio de 3 dígitos: {randint(100,999)}")
#del módulo math importa a todas sus funciones (todos las funciones se
agregan al sistema)
from math import *

#no se debe anteponer math.

print(f"La raiz cuadrada de 56 es: {tan(pi/4):.3f}")
print(f"El logaritmo en base 10 de 12 es: {log10(12):.3f}")

#del módulo random importa a todas sus funciones (todos las funciones
se agregan al sistema)
from random import *

#no se debe anteponer random.

print(f"Dígito aleatorio: {randint(0,9)}")
print(f"Aleatorio en el intervalo [12,54]: {uniform(12,54):.2f}")