PROGRAMACIÓN ORIENTADA A OBJETOS ING.

JOSÉ RODRÍGUEZ RUIZ

CAPÍTULO 2 ESTRUCTURAS BÁSICAS DE CONTROL

Hasta este punto se han desarrollado algoritmos que son muy sencillos por su estructura
secuencial, en donde las instrucciones se ejecutan una sola vez en el orden en que están
escritas. La forma general de este tipo de algoritmos es la siguiente:

1. Obtener datos.
2. Calcular resultados parciales.
3. Calcular resultados finales.
4. Imprimir los resultados.
5. Fin de algoritmo.

Estos algoritmos tienen un flujo de control secuencial. Flujo de control se refiere al orden
de ejecución de las instrucciones individuales de un algoritmo. En los algoritmos
secuenciales, o de flujo lineal, las instrucciones se efectúan una después de otra desde el
inicio hasta el final del algoritmo. Cuando un programa requiera la modificación del flujo
lineal se deben utilizar estructuras de control.

La mayoría de los algoritmos prácticos son no secuenciales, y no siguen este patrón, por lo
que requieren de dos estructuras de control muy importantes: la decisión y la repetición.

1. ESTRUCTURA DE REPETICIÓN. Se basa en la evaluación de una condición

booleana, y dependiendo del resultado (cierto o falso) es posible repetir un grupo de
instrucciones tantas veces como sea necesario.

Las dos instrucciones de ésta estructura son while y for.

2. ESTRUCTURA DE DECISIÓN. Permite seleccionar una entre dos (o más)

opciones, también con base en una condición booleana.
Sus tres instrucciones son if, if..else y elif

Las estructuras de control son condicionales, lo que significa que su funcionamiento está
controlado por condiciones booleanas, simples o compuestas. Por tanto, antes de empezar
el estudio de las estructuras control se sugiere al estudiante regresar a revisar el tema
[Link] DATOS LÓGICOS O BOOLEANOS del capítulo I.

2.1 ESTRUCTURA DE REPETICIÓN (LAZOS)

Los lazos se utilizan para ejecutar varias veces un fragmento de un algoritmo, repitiendo
las mismas operaciones, pero con datos diferentes cada vez. Por ejemplo, se puede escribir
un algoritmo que calcule el salario semanal de los 800 empleados de una fábrica.
Evidentemente se requiere de un lazo que calcule 800 veces un salario. Cada cálculo debe
incluir los datos de una persona particular (nombre, horas trabajadas, pago por hora, etc.), y
estos serán diferentes a los de cualquier otra persona.

1
PROGRAMACIÓN ORIENTADA A OBJETOS ING. JOSÉ RODRÍGUEZ RUIZ

SANGRÍA (INDENTATION)
En Python, el concepto de sangría (indentation en inglés) es muy importante. La mayoría
de los lenguajes, como C, C++ o Java utilizan llaves {} para definir un bloque (conjunto) de
instrucciones. Por el contrario, Python usa sangrías.
Sangría se refiere a colocar espacios al inicio de las líneas de código de un bloque de
instrucciones.
Los bloques de instrucciones forman el cuerpo de las estructuras de control: repeticiones y
decisiones. Entonces, el bloque en las estructuras como while o if..else empieza escribiendo
cada instrucción del bloque cierto número de posiciones (por lo menos una) hacia la derecha
con respecto al inicio de la estructura.

2.1.1 INSTRUCCIÓN while (mientras)

La instrucción while es un lazo condicional porque su ejecución depende de la evaluación de
una condición booleana. Su sintaxis es la siguiente:

while condición booleana:

instrucción 1
instrucción 2
instrucción 3
. . .
instrucción n

Observe que las instrucciones están indentadas. Indentar significa empezar a escribir
cierto número de posiciones (por lo menos una) hacia la derecha con respecto al inicio del
while. No se permite utilizar llaves {}, como sería en otros lenguajes.
El lazo consta de la palabra while seguida de su condición booleana, sin paréntesis, que
termina con dos puntos (:). El cuerpo del while está formado por un bloque de una o más
instrucciones indentadas.
Al conjunto de dos o más instrucciones indentadas se le llama bloque de instrucciones.
Indentar las instrucciones es muy importante porque de esta manera el interprete identifica
qué instrucciones pertenecen al while. Por ejemplo, Si una instrucción while de cuatro
instrucciones se hubiera escrito sin respetar la indentación así:

while condición booleana:

instrucción 1
instrucción 2
instrucción 3
instrucción 4

El interprete Python mostraría el siguiente mensaje:

2
PROGRAMACIÓN ORIENTADA A OBJETOS ING. JOSÉ RODRÍGUEZ RUIZ

La explicación del funcionamiento de la instrucción while es la siguiente: la ejecución

del lazo while inicia evaluando su condición booleana. Si esta es verdadera se entra al bloque
de instrucciones y se ejecutan cada una de ellas. Después de ejecutar la última instrucción
del bloque, se debe regresar al inicio del while para volver a evaluar su condición booleana:

La ejecución del bloque continúa mientras su condición booleana sea verdadera.

La ejecución del while termina cuando su condición booleana es falsa.

Por ejemplo, si se escribe el siguiente fragmento de algoritmo que incluye un lazo while
con su bloque de instrucciones indentado:

A=1
while A <= 3:
print( “HOLA”) # instrucción 1 del while
A= A + 1 # instrucción 2 del while

entonces la ejecución procede así: la variable A se inicializa con el valor 1. A continuación

se evalúa la condición (A <= 3). Como es verdadera se ejecuta el cuerpo del while, que consta
de dos instrucciones: la primera imprime el mensaje HOLA, y la segunda incrementa en uno
el valor de A.
Al finalizar la ejecución de la segunda instrucción termina la primera repetición (más
correctamente, iteración) y se regresa al inicio del while donde se evalúa por segunda vez su
condición, pero ahora con A= 2. La condición sigue siendo verdadera y se ejecutan por
segunda vez las dos instrucciones del cuerpo del lazo, es decir, se imprime por segunda vez
el mensaje HOLA y a continuación se incrementa el valor de A, por lo que ahora A= 3.
Termina la segunda iteración.
Se regresa al inicio del lazo para evaluar por tercera vez su condición. Sigue siendo
verdadera. Se imprime por tercera vez HOLA y ahora A= 4. Termina la tercera iteración.
Se regresa al inicio del lazo, pero ahora la condición (A <= 3) es falsa. En este momento
se da por terminada la ejecución del lazo while.
Es importante observar que se entra al lazo mientras la condición booleana se mantenga
verdadera, y se sale del lazo cuando su condición es falsa. Por tanto, el programador debe
asegurarse de que la condición sea inicialmente verdadera, pero que tome el valor falso en
algún momento de la ejecución del lazo. En caso contrario se tendrá un lazo infinito, lo cual
significa que el lazo nunca terminará. El programa completo es el siguiente:

‘’’PROGRAMA whileImprimeHola
Programa que imprime tres veces la palabra HOLA
AUTOR: ing. josé Rodríguez Ruiz depto. Sistemas y Computación ITCelaya
‘’’
A= 1
while A <= 3:
print("HOLA\n")
A= A + 1

3
PROGRAMACIÓN ORIENTADA A OBJETOS ING. JOSÉ RODRÍGUEZ RUIZ

La salida de este programa es:

Como segundo ejemplo que utiliza un ciclo while es el siguiente. Escribir un programa
que calcule la suma de los primeros n enteros positivos.

''’PROGRAMA sumaNumeros
Este programa suma los primeros n enteros positivos: 1+2+3+4+5+ … + n.
Ejemplo: si n= 5 entonces 1+2+3+4+5= 15
AUTOR: ing. josé Rodríguez Ruiz depto. Sistemas y Computación ITCelaya
'''
# input lee el número como cadena (string). int es el cast que lo convierte en número entero
n= int(input("Hasta que numero (entero positivo) quieres sumar ? "))
suma= 0; numero= 1

while numero <= n :

suma= suma + numero
numero= numero + 1

print("La suma de los primeros ", n, " enteros positivos es ", suma)

Observar que while solamente tiene dos instrucciones. La instrucción print() no está
indentada y no pertenece al while, por lo que se ejecutará una sola vez.
La explicación del código es la siguiente:
En la primera línea (no se toman en cuenta los comentarios ni las líneas en blanco) se pide
el dato “hasta que número se va a sumar” y se asigna a la variable n.
En la segunda línea se inicializan las variables suma a cero y numero a 1. Observe qiue
cuando hay dos o más instrucciones diferentes en la misma línea, cada instrucción se separa
de la otra con um punto y coma.
La variable suma almacena los resultados parciales y el final de sumar los n números. La
variable numero representa a cada uno de los n números que se van a sumar, uno a la vez.
En la tercera línea inicia el while para sumar los números. La condición (numero <= n)
indica que las instrucciones del lazo se ejecutarán mientras (while) sea cierto que el valor de
la variable numero es menor o igual a n, que es la cantidad de números que se quieren sumar.

4
PROGRAMACIÓN ORIENTADA A OBJETOS ING. JOSÉ RODRÍGUEZ RUIZ

Es importante entender que antes de entrar al lazo while por primera vez, se debe evaluar la
condición (numero <= n). Como de línea 1 se tiene que numero= 1, entonces la condición
es verdadera y se entra a la primera de las n repeticiones (iteraciones) del lazo.
Dentro del lazo y en cada una de las iteraciones, la primera instrucción incrementa el valor
de suma con el valor que en ese momento tenga la variable numero; la segunda instrucción
incrementa en uno el valor de numero. Esta modificación a la variable numero es un paso
vital para que en un cierto momento numero sea mayor a n y la condición (numero <= n) se
convierta en falsa para terminarla ejecución del lazo. Si esto no ocurriera entonces se tendría
un lazo infinito que causaría que las dos instrucciones del lazo nunca terminaran su
ejecución, lo cual es un gravísimo error.
Cada vez que termina una iteración se regresa al inicio del lazo para volver a evaluar su
condición. Si continúa siendo verdadera se vuelve a entrar al lazo para efectuar otra iteración,
es decir, para volver a ejecutar sus dos instrucciones. Pero si es falsa en ese momento termina
la ejecución del lazo y se pasará a ejecutar la siguiente instrucción del algoritmo, que en este
ejemplo es la línea 6, donde se imprime el resultado de la suma. Observar que la instrucción

print("La suma de los primeros ", n, " enteros positivos es ", suma)

no está indentada dentro de while. De esta manera el interprete Python sabe que no
pertenece al lazo y, por tanto, se ejecutará una sola vez. La salida, para n= 5, es:

5
PROGRAMACIÓN ORIENTADA A OBJETOS ING. JOSÉ RODRÍGUEZ RUIZ

2.1.2 MÉTODOS PARA CONTROLAR LAS REPETICIONES (LAZOS)

Ahora que ya se sabe cómo repetir la ejecución de un grupo de pasos de un algoritmo por
medio de un lazo, la siguiente cuestión a resolver es: ¿cómo se da por terminada la ejecución
de un lazo?
Hay varias formas. En ésta sección se presentarán tres de ellas:
1) método del contador;
2) método del dato centinela,
3) método de la pregunta directa.

Pero sin importar cuál es el método elegido, para utilizarlos adecuada y correctamente, se
deben incluir en el while los siguientes tres pasos que aseguran que el lazo siempre terminará
de manera correcta. Los pasos son los siguientes:

Paso I. Inicializar la variable de control.

La variable de control es aquella variable que se coloca dentro de la condición booleana
del lazo y que dependiendo de su valor el lazo continúa o se da por terminado. Si la variable
de control tiene un valor tal que haga que la condición booleana sea verdadera entonces el
lazo continúa su ejecución; pero si tiene un valor que la convierta en falsa entonces el lazo
termina. Así, esta variable controla la ejecución del lazo.
Pero antes de utilizarla se le debe dar un valor inicial. Por ejemplo, en el algoritmo
SumaNumeros de la sección anterior, la variable de control es numero. Su inicialización se
hizo con la instrucción
numero= 1

El valor inicial no siempre debe ser 1. Puede ser cualquier valor positivo o negativo, cero
incluido.

+
´KLPaso II. Incluir la variable de control dentro de la condición del lazo.
Después de inicializar la variable de control, esta debe colocarse dentro de la condición
booleana del lazo. En el algoritmo SumaNumeros se utilizó la siguiente instrucción:

while numero <= n:

Recuerde que numero es la variable de control y, como se observa, está colocada dentro
de la condición booleana del lazo while.

Paso III. Modificar el valor de la variable de control.

Todo lazo bien escrito debe ejecutarse un cierto número de veces, pero debe terminar
después de un cierto número de repeticiones (iteraciones). Si esto no sucede, entonces se
tiene un gravísimo error conocido como lazo infinito. Para evitar que esto suceda, la variable
de control debe modificar su valor de manera apropiada (incrementándolo o
decrementándolo, según sea el caso). En el caso del ejemplo anterior, la modificación a la
variable de control se hace incrementado en uno su valor en cada iteración por medio de la
instrucción
numero= numero + 1

6
PROGRAMACIÓN ORIENTADA A OBJETOS ING. JOSÉ RODRÍGUEZ RUIZ

De esta forma se garantiza que mientras la condición (numero <= n) sea verdadera el lazo
continúa, pero también se garantiza que en algún momento (cuando numero > n) la condición
del lazo tendrá el valor falso y el lazo habrá terminado.

Ahora que ya se conocen los tres pasos para asegurar que una repetición termine de manera
correcta, veamos las tres formas de control: contador, dato centinela y pregunta directa.

[Link] CONTROL DEL LAZO POR CONTADOR

Este método consiste en definir una variable, o contador, que almacenará la información
necesaria para controlar el número total de iteraciones. Recuerde que el encabezado del lazo
se establece de la siguiente manera:

while condición booleana:

y que las iteraciones continúan mientras (while) la condición booleana sea cierta. Entonces,
y de acuerdo a los pasos para controlar el lazo mencionados en la sección anterior, el contador
se debe inicializar a un valor apropiado y después debe aparecer en la condición booleana.
Por ejemplo en:

contador= 1 # inicialización de contador

while contador <= numeroEmpleados: #contador está incluido en la condición

Primero se inicializa la variable que desempeña el papel de contador para llevar la cuenta
de cuantas iteraciones se han realizado del total. En este ejemplo la inicialización es con el
valor 1, pero pudo haberse inicializado a cualquier valor, incluso cero o negativo. El valor
inicial apropiado para un contador lo determina el problema que se esté resolviendo.
A continuación, se incluye el contador dentro de la condición booleana del lazo. El lazo
continúa mientras contador tenga un valor que haga que la condición booleana sea cierta.
Cuando contador obtenga un valor que haga falsa a la condición, el lazo termina.
Además, se debe incluir en alguna de las instrucciones del cuerpo del lazo alguna manera
de modificar el valor del contador con el propósito que en algún momento obtenga un valor
tal que haga que la condición booleana se convierta en falsa y el lazo se dé por terminado.
En nuestro ejemplo la instrucción que modifica a contador es:

contador= contador + n # modificación de contador

donde n representa cualquier valor, positivo o negativo .

Ahora la forma general del while con los tres pasos de control mencionados es:

contador= 1 # inicialización de contador

while contador <= numeroEmpleados: # contador está incluido en la condición
.
.
.
contador= contador + n # modificación de contador
7
PROGRAMACIÓN ORIENTADA A OBJETOS ING. JOSÉ RODRÍGUEZ RUIZ

El siguiente ejemplo utiliza un while controlado por contador. Escribir un programa que
imprima una lista de los precios de alimentos con el siguiente formato de salida:

FRITANGAS LINCE
LISTA DE PRECIOS
CANT QUESADILLAS GORDITAS REFRESCOS
1 20.00 15.00 13.00
2 40.00 30.00 26.00
3 60.00 45.00 39.00
. . . .
n ###.## ###.## ###.##

El dato de entrada es el número n de renglones para la tabla. El programa es el siguiente:

'''PROGRAMA listaPreciosGorditas
Imprime una lista de los precios de quesadillas, gorditas y refresco.
Utiliza un ciclo while con contador para imprimir la lista
AUTOR: ing. josé Rodríguez Ruiz depto. Sistemas y Computación ITCelaya
'''
PRECIO_QUESADILLA= 15.0
PRECIO_GORDITA= 20.0
PRECIO_REFRESCO= 13.0

renglones= int(input("cuantos renglones para la lista? "))

print(" FRITANGAS LINCE")
print(" LISTA DE PRECIOS")
print(" CANT", " QUESADILLAS", " GORDITAS", " REFRESCOS")
cant= 1
while cant <= renglones:
quesadilla= cant * PRECIO_QUESADILLA
gordita= cant * PRECIO_GORDITA
refresco= cant * PRECIO_REFRESCO

print(" ", cant, " ", quesadilla, " ", gordita," ", refresco)
cant= cant + 1
print("\nFin de lista")

En este ejemplo, el contador es la variable cant y el número de repeticiones lo define la

variable renglones.
El ciclo while consta de un bloque de cinco instrucciones. Las tres primeras calculan el
precio de cada alimento para esa cantidad, y lo almacena en las variables respectivas
(quesadilla, gordita, refresco). A continuación, en cada iteración (repetición) del ciclo while

8
PROGRAMACIÓN ORIENTADA A OBJETOS ING. JOSÉ RODRÍGUEZ RUIZ

la cuarta instrucción imprime cada una de las líneas de salida de la lista por medio de la
instrucción

print(" ", cant, " ", quesadilla, " ", gordita," ", refresco)

La quinta instrucción modifica el valor del contador cant.

Este proceso se repite mientras la condición booleana del while se mantenga verdadera.
Cuando la condición toma el valor falso, el ciclo while se dá por terminado.

Una salida para 13 renglones es:

Hay una tercera versión con fecha y hora

Observe que la salida no es adecuada porque las columnas se distorsionan conforme crece
el número de renglones. Para evitar este efecto se requiere controlar la manera en que se
imprimen las diferentes columnas. Este control se logra mediante diferentes técnicas para
formatear la salida. Formatear significa mostrar la información en los renglones y columnas
correspondientes de acuerdo a un diseño previo, que se puede hacer en una hoja de
cuadrícula.

9
PROGRAMACIÓN ORIENTADA A OBJETOS ING. JOSÉ RODRÍGUEZ RUIZ

[Link].1 Formateo de la salida

Python tiene varias maneras de formatear la salida de un programa. Una de ellas es con el
método .format( ).

El método .format()
Una de las maneras de utilizar el método .format() se conoce como formateo avanzado.

Formateo avanzado
Permite controlar las alineaciones (o justificaciones) a la derecha, al centro o a la izquierda
de lo que se quiere imprimir. Para esto utiliza los siguientes símbolos de alineación:

:> n Indica alineación a la derecha utilizando n columnas.

:ˆ n Indica alineación al centro utilizando n columnas.

:< n Indica alineación a la izquierda utilizando n columnas.

Donde n es la cantidad de columnas que se quieren utilizar

La forma general de un print que utilice al método .format() es:

print( “{alguno de los símbolos de alineación}”.format(dato) )

Ejemplo con símbolo de alineación a la derecha en 30 columnas

print(“{:>30}”. format(“Alineación a la derecha”))

1 2 3 4 5 6 7 8 9 1 1 1 1 1 1 1 1 1 1 2 2 2 2 2 2 2 2 2 2 3
0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0

A l i n e a c i ó n a l a d e r e c h a

10
PROGRAMACIÓN ORIENTADA A OBJETOS ING. JOSÉ RODRÍGUEZ RUIZ

Ejemplo con símbolo de alineación al centro en 30 columnas:

print(“{: ˆ 30}”. format(“Alineación al centro”))

1 2 3 4 5 6 7 8 9 1 1 1 1 1 1 1 1 1 1 2 2 2 2 2 2 2 2 2 2 3
0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0

A l i n e a c i ó n a l c e n t r o

Ejemplo con símbolo de alineación a la izquierda en 30 columnas:

print(“{:<30}”. format(“Alineación a la izquierda”))

1 2 3 4 5 6 7 8 9 1 1 1 1 1 1 1 1 1 1 2 2 2 2 2 2 2 2 2 2 3
0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0

A l I n e a c i ó n a l a i z q u i e r d a

FORMATEO DE CADENAS (strings)

En el siguiente programa se muestran algunos ejemplos de formatear una salida con

cadenas con el método .format()

'''PROGRAMA pythonMetodoFormat
Muestra ejemplos de como utilizar el método .format() para formatear la salida de un
programa.

AUTOR: ing. josé Rodríguez Ruiz depto. Sistemas y Computación ITCelaya

