UNIVERSIDAD DE CARABOBO

FACULTAD DE INGENIERÍA
DEPARTAMENTO DE COMPUTACIÓN
CÁTEDRA DE COMPUTACIÓN I

Unidad 4

Estructuras de
Control
Estructuras Selectivas

Las estructuras selectivas permiten seleccionar o decidir la

ejecución de un conjunto de instrucciones, según un valor o
expresión lógica.

Octubre de 2022
 FUNDAMENTOS DE PROGRAMACIÓN

Con aplicaciones a la Ingeniería

Libro de estudio de la asignatura Computación I.

Fundamentos de Programación con Aplicaciones a la Ingeniería © 2022 by

Alejandro Bolívar is licensed under CC BY-NC 4.0

Se permite la copia, uso y distribución de este ejemplar, bajo los

términos de la licencia Creative Commons Atribución 4.0.
Contenido
1 Estructuras de Control ................................................................................ 4
1.1 Sangría. ................................................................................................ 4
1.1.1 Una excepción a la regla de sangría .............................................. 5
1.2 Estructuras Selectivas .......................................................................... 6
1.2.1 Estructura Condicional Simple ...................................................... 6
1.2.2 Estructura Condicional Doble ....................................................... 7
1.2.3 Estructura Condicional Múltiple ................................................... 8
1.3 Recomendaciones para la escritura de código en Python .................. 10
1.4 Ejercicios con estructuras condicionales ........................................... 11
1.5 Ejercicios Propuestos de Estructuras Condicionales ......................... 14
1.6 Resumen ............................................................................................ 14
1.7 Glosario ............................................................................................. 15
 Objetivos de la unidad:

En esta unidad aprenderá a utilizar las estructuras condicionales, con el fin de dirigir
el flujo del programa de acuerdo a la necesidad de ejecutar las instrucciones necesarias para
resolver un problema.

1 Estructuras de Control
Todos los lenguajes de programación disponen de instrucciones de control de flujo.
Estas instrucciones permiten al programador decidir el orden de ejecución del código con el
fin de permitir ejecutar diferentes órdenes en función de una serie de condiciones sobre el
estado. Python ofrece los dos tipos básicos de
sentencias de control de flujo: las sentencias
condicionales y los ciclos (o repeticiones).

1.1 Sangría.

La sangría es la sangría que se asigna a las

instrucciones que se ejecutarán dentro de una estructura de control.

No todos los lenguajes de programación, necesitan de una sangría, aunque sí, se estila
implementarla, a fin de otorgar mayor legibilidad al código fuente. Pero en el caso de Python,
la sangría es obligatoria, ya que, de ella, dependerá su estructura.

PEP 8: sangría

Una sangría de 4 (cuatro) espacios en blanco, indicará que las instrucciones

sangradas, forman parte de una misma estructura de control.

Una estructura de control, entonces, se define de la siguiente forma:

inicio de la estructura de control:

expresiones
 ●●●
Sangría.

1.1.1 Una excepción a la regla de sangría

Cada vez que una sentencia acaba con dos puntos (:), Python espera que la sentencia
o sentencias que le siguen aparezcan con una mayor sangría. Es la forma de marcar el inicio
y el fin de una serie de sentencias que ˂˂dependen˃˃ de otra. Hay una excepción: si solo hay
una sentencia que ˂˂depende˃˃ de otra, puedes escribir ambas en la misma línea como se
aprecia en el código parimpar1.py,

a = int(input('Dame un entero positivo: '))

if a % 2 == 0:
print ('El número es par ')
else:
print ('El número es impar ')

# Fin del programa

input('Pulse una tecla para finalizar... ') # Pausa

y este otro, parimpar2.py,

a = int(input('Dame un entero positivo: '))

if a % 2 == 0: print ('El número es par ')

else: print ('El número es impar ')

# Fin del programa

input('Pulse una tecla para finalizar... ') # Pausa

son equivalentes.

Atención

Todas las instrucciones que describen el cuerpo de la estructura deben tener una
sangría mayor que el encabezado de la estructura. Esta sangría puede ingresarse mediante
4 espacios preferiblemente o un tabulador, pero es importante que sea la misma para todas
las instrucciones de la estructura.
 Estructuras de Control
Estructuras Selectivas

1.2 Estructuras Selectivas

Las estructuras de selección o decisión permiten ejecutar un bloque de código entre

varios disponibles, según el resultado de la evaluación de una expresión lógica situada en la
cabecera de la estructura.

1.2.1 Estructura Condicional Simple

if expresión_lógica_a_evaluar:
ejecutar_si_cierto

Esta forma del condicional if se interpreta como Si