'''

print("#Alineamiento a derecha en 30 caracteres:espacios a la izquierda")

print("--------10--------20--------30")
print( "{:>30}".format("A la derecha") )

print("\n#Al centro:espacios a izquierda y derecha")

print( "{:^30}".format("Al Centro") )

print("\n#A la izquierda:espacios a la derecha")

print( "{:<30}".format("A la izquierda\n") )

La salida de este programa es:

11
PROGRAMACIÓN ORIENTADA A OBJETOS ING. JOSÉ RODRÍGUEZ RUIZ

Observe que en las instrucciones del programa se reservan 30 caracteres para imprimir las
cadenas, pero éstas tienen menos de 30 caracteres. Por ésta razón el interprete Python coloca
espacios antes o después de la cadena para completar los 30 caracteres.

Truncar una cadena

El método format() también permite truncar la cadena que se quiere imprimir. Para truncar
una cadena, en el método .format() se coloca un punto antes de un número que sea menor
a la cantidad de caracteres que tiene la cadena. Por ejemplo, “cadena a truncar” tiene 16
caracteres, espacios incluidos. Si se escribe

print( "{: .11}".format("cadena a truncar") )

entonces solo se imprimirá cadena a tr, que son los primeros 11 caracteres de la cadena.

Combinación de alineación con truncamiento de una cadena

Python permite combinar tanto la alineación como el truncamiento de una cadena. Si se
escribe
print( "{:>30.8}".format(“cadena a truncar”) )

la cadena se alineará a la derecha utilizando 30 columnas y solo se imprimirá cadena a que son
los primeros 8 caracteres de la cadena.
El siguiente programa muestra el truncamiento de cadenas.

12
PROGRAMACIÓN ORIENTADA A OBJETOS ING. JOSÉ RODRÍGUEZ RUIZ

'''PROGRAMA pythonMetodoFormat2
Muestra ejemplos de como utilizar el método .format() para formatear la salida de un
programa para truncar la cadena que se va a imprimir
AUTOR: ing. josé Rodríguez Ruiz depto. Sistemas y Computación ITCelaya '''
print("#Cadena sin truncar")
print("Cadena que se va a truncar")

print("\n#Truncamiento a 11 caracteres")
print("--------10--------20--------30")
print( "{:.11}".format("Cadena que se va a truncar") )

print("\n#Truncamiento a 18 caracteres")
frase= "Cadena que se va a truncar"
print("--------10--------20--------30")
print( "{:.18}".format(frase) )

print("\n#Se puede combinar la alineación con el truncamiento")

print("\n#Alineación a la derecha con truncamiento")
print("--------10--------20--------30")
frase= "Cadena que se va a truncar"
print( "{:>30.18}".format(frase) )

print("\n#Alineación al centro con truncamiento")

frase= "Cadena que se va a truncar"
print("--------10--------20--------30")
print( "{:^30.18}".format(frase) )
La salida de éste programa es:

13
PROGRAMACIÓN ORIENTADA A OBJETOS ING. JOSÉ RODRÍGUEZ RUIZ

Varios .format() dentro de un print()

El método .format() se puede usar repetidamente dentro de un print() para controlar
individualmente el formateo de cada dato que se vaya a imprimir. El siguiente ejemplo utiliza
cuatro .format() para imprimir los cuatro datos:

NOMBRE, SAL. BRUTO, IMPUESTO y [Link].

print("{:>16}".format("NOMBRE"), "{:>24}".format("SAL. BRUTO"),

"{:>11}".format("IMPUESTO"), "{:>12}".format("SAL. NETO"))

Cada dato, con su respectivo método .format(), se separa del siguiente con una coma ( , ).

El resultado de este print es:

14
PROGRAMACIÓN ORIENTADA A OBJETOS ING. JOSÉ RODRÍGUEZ RUIZ

VARIOS VALORES DENTRO DEL MISMO FORMAT( )

En la sección anterior hemos visto varios métodos .format con un solo valor dentro de sus
paréntesis, como en el ejemplo anterior que utilizaba cuatro .format() para imprimir los
cuatro datos:

NOMBRE, SAL. BRUTO, IMPUESTO y [Link].

Con la instrucción

print("{:>16}".format("NOMBRE"), "{:>24}".format("SAL. BRUTO"),

"{:>11}".format("IMPUESTO"), "{:>12}".format("SAL. NETO"))

Pero se puede escribir una instrucción equivalente que de el mismo resultado escribiendo
dentro de un solo format los cuatro datos. Esto hará que la instrucción sea más compacta y
ocupe menos espacio. Entonces, la instrucción anterior se puede reescribir así:

print("{:>16}" "{:>24}""{:>11}" "{:>12}".format(“NOMBRE”, “SAL. BRUTO”,

“IMPUESTO”, "SAL. NETO"))

Observe que entre las llaves "{:>16}" "{:>24}" "{:>11}" "{:>12}" que indican el
formato de cada dato no hay comas de separación.

15
PROGRAMACIÓN ORIENTADA A OBJETOS ING. JOSÉ RODRÍGUEZ RUIZ

Un segundo ejemplo es:

"{:^10}” “{:^12}".format("i", "xi*xi")

Observe nuevamente que entre las llaves {:^10} y {:^12} no hay comas de separación. La
instrucción anterior es equivalente a los siguientes dos format():

"{:^10}".format("i"), "{:^12}".format("xi*xi")

De esta manera se puede abreviar la escritura de los formatos de impresión. Al momento

de imprimirse ambas formas mostrarán lo mismo:

i xi*xi
El siguiente programa utiliza esta forma de escribir format()

'''PROGRAMA formatoMultiple
Imprime una tabla del cuadrado de los números enteros del 1 a N

'''
i= 0
xi= 0

N= int(input("Hasta que número quieres la tabla? "))

print("{:^10}{:^12}".format("i", "xi*xi"))
print("{:^22}".format("-"*17))

while i< N:
i= i+1
xi= pow(i,2)
print("{:>5}{:>13}".format(i, xi))

print("\nFin de tabla")

Una salida de ejemplo para N= 6 es:

16
PROGRAMACIÓN ORIENTADA A OBJETOS ING. JOSÉ RODRÍGUEZ RUIZ

Formateo de números
También se puede reservar la cantidad de columnas que se desean para imprimir números
enteros o reales (float). Para esto se toman en cuenta los dígitos, el punto decimal (solo para
números float) y el posible signo algebráico ( + ó - ). Tanto el punto decimal como el
signo ocupan una columna.

Formateo de números enteros

Un número entero tiene dígitos (del 0 al 9) y un posible signo algebráico. El signo negativo
es obligatorio.

La forma general de un print que utilice al método format() con números enteros es:

print( “{:nd }”.format(dato entero) )

donde n es la cantidad de columnas que se quieren reservar para imprimir el número entero, y
d es simplemente el símbolo que le indica al interprete Python que se va a imprimir un número
entero. Ejemplo:

print("{:10d}".format(324))

Esta instrucción ocupa 10 columnas para imprimir el número entero 324, empezando desde
la derecha. Como se pidieron 10 columnas y 324 sólo ocupa 3, entonces Python pone 7
espacios a la izquierda para llenar las 10 posiciones. Esto se muestra en el siguiente programa.

'''PROGRAMA FormatNumerosEnterosConEspacios
Muestra ejemplos de como utilizar el método .format() para formatear la salida de
datos numéricos enteros, rellenando con espacios a la izquierda del número si este
no ocupa todas las posiciones.
AUTOR: ing. josé Rodríguez Ruiz depto. Sistemas y Computación ITCelaya
'''
17
PROGRAMACIÓN ORIENTADA A OBJETOS ING. JOSÉ RODRÍGUEZ RUIZ

print("Numero impreso por default, es decir, sin formateo")

print("----5---10---15---20")
print(324)

print("\n#Formateo de números enteros, rellenados con espacios")

print("Numero impreso en 10 columnas")

print("----5---10---15---20")
print("{:10d}".format(324))

print("\nNumero impreso en 13 columnas")

print("----5---10---15---20")
print("{:13d}".format(-1324))
print("\nNumero impreso en 20 columnas")
print("----5---10---15---20")
print("{:20d}".format(32))

La salida de este programa es:

Rellenar espacios con ceros

Si se desea rellenar con ceros en vez de con espacios, entonces sólo hay que poner un cero
antes del valor de n, de la siguiente manera:

print("{:010d}".format(824))

18
PROGRAMACIÓN ORIENTADA A OBJETOS ING. JOSÉ RODRÍGUEZ RUIZ

Esta instrucción ocupa 10 columnas para imprimir el número entero 824, empezando desde
la derecha. Como se pidieron 10 columnas y 824 sólo ocupa 3, entonces Python pone 7 ceros
a la izquierda para llenar las 10 posiciones. Esto se muestra en el siguiente programa.

'''PROGRAMA formatNumerosEnterosConCeros
Muestra ejemplos de como utilizar el método .format() para formatear la salida de
datos numéricos enteros, rellenando con ceros a la izquierda del número si este no
ocupa todas las posiciones.
AUTOR: ing. josé Rodríguez Ruiz depto. Sistemas y Computación ITCelaya

'''

print("Numero impreso por default, es decir, sin formateo")

print("----5---10---15---20")
print(324)

print("\n#Formateo de números enteros, rellenados con ceros")

print("Numero impreso en 10 columnas")
print("----5---10---15---20")
print("{:010d}".format(824))

print("\nNumero impreso en 13 columnas")

print("----5---10---15---20")
print("{:013d}".format(-1324))

print("\nNumero impreso en 20 columnas")

print("----5---10---15---20")
print("{:020d}".format(32)) '''

La salida de este programa es:

19
PROGRAMACIÓN ORIENTADA A OBJETOS ING. JOSÉ RODRÍGUEZ RUIZ

Se hace lo mismo para números float (reales) . Si se desea rellenar con ceros en vez de con
espacios, entonces sólo hay que poner un cero antes del valor de n, de la siguiente manera:

print("{:010.2f}".format(824.47))

Esta instrucción ocupa 10 columnas para imprimir el número float 824.47, empezando desde
la derecha. Se reservaron 10 columnas totales, y de esas 2 son para la parte fraccionaria.
Como se pidieron 10 columnas y 824.47 sólo ocupa 6, entonces Python pone 4 ceros a la
izquierda para llenar las 10 posiciones. Esto se muestra en el siguiente programa.

Los números reales se denominan float en Python. Un número float consta de una parte
entera separada de una parte fraccionaria por un punto. Pueden ser positivos o negativos.
Ejemplos:

123.98 +765.098 -25.99 0.0000056478 0.0 - 0.345 3.141659 56.0

A la cantidad de dígitos de la parte fraccionaria se le conoce como la precisión del número.

Por ejemplo, la constante PI con:

20
PROGRAMACIÓN ORIENTADA A OBJETOS ING. JOSÉ RODRÍGUEZ RUIZ

2 dígitos de precisión es 3.14

4 dígitos de precisión es 3.1416
8 dígitos de precisión es 3.14159265

También se dice que

3.1 tiene una precisión de décimas

3.14 tiene una precisión de centésimas
3.1416 tiene una precisión de diezmilésimas, etc.

La precisión la decide el usuario dependiendo de cuál sea el propósito para ese número. Por
ejemplo, es común que una cantidad en pesos y centavos tenga una precisión de dos dígitos (a
centésimas). Una aproximación comúnmente utilizada para la constante PI es 3.1416, que tiene
una precisión de 4 dígitos (a diezmilésimas).

Formateo de números float (reales)

Para formatear con el método .format() un número float hay que especificar dos partes
importantes:

• Cuántas columnas o posiciones para el número completo (parte entera, parte

fraccionaria, punto decimal y un posible signo algebráico).
• Cuántas columnas para la parte fraccionaria.

Por ejemplo,

El número 3.14 necesita un mínimo de 4 posiciones.

El número +3.14 necesita un mínimo de 5 posiciones.
El número -4563.89073 necesita un mínimo de 11 posiciones.

La forma general de un print que utilice al método format() con números float es:

print( “{:n.m f }”.format(dato float) )

donde n es la cantidad total de posiciones para imprimir el número, m es la cantidad de dígitos

fraccionarios que se desea conservar y f es el símbolo que le indica a Python que trate al número
como flotante. Ejemplos

print( "{:15.4f}".format(234.7642))

En el print() se indica que para imprimir el número 234.7642 se reservan quince columnas
(posiciones) en total, y de ese total, tres son para la parte entera, una para el punto decimal y
cuatro para la parte farccionaria. Como esto da un total de ocho posiciones, y se reservaron
quince, entonces la diferencia entre 15 - 8 (7 posiciones) se rellenarán con 7 espacios a la
izquierda del número; esto se muestra a continuación:

21
PROGRAMACIÓN ORIENTADA A OBJETOS ING. JOSÉ RODRÍGUEZ RUIZ

1 5 10 15 20 25 30 35 # números de las columnas de la pantalla

234.7642

Dos casos importantes son:

Caso 1.- Si m es menor a la cantidad de dígitos fraccionarios, la parte fraccionaria se corta y

se redondea. Ejemplos

a) print( "{:15.1f}".format(234.7642))

1 5 10 15 20 25 30 35 # estos números indican posiciones

234.8 # el primer dígito eliminado es mayor a 5, el 7 del número original pasa a 8

b) print( "{:15.3f}".format(234.7642))

5 10 15 20 25 30 35 # estos números indican posiciones

234.764 # el primer dígito eliminado no es mayor a 5, no hay cambio en los dígitos

Caso 2.- Si m es mayor a la cantidad de dígitos fraccionarios, se añaden ceros a la derecha del
número. Ejemplo

a) print( "{:15.7f}".format(234.7642))

5 10 15 20 25 30 35 # estos números indican posiciones

234.7642000 # se añaden 3 ceros a la derecha del número

Lo anterior se muestra en el siguiente programa.

La salida de este programa es:

22
PROGRAMACIÓN ORIENTADA A OBJETOS ING. JOSÉ RODRÍGUEZ RUIZ

Justificación de datos numéricos

Similar a las cadenas, los números enteros y flotantes pueden controlar sus alineaciones (o
justificaciones) a la derecha, al centro o a la izquierda, con los símbolos:

:> n Indica alineación a la derecha utilizando n columnas.

:ˆ n Indica alineación al centro utilizando n columnas.
:< n Indica alineación a la izquierda utilizando n columnas.

Donde n es la cantidad de columnas que se quieren utilizar

El siguiente programa ilustra lo anterior