(expresión_lógica) es verdadera, el flujo del programa continúa
ejecutando las instrucciones que estén dentro del bloque if, las cuales
se especifican y se reconocen por estar debidamente
sangradas respecto al inicio de la palabra if. Recuerde que
la sangría se establece dejando espacios en blanco,
pasando la instrucción (palabra) if. Si la
(expresión_lógica) es falsa, el flujo del programa se
continúa ignorando las instrucciones del bloque if.

Por ejemplo, el siguiente código mayoredad.py

verifica si una persona es mayor de edad.

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

if edad >= 18:
print ('Es mayor de edad')
# Fin del programa
input('Pulse una tecla para finalizar... ') # Pausa

Ejecute este programa, probando varias veces con valores diferentes.

 ●●●
Estructuras Selectivas

1.2.2 Estructura Condicional Doble

La forma del if estudiada en la sección anterior presenta la
posibilidad de hacer un desvío en el flujo de ejecución de un programa
cuando la condición o expresión lógica que determina al if es
verdadera (True). Si la expresión lógica no se cumple, es falsa (False),
el flujo del programa continúa su secuencia como si la instrucción if
no estuviese en el programa. La construcción if–else ofrece la
alternativa de ejecutar otras instrucciones en caso que la expresión lógica que determina la
instrucción if sea falsa. Su forma general es como sigue:

if expresion_a_evaluar:
ejecutar_si_cierto
else:
ejecutar_en_caso_contrario

En otras palabras, esta forma del condicional

if la interpretaremos como Si la (expresión lógica) es
verdadera, el flujo del programa se continúa
ejecutando las instrucciones que estén dentro del
bloque if (las cuales se especifican y se reconocen
por estar debidamente sangradas respecto al inicio de
la palabra if). Si la (expresión lógica) es falsa, el flujo
del programa continúa ejecutando las instrucciones
que estén dentro del bloque else (las cuales se
especifican y se reconocen por estar debidamente
sangradas respecto al inicio de la palabra else). En este caso, se garantiza que una de las dos
bifurcaciones del flujo del programa se ejecuta. Debe notarse que las instrucciones if: y else:
NO están sangradas una de la otra. Es decir, ambas instrucciones comienzan al mismo nivel
en el programa (solo se sangra el bloque de instrucciones que debe ejecutarse en caso que
alguna de las condiciones se cumpla). Cabe mencionar que mientras la instrucción if puede
tener significado por sí sola, la instrucción else NO puede aparecer de forma aislada. Siempre
debe ir precedida por un if. Por ejemplo, el siguiente código (parimpar3.py) realiza acciones
distintas dependiendo de si el número de entrada es par o impar:
 Estructuras de Control
Estructuras Selectivas

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

if edad >= 18:
print ('Es mayor de edad')
else:
print ('Es menor de edad')

# Fin del programa

input('Pulse una tecla para finalizar... ') # Pausa

La última sentencia no está sangrada, por lo que no es parte de la estructura

condicional, y será ejecutada siempre.

1.2.3 Estructura Condicional Múltiple

Como el lector puede haber anticipado, se puede tener situaciones en las que se tenga
que seleccionar entre más de dos condiciones. Para estos casos Python ofrece la estructura
condicionada if–elif–else, cuya forma general es como sigue:

if expresion_lógica_1:
ejecutar_si_verdadero_1
elif expresion_lógica_2:
ejecutar_si_ verdadero_2
elif expresion_lógica_3:
ejecutar_si_ verdadero_3
else:
ejecutar_si_ninguna

En palabras, esta forma del condicional if la interpretaremos

como Si la (expresion_lógica_1) es verdadera, el flujo del programa se
continúa ejecutando las instrucciones que estén dentro del bloque if (las
cuales se especifican y se reconocen por estar debidamente sangradas
respecto al inicio de la palabra if). Si la (expresion_lógica_1) es falsa,
entonces el flujo del programa pasa a verificar la primera instrucción elif
cuyo bloque de instrucciones se ejecutan Si la (expresion_lógica_2) es
verdadera. En caso contrario, el flujo del programa continúa con la
verificación de la siguiente instrucción elif cuyo bloque de instrucciones
se ejecutan Si la (expresion_lógica_3) es verdadera. En caso que
ninguna de las condiciones previas a la instrucción else: sea ejecutada,
 ●●●
Estructuras Selectivas

el flujo del programa hace que se ejecuten las instrucciones de ese bloque. A continuación,
se presentan ejemplos de la aplicación de una estructura condicional.

Ejercicio 1-1: Dado un valor real x, determine sí es positivo, negativo o cero

(posneg.py).

# Lectura de datos
x = float(input('Ingrese un valor x: '))

# Procesamiento de datos
if x < 0.0:
msg = 'negativo'
elif x > 0.0:
msg = 'positivo'
else:
msg = 'cero'

# Salida de datos
print ('x es ', msg)

# Fin del programa

input('Pulse una tecla para finalizar... ') # Pausa

Ejercicio 1-2: La tasa de impuesto a pagar por una persona según su sueldo es la
siguiente (impuesto.py).

Tabla 1-1. Tasa de impuesto en función del sueldo recibido

Sueldo Tasa de impuesto

menos de 1000 0%
1000 ≤ sueldo < 2000 5%
2000 ≤ sueldo < 4000 10%
4000 o más 12% ´

Entonces, el programa que calcula el impuesto a pagar es el siguiente:

# Lectura de datos
sueldo = float(input('Ingrese su sueldo: '))

# Procesamiento de datos
if sueldo < 1000:
 Estructuras de Control
Recomendaciones para la escritura de código limpio.

tasa = 0.00
elif sueldo < 2000:
tasa = 0.05
elif sueldo < 4000:
tasa = 0.10
else:
tasa = 0.12

# Salida de datos
print ('Usted debe pagar ', tasa * sueldo, ' de impuesto')

# Fin del programa

input('Pulse una tecla para finalizar... ') # Pausa

Siempre sólo una de las alternativas será ejecutada. Tan pronto alguna de las
condiciones es verdadera, el resto de ellas no se evalúan.

1.3 Recomendaciones para la escritura de código limpio.

Las presentes recomendaciones son el resultado de la recopilación de errores

encontrados en las evaluaciones de la asignatura Computación I. También, se agregan
algunas normas básicas de escritura de código (Adaptado del Manual básico, iniciación a
Python 3 por José Miguel Ruiz Torres).

El estudiante debe procurar aplicar buenas prácticas de programación con el fin de

mejorar las tareas de revisión, intercambio y escalabilidad del código y de esta manera
contribuir con un código limpio y de mejor estilo.

1. Los nombres de los archivos deben escribirse en minúscula. Ejemplo:

hola.py
calculadora.py

2. La llamada a una función se escribe en minúscula. Ejemplo:

print()
input()

3. Las variables se escriben en minúscula y en caso de estar formadas por varias palabras,
éstas van unidas por guiones bajos. Ejemplo:
 ●●●
Ejercicios con estructuras condicionales

velocidad
altura_inicial

4. Declarar las variables con el tipo de dato adecuado, escribiendo en minúscula dicho tipo
de dato. Ejemplo:

nombre: str
contador_alumnos: int

5. Dejar un espacio en blanco después de cada coma. Ejemplo:

print('Tienes', num_zapatos, 'zapatos y', num_blusas, 'blusas.')

6. Dejar un espacio antes y después de cada operador. Ejemplo:

velocidad = distancia / tiempo

total += 6

7. Dejar la sangría con 4 espacios; evita usar la tecla tabuladora. Ejemplo:

if nombre == 'Ángel':
print('Hola', nombre)
input()

8. Escribe los comentarios necesarios en tu código, describiendo cada detalle, para hacer
que sea lo más claro y legible posible.
9. Escriba la expresión lógica de forma clara, sencilla y de forma positiva, es decir, que se
debe cumplir para ejecutar el bloque de instrucciones.
10. No repita instrucciones dentro de los bloques de la estructura condicional, sí esto sucede
evalúe la posibilidad de que dicha instrucción se escriba fuera de la estructura.
11. No escriba condiciones innecesarias, en algunos casos puede hacer analogía con
inecuaciones o conjuntos, evalúe la posibilidad de utilizar el descarte como parte de la
condición.
12. Si la expresión lógica es muy compleja, puede utilizar una variable para almacenar dicha
expresión.

1.4 Ejercicios con estructuras condicionales

 Estructuras de Control
Ejercicios con estructuras condicionales

a∗x + b∗y = c
1) Un sistema de ecuaciones lineales {
d∗x + e∗y = f
Se puede resolver con las siguientes fórmulas: x = (c*e - b*f) / (a*e - b*d); y =
(a*f - c*d) / (a*e - b*d). Desarrolle un programa (sistema.py) que lea los
coeficientes de ambas ecuaciones (a, b, c, d, e y f) y determine los valores
de x e y. Nota: evite la división por cero e imprima el mensaje adecuado.

# Lectura de datos
print('Introduzca los coeficientes: ')
a = float(input('a:'))
b = float(input('b:'))
c = float(input('c:'))
d = float(input('d:'))
e = float(input('e:'))
f = float(input('f:'))

# Procesamiento de datos
deno = a * e - b * d
if deno == 0:
# Sí el denominador es cero, no existe solución
print('No tiene solución el sistema de ecuaciones')
else:
x = (c * e - b * f) / deno
y = (a * f - c * d) / deno

# Salida de datos
print('La solución del sistema de ecuaciones planteado es')
print('X=', x)
print('Y=', y)
input('Pulse una tecla para finalizar... ') # Pausa

2) Dado un valor numérico entero, desarrolle un programa (paroimpar.py)