''' PROGRAMA pythonFormateoFloat2
Muestra como controlar la justificación de números float con el método format()
AUTOR: Ing. José Rodríguez Ruiz ITCelaya Depto. Sistemas

23
PROGRAMACIÓN ORIENTADA A OBJETOS ING. JOSÉ RODRÍGUEZ RUIZ

dato= 5274.613
print("\nJustificación a la izquierda")
print( "{:<25.4f}".format(dato))

print("\nJustificación al centro")
print( "{:^25.4f}".format(dato))

print("\nJustificación a la derecha")
print( "{:>25.4f}".format(dato))

La salida es:

A continuación, se presenta una segunda versión del programa listaPreciosGorditas que

imprime una lista con los precios de gorditas, que ahora incluye la instrucción format() para
controlar completamente la manera en que se quiere mostrar la salida en el formato que se
diseñó al analizar la salida del problema.

'''PROGRAMA listaPreciosGorditasVersión 2
Imprime una lista de los precios de quesadillas, gorditas y refresco. Utiliza un ciclo while
con contador para imprimir la lista que incluye formateo con el método .format()
AUTOR: ing. josé Rodríguez Ruiz depto. Sistemas y Computación ITCelaya
'''
PRECIO_QUESADILLA= 15.0
PRECIO_GORDITA= 20.0
PRECIO_REFRESCO= 13.0
renglones= int(input("cuantos renglones para la lista? "))

print("{:>29}".format("FRITANGAS LINCE", sep=""))

print("{:>30}".format("LISTA DE PRECIOS", sep="" ))
#print("{:>29}" "{:>30}".format("FRITANGAS LINCE\n","LISTA DE PRECIOS\n",
sep="" ))

24
PROGRAMACIÓN ORIENTADA A OBJETOS ING. JOSÉ RODRÍGUEZ RUIZ

print("{:>7}".format("CANT"),"{:>12}".format("QUESADILLAS"),
"{:>10}".format("GORDITAS")
"{:>11}".format("REFRESCOS"),sep="")
#print("{:>7}”"{:>12”"{:>10}""{:>11}".format("CANT","QUESADILLAS","GORDITA
S","REFRESCOS"),sep="")

cant= 1
while cant <= renglones:
quesadilla= cant * PRECIO_QUESADILLA
gordita= cant * PRECIO_GORDITA
refresco= cant * PRECIO_REFRESCO

print("{:>6}".format(cant), "{:>11.2f}".format(quesadilla),
"{:>11.2f}".format(gordita), "{:>11.2f}".format(refresco), sep="")

#print("{:>6}""{:>11.2f}""{:>11.2f}""{:>11.2f}".format(cant,quesadilla,gordita,refresco),
sep= "")

cant= cant + 1

print("\nFin de lista")

Una salida para 11 renglones es:

Observe que ahora las columnas ya no están distorsionadas y que el punto decimal de los
números reales está en la misma columna.

25
PROGRAMACIÓN ORIENTADA A OBJETOS ING. JOSÉ RODRÍGUEZ RUIZ

Explicación del diseño del formato de salida

Como se mencionó anteriormente, para hacer el diseño del formato de salida se puede utilizar
una hoja de cuadrícula para definir perfectamente, con números, los renglones y columnas
donde se van a imprimir los diferentes elementos de la salida.
En esta explicación se tomará como ejemplo la salida del programa
listaPreciosGorditasConFormato.

El siguiente diagrama muestra una matriz de seis renglones y cuarenta y dos columnas.

1 1 1 1 1 1 1 1 1 1 2 2 2 2 2 2 2 2 2 2 3 3 3 3 3 3 3 3 3 3 4
1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0
F R I T A N G A S L I N C E
L I S T A D E P R E C I O S
C A N T Q U E S A D I L L A S G O R D I T A S R E F R E S C O S
# # # # # # . # # # # # # . # # # # # # . # #
1 1 5 . 0 0 2 0 . 0 0 1 3 . 0 0
2 3 0 . 0 0 4 0 . 0 0 2 6 . 0 0

La matriz se llena manualmente, de preferencia a lápiz para poder hacer modificaciones

fácilmente de ser necesario. Generalmente los diseños son centrados.
Una vez que se tiene el diseño deseado, se utilizan instrucciones print() para implementar
el diseño en el código Python.
CÁLCULO DE LAS COLUMNAS PARA CADENAS
Para el primer renglón, se observa que la frase “FRITANGAS LINCE” termina en la
columna 29, por tanto en el método .format() se reservan 29 posiciones con alineación a la
derecha de la siguiente manera:

print("{:>29}”.format(“FRITANGAS LINCE"))

La frase “LISTA DE PRECIOS” del segundo renglón termina en la columna 30. Entonces,
la instrucción print() reserva para ese renglón 30 columnas con alineación a la derecha así:

print("{:>30}”.format(“LISTA DE PRECIOS"))

En el tercer renglón se imprimen con un solo print() cuatro datos, cada uno con su
respectivo método .format().
Observe que CANT es el primer dato del renglón y termina en la columna 7. Entonces se
reservan las primeras 7 columnas para imprimir CANT.

En general, para calcular la cantidad de columnas totales para imprimir del segundo dato
en adelante se resta el número de la columna donde termina el dato que se va a imprimir
menos el número de la columna donde termina el dato inmediatamente anterior.
Aplicando lo anterior, Para determinar la cantidad de columnas totales que se requieren
para QUESADILLAS se hace la resta de 19, que es la columna donde termina
QUESADILLAS, menos 7, que es la columna donde termina CANT.

26
PROGRAMACIÓN ORIENTADA A OBJETOS ING. JOSÉ RODRÍGUEZ RUIZ

Se tiene entonces 19 – 7= 12. Esto significa que las siguientes 12 columnas después de 7
son para QUESADILLAS.
Similarmente, para calcular las columnas para GORDITAS la resta es 29 – 19= 10; para
REFRESCOS es 40 – 29= 11. Entonces, el print() respectivo es:

print("{:>7}".format("CANT"), "{:>12}".format("QUESADILLAS"),
"{:>10}".format("GORDITAS"), "{:>11}".format("REFRESCOS"), sep="")

Es importante observar que el print() termina con el argumento sep="" para eliminar el
espacio que pone print() por default cuando los datos a imprimir están separados por una
coma. Revisar tema Argumento sep= de la página 49, unidad I.

CÁLCULO DE LAS COLUMNAS PARA NÚMEROS

De manera similar, para imprimir los valores numéricos de la cuarta línea en adelante, se
toman en cuenta los números de las columnas donde termina cada número. El valor para
CANT termina en la columna 6, para QUESADILLAS en la 17, para GORDITAS en la 28
y para REFRESCOS en la 39. Entonces, para imprimir el valor para CANT se pone
directamente en el método format() un 6.
Para calcular el número de columnas para cada uno de los otros valores se hacen las
siguientes restas:

Para quesadillas: 17 – 6 = 11
Para gorditas : 28 – 17= 11
Para refrescos: 39 – 28= 11

Finalmente se toma en cuenta la precisión del número que se va a imprimir. En este caso,
por ser pesos y centavos, la precisión es de dos dígitos fraccionarios. Por tanto, el print() que
imprime el cuarto renglón es el siguiente:

print("{:>6}".format(cant), "{:>11.2f}".format(quesadilla),
“{:>11.2f}".format(gordita), "{:>11.2f}".format(refresco), sep= "")

Otro ejemplo de un lazo while controlado por contador es el siguiente:

Calcular el salario semanal de varios empleados de una empresa. Los datos de cada
empleado son: nombre, pago por hora y horas trabajadas en la semana. El número de
empleados también es un dato.
Hay un impuesto del 25% sobre el salario bruto (horas multiplicadas por pago x hora). El
salario neto semanal es el salario bruto menos el impuesto. La salida debe ser un reporte con
el siguiente formato:

27
PROGRAMACIÓN ORIENTADA A OBJETOS ING. JOSÉ RODRÍGUEZ RUIZ

EMPRESAS LINCE
REPORTE DE NOMINA SEMANAL
NOMBRE SAL. BRUTO IMPUESTO SAL. NETO
XXXXXXXXXX ####.## ####.## ####.##
. . . ... . . . ...
XXXXXXXXXX ####.## ####.## ####.##

En este diseño se indica una cadena de caracteres con una sucesión de X; para un numero
real cada dígito se indica con un símbolo de número (#) y un punto decimal. Los puntos
suspensivos indican que puede haber varias líneas de salida.

El programa es el siguiente:

'''PR0GRAMA salarioSemanalSinConcatenarSalida
Calcula el salario semanal neto (salario con descuento de impuesto) de varios empleados
de una empresa. Los datos de cada empleado son: nombre, horas semanales trabajadas y pago
por hora. El numero de empleados también es un dato.
AUTOR: ing. josé Rodríguez Ruiz depto. Sistemas y Computación ITCelaya
'''
PORCENTAJE_IMPUESTO= 0.25
numEmpleados= int( input("cuantos empleados? ") )

print("{:>44}".format("EMPRESAS LINCE"))
print("{:>50}".format("REPORTE DE NOMINA SEMANAL"))
print("{:>16}".format("NOMBRE"), "{:>24}".format("SAL. BRUTO")
,"{:>11}".format("IMPUESTO"), "{:>11}".format("SAL. NETO"))
contador= 1
while contador <= numEmpleados:
nombre= input("Nombre del empleado? ")
horas= int(input("Horas trabajadas? "))
pagoHora= float(input("Pago por hora? "))

salarioBruto= horas * pagoHora;

impuesto= PORCENTAJE_IMPUESTO * salarioBruto;
salarioNeto= salarioBruto - impuesto;

print("{:25}" "{:14.2f}" "{:11.2f}" "{:11.2f}".format(nombre, salarioBruto,

impuesto,salarioNeto) )

contador= contador + 1;
print("Fin de reporte") # esta instrucción ya no es parte del ciclo while

Tal como está escrito el programa, con los datos:

28
PROGRAMACIÓN ORIENTADA A OBJETOS ING. JOSÉ RODRÍGUEZ RUIZ

NOMBRE HORAS PAGO POR HORA

Javier Martinez Lugo 40 92.00
Maria Sandoval Vera 38 102.40
Roberto Solis Ortiz 40 101.10
Carmen Garcia Nieto 39 105.00

su salida es la siguiente:

En este caso, la salida está mezclada con los datos de entrada, por lo que no es legible.
Aunque el resultado es correcto numéricamente, una persona tendrá dificultades para
comprenderla.
Para resolver está situación y tener una salida más adecuada y fácilmente comprensible se
requiere que las líneas de salida para cada empleado se almacenen temporalmente como
una cadena (string) en una variable que se imprimirá cuando finalice el ciclo while.
Para esto se requiere la operación de contatenación de cadenas. Concatenar cadenas
significa unir una cadena al final de la cadena anterior para tener como resultado una cadena
más grande. Se podría decir que concatenar significa “sumar” cadenas. En Python la
concatenación se hace con el símbolo “+”.
Ejemplo, si se tienen las siguientes tres cadenas

cadena1= “Hola “
cadena2= “amigos. Bienvenidos “
cadena3= “a mi casa.”

Entonces la concatenación cadena4= cadena1 + cadena2 + cadena3 da como resultado

una sola cadena:
“Hola amigos. Bienvenidos a mi casa.”

29
PROGRAMACIÓN ORIENTADA A OBJETOS ING. JOSÉ RODRÍGUEZ RUIZ

[Link].2 CÓMO CONCATENAR EN UNA VARIABLE TODAS LAS LÍNEAS DE

SALIDA DEL PROGRAMA
Al correr un programa, por default el resultado o salida se muestra mezclado con los datos
de entrada, lo que puede dificultar visualizar la salida, o sea, el resultado del problema que
se está resolviendo. Esto ya se mostró en la salida del programa de la sección anterior llamado
salarioSemanalSinConcatenarSalida.
Para evitar esta mezcla, se puede usar una variable que concatene y almacene en memoria
todas las líneas de salida hasta el momento de imprimirlas. Esto se muestra en el siguiente
programa, donde la variable llamada salida almacena todas las líneas concatenadas.

'''PROGRAMA salarioSemanalConcatenarSalida
El programa calcula el salario semanal neto (salario con descuento de impuesto) de varios
empleados de una empresa. Los datos de cada empleado son: nombre, horas semanales
trabajadas y pago por hora. El numero de empleados también es un dato.
Para evitar que los datos de entrada se intercalen con las líneas del resultado, primero se
almacenan en la variable salida, de tipo string, todas las líneas que se quieren mostrar en la
salida. Despues manda la variable salida a pantalla con una instruccion print(salida).
AUTOR: ing. josé Rodríguez Ruiz depto. Sistemas y Computación ITCelaya
'''
PORCENTAJE_IMPUESTO= 0.25;

salida= "" #Inicialmente la variable de salida está vacía.

numEmpleados= int( input("cuantos empleados? ") )

salida= salida + "{:>44}".format("EMPRESAS LINCE\n")

salida= salida + "{:>50}".format("REPORTE DE NOMINA SEMANAL\n")
salida= salida + "{:>16}".format("NOMBRE")+ "{:>24}".format("SAL. BRUTO")
salida= salida + "{:>11}".format("IMPUESTO")+ "{:>11}".format("SAL. NETO\n")
contador= 1;
while contador <= numEmpleados:
nombre= input("Nombre del empleado? ")
horas= int(input("Horas trabajadas? "))
pagoHora= float(input("Pago por hora? "))

salarioBruto= horas * pagoHora;

impuesto= PORCENTAJE_IMPUESTO * salarioBruto;
salarioNeto= salarioBruto - impuesto

salida=salida+"{:25}" "{:14.2f}" "{:12.2f}""{:11.2f}".format(nombre, salarioBruto,

impuesto, salarioNeto) + "\n"

contador= contador + 1

print(salida) # Observe que estas dos instrucciones no están indentadas

print("Fin de reporte") # por lo que no pertenecen al ciclo while.

30
PROGRAMACIÓN ORIENTADA A OBJETOS ING. JOSÉ RODRÍGUEZ RUIZ

En la versión anterior de este programa, se utilizaba la función print() para imprimir

inmediatamente las diferentes líneas de la [Link] ejemplo, la primera línea de la salida es

print("{:>44}".format("EMPRESAS LINCE"))
Ahora, en la segunda versión del programa, las instrucciones que utilizan el operador de
asignación (=) y que tienen la forma general:

salida= salida + cadena

le indican a la máquina que en vez de mandar a la pantalla de salida las cadenas, las guarde
en la variable salida, la cual estará almacenada en la memoria de la computadora. Por
ejemplo, la primera línea de la salida en el programa anterior se puede escribir así:

salida= salida + "{:>44}".format("EMPRESAS LINCE\n")

Así, cualquier instrucción que empiece con salida se concatenará y se almacenará en
memoria a la espera de que se le mande a la pantalla del monitor.
Cuando se quiera visualizar todo el contenido de la variable salida, entonces se utilizará la
instrucción de salida print() del siguiente modo:

print(salida)

Tal como está ahora escrito el programa, con los datos:

NOMBRE HORAS PAGO POR HORA

Javier Martinez Lugo 40 92.00
Maria Sandoval Vera 38 102.40
Roberto Solis Ortiz 40 101.10
Carmen Garcia Nieto 39 105.00

su salida es la siguiente:

31
PROGRAMACIÓN ORIENTADA A OBJETOS ING. JOSÉ RODRÍGUEZ RUIZ

Observar que ahora los datos de entrada están separados de la salida y son más fáciles de
leer y comprender por una persona.
La ejecución de este programa procedió así: al inicio de la ejecución del programa se piden
los datos. Después se procesan los datos con las instrucciones

salarioBruto= horas * pagoHora;

impuesto= PORCENTAJE_IMPUESTO * salarioBruto
salarioNeto= salarioBruto - impuesto

y cada línea del resultado para un empleado se almacena en memoria en la variable salida
por medio de la siguiente instrucción:

salida=salida+"{:25}" "{:14.2f}" "{:12.2f}""{:11.2f}".format(nombre, salarioBruto,

impuesto, salarioNeto) + "\n"

Un ejemplo particular de una línea almacenada en la variable salida es:

Javier Martínez Lugo 3680.00 920.00 2760.00

Cuando termina la ejecución del ciclo while se tienen todas las líneas del reporte en la
variable salida. Entonces se utiliza la instrucción

print(salida)

para mandar todas las líneas del resultado de una sola vez.
Ahora ya no se tiene mezclada la entrada de datos con la salida y el reporte se puede leer y
apreciar con toda facilidad. Las instrucciones del programa que permiten realizar este tipo de
salida son las que están resaltadas en negrita.

32
PROGRAMACIÓN ORIENTADA A OBJETOS ING. JOSÉ RODRÍGUEZ RUIZ

[Link].3 VALIDACIÓN DE DATOS DE ENTRADA. Una aplicación frecuente de los

lazos es para implementar la validación de los datos de entrada. Validar significa asegurarse
que los datos sean los apropiados para el problema que se está resolviendo, o de lo contrario
no se aceptarán y debe pedirse al usuario que los vuelva a teclear. Este proceso debe continuar
mientras se sigan proporcionando datos incorrectos.

VALIDACIÓN DE DATOS NUMÉRICOS.

Esta validación consiste en asegurarse que los datos sean apropiados para las operaciones
del problema. Por ejemplo, para leer datos que representen calificaciones enteras en el rango
de 0 a 100, si se teclea 85, se debe aceptar. Pero si se teclea un -80 o un 110 ninguna de ellas
se debe aceptar y se debe pedir al usuario que rectifique su calificación y la vuelva a teclear.
Los siguientes ejemplos ilustran la utilización de while para implementar la verificación de
datos de entrada.
Ejemplo 1. Si se desea verificar que los datos de entrada solamente sean números mayores
a cero (números naturales) entonces se puede escribir el siguiente código:
# código de 5 instrucciones para verificar que el numero leído sea mayor a cero
numero= int(input( "Dame un numero mayor a cero: ") )

while numero<= 0:
print("Error. El numero es cero o negativo. Dame un numero mayor a cero: ")
numero= int(input( "Dame un numero mayor a cero: ") )

print(“El número leído es “, numero”)

Si se analiza este código se verá que el lazo while se ejecutará mientras sea verdadero que
la variable numero sea menor o igual a cero, lo que significa que hay un error en el dato
leído. Si se lee un valor que sea cero o negativo, la condición (numero<= 0) será verdadera
y se volverá a entrar al lazo para pedir nuevamente un número. Mientras se sigan metiendo
números que hagan verdadera a la condición se estará “atrapado” en el lazo. La única manera
de salir del lazo es introduciendo un valor mayor a cero que haga falsa a la condición. En
Python, la salida es:

33
PROGRAMACIÓN ORIENTADA A OBJETOS ING. JOSÉ RODRÍGUEZ RUIZ

Ejemplo 2. Para verificar que un número esté en un cierto rango, por ejemplo, entre 0 y
100, se puede escribir el siguiente código, suponiendo que el número es una calificación:

''' Verificar que la calificación (valor entero) este en el rango 0 a 100, limites incluidos. Es
decir, no se permiten calificaciones fuera del rango 0 a 100. '''

calificación= int( input("Dame una calificación entre 0 y 100: ") )

while (calificación< 0) or (calificación > 100):

print( "Error en la calificación. Dame una calificacion entre 0 y 100 ")
calificación= int( input("Dame una calificación entre 0 y 100: ") )

print("\nLa calificación ", calificación, " es correcta") # este print no es parte del while

Este ejemplo utiliza la condición compuesta ((calificacion< 0) or (calificacion > 100)) que
incluye las dos condiciones individuales

(calificacion< 0) (calificacion > 100)

unidas por el operador lógico or.

Una condición compuesta con or es verdadera si por lo menos una de sus condiciones
individuales es verdadera. Por lo tanto, si la calificación es menor a cero (calificación
negativa) no se debe aceptar; ó si es mayor a 100 (calificación mayor al máximo) tampoco
se debe aceptar. Si cualquiera de las condiciones es verdadera, la calificación no se acepta y
se regresa al inicio del while para volver a pedir la calificación. El ciclo while continuará su
ejecución mientras su condición booleana sea verdadera, es decir, mientras la variable
numero tenga un valor fuera del rango 0 a 100, y terminará cuando tenga un valor dentro del
rango. De esta manera se evita procesar calificaciones incorrectas.
Una salida de ejemplo es:

34
PROGRAMACIÓN ORIENTADA A OBJETOS ING. JOSÉ RODRÍGUEZ RUIZ

VALIDACIÓN DE DATOS CADENA DE CARACTERES

Para verificar datos cadena no se tienen reglas definidas como en el caso de los números.
Por ejemplo, al verificar el nombre de una persona es difícil determinar si es correcto o
incorrecto porque un mismo nombre puede ser escrito de varias maneras. Por ejemplo, una
persona puede escribir su nombre con la cadena Javier, mientras que otra persona puede
escribirlo como Xavier, y otra como Jhavier. En los tres casos el nombre es correcto si así es
como se registró en las actas de nacimiento respectivas. La dificultad de verificar datos
cadena se puede comprobar al utilizar paquetes de software que hacen correcciones
automáticas. Al momento de estar escribiendo este texto, el procesador Word me marca como
erróneo el nombre Jhavier.
Por tanto, para verificar un dato cadena lo que se puede hacer es pedir al usuario la
comprobación de la cadena pidiéndole que la vuelva a teclear en caso que sea incorrecta. Esta
técnica se ilustra a continuación:

nombre= input("Cual es tu nombre: ")

respuesta= input("El nombre es correcto s)i o n)o? ")

while respuesta== "N" or respuesta== "n":

nombre= input("Cuál es tu nombre: ")
respuesta= input("El nombre es correcto s)i o n)o? ")

print("\nTu nombre es: ", nombre)

Se pide al usuario que teclee su nombre y después se le solicita que confirme si es correcto.
Si lo es, contestará con una s, la cual hará falsa a la condición y abandonará el lazo. Pero si
contesta con una n entonces la condición será verdadera y se volverá a entrar al ciclo para
volver a pedir el nombre.
Una salida de ejemplo es:

35
PROGRAMACIÓN ORIENTADA A OBJETOS ING. JOSÉ RODRÍGUEZ RUIZ

BEEP (TIMBRE) PARA ALERTAR DE DATOS INCORRECTOS

Python tiene el módulo winsound que incluye la función Beep(frecuency, duration).
Esta función emite un sonido tipo timbre con la frecuencia señalada por el parámetro
frecuency y con duración en milisegundos señaladsa por el parámetro duration.
Para utilizar el beep se debe importar el módulo con la instrucción

import winsound

y después se puede escribir una pequeña función que active el beep cuando la función sea
invocada (llamada) por otro código. La función es la siguiente:

def suenaBeep(frecuency, duration):

[Link](frequency, duration)

Este es un ejemplo de una función creada por el usuario. Estas funciones se estudiarán en
el capítulo 3.
Esta función recibe como parámetros los valores de frecuencia y duración. Dentro de esta
función esta la instrucción que genera el sonido. Los valores para los parámetros los manda
el código que invoca (llama) a la función. Un ejemplo es el siguiente:

suenaBeep(1000, 900)

El siguiente programa de ejemplo utiliza verificaciones de datos de entrada con la

utilización de la función suenaBeep(). El peoblema es el siguiente:

Escribir un programa que calcule el salario semanal, incluyendo impuestos, de cada uno
de los empleados de una fábrica. El salario se calcula multiplicando las horas semanales
trabajadas por el pago por hora. El impuesto es el 15% del salario.
Se debe validar que las horas trabajadas estén en el rango 35 a 50, que el pago por hora no
sea menor a $50.00 ni mayor a $100.00, y que el departamento sea A, B, C. Si hay algún
error en los datos, sew debe sonar el beep.
Los datos de entrada para cada empleado son el nombre, las horas semanales trabajadas, el
pago por hora y el departamento al que está asignado (A, B, C).

'''PROGRAMA calculoSalarioValidacion
Calcula el salario semanal delos empleados de una empresa. El empleado esta asignado a
uno de los tres departamentos de la empresa (A, B, C). El salario se calcula multiplicando el
numero de horas trabajadas por el pago por hora. Hay un impuesto del 15% sobre el salario.
AUTOR: ing. josé Rodríguez Ruiz depto. Sistemas y Computación ITCelaya
'''
import winsound

def suenaBeep():
[Link](frequency, duration)

36
PROGRAMACIÓN ORIENTADA A OBJETOS ING. JOSÉ RODRÍGUEZ RUIZ

# ++++++++++++++++++ Sección del programa principal

TASA_IMPUESTO= 0.15
salida= ""

salida= salida + ("{:>40}".format("EMPRESAS LINCE\n"))

salida= salida + ("{:>49}".format("TALON DE PAGO PARA EL EMPLEADO\n"))
salida= salida + ("{:>13}".format("NOMBRE") +"{:>20}".format("DEPTO.") +
"{:>10}".format("SALARIO") +"{:>11}".format("IMPUESTO") +
"{:>8}".format("PAGO\n"))

numEmpleados= int(input("Cuantos empleados? "))

cuentaEmpleados= 1

while cuentaEmpleados <= numEmpleados:

# lectura y verificación del nombre
nombreEmp= input("Cuál es tu nombre: ")
respuesta= input("El nombre es correcto s)i o n)o? ")
respuesta= [Link]()

while respuesta == 'n':

suenaBeep(1000, 900) # primera invocación a esta función
nombreEmp= input("Cuál es tu nombre: ")
respuesta= input("El nombre es correcto s)i o n)o? ")
respuesta= [Link]()

# lectura y verificación del departamento

departamento= input("En que departamento trabaja: A, B , C? ")
departamento= [Link]()

while departamento != 'A' and departamento != 'B' and departamento != 'C':

suenaBeep(1200, 950) #segunda invocación a esta función
departamento= input("En que departamento trabaja: A, B , C? ")
departamento= [Link]()

#lectura y verificación de horas trabajadas

horasTrab= int( input("Cuantas horas trabajo en la semana: 35 a 50? ") )

while (horasTrab < 35) or (horasTrab > 50):

suenaBeep(850, 1300) #tercera invocación a esta función
horasTrab= int( input("Cuantas horas trabajo en la semana? ") )

#lectura y verificación de pago por hora

pagoxHora= float(input("Cual es su pago por hora? ") )

37
PROGRAMACIÓN ORIENTADA A OBJETOS ING. JOSÉ RODRÍGUEZ RUIZ

while (pagoxHora < 50.0) or (pagoxHora > 100.0):

suenaBeep(1200, 1000) #cuarta invocación a esta función
pagoxHora= float(input("Cual es su pago por hora: 50 a 100? ") )

salario= horasTrab * pagoxHora;

impuesto = salario * TASA_IMPUESTO
pago= salario - impuesto

salida= salida + ("{:25}".format(nombreEmp)+"{:>5}".format(departamento) +

"{:13.2f}".format(salario)+ "{:10.2f}".format(impuesto) +"{:10.2f}".format(pago)+ "\n")

cuentaEmpleados= cuentaEmpleados + 1

print("\n")
print(salida)

La salida para dos empleados es:

38
PROGRAMACIÓN ORIENTADA A OBJETOS ING. JOSÉ RODRÍGUEZ RUIZ

[Link] CONTROL DEL LAZO POR DATO CENTINELA

Esta forma de controlar un lazo consiste en incluir al final del conjunto de

datos que se van a procesar un grupo de datos, llamados centinela, que no serán
procesados por la computadora y cuya única función es la de indicar a la
máquina que se terminaron los datos procesables, por lo que el lazo se da por
terminado. Los datos centinela se escogen de tal modo que no exista la posibilidad de
confundirlos con datos procesables. Por ejemplo, si los datos procesables consisten solo de
números positivos, los datos centinela podrían ser números negativos.
El siguiente es el conjunto de datos para tres empleados con sus respectivos datos centínela:

NOMBRE HORAS PAGOxHORA.

Manuel Tovar Ramos 40 98.75
Andrea Vera Solis 43 88.05 datos procesables
Javier Jiménez Soto 40 88.05
$ -99 -999.99 datos centinela

A cada una de las columnas de datos se les llama campos, y a cada campo se les puede
asignar un dato centinela. Cada campo tiene dos tipos de datos: los datos procesables y el
dato centinela, que se coloca al final del campo.
Los datos centinela deben ser del mismo tipo de su campo: un campo string debe tener un
centinela string, un campo int debe tener un centinela int, y un campo float debe tener un
centinela float.
En este ejemplo el campo string NOMBRE tiene el centinela string “$”, el campo int
HORAS tiene el centinela int -99 y el float PAGOxHORA tiene el centinela float -999.99.
Además, los valores de los datos centinela se eligen de manera que no puedan ser
confundidos por datos procesables. Por ejemplo, el centinela $ difícilmente puede ser
confundido con el nombre de una persona. Asi mismo, el centínela -99 no podría confundirse
con horas de trabajo porque estas no pueden ser negativas. Razonamiento similar para el
centinela -999.99.
Aunque cada campo puede tener su centinela, en la condición booleana de un lazo while no
es necesario colocar todos los centinelas; uno es suficiente. Se elige uno de los campos para
utilizar su centinela.

A continuación, se presentará un pequeño código que mostrará como funciona un while con
centinela. El código calculará el sueldo semanal de cada empleado y lo imprimirá. Los datos
son como los del ejemplo de arriba. El centinela se toma del campo NOMBRE.

✓ Primero se pide el nombre, ya que este es el que va a “prestar” su centinela. Esto es

equivalente a inicializar la variable de control, la cual es nombreEmp.

nombreEmp= input("Teclea tu nombre o $ para salir del ciclo while: ")

✓ Ahora se establece el ciclo while y se compara la variable de control contra el

centinela.

39
PROGRAMACIÓN ORIENTADA A OBJETOS ING. JOSÉ RODRÍGUEZ RUIZ

while nombreEmp != “$”:

✓ Puesto que ya se leyó el dato nombre, ahora se piden los otros dos: horas y
pagoxhora:

while nombreEmp != “$”:

horasTrab= int( input("Cuantas horas trabajó en la semana? ") )
pagoxHora= float(input("Cual es su pago por hora? ") )

✓ Se calcula el salario y se imprime:

salario= horasTrab * pagoxHora

print(nombreEmp, “ $“, salario)

✓ Se pide el siguiente nombre. Esto es equivalente a modificar la variable de control

nombreEmp. Esta es la última instrucción del bloque de instrucciones del ciclo
while

nombreEmp= input("Teclea tu nombre o $ para salir del ciclo while: ")

Todo completo se ve así:

1. nombreEmp= input("Teclea tu nombre o $ para salir del ciclo while: ")

2. while nombreEmp != “$”:
3. horasTrab= int( input("Cuantas horas trabajó en la semana? ") )
4. pagoxHora= float(input("Cual es su pago por hora? ") )

5. salario= horasTrab * pagoxHora

6. print(nombreEmp, “ $“, salario)

7. nombreEmp= input("Teclea otro nombre o $ para salir del ciclo while: ")

Los números son solo para facilitar la siguiente explicación de la ejecución de

estealgoritmo; para correrlo hay que eliminarlos.

En el paso 1 se pide el primer nombre: Manuel Tovar Ramos.

En 2 se evalua la condición booleana: “ Manuel Tovar Ramos” != “$”
Que se interpreta así: ¿La cadena “Manuel Tovar Ramos” es diferente a la cadena “$”?
La respuesta es True, y se entra cuerpo del ciclo while.
En 3 se piden las horas que trabajó Manuel Tovar Ramos.
En 4 se piden el pago por hora para Manuel Tovar Ramos
En 5 se calcula el salario para Manuel Tovar Ramos.
En 6 se imprime su nombre y su salario.
En 7 se pide el siguiente nombre: Andrea Vera Solis.

40
PROGRAMACIÓN ORIENTADA A OBJETOS ING. JOSÉ RODRÍGUEZ RUIZ

Termina la primera repetición y se regresa al paso 2 para volver a evaluar la condición

“Andrea Vera Solis” != “$” , la cual sigue siendo True. Inicia segunda repetición.

En 3 se piden las horas que trabajó Andrea Vera Solis.

En 4 se piden el pago por hora para Andrea Vera Solis
En 5 se calcula el salario para Andrea Vera Solis.
En 6 se imprime su nombre y su salario.
En 7 se pide el siguiente nombre: Javier Jiménez Soto. .

Termina la segunda repetición y se regresa al paso 2 para volver a evaluar la condición

“Javier Jiménez Soto” != “$” , la cual sigue siendo True. Inicia tercera repetición.
En 3 se piden las horas que trabajó Javier Jiménez Soto .
En 4 se piden el pago por hora para Javier Jiménez Soto.
En 5 se calcula el salario para Javier Jiménez Soto.
En 6 se imprime su nombre y su salario.
En 7 se pide el siguiente nombre: es el centinela $.

Termina la tercera repetición y se regresa al paso 2 para volver a evaluar la condición

“$” != “$” , la cual es False porque la cadena “$” es igual a la cadena “$”.

El ciclo while termina porque ya se encontró el dato centinela y ya no hay más datos a
procesar.

El siguiente programa ilustra el ejemplo de arriba con más detalles, como el formato y la
concatenación de la salida, además de la validación de los datos de entrada.

'''PROGRAMA calculoSalarioCentinela
Utiliza un while controlado con dato centinela para calcular el salario semanal de los
empleados de una empresa. El empleado esta asignado a uno de los tres departamentos
de la empresa (A, B, C). El salario se calcula multiplicando el número de horas trabajadas
por el pago por hora. Hay un impuesto del 15% sobre el salario.
AUTOR: ing. josé Rodríguez Ruiz depto. Sistemas y Computación ITCelaya
'''
TASA_IMPUESTO= 0.15
salida= ""
salida= salida + ("{:>40}".format("EMPRESAS LINCE\n"))
salida= salida + ("{:>49}".format("TALON DE PAGO PARA EL EMPLEADO\n"))
salida= salida + ("{:>13}".format("NOMBRE") +"{:>20}".format("DEPTO.") +
"{:>10}".format("SALARIO")+"{:>11}".format("IMPUESTO")+
"{:>8}".format("PAGO\n"))

nombreEmp= input("Cuál es tu nombre o teclea la letra f para terminar: ")

respuesta= input("El nombre es correcto s)i o n)o? ")
respuesta= [Link]()

41
PROGRAMACIÓN ORIENTADA A OBJETOS ING. JOSÉ RODRÍGUEZ RUIZ

while respuesta!= 's': #ciclo while para validar el nombre

nombreEmp= input("Cuál es tu nombre: ")
respuesta= input("El nombre es correcto s)i o n)o? ")
respuesta= [Link]()

while nombreEmp != 'f': #Este es el while principal controlado por centinela

# lectura y verificación del departamento
departamento= input("En que departamento trabaja: A, B , C? ")
departamento= [Link]()

while departamento != 'A' and departamento != 'B' and departamento != 'C':

departamento= input("En que departamento trabaja: A, B , C? ")
departamento= [Link]()

#lectura y verificación de horas trabajadas

horasTrab= int( input("Cuantas horas trabajo en la semana? ") )

while (horasTrab < 35) or (horasTrab > 50):

horasTrab= int( input("Cuantas horas trabajo en la semana? ") )

#lectura y verificación de pago por hora

pagoxHora= float(input("Cual es su pago por hora? ") )

while (pagoxHora < 50.0) or (pagoxHora > 100.0):

pagoxHora= float(input("Cual es su pago por hora? ") )

salario= horasTrab * pagoxHora;

impuesto = salario * TASA_IMPUESTO
pago= salario - impuesto

salida= salida + ("{:25}" "{:>5}" "{:13.2f}" "{:10.2f}" "{:10.2f}".format(nombreEmp,

departamento, salario,impuesto, pago)+"\n")

nombreEmp= input("Cuál es tu nombre o teclea o la letra f para terminar: ")

respuesta= input("El nombre es correcto s)i o n)o? ")
respuesta= [Link]()

while respuesta != 's':

nombreEmp= input("Cuál es tu nombre: ")
respuesta= input("El nombre es correcto s)i o n)o? ")
respuesta= [Link]()

print("\n")
print(salida)

42
PROGRAMACIÓN ORIENTADA A OBJETOS ING. JOSÉ RODRÍGUEZ RUIZ

Probando el código con los siguientes datos:

NOMBRE DEPTO. HORAS PAGOxHORA.

Manuel Tovar Ramos B 40 98.75
Andrea Vera Solis A 43 88.05
Juan Flores Miranda C 40 96.50
F $ -99 -999.99

Una salida de ejemplo es:

Un segundo ejemplo de while con centinela es el siguiente.

La compañía de TRANSPORTES LINCE calcula el gasto semanal de gasolina de sus

vehículos de la siguiente manera:
El valor de la gasolina es de $50.00 por galón, y el consumo de sus vehículos es de 25 km
por galón. Además, cada chofer recibe por viáticos $15.00 por cada 100 kilómetros
recorridos.
Escriba un programa que lea los siguientes datos: código del chofer (número entero),
kilómetros iniciales, y kilómetros finales. Los datos terminan con el centinela -999 del
campo código chofer. Un ejemplo de los datos es:

43
PROGRAMACIÓN ORIENTADA A OBJETOS ING. JOSÉ RODRÍGUEZ RUIZ

CÓDIGO CHOFER KILOMETROS INICIALES KILÓMETROS FINALES

57 35900 36700
45 45900.6 47100.4
62 35300.5 35800.7
16 65700 66400
-999

La salida debe incluir, para cada chofer, el codigo del chofer, el kilometraje total, el costo
total de la gasolina consumida,,los viaticos del chofer, y el costo total del viaje (gasolina mas
viticos). El formato de salida debe ser el siguiente:

AUTOTRANSPORTES LINCE
CODIGO CHOFER: ## KILOMETRAJE TOTAL: ####.#
COSTO GASOLINA ($) VIATICOS ($) TOTAL GASTOS ($)
####.## ####.## #####.##
. . . . . . . . .
CODIGO CHOFER: ## KILOMETRAJE TOTAL: ####.#
COSTO GASOLINA ($) VIATICOS ($) TOTAL GASTOS ($)
####.## ####.## #####.##

En este diseño de formato de salida los puntos suspensivos indican que puede haber màs
de dos choferes.

''' PROGRAMA formatoTransportesLince

Calcula el costo total de un viaje considerando la gasolina consumida y los viaticos que
recibe cada chofer. Hay un tipo de gasolina: Magna, $50.00 por galon. El rendimiento de
los vehiculos es de 25 kilometros (km) por galon. Cada chofer recibe $15.00 por cada 100
km recorridos.
Utiliza un ciclo while controlado por dato centinela en el campo de código del chofer.
AUTOR: ing. josé Rodríguez Ruiz depto. Sistemas y Computación ITCelaya'''

PRECIO_GALON= 50.0;
PRECIO_VIATICO= 15.0;
salida= ""
salida= salida + "{:>40}".format("AUTOTRANSPORTES LINCE") + "\n"
salida= salida + "{:>45}".format("REPORTE DE VIÁTICOS DE CHOFERES") + "\n"

codigo= int(input("Código del chofer o -999 para terminar "))Y

while codigo != -999:

kiloIni= float(input("Kilometraje inicial? "))
kiloFin= float(input("Kilometraje final? "))

kiloTotal= float(kiloFin - kiloIni)

costoGas= float((kiloTotal / 25) * PRECIO_GALON)
44
PROGRAMACIÓN ORIENTADA A OBJETOS ING. JOSÉ RODRÍGUEZ RUIZ

viáticos= float((kiloTotal /100) * PRECIO_VIATICO)

totalGastos= float(costoGas + viáticos)

salida= salida + "{:>15}" "{:3d}" "{:>32}""{:7.2f}".format("CODIGO CHOFER:", codigo,

"KILOMETRAJE TOTAL:", kiloTotal) + "\n"
salida= salida + "{:>12}" "{:>15}" "{:>20}".format("GASOLINA ($)","VIATICOS($)",
"TOTAL GASTOS($)") + "\n"
salida= salida +"{:10.2f}" "{:14.2f}" "{:20.2f}".format(costoGas, viáticos, totalGastos) +
"\n"*2

codigo= int(input("Código del chofer o -999 para terminar "))

print(salida)
print("\nFIN DE REPORTE")

La ejecución de este programa procede así: al inicio de la ejecución de esta nueva versión
del programa se piden los datos, como lo muestra la siguiente pantalla:

Después se procesan los datos y se muestra la salida debajo de los datos de entrada:

45
PROGRAMACIÓN ORIENTADA A OBJETOS ING. JOSÉ RODRÍGUEZ RUIZ

[Link] CONTROL DEL LAZO POR PREGUNTA DIRECTA

Esta forma de control consiste en preguntar directamente al usuario si quiere continuar
con el lazo o quiere terminarlo. Generalmente se presenta al usuario un mensaje similar al
siguiente:
respuesta= input(“¿Quieres continuar? S)i ó N)o”)

El usuario responde con una S para continuar o con una N para salir del lazo. Desde luego
que el mensaje puede variar, pero la idea básica es la misma: permitir que el usuario controle
la ejecución del lazo a través de su respuesta. El siguiente ejemplo ilustra esta forma de
control.
Se quiere consultar el costo de equilibrio (no hay pérdidas ni ganancias) para producir un
libro, y cual debe ser su precio de venta aplicando un factor de ganancia de 2.1 veces el costo
de equilibrio.
Requiere como datos el título del libro, el número de páginas y la cantidad de libros a
producir. Los datos constantes son: factor de producción= 0.726 y el costo fijo= 2450 Este
costo incluye todos los gastos que se deben hacer para producir el libro, como renta del taller,
sueldo de empleados, pago de luz, etc.

'''PROGRAMA PrecioLibrosConsulta
Permite hacer consultas sobre costo de equilibrio (no hay perdidas ni ganancias) de
producir un libro y cual debe ser su precio de venta. Los datos son el titulo del libro, el
numero de páginas, la cantidad de libros a producir.
Se supone un factor de ganancia de 2.1 veces el costo de equilibrio.
Los datos constantes son: factor de producción = 0.726 y costo fijo= 2450(renta, luz, papel,
tinta, salarios, etc.)

46
PROGRAMACIÓN ORIENTADA A OBJETOS ING. JOSÉ RODRÍGUEZ RUIZ

AUTOR: ing. josé Rodríguez Ruiz depto. Sistemas y Computación ITCelaya

'''
FACTOR_PROD= 0.726
FACTOR_GANANCIA= 2.1
COSTO_FIJO= 2450.00

resp= input("\nQuieres hacer una consulta sobre un libro; S/N? ")

resp= [Link]() #convierte la letra de respuesta a minúscula
while resp== 's':
titulo= input("Titulo del libro: ")
cantidadLibros= int(input("Cantidad de libros: "))
numPaginas= int(input("Numero de paginas: "))

costoProd= float(COSTO_FIJO + cantidadLibros*(numPaginas * FACTOR_PROD))

costoEqui= float(costoProd / cantidadLibros)
precioVenta= float(FACTOR_GANANCIA * costoEqui)

ingresoTotalPorVenta= float(precioVenta * cantidadLibros)

gananciaTotal= float(ingresoTotalPorVenta - costoProd)

print("{:>33}".format("EDITORIAL LINCE"))
print("{:>39}".format("RESULTADO DE LA CONSULTA\n"))
print("{:7}".format("TEXTO: "), titulo)

print("{:>12}" "{:>19}" "{:>15}".format("PÁGINAS","[Link]", "COSTO

FIJO"))
print("{:10}" "{:18}" "{:17.2f}".format(numPaginas,cantidadLibros, COSTO_FIJO))
print("{:22}" "{:<6.2f}".format("Costo de equilibrio: $", costoEqui),
"{:>23}" "{:<6.2f}".format("Precio de venta: $", precioVenta), "\n" * 2)

resp= input("\nQuieres hacer otra consulta sobre un libro; S/N? ")

resp= [Link]()
print("FIN DE CONSULTAS")

Una salida de ejemplo es la siguiente:

47
PROGRAMACIÓN ORIENTADA A OBJETOS ING. JOSÉ RODRÍGUEZ RUIZ

Mientras se conteste con una S el ciclo while continuará su ejecución. Cuando se conteste
N se abandonará el ciclo y se imprimirá el mensaje FIN DE CONSULTAS.

48
PROGRAMACIÓN ORIENTADA A OBJETOS ING. JOSÉ RODRÍGUEZ RUIZ

1.1.3 INSTRUCCIÓN for (lazo contado)

En muchos problemas se sabe con exactitud el número de repeticiones (iteraciones) que se
deben ejecutar. En este caso se puede utilizar la instrucción while con contador. Pero también
se puede utilizar otra instrucción, llamada for, que es equivalente al while con contador.
Sin embargo, el ciclo for en Python es muy diferente y más versátil que el for de otros
lenguajes. Puede escribirse de varias formas. La más sencilla es utilizar junto con el ciclo for
la función range().

FUNCIÓN range()
La función range() genera una secuencia de números enteros entre un límite inferior y
uno superior.

Caso 1. range(N). Función range con un solo argumento. N es la cantidad de números que
se quieren producir. El rango empieza en 0 y termina en N - 1 con incrementos de 1.

N= 10
range(N)
crea la lista 0, 1, 2, 3, 4, 5, 6 ,7, 8, 9.

Observe qjue aunque N= 10, el 10 no se imprime porque entre 0 y 9 están los 10 valores
pedidos.

Caso 2. range(N, M). Función con dos argumentos. N es el límite inferior del rango y M
es el superior. Crea números desde N hasta M-1, en incrementos de 1.

range(4, 12)

crea la lista 4, 5, 6, 7, 8, 9, 10, 11.

Similar al caso 1, el ultimo valor generado es uno menor al límite superior del rango. En
este ejemplo, el límite superior es 12, por lo que el último valor generado es 11.

Caso 3. range(N, M, I). Función con tres argumentos. Crea números desde N hasta M-1
en incrementos de I.

range(12, 38, 3)

crea la lista 12, 15, 18, 21, 24, 27, 30, 33, 36.

Aquí se creo la lista en incrementos de 3 iniciando en 12. Observe que en este caso el rango
se terminó en el número 36 debido a que si a 36 se suman 3 el resultado sería 39 y se habría
rebasado el límite superior M-1 (38 -1= 37)

49
PROGRAMACIÓN ORIENTADA A OBJETOS ING. JOSÉ RODRÍGUEZ RUIZ

for con range()

La sintaxis del ciclo for con range es:

for variableDeControl in range(N):

instrucción 1
instrucción 2
instrucción 3
...
instrucción n

Observe que el lazo está controlado por la variableDecontrol, la cual toma el primer valor
de rango como su valor inicial y a cada pasada por el lazo se incrementa de uno en uno hasta
llegar a N - 1, y entonces el lazo termina.
Cuando se explicó el ciclo while, el primer ejemplo se referia a imprimir tres veces la
palabra Hola. Este ejercicio se reescribirá con for añadiendo el valor de la variable de control
i para observar claramente los valores que genera range().

for i in range(3)
print(i, “ Hola”)

print(“\nAl terminar el lazo for, i= “, i)

Observe que el lazo está controlado por la variable de control, que en este caso es i, la cual
toma un valor inicial (0 en este ejemplo) y a cada pasada por el lazo se incrementa en una
unidad. En el momento que el valor de la variable de control sea igual a 2 (en este ejemplo)
el lazo termina.
La ejecución de este ciclo es: inicialmente i= 0. y se entra por primera vez al lazo para
imprimir el primer hola y se regresa al inicio del for para incrementar el valor de i en 1.
Ahora i= 1.
Se imprime el segundo hola y se regresa al inicio del for para volver a incrementar el valor
de i en 1. Ahora i= 2.
Se imprime el tercer hola y se da por terminado el lazo.
Al salir del lazo se imprime el mensaje final. Observe que i nunca toma el valor 3, porque
range(3) generan los tres valores 0, 1 y 2 y nunca llega a 3.

La salida de este código es:

0 hola
1 hola
2 hola

Al terminar el lazo, i= 2

50
PROGRAMACIÓN ORIENTADA A OBJETOS ING. JOSÉ RODRÍGUEZ RUIZ

Otra forma de lograr los mismos tres “hola” con un range() de dos argumentos es:

for i in range(5, 8): ( 5 6 7)

print(i, “ hola”)

print(“\nAl terminar el lazo: i= “, i)

La salida de este código es:

5 hola
6 hola
7 hola

Al terminar el lazo: i= 7

Observe nuevamente que i nunca toma el valor del límite superior, 8, porque range(5, 8)
generan los tres valores 5, 6 y 7 y nunca llega a 8.
Similar al ejemplo anterior, el lazo está controlado por la variable de control i, la cual toma
un valor inicial (5 en este ejemplo) y a cada pasada por el lazo se incrementa en una unidad.
En el momento que el valor de la variable de control sea igual a 7 el lazo termina.
La ejecución de este ciclo es: inicialmente i= 5. y se entra por primera vez al lazo para
imprimir el primer hola. Se regresa al inicio del for sumar 1 al valor de i. Ahora i= 6.
Se imprime el segundo hola y se regresa al inicio del for para volver a incrementar el valor
de i en 1. Ahora i= 7.
Se imprime el tercer hola y se da por terminado el lazo. Observe que i nunca toma el valor
8, porque range(5, 8) generan los tres valores 5, 6 y 7 y nunca llega a 8 .
Hay que advertir que hay infinidad de pares de argumentos que hacen que el for se ejecute
tres veces, por ejemplo 1 y 4; 20 y 23; 245 y 248, etc.
La salida de estos dos ciclos es:

51
PROGRAMACIÓN ORIENTADA A OBJETOS ING. JOSÉ RODRÍGUEZ RUIZ

Algunos otros ejemplos generales de la sintaxis del for son los siguientes:

✓ For con rango de un solo argumento

1) for numero in range(6):

print("Hola")

El rango de este ciclo generará los seis valores 0, 1, 2, 3, 4, 5, por lo que el for imprimirá
seis Hola. El valor del rango debe ser un número entero positivo. No se acepta el cero o
negativos.

✓ For con rango de dos argumentos. Aquí sí se acepta el cero o negativos.

2) for numero in range(-1, 2):

print("Hola”)

3) for numero in range(-12, -9):

print("Hola")

4) for numero in range(0, 3):

print("Hola")

Estos tres ejemplos son equivalentes en el sentido que todos imprimen tres Hola. También
se debe observar que en un for con dos argumentos los valores del rango pueden ser
números enteros positivos, negativos o cero.
Es importante aclarar que en un rango el primer valor debe ser menor que el segundo valor.
Por ejemplo, si se escribe

5) for numero in range(3, 0):

print("Hola")

el ciclo no se ejecutará, aunque el interprete Python no mostrará ningún mensaje de error.

✓ También podría haberse escrito el ciclo for con un range() de tres argumentos para
indicar un incremento. Aquí también se acepta el cero o negativos. Ejemplos:

6) for numero in range(-6, 0, 2 )

print(numero, " Hola")

print("\nAl terminar el lazo numero= ", numero)

La salida de este código es:

-6 hola
-4 hola
-2 hola
Al terminar el lazo numero= -2

52
PROGRAMACIÓN ORIENTADA A OBJETOS ING. JOSÉ RODRÍGUEZ RUIZ

7) for numero in range(10, 18, 3): 10 13 16

print("hola")

print(“\nAl terminar el lazo i= “, numero)

La salida de este código es:

10 hola
13 hola
16 hola

Al terminar el lazo numero= 16

Primer programa de ejemplo con for

En la sección de la instrucción while se presento el algoritmo SumaNumeros que suma los
primeros N enteros positivos. Se podrá observar que para este problema se conoce por
anticipado el número exacto de iteraciones, que son N (por ejemplo, si N= 20, entonces se
requieren 20 iteraciones). A continuación se presenta una segunda versión del algoritmo
SumarNumeros que utiliza un for en vez de while.

''' PROGRAMA sumaNumerosFor

Obtiene e imprime la suma de los primeros n enteros positivos (1+2+3+4+..+n).
Utiliza el ciclo for en vez del while de la versión anterior.
AUTOR: ing. josé Rodríguez Ruiz depto. Sistemas y Computación ITCelaya
'''
suma= 0
N= int(input("Hasta que numero (entero positivo quieres sumar? "))

for numero in range(1, N+1):

suma= suma + numero

print("La suma de los primeros ", N, " enteros positivos es ", suma)

La diferencia principal con la versión anterior que usaba while con contador es:

Se establece un ciclo for (que reemplaza al while):

for numero in range(1, N+1):

De esta manera se elimina la inicialización de la variable de control (numero= 1) porque
esto se hace dentro del encabezado del for. Ahora solo se requiere inicializar suma a cero, ya
que esta variable almacena las sumas parciales y, en su momento, la suma total.
Como se puede observar, la cantidad de repeticiones (el valor que se lea para N) se controla
mediante la variable numero, que tomará sucesivamente los valores del range empezando en
1 y terminando en N+1. Entonces los números serán:

53
PROGRAMACIÓN ORIENTADA A OBJETOS ING. JOSÉ RODRÍGUEZ RUIZ

1, 2, 3, 4, 5, … , N +1

Si se quieren sumar los primeros 8 números, N= 8. Pero, si se escribe

for numero in range(1, N):

la secuencia original de los números será de 1 a N-1 (de 1 a 7):

1, 2, 3, 4, 5, 6, 7

Por lo que nunca se obtedrá el número 8.

Por esta razón es que se debe sumar 1 a N y la instrucción for es.

for numero in range(1, N+1):

De esta manera se obtendrán los 8 números pedidos:

1, 2, 3, 4, 5, 6, 7, 8

El for completo para este programa es:

for numero in range(1, N+1):

suma= suma + numero

que tiene como única instrucción el incremento de suma con el valor que tenga la variable
numero en cada repetición. Observar que ahora ya no se requiere incrementar explicitamente
la variable de control numero con la instrucción

numero= numero + 1

como era el caso con el while con contador.

Segundo programa de ejemplo con for

Un segundo ejemplo de la aplicación del lazo for es el siguiente: Calcular el Promedio de N
números. El programa es el siguiente:

''' PROGRAMA promedioFor