que determine si es par o impar.

# Entrada del dato

n = int(input('De un valor entero: '))
# Procesamiento y salida de datos
if n == 0:
print(n, ' No es par ni impar')
elif n % 2 != 0:
print(n, ' Es Impar')
else:
print(n, ' Es Par')
 ●●●
Ejercicios con estructuras condicionales

# Fin del programa

input('Pulse una tecla para finalizar... ') # Pausa

3) Dada la el valor numérico con que una persona indica el agrado por un
determinado producto, un valor entre 0 y 100, elabore un programa
(calificación.py) que determine la calificación del producto en base a la
siguiente tabla y empleando if anidados.

Rango Calificación
0-20 Muy Malo
21-40 Deficiente
41-60 Regular
61-80 Bueno
81-100 Muy Bueno

Para plantear la solución empezamos con una decisión considerando el límite superior
del rango, si es menor o igual a ese valor está en esa calificación sino en alguna de las otras,
así vamos descartando una a una las posibilidades, quedando en diagrama de flujo algo como
lo siguiente:

# Lectura de datos
agrado = float(input('Ingrese el valor de agrado: '))

# Procesamiento de datos
if agrado <= 20:
msg = 'Muy Malo'
elif agrado <= 40:
msg = 'Deficiente'
elif agrado <= 60:
 Estructuras de Control
Ejercicios Propuestos de Estructuras Condicionales

msg = 'Regular'
elif agrado <= 80:
msg = 'Bueno'

else: # Observe que no es necesario hacer la última pregunta

msg = 'Muy Bueno'

# Salida de datos
print ('La Calificación es ' + msg)

# Fin del programa

input('Pulse una tecla para finalizar... ') # Pausa

1.5 Ejercicios Propuestos de Estructuras Condicionales

1) Dadas las coordenadas de un punto en el plano cartesiano, desarrolle

un programa que, utilizando operadores lógicos, determine e imprima
en que cuadrante está, o si está en el eje X, o en el eje Y, o el origen
del plano cartesiano.
2) La distancia entre dos puntos de coordenadas cartesianas (X1, Y1) y
2 2
(X2, Y2) se determina como √(X2 − X1) + (Y2 − Y1) . Dadas las
coordenadas cartesianas de tres puntos, desarrolle un programa que
determine e imprima si el triángulo que forman es equilátero (tres lados
iguales), isósceles (sólo dos lados iguales) o escaleno (tres lados
diferentes). Determine e imprima, además, el valor del área que
encierra según el método del semiperímetro.
3) Obtener el mayor valor de 3 números dados y mostrarlo.
4) Ordenar 3 números en forma ascendente y descendente.

1.6 Resumen

Para poder tomar decisiones en los programas y ejecutar una acción u otra, es
necesario contar con una estructura condicional.

Las condiciones son expresiones booleanas, es decir, cuyos valores pueden ser
verdadero o falso, y se escriben mediante operadores entre distintos valores.

Mediante expresiones lógicas es posible modificar o combinar expresiones

booleanas.
 ●●●
Glosario

La estructura condicional puede contener, opcionalmente, un bloque de código que

se ejecuta si no se cumplió la condición.

Es posible anidar estructuras condicionales, colocando una dentro de otra.

También es posible encadenar las condiciones, es decir, colocar una lista de posibles
condiciones, de las cuales se ejecuta la primera que sea verdadera.

1.7 Glosario

anidamiento: Una estructura de programa dentro de otra; por ejemplo, una sentencia
condicional dentro de una o ambas ramas de otra sentencia condicional.
bloque: Grupo sentencias consecutivas con el mismo sangrado.
condición: La expresión booleana de una sentencia condicional que determina qué
rama se ejecutará.
cuerpo: En una sentencia compuesta, el bloque de sentencias que sigue a la cabecera
de la sentencia.
expresión booleana: Una expresión que es cierta o falsa.
operador de comparación: Uno de los operadores que comparan dos valores: ==.
!=, >, <. >= y <=.
operador lógico: Uno de los operadores que combinan expresiones booleanas: and,
or y not.
operador módulo: Operador, señalado con un signo de tanto por ciento (que trabaja
sobre enteros y devuelve el resto cuando un número se divide entre otro.
sentencia compuesta: Estructura de Python que está formado por una cabecera y un
cuerpo. La cabecera termina en dos puntos (:). El cuerpo tiene una sangría con respecto a la
cabecera.
sentencia condicional: Sentencia que controla el flujo de ejecución de un programa
dependiendo de cierta condición.