Obtiene e imprime el promedio de N numeros. Utiliza un ciclo for.
AUTOR: ing. José Rodríguez Ruiz depto. Sistemas y Computación ITCelaya
'''
suma= 0
n= int(input("Cuantos números para el promedio? "))
for i in range( n):

54
PROGRAMACIÓN ORIENTADA A OBJETOS ING. JOSÉ RODRÍGUEZ RUIZ

numero= float(input("Teclea un número: "))

suma= suma +numero
prom= suma / n # instrucción fuera del for

print("El promedio de ", n, " enteros es: ", prom)

La salida para n= 8 de este programa es:

Iterando (repitiendo) a través de una cadena

También se pueden controlar las iteraciones (repeticiones) de un ciclo for colocando en su

encabezado una cadena en vez de la función range(). Cada carácter de la cadena representa
una iteración. Por ejemplo , la cadena “Elefante” tiene 8 caracteres (letras). Si se coloca en
el encabezado de un for se tendrán 8 repeticiones. El siguiente programa muestra esto.

'''PROGRAMA forIteraUnaCadena
Muestra como el control de una instrucción for se puede hacer con un string (cadena)
AUTOR: ing. José Rodríguez Ruiz depto. Sistemas y Computación ITCelaya
'''
cuenta= 0
for letra in “Elefante”:
print(“Hola”)
cuenta= cuenta + 1

print(“Se imprimieron “, cuenta, “ Hola”)

55
PROGRAMACIÓN ORIENTADA A OBJETOS ING. JOSÉ RODRÍGUEZ RUIZ

El programa se ejecuta así: La variable cuenta va a contar cuantas veces se imprime la

palabra “Hola”. Se inicializa al valor cero para indicar que antes de entra al for todavía no
se ha impreso ningún “Hola”. En el encabezado del for

for letra in “Elefante”

la variable letra irá tomando sucesivamente cada letra de la cadena “Elefante”. Al llegar a la
e final terminará la ejecución del for. Entonces,
cuando letra= “E” se imprime el primer Hola,
cuando letra= “l” se imprime el segúndo Hola,
cuando letra= “e” se imprime el tercer Hola,
cuando letra= “f” se imprime el cuarto Hola,
cuando letra= “a” se imprime el quinto Hola,
cuando letra= “n” se imprime el sexto Hola,
cuando letra= “t” se imprime el septimo Hola,
cuando letra= “e” se imprime el octavo Hola.

Y el ciclo for termina. A continuación se imprime el mensaje final:

Se imprimieron 8 Hola
En Python se tiene:

INSTRUCCIÓN do..while. No existe en Python

56
PROGRAMACIÓN ORIENTADA A OBJETOS ING. JOSÉ RODRÍGUEZ RUIZ

2.2 NÚMEROS ALEATORIOS

Los números aleatorios son un conjunto de valores dentro de un cierto rango, donde
cualquier número del conjunto tiene la misma probabilidad de ser elegido. La biblioteca
interna random del intrerprete Python genera números aleatorios (random, en inglés).
Antes de utilizar cualquier función interna se debe importar la biblioteca adecuada.
Entonces, para generar funciones internas se puede hacer lo siguiente:

➢ Importar la biblioteca completa. Así están disponibles en el programa todas las

funciones des esa biblioteca, aunque no se usen. Para esto se escribe al inicio del
programa

import nombre de la biblioteca

➢ Importar la biblioteca y una función particular. Se obtiene solamente la función

mencionada:

from nombre de la biblioteca import nombre de la función

Observe que se inicia con la palabra from (desde) y que el nombre de la biblioteca
se separa con la palabra import del nombre de la función.

➢ Importar la biblioteca y dos o más funciónes particulares. Similar al punto

anterior, se obtiene solamente la funciónes mencionadas:

from nombre de la biblioteca import nombre función, nombre de función, …

Aquí, cada nombre de función se separa de la siguiente con una coma. Los puntos
suspensivos indican que se pueden incluir más funciones, no solo dos.

Después de importar la biblioteca ya se puede utilizar la función para generar números

aleatorios. Para esto se escribe
nombre de la [Link] del función

Observe que el nombre de la biblioteca y el de la función están separados por un punto. En

la unidad I de este texto ya se vieron ejemplos con las funciones matemáticas como

import math

[Link](x)

Generación de números aleatorios enteros

Para utilizar números enteros aleatorios se pueden utilizar las siguientes dos funciones de
la bilblioteca random:

• randint(a,b)
• randrange(a, b, c)
57
PROGRAMACIÓN ORIENTADA A OBJETOS ING. JOSÉ RODRÍGUEZ RUIZ

✓ Función randint(a,b). Genera números aleatorios enteros entre a y b, ambos incluidos,

donde a debe ser menor o igual a [Link] ejemplo,

[Link](3,8) generará un número aleatorio en el rango 3, 4, 5, 6 ,7, 8.

Se aceptan números negativos o el cero para a o para b:

[Link](-6, 2) generará un número aleatorio en el rango

-6, -5, -4, -3, -2, -1, 0, 1,2

[Link](0, 5) generará un número aleatorio en el rango

0, 1, 2, 3, 4, 5

Los siguientes dos programas muestran la utilización de la función randint(a,b).

'''PROGRAMA generaAleatorioEnteros
Genera aleatoriamente N números enteros. Se usan el contador cuentaNumeros para
controlar el lazo while.
AUTOR: ing. José Rodríguez Ruiz depto. Sistemas y Computación ITCelaya '''

import random

cuentaNumeros= 1

N= int(input("Cuantos numeros se van a leer? "))

while cuentaNumeros <= N:
numero= [Link](-100, 150)
print(f"{cuentaNumeros}) ", numero)
cuentaNumeros= cuentaNumeros + 1

Una salida de ejemplo de este programa es:

58
PROGRAMACIÓN ORIENTADA A OBJETOS ING. JOSÉ RODRÍGUEZ RUIZ

Este segundo programa de ejemplo “genera N números enteros y cuentar cuantos de

ellos son negativos”.

'''PROGRAMA cuentaNegativos
Genera aleatoriamente N números enteros y cuenta cuantos de ellos son negativos. Se usan
los contadores cuentaNumeros para controlar el lazo while, y cuentaNegativos, para llevar
la cuenta de los negativos.
AUTOR: ing. josé Rodríguez Ruiz depto. Sistemas y Computación ITCelaya '''

import random

cuentaNumeros= 1
cuentaNegativos= 0
N= int(input("Cuantos numeros se van a leer? "))
while cuentaNumeros <= N:
numero= [Link](-10, 12)
print(numero)
if(numero < 0.0):
cuentaNegativos= cuentaNegativos + 1

cuentaNumeros= cuentaNumeros + 1

print("Del total de ", N, " números ", cuentaNegativos, " son negativos")

Una salida de ejemplo de este programa es:

59
PROGRAMACIÓN ORIENTADA A OBJETOS ING. JOSÉ RODRÍGUEZ RUIZ

✓ Función randrange(a, b, c). Esta función admite uno, dos o tres argumentos.

Si se usa esta función con uno o dos argumentos se comporta de manera muy similar a
randint() con uno o con dos argumentos. Ver los ejemplosd anteriores.

Cuando se utiliza con tres argumentos, el primero es el límite inferior del rango, el
segundo es el límite superior y el tercero es el incremento. Ejemplo:

[Link](10, 40, 5)

Se generan números en el rango 10, 15, 20, 25, 30, 35, 40

Obseve que el límite inferior es 10, el superior es 40, y el rango se incrementa en 5.

El siguiente programa muestra la utilización de la función randrange(a, b, c).

'''PROGRAMA randrangeExamplesInt
Muestra la utilización de la biblioteca random y de las funciones
randint() y randrange() para generar números aleatorios enteros '''
import random

print("#Se generan 5 números aleatorios del conjunto {3,4,5,6,7,8}")

for i in range(5):
print([Link](3,8))

print("#Se generan 5 números aleatorios del conjunto {-6,-5,-4,-3,-2,-1,0,1,2}")

for i in range(5):
print([Link](-6,2))

print("#Se generan 5 números aleatorios del conjunto {0,1,2,3,4,5}")

for i in range(5):
print([Link](0,5))

print("# Se generan 5 números aleatorios del conjunto {10,15,20,25,30,35,40}")

for i in range(5):
print([Link](10, 40, 5))

La salida de este programa es la siguiente

60
PROGRAMACIÓN ORIENTADA A OBJETOS ING. JOSÉ RODRÍGUEZ RUIZ

Recuerde que como son números aleatorios, en cada corrida los números van a cambiar.

✓ La Función choice()

➢ La función choice() elige un valor al azar en un conjunto de elementos. Cualquier

tipo de datos enumerable (tupla, lista, cadena, range) puede utilizarse como conjunto
de elementos. Ejemplo, la instrucción
[Link](14, 15.45, 20.7, 16, 321, 150)
genera aleatoriamenter alguno de los números de conjunto. En una corrida podría generar
el 20, en otra el 321, etc.

➢ Se puede utilizar un rango. La instrucción

[Link](range(5, 40))
genera aleatoriamenter alguno de los números del rango. En una corrida podría generar
el 38 en otra el 5, etc.

61
PROGRAMACIÓN ORIENTADA A OBJETOS ING. JOSÉ RODRÍGUEZ RUIZ

➢ Una cadena es un objeto enumerable, se puede considerar como una secuencia de

caracteres indexados. Por ejemplo, en la cadena
“AEIOU”
La letra A tiene el índice cero, E el uno, I el dos, O el tres y U el cuatro.
La siguiente instruccion
[Link]("AEIOU"))
genera aleatoriamenter alguna de las letras. En una corrida podría generar la E, en otra la
U, etc.
Los ejemplos anteriores se muestran en el siguiente programa.

'''PROGRAMA randomExamplesFloat
Muestra la utilización de la biblioteca random y de la funcion choice() para generar
números aleatorios
'''
import random

print("#En cada repetición se escoge al azar uno de los números")

for i in range(5):
print([Link]( (14, 15.45, 20.7, 16, 321, 150) ) )

print("#En cada repetición se escoge al azar uno de los numeros del rango 5 a 40")
for i in range(5):
print([Link](range(5, 40)))

print("#En cada repetición se escoge al azar una de las letras de la cadena \"AEIOU\"")
for i in range(5):
print([Link]("AEIOU"))

La salida de este programa es:

62
PROGRAMACIÓN ORIENTADA A OBJETOS ING. JOSÉ RODRÍGUEZ RUIZ

✓ Función choice con el objeto list

Con la función choice() tanbién se puede utilizar el objeto list de Python. Un list (lista)
guarda un conjunto indexado de elementos del mismo tipo o diferente. La función list()
se verá a detalle en el capítulo 4.
Los elementos de la lista se escriben dentro de paréntesis cuadrados (square brackets) y
se separan uno de otro por comas. Cada elemento de la lista se accesa por su índice. El
primer elemento tiene el índice cero, el segundo el índice 1, el tercero el 2, y así
sucesivamente.

➢ Un objeto list es similar al arreglo (array) de otros lenguajes, aunque más versátil
y poderoso. Por ejemplo, un arreglo tradicional solo puede guardar elementos del
mismo tipo de dato, pero un list de Python puede almacenar alementos de diferenten
tipo, incluyendo otros list (list anidado). El siguiente list contiene cadenas de
nombres de animales.
["gato", "ave", "perro", "cebra", "león", "perico"]
“gato” se identifica con el índice cero, “ave” con el uno, “perro” con el dos, y asì
sucesivamente.
La función choice también puede seleccionar aleatoriamente alguno de los elementos de
un list. Por ejemplo, la instrucción

[Link]( ["gato", "ave", "perro", "cebra", "león", "perico"] )

genera aleatoriamenter alguna de los cadenas de la lista. En una corrida podría generar
cebra, en otra gato, etc.

➢ Como ya se mencionò, un list puede contener elementos de diferentes tipos,

incluyendo otras listas, como en el siguiente ejemplo:

[ "s", 0, [1, 2, dato], “cadena”, ["avion", "carro"], 4.56 ]

Este list tiene cadenas, dígitos, una variable (dato), y dos list.
Si se escriben las siguientes instrucciones:
dato = 43
lista = ["s", 0, [1, 2, dato]”, “cadena ["avion", "carro"], 4.56]

for i in range(5):
print([Link](lista)

se generarà aleatoriamenter alguno de los elementos de la lista. En una corrida podría

generar 4.56, en otra [1,2,43], etc.
El siguiente programa muestra la utilización de la función choice con el objeto list.

63
PROGRAMACIÓN ORIENTADA A OBJETOS ING. JOSÉ RODRÍGUEZ RUIZ

'''PROGRAMA randomExamplesFloat2
Muestra la utilización de la biblioteca random y de la funcion choice() con un list para
generar números aleatorios.
AUTOR: ing. josé Rodríguez Ruiz depto. Sistemas y Computación ITCelaya
'''
import random
print("#Se escoge al azar una de las palabras del list")
for i in range(5):
print([Link](["gato", "ave", "perro", "cebra", "león", "perico"]))

print("#Se escoge al azar uno de los elementos de la lista")

dato = 43
cadena = ["s", 0, [1, 2, dato], "cadena", ["avion", "carro"], 4.56]
for i in range(5):
print([Link](cadena))
La salida de este programa es:

64
PROGRAMACIÓN ORIENTADA A OBJETOS ING. JOSÉ RODRÍGUEZ RUIZ

Generación de números aleatorios decimales (reales o float)

Similar a los números enteros, Python tiene varias funciones para generar números
aleatorios decimales. Algunas de ellas son:
✓ La función random()
la función random() genera un número decimal entre 0.0 y <1.0, pero el valor 1.0 nunca
se obtiene. Esto significa que se pueden obtener valores como 0.3, 0.4, 0.8, 0.9, 0.99,
0.999999, y aunque se aumente el número de dígitos decimales nunca será 1.0. Por
ejemplo, la siguiente instrucción
[Link]()
podría generar números como
0.36367908769945445
0.919138316555906
Observe que la función random() genera números con aproximadamente 16 decimales.
✓ La función uniform(a, b)
La función uniform(a, b) genera un número decimal entre a y b. Puede generar a pero
debido a la forma de redondear de Python, puede que genere b o no. Por ejemplo, la
siguiente instrucción
[Link](3, 9)
podría generar números tales como

0.36367908769945445
0.919138316555906

El siguiente programa muestra la utilización de estas dos funciones:

'''PROGRAMA pyAleatoriosReales
Este programa utiliza las funciones aleatorias:

1) función random(), que genera un número decimal entre 0.0 y <1.0,

pero el valor 1.0 nunca se obtiene. Esto significa que se pueden obtener valores como
0.3, 0.4, 0.8, 0.9, 0.99, 0.999999, y aunque se aumente el número de dígitos decimales
nunca será 1.0.

2) La función uniform(a,b). La función uniform(a, b) genera un número decimal entre

a y b (puede generar a pero debido a la forma de redondear de Python, puede que genere b
o no

AUTOR: ing. josé Rodríguez Ruiz depto. Sistemas y Computación ITCelaya

'''
import random

65
PROGRAMACIÓN ORIENTADA A OBJETOS ING. JOSÉ RODRÍGUEZ RUIZ

print("#Función random(): genera 5 números aleatorios reales entre 0.0 y <1.0\n")

for i in range(5):
numeroAleatorioFloat= [Link]()
print("Número aleatorio", i+1, " ", numeroAleatorioFloat)

print("\n\n#Función uniform(): genera 5 aleatorios reales entre a= 12.0 y b= 90.0\n")

for i in range(5):
numeroAleatorio= [Link](12.0, 90.0)
print("Número aleatorio", i+1, " ", numeroAleatorio)

Una salida de ejemplo de este programa es:

66
PROGRAMACIÓN ORIENTADA A OBJETOS ING. JOSÉ RODRÍGUEZ RUIZ

2.4 REPETICIONES ANIDADAS

Como cualquier estructura de control, las instrucciones de repetición se pueden anidar,

escribiendo una dentro de otra. Las instrucciones interior y exterior pueden ser iguales (for
en for, while en while, etc.) o diferentes (while en for, for en while, etc.), pero siempre se
debe cumplir que la estructura interna debe estar completamente dentro de la externa. No se
permiten traslapes, es decir, no se permite que la estructura interna rebase los límites de la
estructura externa. En diagrama se tiene:

...

a) b) c)

Cada corchete indica una instrucción de repetición (while o for):

En la figura a) se tienen dos instrucciones repetitivas anidadas, y se puede observar que la

repetición interna está completamente dentro de la externa.

En b) se muestra que la anidación no se limita a dos estructuras. Se pueden anidar tantas

como se desee, siempre y cuando se respete la condición de no traslaparlas.

En c) la anidación está traslapada, es decir, la estructura interna no está completamente

dentro de la externa y la rebasa. Esta última es una anidación ilegal.

La clave para comprender el funcionamiento de las repeticiones anidadas es recordar el

siguiente principio:

La repetición interior (anidada) se ejecuta completamente por cada pasada

a través de la repetición exterior.

Este principio se ilustra con el siguiente fragmento de pseudocódigo:

for i in range(2): # Establecer for exterior

print("EQUIPO ", i+1)
for j in range(3): # Establecer for interior (anidado)
print(" Jugador ", j+1)

En este ejemplo, cuando la variable de control i del lazo for exterior toma el valor 0, este
se mantiene constante; el lazo for interior se ejecuta completamente tomando los valores
j= 0, j= 1, y j= 2.

67
PROGRAMACIÓN ORIENTADA A OBJETOS ING. JOSÉ RODRÍGUEZ RUIZ

Una vez que la ejecución del lazo interior haya terminado su procesamiento, se regresa al
inicio del lazo exterior donde el valor de i se incrementa. Por tanto, cuando i= 1, el lazo
interior se ejecuta nuevamente de principio a fin para los valores j= 0, j= 1 y j=2. El lazo
termina.
La prueba de este fragmento de algoritmo es:

i j Salida
0 --- EQUIPO 1
0 0 Jugador 1
0 1 Jugador 2
0 2 Jugador 3
1 --- EQUIPO 2
1 0 Jugador 1
1 1 Jugador 2
1 2 Jugador 3

Los siguientes ejemplos ilustran la utilización de las repeticiones anidadas.

Ejemplo 1. Dibujar un cuadrado, lleno, de asteriscos. El usuario debe decidir de cuantos

renglones quiere el cuadrado. Por ejemplo, si quiere un cuadrado de 4 renglones, la salida del
programa es:
* * * *
* * * *
* * * *
* * * *
El programa para este ejercicio es:

''' PROGRAMA asteriscosCuadradolleno

Dibuja un cuadrado lleno de asteriscos. El usuario decide de cuantos renglones quiere el
cuadrado. Por ejemplo, si quiere un cuadrado de 3 renglones, la salida del programa es:
* * *
* * *
* * *

AUTOR: ing. josé Rodríguez Ruiz depto. Sistemas y Computación ITCelaya

‘’’
nReng= int(input("Cuantos renglones para el cuadrado? "))
for renglon in range(nReng):
for columna in range(nReng):
print(' * ', end="")

print("\n")

Observe que el cuadrado consiste de un plano cartesiano formado por renglones y columnas.
En un cuadrado, desde luego, el número de renglones es igual al número de columnas. Por

68
PROGRAMACIÓN ORIENTADA A OBJETOS ING. JOSÉ RODRÍGUEZ RUIZ

eso, para dibujar el cuadrado es suficiente con especificar el número de renglones (pudo haber
sido también el número de columnas).
Para dibujar el cuadrado el programa utiliza una repetición anidada formada por dos lazos
for. El primero (externo) controla los renglones y el segundo (interno) controla las columnas.
Entonces, se mantiene fijo el valor de la variable renglon del for exterior mientras el valor
de la variable columna del lazo interior va cambiando su valor desde 0 hasta nReng -1.
Así, se dibuja con asteriscos un renglón completo antes de pasar al siguiente. Aquí la
palabra dibuja significa imprimir un asterisco por cada vuelta a través del lazo interior, el
cual se reproduce a continuación para comodidad del lector:

for columna in range(nReng):

print(' * ', end="")

Entonces, al terminar cada ejecución del lazo interior se tendrá un renglón de asteriscos.
Para iniciar el siguiente renglón, se salta de línea con la instrucción print("\n") y se termina
el lazo exterior.
El lazo exterior se repite tantas veces como renglones haya solicitado el usuario. Al terminar
todas las repeticiones (iteraciones) del lazo exterior, se tendrá el cuadrado completo.
Una salida de ejemplo es:

69
PROGRAMACIÓN ORIENTADA A OBJETOS ING. JOSÉ RODRÍGUEZ RUIZ

Ejemplo 2. Calcular el promedio de calificaciones de N grupos de M alumnos cada uno.

El programa es el siguiente
''' PROGRAMA promedioAnidado
Obtiene e imprime el promedio de calificaciones de N [Link] grupo tiene M
alumnos. Utiliza dos ciclos for anidados: el externo controla el paso de grupo a grupo, y el
anidado o externo controla los alumnos dentro de cada grupo.
AUTOR: ing. josé Rodríguez Ruiz depto. Sistemas y Computación ITCelaya
'''
grupos= int(input("Cuantos grupos: "))
for i in range(grupos):
alumnos= int(input(f"Cuantos alumnos del grupo: {i+1} "))

suma= 0
for j in range(alumnos):
numero= float(input(f"Teclea la calificacion: {j+1} "))
suma= suma + numero

prom= suma / alumnos

print("\nEl promedio del grupo ", i+1, " es: ", prom, "\n")

Una salida de ejemplo de este programa es:

70
PROGRAMACIÓN ORIENTADA A OBJETOS ING. JOSÉ RODRÍGUEZ RUIZ

2.5 ESTRUCTURA DE DECISIÓN

Una de las características más importantes de cualquier lenguaje algorítmico (y por tanto,
de programación) es la capacidad para comparar números, letras o símbolos especiales y
realizar diferentes operaciones dependiendo del resultado de la comparación. La parte lógica
de su unidad aritmética y lógica (ALU) da a la computadora la habilidad de tomar decisiones
por medio de las estructuras algorítmicas if, if..else, y elif. A estas se les llama instrucciones
de decisión.

2.5.1 INSTRUCCIÓN if
La instrucción if se utiliza cuando se quiere ejecutar una acción sólo si su condición
booleana es verdadera. Si es falsa no se hace nada. La instrucción if en diagrama de flujo es
la siguiente:

ENTRADA

falso Condición verdadero

booleana
operación

SALIDA

En código Python, la instrucción if se escribe así:

if condición booleana:
instrucción 1
instrucción 2
instrucción 3
. . .
Las instrucciones se ejecutan solo en el caso de que la condición booleana sea verdadera.
Si es falsa, la operación no se efectúa y el algoritmo continuará su ejecución en la instrucción
que inmediatamente siga a la estructura if. A continuación, se presenta un ejemplo que usa
if.
El ejemplo consiste en hacer un algoritmo pseudocódigo que calcule el precio final que
pagaría un cliente por un artículo. Hay un descuento del 10% solo si la etiqueta del artículo
tiene marcado un precio igual o mayor a $150.00.
Observe en el enunciado del ejercicio se tiene una especificación respecto a qué hacer en
caso de que la condición sea cierta, pero no hay instrucciones sobre qué hacer si la condición
es falsa. Este es un caso apropiado para usar la instrucción if. Aplicando los pasos del Ciclo
de desarrollo de un algoritmo a este problema se tiene:

71
PROGRAMACIÓN ORIENTADA A OBJETOS ING. JOSÉ RODRÍGUEZ RUIZ

I.- ENTENDER PROBLEMA

En este paso se obtiene una comprensión completa del problema. Para esto se resuelve el
problema, haciendo cálculos manuales; se diseña la salida en cuanto al resultado que se pide
y el formato que se utilizará para presentarlo al usuario; se define el proceso (operaciones)
que se deban realizar; y se identifican los datos de entrada.
Para iniciar este paso se resuelven manualmente algunos casos particulares de todos los
casos generales del problema, utilizando solamente papel y lápiz (desde luego que puede
utilizarse una calculadora para los cálculos numéricos). En este ejemplo se distinguen tres
casos generales: 1) El precio etiqueta es mayor a $150.00; 2) el precio etiqueta es igual a
$150.00; 3) el precio etiqueta es menor a $150.00.
Desde luego que hay muchísimos casos particulares para cada uno de los casos generales.
Por ejemplo, para el caso 1) algunos casos particulares son: $340.00, $1234.50, $200.00, y
muchísimos más; para el caso 2) solo hay $150.00; para el caso 3) hay $49.90, 149.00,
$100.00, etc.
Puesto que se van a resolver algunos casos particulares de manera manual, conviene elegir
valores sencillos. Seleccionando los valores $200.00 para el caso general 1), $150.00 para el
caso 2), y $100.00 para el caso 3), los cálculos son los siguientes:

Caso 1) precio etiqueta= $200.00

Puesto que $200.00 es mayor a $150.00, el artículo tiene el 10% de descuento. Por tanto:
Precio a pagar= precio etiqueta – precio etiqueta * 0.1= 200 – 200 * 0.1= 200 – 20= 180

Caso 2) precio etiqueta= $150.00

Como $150.00 es igual $150.00, el artículo tiene el 10% de descuento. Por tanto:
Precio a pagar= precio etiqueta – precio etiqueta * 0.1= 150 – 150 * 0.1= 150 – 15= 135

Caso 3) precio etiqueta= $100.00

El valor $100.00 no es mayor ni igual a $150.00, el artículo no tiene descuento. Así:
Precio a pagar= precio etiqueta= 100

Resumiendo, los cálculos:

DATOS DE PRUEBA RESULTADOS CORRECTOS

precio etiqueta precio a pagar

caso 1) $200.00 $180.00
caso 2) $150.00 $135.00
caso 3) $100.00 $100.00

Una vez que se ha resuelto el problema de manera manual, sin pensar siquiera en una
computadora, utilizando solamente nuestra lógica y como instrumentos papel y lápiz
(posiblemente una calculadora), entonces es momento de empezar a organizar nuestras ideas
de manera más formal.
Continuando con el paso I, entender problema, del Ciclo de desarrollo de un algoritmo,
ahora se consideran los tres aspectos principales de cualquier sistema: salida, proceso y
entrada, en este orden exclusivamente para este paso.

72
PROGRAMACIÓN ORIENTADA A OBJETOS ING. JOSÉ RODRÍGUEZ RUIZ

Salida. El problema pide calcular el precio final a pagar por un artículo. El diseño de la salida
es como se ve a continuación:

EL PRECIO A PAGAR ES: $####.##

Donde cada # representa un dígito. Observe que se incluye un punto decimal, lo que significa
que el resultado se considera de tipo real (float).

Proceso. Utilizar un if para averiguar si el precio es mayor o igual a $150.00. Si esto es

verdad se calcula el nuevo precio que incluye el descuento del 10%.

Entrada. El único dato de entrada es el precio etiqueta del artículo.

II. DISEÑAR EL ALGORITMO

Aquí se identifican y se ordenan los pasos necesarios para resolver el problema. Para este
problema los pasos son:

1. Leer precio etiqueta del artículo.

2. Si el precio es mayor o igual a $150.00
Entonces se calcula el nuevo precio con descuento con la fórmula
precio= precio – precio * 0.1

3. Imprimir la salida.
4. Fin de algoritmo.

III. CONSTRUIR Y PROBAR EL ALGORITMO COMO PSEUDOCÓDIGO

En este paso se escribe el algoritmo en pseudocódigo. Para este ejemplo es el siguiente:

''' ALGORITMO descuentoIf

Calcula el precio a pagar por un artículo. Si el artículo tiene en su etiqueta un precio mayor
o igual a $150.00, hay un descuento del 10%.
Se usa la instrucción if para averiguar si hay descuento o no.
'''
1. precio= float(input("Dame el precio etiqueta: "))
2. if precio >= 150:
precio= precio - precio * 0.1

3. print("EL PRECIO A PAGAR ES: $", precio)

Los números al inicio de cada paso son para facilitar su identificación durante la prueba del
algoritmo. Después de haber realizado la prueba los números se pueden eliminar.

Prueba del algoritmo

Como se mencionó al inicio del paso I, entender problema, la prueba debe incluir todos los
casos que el algoritmo pueda tomar. Por tanto, la prueba incluirá los siguientes datos para sus
tres casos generales:
73
PROGRAMACIÓN ORIENTADA A OBJETOS ING. JOSÉ RODRÍGUEZ RUIZ

Caso 1) $200.00 (para el caso general precio > $150.00)

Caso 2) $150.00 (para el caso general precio == $150.00)
Caso 3) $100.00 (para el caso general precio < $150.00)

Para todos estos casos el algoritmo deberá trabajar correctamente. Si se recupera el resumen
de los cálculos manuales:

DATOS DE PRUEBA RESULTADOS CORRECTOS

precio etiqueta precio a pagar

caso 1) $200.00 $180.00
caso 2) $150.00 $135.00
caso 3) $100.00 $100.00

entonces la prueba procede como sigue:

Caso 1) paso precio precio >= 150 salida

1 200 ----- ------
2 180 verdadero ------
3 180 verdadero EL PRECIO A PAGAR ES: $180.00

Caso 2) paso precio precio >= 150 salida

1 150 ----- -----
2 135 verdadero ------
3 135 verdadero EL PRECIO A PAGAR ES: $135.00

Caso 3) paso precio precio >= 150 salida

1 100 ----- ------
2 100 falso ------
3 100 falso EL PRECIO A PAGAR ES: $100.00

Es importante observar que la prueba incluyó tres corridas diferentes del algoritmo. Una
corrida para precio= $200.00, otra para precio= $150.00, y una más para precio= $100.00.
Esto es necesario ya que, como se mencionó anteriormente, cada corrida prueba un caso
particular para un caso general. Por corrida se entiende ejecutar el algoritmo completamente
desde el primer paso hasta el último.
Cuando la prueba demuestre que el algoritmo es correcto, entonces es el momento de
convertirlo a programa. Para este ejemplo el programa Python es el siguiente.

''' PROGRAMA descuentoIf

Calcula el precio a pagar por un artículo. Si el artículo tiene en su
etiqueta un precio mayor o igual a $150.00, hay un descuento del 10%.
e usa la instrucción if para averiguar si hay descuento o no.

74
PROGRAMACIÓN ORIENTADA A OBJETOS ING. JOSÉ RODRÍGUEZ RUIZ

'''
precio= float(input("Dame el precio etiqueta: "))
if precio >= 150:
precio= precio - precio * 0.1

print("EL PRECIO A PAGAR ES: $", precio)

Observe que no tiene ciclo de repetición. Una salida de ejemplo para tres corridas es:

Ya se mencionó en el paso I del ciclo de desarrollo de software, que la salida se considera

primero que el proceso y la entrada. En los pasos posteriores se sigue el orden entrada,
proceso y salida. Esto es porque la salida define el proceso que se debe seguir, y a su vez el
proceso define los datos de entrada que requiere.
,
Ejercicio. Reescriba el programa anterior para incluir un ciclo while con
contador para N artículos, con centinela y con pregunta directa

Un cambio en el formato de la salida, aunque sea pequeño, obliga a que el programador

modifique su lógica, aunque sea de manera mínima. Para ilustrar este punto consideremos la
siguiente modificación a la salida del programa descuentoIf del ejemplo anterior (el problema
es exactamente el mismo, solo se modifica la salida). La salida ahora se debe mostrar en tres
renglones, como se muestra a continuación:

EL PRECIO ETIQUETA ES: $####.##

EL DESCUENTO ES: $ ###.##
EL PRECIO A PAGAR ES: $####.##

Esta simple modificación a la salida del problema obliga a rediseñar el algoritmo para
escribir una segunda versión que incluya los cambios pedidos. A esta segunda versión se le

75
PROGRAMACIÓN ORIENTADA A OBJETOS ING. JOSÉ RODRÍGUEZ RUIZ

puede llamar descuentoIf2, para indicar que al algoritmo anterior se le han hecho algunas
modificaciones (mantenimiento), pero se refiere al mismo problema.
El programa con esa modificación en la salida es:

''' PROGRAMA descuentoIf2

Calcula el precio a pagar por un artículo. Si el artículo tiene en su etiqueta un precio mayor
o igual a $150.00, hay un descuento del 10%. Se usa la instrucción if para averiguar si hay
descuento o no. Ahora la salida se presenta en tres líneas.
AUTOR: ing. josé Rodríguez Ruiz depto. Sistemas y Computación ITCelaya
'''
precioEtiqueta= float(input("Dame el precio etiqueta: "))

precioPagar= precioEtiqueta
descuento= 0.0

if precioEtiqueta >= 150:

descuento= precioEtiqueta * 0.1
precioPagar= precioEtiqueta - descuento

print("{:25}".format("EL PRECIO ETIQUETA ES: $"), "{:7.2f}".format(precioEtiqueta))

print("{:25}".format("EL DESCUENTO ES: $"), "{:7.2f}".format(descuento))
print("{:25}".format("EL PRECIO A PAGAR ES: $"), "{:7.2f}".format(precioPagar))

Un ejemplo de la salida que genera este programa es:

Ejercicio. Reescriba el programa anterior para incluir un ciclo while

con: contador para N artículos, centinela y pregunta directa.

76
PROGRAMACIÓN ORIENTADA A OBJETOS ING. JOSÉ RODRÍGUEZ RUIZ

Varios if en el mismo programa

Es posible utilizar varios if en el mismo programa. Esto lo muestra el siguiente problema:

“Se tienen varios grupos de tres números cada uno. Encontrar el mayor de cada grupo.”

Se utiliza un ciclo while con centinela. El programa es el siguiente:

‘’’PROGRAMA mayorDeTresNumerosIf
Lee grupos de tres números y encuentra el mayor de cada grupo. El centinela es el -9
Un ejemplo de los datos es:

Num1 Num2 Num3

grupo 1 23 67 98
grupo 25 89 -9 0
grupo 13 76.5 89.4 34
. . .
grupo -9
AUTOR: ing. José Rodríguez Ruiz depto. Sistemas y Computación ITCelaya
'''
grupo= int(input("\nTeclea número del grupo o -9 para terminar: "))

while grupo != -9:

num1= float(input("Numero 1? "))
num2= float(input("Numero 2? "))
num3= float(input("Numero 3? "))

mayor= num1

if num2 > mayor:

mayor= num2

if num3 > mayor:

mayor= num3

print("\nGrupo ", grupo, ": ", num1, ",",num2, ",",num3, " El mayor es: ", mayor, sep= "")

grupo= int(input("\nTeclea número del grupo o -9 para terminar: "))

print("FIN DE PROGRAMA")

Una salida de ejemplo de este programa es la siguiente:

77
PROGRAMACIÓN ORIENTADA A OBJETOS ING. JOSÉ RODRÍGUEZ RUIZ

Ejercicio. Reescriba el programa anterior para incluir:

1. un ciclo while con contador
2. un ciclo while con pregunta directa

78
PROGRAMACIÓN ORIENTADA A OBJETOS ING. JOSÉ RODRÍGUEZ RUIZ

CONTADORES Y ACUMULADORES
Aparte de utilizar un contador para saber cuantas repeticiones (iteraciones) se han realizado
y decidir cuando salir de un ciclo, en muchos programas que utilizan repeticiones se requiere
contar cuantas veces ha sucedido un evento particular (por ejemplo, de una lista cuantas
personas son hombres o cuantas personas son mujeres) o acumular el valor de una o más
variables para obtener un total (por ejemplo, cual es el total de salarios pagados a 10
empleados). Esto es para lo que se utilizan los contadores y los acumuladores.

CONTADORES
Un contador es una variable cuyo valor se modifica en una cantidad constante. Es decir,
puede incrementar o decrementa su valor, pero siempre en una cantidad constante. Por
ejemplo, de dos en dos. Así, si el contador empieza en cero y se incrementa de dos en dos, la
sucesión es: 0, 2, 4, 6, 8, etc. Pero si se incrementa de cuatro en cuatro los valores son: 0, 4,
8, 12, 16, etc.
Los usos más frecuentes para un contador son:

➢ Como variable de control de una repetición. El contador lleva la cuenta de cuantas

iteraciones (repeticiones) del total se han efectuado, e indica la salida del lazo
cuando se haya realizado el número suficiente de repeticiones .

➢ Como contabilizador de un evento particular. A cada aparición del evento que

interesa, el contador respectivo se modifica en una cantidad apropiada constante.
Por ejemplo, si de un grupo de personas se quiere saber cuantas son casadas, cada
que se lean los datos de una persona con esta característica se incrementará en uno
el contador de personas casadas.

En general, el contador se inicializa a un valor particular (con frecuencia el cero o el uno)

antes de entrar al ciclo. Dentro del lazo el contador se incrementa o decrementa con un valor
constante apropiado cuando ocurre el evento que nos interesa contabilizar.
Para ilustrar el uso de contadores a continuación se presenta un programa con un ciclo while
controlado por centinela que lee nombres y al final imprime cuántos nombres se teclearon-

''' PROGRAMA pyContadorNombres

lee varios nombres y al final imprime cuántos nombres se teclearon. Utiliza un while con
el centinela ‘f’
AUTOR: ing. josé Rodríguez Ruiz depto. Sistemas y Computación ITCelaya '''
'''
contadorNombres= 0
nombre= input("Teclea el nombre de una persona o 'f' para terminar ")
while nombre != 'f' and nombre != 'F':
contadorNombres= contadorNombres + 1
nombre= input("Teclea el nombre de otra persona o 'f' para terminar ")

print("Se teclearon ", contadorNombres, "nombres")

79
PROGRAMACIÓN ORIENTADA A OBJETOS ING. JOSÉ RODRÍGUEZ RUIZ

La salida para este programa es la siguiente:

Teclea el nombre de una persona o 'f' para terminar Raúl

Teclea el nombre de otra persona o 'f' para terminar María
Teclea el nombre de otra persona o 'f' para terminar Tomás
Teclea el nombre de otra persona o 'f' para terminar Pedro
Teclea el nombre de otra persona o 'f' para terminar Samuel
Teclea el nombre de otra persona o 'f' para terminar Diana
Teclea el nombre de otra persona o 'f' para terminar Sandra
Teclea el nombre de otra persona o 'f' para terminar f

Se teclearon 7 nombres
En este programa, el contador se llama contadorNombres y se inicializa con el valor cero
antes de entrar al while:

0
contadorNombres

A continuación, se pide el primer nombre o el centinela para terminar y se evalua con la

instrucción

while nombre != 'f' and nombre != 'F':

En el while se evalua la variable nombre. Si tiene un nombre diferente a la letra f

(minúscula o mayúscula) la condición del while obtiene el valor True (verdadero) y se entra
por primera vez al ciclo while.
Entrar al ciclo while significa que se leyó un nombre de persona y no el centinela, entonces
es el momento de incrementar el contador de personas con la instrucción

contadorNombres= contadorNombres + 1

En la primera repetición la operación es:

contadorNombres= 0 + 1

y la variable se vé ahora así:

1
contadorNombres

A continuación se pide otro nombre o el centinela. Si se tecleó un nombre diferente a la

letra f (minúscula o mayúscula) la condición del while obtiene nuevamente el valor True

80
PROGRAMACIÓN ORIENTADA A OBJETOS ING. JOSÉ RODRÍGUEZ RUIZ

(verdadero) y se entra nuevamente al ciclo while para volver a incrementar el contador con
la instrucción

contadorNombres= contadorNombres + 1

Esta vez se tiene

contadorNombres= 1 + 1

y la variable se vé ahora así:

contadorNombres
A continuación se pide otro nombre o el centinela y el proceso se repite mientras se siga
contestando con un nombre diferente al centinela
Cuando se teclea el centinela f la condición booleana del while toma el valor falso y la
ejecución del while termina.
Por último, ya fuera del while, se imprime el último valor que obtuvo contadorNombres
para indicar cuantos nombres se leyeron con la instrucción

print("Se teclearon ", contadorNombres, "nombres")

Un segundo ejemplo de la utilización de un contador es el siguiente:

“Escriba un programa que genere N números aleatorios enteros y cuente cuantos de

ellos son negativos.”

'''PROGRAMA cuentaNegativos
Genera aleatoriamente N números enteros y cuenta cuantos de ellos son negativos. Se usan
los contadores cuentaNumeros para controlar el lazo while, y cuentaNegativos, para llevar
la cuenta de los negativos.
AUTOR: ing. josé Rodríguez Ruiz depto. Sistemas y Computación ITCelaya '''

import random

cuentaNumeros= 1
cuentaNegativos= 0

N= int(input("Cuantos numeros se van a leer? "))

while cuentaNumeros <= N:
numero= [Link](-10, 12)
print(numero)
if (numero < 0.0):
cuentaNegativos= cuentaNegativos + 1

81
PROGRAMACIÓN ORIENTADA A OBJETOS ING. JOSÉ RODRÍGUEZ RUIZ

cuentaNumeros= cuentaNumeros + 1

print("Del total de ", N, " números ", cuentaNegativos, " son negativos")

Una salida de ejemplo de este programa es:

82
PROGRAMACIÓN ORIENTADA A OBJETOS ING. JOSÉ RODRÍGUEZ RUIZ

ACUMULADORES
Un acumulador es una variable cuyo valor se incrementa (o decrementa) en una cantidad
variable a cada repetición.
Los acumuladores se usan principalmente para obtener el total final de un conjunto de
cantidades diferentes. Se deben inicializar a un valor apropiado (generalmente uno o cero)
antes de entrar a un lazo. Dentro del lazo se incrementan (o decrementan) en una cantidad
que es diferente en cada repetición. El uso de los acumuladores se muestra en el siguiente
programa que calcula la suma de los cuadrados de un conjunto de números.

'''PROGRAMA sumaCuadrados
Calcula la suma de los cuadrados de los números de una lista de N números.
AUTOR: ing. josé Rodríguez Ruiz depto. Sistemas y Computación ITCelaya
'''
salida= ""

N= int(input("Cuantos numeros se van a leer? "))

cuentaNumeros= 1
acumulaCuadrados= 0

salida= salida + " NÚMERO CUADRADO" + "\n"

while cuentaNumeros <= N:
numero= float(input("Teclea un numero: "))
cuadrado= pow(numero, 2)
acumulaCuadrados= acumulaCuadrados + cuadrado
salida= salida + "{:>7.1f}" "{:>12.1f}".format(numero, cuadrado) + "\n"
cuentaNumeros= cuentaNumeros + 1

salida= salida + "\nLa suma de los cuadrados es: " + "{:>7.1f}".format(acumulaCuadrados)

+"\n"
print("\n")
print(salida

La salida de este programa es:

¿Cuantos numeros se van a leer? 5
Teclea un numero: 20
Teclea un numero: 10
Teclea un numero: 9.834
Teclea un numero: 5
Teclea un numero: 6

NÚMERO CUADRADO
20.0 400.0
10.0 100.0
9.8 96.7
5.0 25.0
6.0 36.0
La suma de los cuadrados es: 657.7
83
PROGRAMACIÓN ORIENTADA A OBJETOS ING. JOSÉ RODRÍGUEZ RUIZ

2.5.2 INSTRUCCIÓN if..else

La instrucción if..else se utiliza cuando se quiere ejecutar una acción cuando su condición
booleana es verdadera, pero también se desea realizar una acción diferente si la condición es
falsa. La instrucción if ..else en diagrama de flujo es la siguiente:

ENTRADA

Falso Condición verdadero

booleana
Operación 2 Operación 1

SALIDA

La instrucción if .. else se escribe así:

if condición booleana:
instrucción 1.1
instrucción 1.2
instrucción 1.3
. . .
else:
instrucción 2.1
instrucción 2.2
instrucción 2.3
. . .
Las instrucciones del bloque 1 se ejecutan solo en el caso de que la condición booleana
sea verdadera. Si es falsa, se ejecutan las instrucciones del bloque 2. Después de ejecutar
cualquiera de estas operaciones (pero no las dos al mismo tiempo) el algoritmo continúa su
ejecución en la instrucción que inmediatamente siga a la estructura if..else. El siguiente
ejemplo usa if..else.
Un ejemplo es el siguiente. Leer un número entero y determinar si es par o non.

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

if num % 2 == 0:
print("El número", num, "es par")
else:
print("El número", num, "es non")

84
PROGRAMACIÓN ORIENTADA A OBJETOS ING. JOSÉ RODRÍGUEZ RUIZ

Con este if..else, si se teclea el número 90, entonces la condición booleana es verdadera
y se imprime
El número 90 es par

Pero con el el número 45, entonces la condición booleana es falsa y se imprime

El número 45 es non

PROBLEMA. Dados tres números positivos mayores que cero que representan las
longitudes de los lados de un probable triángulo, construya un programa que determine si los
datos corresponden a un triángulo. Considere que un triángulo se forma cuando la suma de
los lados menores es más grande que el lado mayor. Considere también que los tres números
están ordenados de mayor a menor. Además, si se tiene un triangulo, calcule su área con
la fórmula

area= √ s(s-a) (s-b) (s-c)

donde a, b, c son los tres lados del triángulo, y s es la suma de los tres lados dividida entre
2.
Aplicando los pasos del Ciclo de desarrollo de software a este problema se tiene:

I.- ENTENDER PROBLEMA

En este paso se obtiene una comprensión completa del problema. Para esto se resuelve el
problema, haciendo cálculos manuales; se diseña la salida en cuanto al resultado que se pide
y el formato que se utilizará para presentarlo al usuario; se define el proceso (operaciones)
que se deban realizar; y se identifican los datos de entrada.
Para iniciar este paso se resuelven manualmente algunos casos particulares de todos los
casos generales del problema, utilizando solamente papel y lápiz (desde luego que puede
utilizarse una calculadora para los cálculos numéricos). En este ejemplo se distinguen dos
casos generales:

1) los lados forman un triángulo;

2) los lados no forman un triángulo.

Desde luego que hay muchísimos casos particulares para cada uno de los casos generales.
Por ejemplo:

Para el caso 1) algunos casos particulares son: (5, 4, 3), (8, 7, 3), (6, 6, 4), y muchísimos más;
Para el caso 2) algunos casos particulares son: (10, 3, 4), (12, 4, 7), etc.

Puesto que se van a resolver algunos casos particulares de manera manual, conviene elegir
valores sencillos. Seleccionando los lados (5, 4, 3) para el caso general 1), y (12, 4, 7) para
el caso general 2), los cálculos son los siguientes:

Caso 1) lados del triangulo a= 5, b= 4, c= 3

El lado mayor es a= 5, Por tanto:

85
PROGRAMACIÓN ORIENTADA A OBJETOS ING. JOSÉ RODRÍGUEZ RUIZ

Para que se forme un triángulo se debe cumplir a < b+ c. Entonces 5 < 4 + 3 cumple la
condición. Se forma un triángulo.

Su área es:
s= (a+b+c) / 2 s= (5+4+3) / 2 s= 12 / 2= 6 s= 6

area= √ s(s-a) (s-b) (s-c) area= √ 6(6-5) (6-4) (6-3)

area= √ 6(1) (2) (3) area= √ 36 = 6

area= 6

Caso 2) lados del triangulo a= 12, b= 4, c= 7

El lado mayor es a= 12, Por tanto, para que se forme un triángulo se debe cumplir

a < b+ c.

Entonces 12 < 4 + 7 no cumple la condición. No se forma un triángulo. No hay triángulo,

tampoco hay área.

Resumiendo, los cálculos:

DATOS DE PRUEBA RESULTADOS CORRECTOS

Lados del triángulo ¿Se forma triángulo? area

caso 1) a= 5 b= 4 c= 3 si 6
caso 2) a= 12 b= 4 c= 7 no no hay

Una vez que se ha resuelto el problema de manera manual, sin pensar siquiera en una
computadora, utilizando solamente nuestra lógica y como instrumentos papel y lápiz
(posiblemente una calculadora), entonces es momento de empezar a organizar nuestras ideas
de manera más formal.
Continuando con el paso I, entender problema, del Ciclo de desarrollo de software, ahora
se considera la salida, el proceso y la entrada de datos, en este orden exclusivamente para
este paso.

Salida. El problema pide determinar si con los lados proporcionados se forma ó no se forma
un triángulo. Si se forma un triángulo, entonces también hay que calcular su área. El diseño
de la salida debe considerar ambos casos: 1) hay triángulo; 2) no hay triángulo:

Caso 1) Con los lados ##.#, ##.# y ##.# se forma un triángulo

Su área es ##.#

Caso 2) Con los lados ##.#, ##.# y ##.# no se forma un triángulo

Cada # representa un dígito. Observe que se incluye un punto decimal, lo que significa que
el resultado se considera de tipo real (float).
86
PROGRAMACIÓN ORIENTADA A OBJETOS ING. JOSÉ RODRÍGUEZ RUIZ

Proceso. Utilizar un if..else para averiguar si con los lados proporcionados se forma un
triángulo. Es decir, se debe probar la condición if (a < b + c). Si se cumple hay triángulo y
se calcula su área. Si no se cumple no hay triángulo.

Entrada. Los datos de entrada son las longitudes de los tres lados del posible triángulo.

II. DISEÑAR EL ALGORITMO

Aquí se identifican y se ordenan los pasos necesarios para resolver el problema. Para este
problema los pasos son:

1. Leer las longitudes de los tres lados a, b, c, siendo a el mayor.

2. Si (a < b + c)
Entonces se forma un triángulo: se calcula el área y se imprime la salida del caso 1)
De lo contrario no hay triángulo: se imprime la salida del caso 2)
3. Fin de algoritmo.

III. CONSTRUIR Y PROBAR EL ALGORITMO

En este paso se escribe el algoritmo en pseudocódigo. Para este ejemplo es el siguiente:

''' ALGORITMO definirTriangulo

Lee tres valores que son las longitudes de los lados de un posible triángulo. Si esos lados
forman un triángulo, se calcula su área.
'''
1. ladoA= float(input("Dame la longitud del lado A: "))
ladoB= float(input("Dame la longitud del lado B: "))
ladoC= float(input("Dame la longitud del lado C: "))

2. if ladoA < ladoB + ladoC:

s= (ladoA + ladoB + ladoC) / 2
area= sqrt(s*(s-ladoA)* (s-ladoB)* (s-ladoC) )
print("Con los lados ", ladoA, ", ", ladoB, "y ", ladoC, "se forma un triángulo.")
print(" con area= ", area)
else:
print("Con los lados ", ladoA, ladoB, "y ", ladoC, " no se forma un triángulo.")

Los números al inicio de cada paso son para facilitar su identificación durante la prueba del
algoritmo. Después de haber realizado la prueba los números se pueden eliminar.

Prueba del algoritmo

Como se mencionó al inicio del paso I, entender problema, la prueba debe incluir todos los
casos que el algoritmo pueda tomar. Hay dos casos generales: 1) se forma triángulo; 2) no se
forma triángulo. Por tanto, la prueba incluirá los siguientes datos para sus dos casos
generales:

87
PROGRAMACIÓN ORIENTADA A OBJETOS ING. JOSÉ RODRÍGUEZ RUIZ

Caso 1) ladoA= 5 ladoB= 4 ladoC= 3

Caso 2) ladoA= 12 ladoB= 4 ladoC= 7

Para todos estos casos el algoritmo deberá trabajar correctamente. Si se recupera el resumen
de los cálculos manuales:

DATOS DE PRUEBA RESULTADOS CORRECTOS

Lados del triángulo ¿Se forma triángulo? area

caso 1) a= 5 b= 4 c= 3 si 6

caso 2) a= 12 b= 4 c= 7 no no hay
entonces la prueba procede como sigue:

Caso 1)
paso ladoA ladoB ladoC (A< B+C) salida
1 5 4 3 ---- ----
2 5 4 3 verdadero Con los lados 5, 4 y 3 se forma un triángulo
Su área es 6

Caso 2)
paso ladoA ladoB ladoC (A< B+C) salida
1 12 4 7 ---- ----
2 12 4 7 falso Con los lados 12, 4 y 7 no se forma un triángulo

Es importante observar que la prueba incluyó dos corridas diferentes del algoritmo. Una
corrida para el caso donde se forma un triángulo, y otra para el caso donde no se forma un
triángulo. Esto es necesario ya que, como se mencionó anteriormente, cada corrida prueba
un caso particular de un caso general.
Cuando la prueba demuestre que el algoritmo es correcto, entonces es el momento de
convertirlo a programa. Para este ejemplo el programa Python es el siguiente.

''' PROGRAMA definirTriangulo

Lee tres valores que son las longitudes de los lados de un posible triángulo. Si esos lados
forman un triángulo, se calcula su área.
AUTOR: ing. josé Rodríguez Ruiz depto. Sistemas y Computación ITCelaya
'''
import math

ladoA= float(input("Dame la longitud del lado A: "))

ladoB= float(input("Dame la longitud del lado B: "))
ladoC= float(input("Dame la longitud del lado C: "))

if ladoA < ladoB + ladoC:

s= (ladoA + ladoB + ladoC) / 2
area= [Link](s*(s-ladoA)* (s-ladoB)* (s-ladoC) )

88
PROGRAMACIÓN ORIENTADA A OBJETOS ING. JOSÉ RODRÍGUEZ RUIZ

print("Con los lados ", ladoA, ", ", ladoB, "y ", ladoC, "se forma un triángulo.")
print(" con area= ", area)
else:
print("Con los lados ", ladoA, ladoB, "y ", ladoC, " no se forma un triángulo.")

Una salida de ejemplo es:

Ejercicio. Reescriba el programa anterior para incluir un ciclo while con

pregunta directa.
Un segundo ejemplo de la utilización de la instrucción if..else es el siguiente. Escribir un
programa Python que convierta temperaturas Celsius a Fahrenheit o que convierta
temperaturas Fahrenheit a Celsius. El usuario debe decidir qué tipo de conversión quiere.
Aplicando los pasos del Ciclo de desarrollo de software a este ejemplo se tiene:

I.- ENTENDER PROBLEMA

Aquí se resuelve el problema, haciendo cálculos manuales; se diseña la salida en cuanto al
resultado que se pide y el formato que se utilizará para presentarlo al usuario; se define el
proceso (operaciones) que se deban realizar; y se identifican los datos de entrada.
Para iniciar este paso se resuelven manualmente algunos casos particulares de todos los
casos generales del problema, utilizando solamente papel y lápiz (desde luego que puede
utilizarse una calculadora para los cálculos numéricos). En este ejemplo se distinguen dos
casos generales: 1) convertir temperaturas Celsius a Fahrenheit; 2) convertir temperaturas
Fahrenheit a Celsius.
Desde luego que hay muchísimos casos particulares para cada uno de los casos generales.
Por ejemplo, para el caso 1) algunos casos particulares son: 100˚C, -40˚C, 0˚C, 35˚C y
muchísimos más; para el caso 2) algunos casos particulares son: 212˚F, -40˚F, 0˚F, 455˚F,
etc. Puesto que se van a resolver algunos casos particulares de manera manual, conviene
elegir valores sencillos. Seleccionando 100˚C para el caso general 1), y 212˚F para el caso
general 2), los cálculos son los siguientes:

89
PROGRAMACIÓN ORIENTADA A OBJETOS ING. JOSÉ RODRÍGUEZ RUIZ

Caso 1) Temperatura = 100˚C

Aplicando la fórmula: gradosF= 1.8 * gradosC + 32

. gradosF= 1.8 * 100 + 32= 180 + 32= 212

Se obtiene el resultado: 100 grados Celsius equivalen a 212 grados Fahrenheit

Caso 2) Temperatura = 212˚F

Aplicando la fórmula: gradosC= (gradosF - 32.0) / 1.8

. gradosF= (212 - 32) / 1.8= 180 / 1.8= 100

Se obtiene el resultado: 212 grados Fahrenheit equivalen a 100 grados Celsius

Resumiendo los cálculos:

DATOS DE PRUEBA RESULTADOS CORRECTOS

TEMPERATURA TEMPERATURA
caso 1) 100˚C 212˚F
caso 2) 212˚F 100˚C

Una vez que se ha resuelto el problema de manera manual, sin pensar siquiera en una
computadora, utilizando solamente nuestra lógica y como instrumentos papel y lápiz
(posiblemente una calculadora), entonces es momento de empezar a organizar nuestras ideas
de manera más formal.
Continuando con el paso I, entender problema, del Ciclo de desarrollo de software, ahora
se considera ahora la salida, el proceso y la entrada de datos, en este orden exclusivamente
para este paso.

Salida. El problema pide convertir temperaturas Celsius a Fahrenheit y viceversa. El diseño

de la salida debe considerar ambos casos.

Caso 1) ###.# grados Celsius equivalen a ###.# grados Fahrenheit

Caso 2) ###.# grados Fahrenheit equivalen a ###.# grados Celsius

Cada # representa un dígito. Observe que se incluye un punto decimal, lo que significa que
el resultado se considera de tipo real (double o float).

Proceso. Utilizar un if..else para averiguar cuál es la opción elegida por el usuario: 1)
Convertir Celsius a Fahrenheit; 2) convertir Fahrenheit a Celsius. Es decir, se debe probar la
condición if(codigoConversion == 1). Si se cumple se convierte de Celsius a Fahrenheit. De
lo contrario se convierte de Fahrenheit a Celius.
Entrada. El único dato de entrada es una temperatura.
90
PROGRAMACIÓN ORIENTADA A OBJETOS ING. JOSÉ RODRÍGUEZ RUIZ

II. DISEÑAR EL ALGORITMO

Aquí se identifican y se ordenan los pasos necesarios para resolver el problema. Para este
problema los pasos son:

1. Mostrar menú de opciones y leer la opción del usuario: qué tipo de conversión desea.
2. if(codigoConversion == 1)
Convertir la temperatura Celsius a Fahrenheit e imprimir la salida del caso 1).
Else (de lo contrario) convertir la temperatura Fahrenheit a e imprimir la salida del
caso 2).
3. Fin de algoritmo.

III. CONSTRUIR Y PROBAR EL PROGRAMA

En este paso se escribe el programa en Python. Para este ejemplo es el siguiente:

'''PROGRAMA conversionTemperaturas
Convierte una temperatura Celsius a Fahrenheit o una temperatura Fahrenheit a Celsius. El
usuario decide cual conversion desea. La formula para convertir una temperatura fahrenheit
a celsius es:
celsius = (fahrenheit - 32) / 1.8

AUTOR: ing. josé Rodríguez Ruiz depto. Sistemas y Computación ITCelaya

'''
codigoConversion= int(input("Elige el código de la conversion que deseas:"
"1 Grados celsius a fahrenheit."
"2 Grados fahrenheit a Celsius."
"3 Salir "))
while codigoConversion != 3:
if codigoConversion == 1:
gradosC= float(input("¿Temperatura en grados Celsius ? "))

gradosF= 1.8 * gradosC + 32

print("\n", gradosC, " grados celsius equivalen a ",

"{:>7.1f}".format(gradosF), " grados fahrenheit\n\n")
else:
gradosF= float(input("¿Temperatura en grados Fahrenheit ? "))
gradosC= (gradosF - 32.0) / 1.8

print("\n", gradosF, " grados fahrenheit equivalen a ",

"{:>7.1f}".format(gradosC)," grados celsius\n\n")

codigoConversion= int(input("Elige el código de la conversion que deseas: "

"1 Grados celsius a fahrenheit.\n"
"2 Grados fahrenheit a Celsius.\n"
"3 Salir "))
print("\n\n FIN DE PROGRAMA")

91
PROGRAMACIÓN ORIENTADA A OBJETOS ING. JOSÉ RODRÍGUEZ RUIZ

Prueba del algoritmo

Como se mencionó al inicio del paso I, entender problema, la prueba debe incluir todos los
casos que el algoritmo pueda tomar. Hay dos casos generales: 1) Convertir de Celsius a
Fahrenheit; 2) convertir de Fahrenheit a Celsius. Para ambos casos el algoritmo deberá
trabajar correctamente. Si se recupera el resumen de los cálculos manuales:

DATOS DE PRUEBA RESULTADOS CORRECTOS

TEMPERATURA TEMPERATURA
caso 1) 100˚C 212˚F
caso 2) 212˚F 100˚C

entonces la prueba procede como sigue:

Caso 1)
paso codigoConversion gradosC gradosF salida
1 1 ---- ---- ----
2 1 100 212

SALIDA
100 grados Celsius equivalen a 212 grados Fahrenheit
Caso 2)
paso codigoConversion gradosC gradosF salida
1 2 ---- ---- ----
2 2 212 100

SALIDA

212 grados Fahrenheit equivalen a 100 grados Celsius

Es importante observar que la prueba incluyó dos corridas diferentes del algoritmo. Una
corrida para el caso donde la temperatura de entrada es Celsius, y otra para el caso donde la
temperatura de entrada es Fahrenheit. Esto es necesario ya que, como se mencionó
anteriormente, cada corrida prueba un caso particular de un caso general.

Al ejecutar este programa, una salida de ejemplo es:

92
PROGRAMACIÓN ORIENTADA A OBJETOS ING. JOSÉ RODRÍGUEZ RUIZ

Un tercer ejemplo donde se utiliza tanto el if como el if..else es el siguiente:

Se hizo una encuesta a un grupo de personas. Los datos de cada una de las personas son el
nombre, su edad, su sexo (M para masculino y F para femenino) y su estado civil (C para
casado y S para soltero). Se debe hacer un ´programa que imprima el reporte de la encuesta
con el siguiente formato

REPORTE DE ENCUESTA
NOMBRE EDAD EDO. CIVIL
xxxxxxxxxxxxx ## solter@
. . .
xxxxxxxxxxxxx ## casad@

TOTAL PERSONAS ##
TOTAL MUJERES ##
TOTAL CASADAS ##
TOTAL PERSONAS MAYORES DE 18 ##

El programa es el siguiente

93
PROGRAMACIÓN ORIENTADA A OBJETOS ING. JOSÉ RODRÍGUEZ RUIZ

''' PROGRAMA pyCuentaDatos

Se hizo una encuesta a un grupo de personas. Los datos de cada una de las personas son:
nombre, edad, sexo (M para masculino y F para femenino) y su estado civil (C para casado
y S para soltero). Este programa imprime una salida con el siguiente formato:

REPORTE DE ENCUESTA
NOMBRE EDAD EDO. CIVIL
xxxxxxxxxxxxx ## Solter@
. . .
xxxxxxxxxxxxx ## Casad@

TOTAL PERSONAS ##
TOTAL MUJERES ##
TOTAL CASADAS ##
TOTAL PERSONAS MAYORES DE 18 ##
'''
salida= ""
totalPersonas= 0
totalMujeres= 0
totalMayores18= 0
totalCasadas= 0

salida= salida + "{:>30}".format("REPORTE DE ENCUESTA") + "\n"

salida= salida + "{:>10}" "{:>21}" "{:>13}".format("NOMBRE","EDAD", "EDO.
CIVIL") + "\n"

nombre= input("Nombre de la persona o F para terminar: ")

while (nombre != ‘f’) and (nombre != “F”)

totalPersonas= totalPersonas + 1

sexo= input("M)asculino o F)emenino: ")

sexo= [Link]()
if sexo == 'f':
totalMujeres= totalMujeres + 1

edad= int(input("Edad: "))

if edad > 18:
totalMayores18= totalMayores18 + 1

edoCivil= input("Estado civil: C)asad@ o S)olter@: ")

edoCivil= [Link]()

94
PROGRAMACIÓN ORIENTADA A OBJETOS ING. JOSÉ RODRÍGUEZ RUIZ

if edoCivil== 'C':
estadoCivil= "CASAD@"
else:
estadoCivil= "SOLTER@"

if sexo== 'f’' and edoCivil == 'C':

totalCasadas= totalCasadas + 1

salida= salida + "{:28}" "{:<7d}" "{:8}".format(nombre,edad, estadoCivil) + "\n"

nombre= input("Nombre de otra persona o F para terminar: ")

salida= salida + "\n"

salida= salida + "TOTAL PERSONAS " + "{:2d}".format(totalPersonas) +"\n"
salida= salida + "TOTAL MUJERES " + "{:2d}".format(totalMujeres) +"\n"
salida= salida + "TOTAL CASADAS " + "{:2d}".format(totalCasadas) +"\n"
salida= salida + "TOTAL PERSONAS MAYORES DE 18 " +
"{:2d}".format(totalMayores18) +"\n"

print("\n")
print(salida)
print("FIN DE REPORTE")

Una salida de ejemplo es:

95
PROGRAMACIÓN ORIENTADA A OBJETOS ING. JOSÉ RODRÍGUEZ RUIZ

96
PROGRAMACIÓN ORIENTADA A OBJETOS ING. JOSÉ RODRÍGUEZ RUIZ

2.5.4 ESTRUCTURAS DE DECISIÓN ANIDADAS

Cuando una estructura contiene una o más estructuras se dice que se tiene una estructura
anidada. Entonces, una estructura de decisión anidada es cuando una estructura de decisión
(if, if..else) contiene dentro de ella a una o más estructuras de decisión. Como ejemplo de
este tipo de estructura se utilizará la anidación del if . .else.
Un if . .else anidado es uno o màs if . .else dentro de otro if . .else. La figura siguiente
muestra el diagrama general de un if ..else anidado. Tome en cuenta que la forma particular
de una anidación depende del problema que se esté resolviendo.

ENTRADA

Falso condición Verdadero

booleana 1

F condición V F condición V
booleana 3 booleana 2

Operación 4 Operación 3 Operación 2 Operación 1

SALIDA

Diagrama de flujo general para la instrucción de decisión if .. else anidada.

En el diagrama se puede observar lo siguiente. La estructura if .. else anidada se accesa a

través de la flecha rotulada entrada que está arriba de la condición booleana exterior. Como
en el caso de un if .. else simple, esta condición de evalúa. Si es verdadera se toma la rama
que conduce a una segunda condición booleana que pertenece a un if .. else anidado (interno),
pero si es falsa se toma la rama opuesta que lleva a otra condición booleana que pertenece a
otro if .. else interior. En cada caso se ignora la rama que no se tomó. El if .. else anidado que
se haya seleccionado con base en el valor verdadero o falso de la evaluación de la condición
booleana exterior es a su vez evaluado. Si su condición booleana es verdadera se ejecuta una
operación (que puede contener muchas instrucciones individuales); si es falsa se ejecuta una
operación diferente. Nuevamente, la operación que no se seleccionó no se ejecuta. Una vez
que termina ejecución de la operación que se eligió se abandona la estructura if .. else anidada
a través de la flecha rotulada salida para continuar la ejecución del algoritmo. Es importante
entender que este diagrama de flujo es general, y que por tanto puede tomar diferentes formas
de acuerdo al problema que se esté resolviendo, pero siempre funcionará de la forma que se
explicó.

97
PROGRAMACIÓN ORIENTADA A OBJETOS ING. JOSÉ RODRÍGUEZ RUIZ

En código Python la estructura if ..else anidada se escribe de la siguiente forma:

if condiciónBooleana 1: F
if condiciónBooleana 2:
operación1
else:
operación2
else:
if condiciónBooleana 3: F
operación3
else:
operación4

La explicación de la estructura en if .. else anidada es la misma que para su diagrama de

flujo.
Para ilustrar la aplicación del if ..else anidado a un problema, a continuación se presenta
un algoritmo que encuentra el mayor de tres números.

'''ALGORITMO mayorDeTresNúmerosAnidación
Lee tres valores y determina cual es mayor. Utiliza una anidación de if..else
AUTOR: ing. josé Rodríguez Ruiz depto. Sistemas y Computación ITCelaya
'''
1. Leer A, B, C
2. if(A > B):
if(A > C):
mayor= A # A > B, A > C
else:
mayor= C # A > B, C > A
else:
if(B > C):
mayor= B # B > A, B > C
else:
mayor= C # C > B, C > A

3. Imprimir la salida (resultado)

La explicación del programa es la siguiente.

El paso 1 lee los tres números a comparar.
El paso 2 contiene el proceso de comparar los números, tomados dos a la vez, para
encontrar el mayor de los tres. La primera comparación es if(A > B), que tiene dos posibles
resultados: verdadero o falso. El valor falso se indica con la palabra else. Se sugiere que la
palabra else empiece en la misma columna que su respectivo if.

98
PROGRAMACIÓN ORIENTADA A OBJETOS ING. JOSÉ RODRÍGUEZ RUIZ

Si A es mayor que B, entonces se toma la parte verdadera del if y se ignora su parte else
(todas las instrucciones debajo de la línea sólida). Ahora se evalúa el segundo if: if(A > C),
que tiene sus respectivas ramas verdadero y falso.
Si A es mayor que C, entonces se toma la parte verdadera de este if y se ignora su parte
else y se asigna el valor de A a la variable mayor; esto indica que A es el mayor de los tres
números.
Pero si C es mayor que A, se toma la parte else y se asigna el valor de C a la variable
mayor. Aquí termina la evaluación de la parte verdadera del if exterior cuya condición es (A
> B).
Volviendo a la primera comparación, if(A > B). Si es falsa entonces significa que B es
mayor. Se toma su parte else.
A continuación se evalúa la comparación if(B > C). Si B es mayor que C, se toma su parte
verdadera, se ignora la parte else y se asigna el valor de B a la variable mayor.
Pero si C es mayor que B, se toma la parte else y se asigna el valor de C a mayor.
Con esto se habrán evaluado todas las posibilidades y al final de este proceso se habrá
encontrado el mayor de los tres números A, B, C.
Es importante entender que el paso 2 termina inmediatamente después de que se hace una
asignación a la variable mayor. Por ejemplo, cuando se ejecuta mayor= A, en este momento
se da por terminado el paso 2. Esto significa que las otras asignaciones a mayor ya no se
ejecutan, por lo que al finalizar este paso, mayor tiene un valor único. Lo mismo sucede
cuando se hace cualquier otra asignación a mayor.
En el paso 3 se imprime el valor que se la haya asignado a mayor en el paso 2.

Prueba del algoritmo

Cualquiera de los tres valores puede ser el mayor. La prueba debe verificar que el
algoritmo da el resultado correcto sin importar cuál de ellos es el mayor y sin importar en
que orden se leyeron:

Caso 1) A= 5 B= 14 C= 3
Caso 2) A= 12 B= 4 C= 7
Caso 3) A= 8 B= 12 C= 26

Para todos estos casos el algoritmo deberá trabajar correctamente.

DATOS DE PRUEBA RESULTADOS CORRECTOS

Números Mayor
caso 1) A= 5 B= 14 C= 3 B= 14
caso 2) A= 12 B= 4 C= 7 A=12
caso 3) A= 8 B= 12 C= 26 C=26

entonces la prueba procede como sigue:

99
PROGRAMACIÓN ORIENTADA A OBJETOS ING. JOSÉ RODRÍGUEZ RUIZ

Caso 1)
paso A B C (A > B) (A > C) (B > C) mayor salida
1 5 14 3 ---- ---- ---- ---- ----
2 5 14 3 falso no se evalúa verdadero B=14
3 5 14 3 falso no se evalúa verdadero B=14 LOS NUMEROS SON 5, 14 y 3
EL VALOR MAYOR ES 14
Caso 2)
paso A B C (A > B) (A > C) (B > C) mayor salida
1 12 4 7 ---- ---- ---- ---- ----
2 12 4 7 v v no se evalúa A=12
3 12 4 7 v v no se evalúa A=12 LOS NUMEROS SON 12, 4 y 7
EL VALOR MAYOR ES 12
Caso 3)
paso A B C (A > B) (A > C) (B > C) mayor salida
1 8 12 26 ---- ---- ---- ---- ----
2 8 12 26 f no se evalúa f C=26
3 8 12 26 f no se evalúa f C=26 LOS NUMEROS SON 8, 12 y 26
EL VALOR MAYOR ES 26

El programa correspondiente al algoritmo es el siguiente.

'''PROGRAMA mayorDeTresNúmerosAnidación
Lee tres valores y determina cual es mayor. Utiliza una anidación de if..else anidado.
AUTOR: ing. josé Rodríguez Ruiz depto. Sistemas y Computación ITCelaya
'''
A= float(input("Dame primer numero A: "))
B= float(input("Dame segundo numero B: "))
C= float(input("Dame tercer numero C: "))

if(A > B):

if(A > C):
mayor= A # A > B, A > C
else:
mayor= C # A > B, C > A
else:
if(B > C):
mayor= B # B > A, B > C
else:
mayor= C # C > B, C > A

print("\n\nLOS NUMEROS SON: ", A, ", ", B, ", ", C)

print("EL VALOR MAYOR ES ", mayor)

Una salida de ejemplo es:

100
PROGRAMACIÓN ORIENTADA A OBJETOS ING. JOSÉ RODRÍGUEZ RUIZ

Un segundo ejemplo de la utilización de if..else anidado es:

Imprimir un reporte de turistas por su estancia en un parque estatal. La cuenta se calcula

de la siguiente manera:
Si el turista es residente del estado, el costo por los primeros tres días de estancia en el
parque es de $1000.00 por día. Después de tres días el costo se reduce a $800.00 por día. Si
el turista no es residente del estado, el costo por los primeros 5 días es de $1100.00 por día.
Después de cinco días el costo se reduce a $900.00 por día.
Los datos de entrada son el nombre de cada turista; un código que tiene una R para
residente del estado y N para no residente; y los días de estancia en el parque. La salida
debe ser un reporte que debe incluir dos líneas de encabezado (una para la razón social del
parque y la otra para indicar el mes en que se hace la factura), y debajo de ella el nombre de
cada turista, su estatus de residencia (residente o foráneo), sus días de estancia en el parque
y la cuenta a pagar.
Al final de la lista de turistas se deben imprimir totales para: turistas, los días de estancia
de todos los turistas y el total de la cuenta pagada por todos los turistas.

Aplicando los pasos del Ciclo de desarrollo de un algoritmo a este problema se tiene:

101
PROGRAMACIÓN ORIENTADA A OBJETOS ING. JOSÉ RODRÍGUEZ RUIZ

I. ENTENDER PROBLEMA. Se deja como ejercicio al alumno que resuelva con lápiz
y papel algunos casos particulares del problema. A continuación se define el formato de la
salida, el proceso (operaciones) que se deba realizar, y los datos de entrada.

SALIDA. Se debe imprimir una factura con el siguiente formato:

PARQUE ESTATAL LINCE

REPORTE DE ESTANCIA

NOMBRE RESIDENCIA DÍAS CUENTA ($)

XXXXXXXXXXXXXX RESIDENTE ## #####.##
. . .
XXXXXXXXXXXXXX FORANEO ## #####.##

TOTAL TURISTAS: ###

TOTAL DIAS DE ESTANCIA: ###
TOTAL CUENTA: #####.##

PROCESO. La tarifa que cada turista debe pagar se calcula de acuerdo a lo siguiente:
Si el turista es residente del estado, el costo por los primeros tres días de estancia en el
parque es de $1000.00 por día. Después de tres días el costo se reduce a $800.00 por día. Si
el turista no es residente del estado, el costo por los primeros 5 días es de $1100.00 por día.
Después de cinco días el costo se reduce a $900.00 por día.

ENTRADA. Los datos de entrada son el nombre de cada turista; un código que tiene una
R para residente del estado y N no residente; y los días de estancia en el parque. Un ejemplo
para cuatro turistas es:

NOMBRE CÓDIGO DÍAS

Pablo Ríos R 10
Juan Téllez N 4
Carmen García R 5
Arturo Coloma N 6
fin X -99

Observe que al final de la lista de datos procesables se han añadido los tres datos centinela
“fin”, ´X´, y -99. También observe que los datos centinela deben de ser del mismo tipo de
dato que su respectivo dato procesable. Así, como el dato nombre es de tipo cadena (String)
su respectivo dato centinela también es una cadena (“fin”); el dato código es de tipo carácter
(char) y su respectivo dato centinela también lo es (´X´); y finalmente, el dato días es de tipo
entero al igual que su centinela (-99). Además, los datos centinela se eligieron de tal modo
que difícilmente puedan ser confundidos con datos procesables.

El programa es el siguiente:

102
PROGRAMACIÓN ORIENTADA A OBJETOS ING. JOSÉ RODRÍGUEZ RUIZ

'''PROGRAMA TarifasParqueLinceCentinela
Calcula e imprime la tarifa a pagar para cada uno de los turistas con base en el número de
días de estancia en el parque estatal y en su status: residentes o no residentes del estado.
Se utiliza un while con el centinela FIN en el campo NOMBRE
AUTOR: ing. josé Rodríguez Ruiz depto. Sistemas y Computación ITCelaya
'''
salida= ""
totalTuristas= 0
totalDiasEstancia= 0
totalCuenta= 0.0

salida= salida + "\n"

salida= salida + "{:>40}".format("PARQUE ESTATAL LINCE\n")
salida= salida + "{:>39}".format("REPORTE DE ESTANCIA\n")
salida= salida + "{:>10}".format("NOMBRE")+ "{:>23}".format("RESIDENCIA")
salida= salida + "{:>8}".format("DIAS") + "{:>14}". format("CUENTA ($)") + "\n"

nombre= input("Dame nombre del primer turista o FIN para terminar ")
nombre= [Link]()

while nombre != "FIN":

totalTuristas= totalTuristas + 1

codigo= input("Dame codigo: R)esidente o N)o residente ")

codigo= [Link]()
dias= int(input("Dame dias de estancia en el parque "))
totalDiasEstancia= totalDiasEstancia + dias

if codigo == "R":
status= "RESIDENTE"
else:
status= "FORANEO"

if codigo == 'R':
if dias > 3:
cuenta= 3 * 1000 + (dias - 3) * 800
else:
cuenta= dias * 1000
else:
if(dias > 5):
cuenta= 5 * 1100 + (dias - 5) * 900
else:
cuenta= dias * 1100

totalCuenta= totalCuenta + cuenta

salida= salida + "{:23}" "{:11}" "{:>6d}" "{:>14.2f}". format(nombre, status,dias, cuenta) + "\n"

103
PROGRAMACIÓN ORIENTADA A OBJETOS ING. JOSÉ RODRÍGUEZ RUIZ

nombre= input("Dame nombre del siguiente turista o FIN para terminar ")
nombre= [Link]()

salida= salida + "\n"

salida= salida + "{:16}" "{:>14d}". format("TOTAL TURISTAS: ", totalTuristas) + "\n"
salida= salida + "{:16}" "{:>6d}". format("TOTAL DIAS DE ESTANCIA: ",
totalDiasEstancia) + "\n"
salida= salida + "{:16}" "{:>17.2f}". format("TOTAL CUENTA:", totalCuenta, sep="") +
"\n"

print(salida)
print("\nTermina programa")

La siguiente es una corrida de ejemplo con los datos de prueba

NOMBRE CÓDIGO DÍAS

Pablo Ríos R 10
Juan Téllez N 4
Carmen García R 5
Arturo Coloma N 6
fin X -99

104
PROGRAMACIÓN ORIENTADA A OBJETOS ING. JOSÉ RODRÍGUEZ RUIZ

INSTRUCCIÓN elif
En muchas aplicaciones se necesitan varias decisiones anidadas en forma de “cascada”
para probar varias alternativas mutuamente excluyentes (al elegir una automáticamente se
desechan las otras). Desde luego que podían usarse if ..else independientes (no anidados),
pero en este caso se tendrían que evaluar todas y cada una de las alternativas aún cuando no
fuera necesario. Para situaciones de este tipo se puede utilizar un if..else anidado también ,
como el que se vió en la sección anterior.
También se puede utilizar la instrucción elif. La instrucción elif es la contracción para un
else seguido de un if (ver if..else anidado).

En diagrama de flujo, la “cascada” elif toma la siguiente forma general:

ENTRADA

condición
Falso Verdadero
booleana 1

Operación 1

Falso condición Verdadero

booleana 2

Operación 2

Falso condición Verdadero

booleana 3

Operación 3
Falso Verdadero
condición
booleana n

Operación n Operación n-1

SALIDA

Diagrama de flujo general para la instrucción de decisión elif

105
PROGRAMACIÓN ORIENTADA A OBJETOS ING. JOSÉ RODRÍGUEZ RUIZ

En este ejemplo la “cascada” está sobre el valor falso de las condiciones booleans, pero
también puede estar sobre las condiciones verdaderas. Aunque en este ejemplo hay cuatro
niveles de condiciones boolenas, en un programa en particular puede haber cualquier número
de niveles

En el diagrama se puede observar lo siguiente. La estructura elif se accesa a través de la

flecha rotulada entrada que está arriba de la condición booleana exterior. Como en el caso
de un if .. else simple, esta condición de evalúa. Si es verdadera se toma la opción 1 y se
llega a la salida para continuar con la siguiente instrucción fuera del elif. Si es falsa se avalua
la siguiente condición booleana y se repite el proceso hasta encontra la opción que se deba
realizar o hasta llegar a la última condición booleana.

En código Python, diagrama anterior se escribe así:

if condición booleana 1:
operación 1
elif condición booleana 2:
operación 2
elif condición booleana 3:
operación 3
. . .
elif condición booleana n:
operación n - 1
else:
operación n

Primer programa de ejemplo elif. Una compañía da un bono navideño a sus

empleados con base en dos criterios: el número de horas extra semanales trabajadas, y el
número de horas que no se presentó a trabajar durante el año (de enero a diciembre). Para
calcular el bono se utiliza la siguiente fórmula: a las horas extra se les restan 2/3 de las horas
de ausencia. El bono se asigna de acuerdo a:

Horas extra – 2/3 * horasAusencia Bono($)

> 40 10 000
> 30 y <= 40 8 000
> 20 y <= 30 6 000
> 10 y <= 20 4 000
<= 10 2 000

Aunque se tienen varias alternativas de bono, estas son mutuamente excluyentes, porque
ningún empleado puede caer en más de una de ellas. Esta situación es apropiada para
resolverse con elif. El algoritmo se presenta a continuación. Se deja como ejercicio al
estudiante que aplique todos los pasos del Ciclo de desarrollo de algoritmos.

106
PROGRAMACIÓN ORIENTADA A OBJETOS ING. JOSÉ RODRÍGUEZ RUIZ

'''PROGRAMA bonoDeNavidad
Calcula el bono de navidad para los empleados de una fábrica de acuerdo a las horas
extras trabajadas y a las horas que estuvieron ausentes de su trabajo.

AUTOR: ing. josé Rodríguez Ruiz depto. Sistemas y Computación ITCelaya

'''
nombre= input("Dame nombre del empleado: ")
horasExtra= int(input("Dame horas extra trabajadas: "))
horasAusencia= int(input("Dame horas de ausencia al trabajo: "))

resulFormula= horasExtra - 2/3 * horasAusencia

if(resulFormula > 40):

bono= 10000
elif(resulFormula > 30):
bono= 8000
elif(resulFormula > 20):
bono= 6000
elif(resulFormula > 10):
bono= 4000
else:
bono= 2000

print("{:>15}".format("NOMBRE"),
"{:>20}".format("FÓRMULA"),"{:>10}".format("BONO ($)"))
print("{:25}".format(nombre), "{:9.1f}".format(resulFormula), "{:11.2f}".format(bono))

El algoritmo empieza leyendo los datos del empleado en el paso 1. En el paso 2 se evalúa
la fórmula en que se basa la asignación del bono. El resultado se almacena en la variable
resulFormula. Con esto se evita repetir la evaluación de resulFormula en cada uno de los
if..else anidados del siguiente paso.
En el paso 3 se determina el bono. Inicia con la comparación if(resulFormula > 40). Si es
verdadera se ejecuta la instrucción bono= 10000 y se ignora su parte elif y el paso 3 habrá
terminado ya que las otras comparaciones elif no se evalúan porque están contenidas en la
parte elif de la primera comparación.
Por el contrario, si la primera comparación, if(resulFormula > 40), es falsa se continúa
con la siguiente comparación de su parte elif y se repite el proceso que se explicó
anteriormente hasta que se asigne un valor a la variable bono.
Por ejemplo, si en el paso 2 la variable resulFormula obtiene el valor 25, la primera
comparación del paso 3, if(resulFormula > 40), es falsa y se toma su else para evaluar la
segunda comparación, if(resulFormula > 30). Esta comparación también es falsa, por lo que
nuevamente se toma la parte elif para evaluar la tercera comparación, if(resulFormula > 20),
En este caso la comparación es cierta y se asigna a bono el valor 6000 y ya no es necesario
evaluar la cuarta comparación. En este momento termina el paso 3.
Una vez terminado el paso 3, se imprime el nombre del empleado y su bono en el paso 4.

107
PROGRAMACIÓN ORIENTADA A OBJETOS ING. JOSÉ RODRÍGUEZ RUIZ

Prueba del algoritmo

Aquí solo se mostrará la prueba para los datos de la siguiente persona:

NOMBRE HORAS EXTRAS HORAS AUSENTE

Salvador Torres 39 12

Se deja como ejercicio que el estudiante haga la prueba para otros casos posibles.

DATOS DE PRUEBA RESULTADOS CORRECTOS

Nombre horas extra horas ausente resulFormula bono
Salvador Torres 39 12 31 8000

La prueba procede como sigue:

paso nombre horasExtra horasAusente resulFormula bono salida
1 Salvador Torres 39 12 ---- ---- ---
2 Salvador Torres 39 12 31 ---- ---
3 Salvador Torres 39 12 31 8000 ---
4 Salvador Torres 39 12 31 8000 El bono para Salvador Torres es $8000

Segundo programa de ejemplo de elif.

Se tiene un número conocido de empleados de una empresa y se quiere saber quién es el
que gana el sueldo máximo y quién gana el sueldo mínimo. Por simplicidad considere todos
los salarios diferentes. Aplicando todos los pasos del ciclo de desarrollo de un algoritmo, se
tiene lo siguiente.

I. ENTENDER PROBLEMA
Cálculos manuales.

Nombre Sueldo Sueldo Máximo Sueldo Mínimo

Luis Alva $5600.00
Raul Gutierrez $7350.00
Pedro Solís $4450.00
María Nava $6180.00 Raul Gutierrez: $7350.00 Pedro Solís: $4450.00

Salida. La salida debe ser similar a la siguiente:

Sueldo Máximo: xxxxxxxxxxx $####.##
Sueldo Mínimo: xxxxxxxxxxx $####.##

Proceso. Se inicializan las variables para máximo y mínimo (para sueldo y para nombre)
con los datos del primer empleado. Después se comparan estas variables con los sueldos de
los restantes empleados para encontrar los verdaderos sueldos máximo y mínimo.

Entrada. Los datos son: nombre y sueldo de cada empleado, número de empleados.

108
PROGRAMACIÓN ORIENTADA A OBJETOS ING. JOSÉ RODRÍGUEZ RUIZ

II. DISEÑAR ALGORITMO

Aquí se definen los pasos necesarios para resolver el problema y su orden correcto dentro
del algoritmo. Para este problema los pasos son:

1. Leer el número de empleados.

2. Leer los datos del primer empleado
3. Inicializar las variables para máximo y mínimo con los datos del primer empleado
4. Establecer un lazo for para buscar sueldos máximo y mínimo y repetir los pasos 5 y 6
5. Leer datos del siguiente empleado
6. Si(sueldo > sueldoMax
sueldoMax= sueldo
nombremax= nombre
elsi sueldo < sueldoMin
sueldoMin= sueldo
nombreMin= nombr

7. Imprimir salida
8. Fin de algoritmo

Los números en las líneas del algoritmo son para indicar en la prueba cual es el paso que se
está ejecutando. Para correr el programa en computadora esos números deben eliminarse. La
prueba se hará con los siguientes datos de entrada

PRUEBA DEL PROGRAMA

DATOS DE PRUEBA RESULTADO CORRECTO

Nombre Sueldo
Luis Alva $5600.00
Raul Gutiérrez $7350.00
Pedro Solís $4450.00 Sueldo Máximo: Raul Gutierrez: $7350.00
María Nava $6180.00 Sueldo Mínimo: Pedro Solis $4450.00

Para la prueba se necesitará una tabla con renglones para cada uno de los pasos y con
columnas para cada una de las variables.

num Max Min

Paso Empleados nombre sueldo nombre sueldo nombre sueldo i sueldo>sMax sueldo<sMin
1 4 --- --- --- --- --- --- - --- ---
2 4 Luis Alva 5600 --- --- --- --- - --- ---
3 4 Luis Alva 5600 Luis Alva 5600 Luis Alva 5600 - --- ---

4 4 Luis Alva 5600 Luis Alva 5600 Luis Alva 5600 2 --- ---
5 4 Raul Guti 7350 Luis Alva 5600 Luis Alva 5600 2 --- ---
6 4 Raul Guti 7350 Raul Guti 7350 Luis Alva 5600 2 verdadero ---

4 4 Raul Guti 7350 Raul Guti 7350 Luis Alva 5600 3 verdadero ---
5 4 Pedro Sol 4450 Raul Guti 7350 Luis Alva 5600 3 verdadero ---
6 4 Pedro Sol 4450 Raul Guti 7350 Pedro Sol 4450 3 falso verdadero

109
PROGRAMACIÓN ORIENTADA A OBJETOS ING. JOSÉ RODRÍGUEZ RUIZ

4 4 Pedro Sol 4450 Raul Guti 7350 Pedro Sol 4450 4 falso verdadero
5 4 María Nav 6180 Raul Guti 7350 Luis Alva 5600 4 falso verdadero
6 4 María Nav 6180 Raul Guti 7350 Pedro Sol 4450 4 falso falso

4 4 María Nav 6180 Raul Guti 7350 Pedro Sol 4450 5 falso falso

7 Sueldo Máximo: Raul Gutierrez: $7350.00

Sueldo Mínimo: Pedro Solis $4450.00
8 fin de algoritmo

III. CONSTRUIR EL PROGRAMA Y PROBARLO

'''PROGRAMA sueldoMaxMin
Obtiene los datos de n empleados y encuentra quien gana el sueldo máximo y quién el
Sueldo mínimo. Por simplicidad se considera que todos lo sueldos son diferentes. '''

numEmpleados= int(input("Cuantos empleados son:? "))

nombre= input("Nombre del primer empleado? ")
sueldo= float(input(f"Sueldo del empleado {nombre}? "))
nombreMax= nombre; sueldoMax= sueldo
nombreMin= nombre; sueldoMin= sueldo

for i in range(1, numEmpleados):

nombre= input(f"Nombre del empleado {i+1}? ")
sueldo= float(input(f"Sueldo del empleado {nombre}? "))

if sueldo > sueldoMax:

sueldoMax= sueldo
nombreMax= nombre
elif (sueldo < sueldoMin):
sueldoMin= sueldo;
nombreMin= nombre;

print("\n\nSueldo Máximo: ", nombreMax, " $", sueldoMax, "\n",

"Sueldo Mínimo: ", nombreMin, " $", sueldoMin, sep= "")

Una salida de ejemplo es:

110
PROGRAMACIÓN ORIENTADA A OBJETOS ING. JOSÉ RODRÍGUEZ RUIZ

Tercer programa de ejemplo de elif

'''PROGRAMA estaciones del año

Utiliza las instrucciones for y elif para imprimir las características de las cuatro
estaciones del año. Utilizauna listas para almacenar las estaciones del año.
AUTOR: ing. josé Rodríguez Ruiz depto. Sistemas y Computación ITCelaya
'''

for estacion in ["Primavera", "Verano", "Otoño", "Invierno"]:

print(estacion)
if estacion== "Primavera":
print("La primavera es la estación de las flores")
elif estacion== "Verano":
print("El Verano es la estación de las vacaciones")
elif estacion== "Otoño":
print("El Otoño es la estación de las hojas caidas")
else:
print("El Invierno es la estación de las posadas")

La salida de este programa es:

111