UNIDAD II ESTRUCTURAS BÁSICAS DE CONTROL

(1)

UNIDAD II 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 ya sea 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.

3. 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 1.5.1.4 DATOS LÓGICOS O BOOLEANOS de la unidad I.

2.1 ESTRUCTURAS 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.

(2)

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

(3)

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\n”) # 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

(4)

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

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.

(5)

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. 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. 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

(6)

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 código los siguientes tres pasos que aseguran que el lazo siempre terminará de manera correcta. Los pasos son los siguientes:

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.

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.

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

(7)

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..

2.1.2.1 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

.

(8)

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

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 para imprimir la lista

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

(9)

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:

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.

3.1.2.1.1 Formateo de la salida

Python tiene varias formas 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.

(10)

Permite controlar las alineaciones (o justificaciones) a la derecha, al centro o a la izquierda: Utiliza los 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

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

print(“{:

ˆ

3

0}”

.

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

(11)

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 '''

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:

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.

(12)

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 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.

'''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)

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 SAL.NETO.

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)

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(824))

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

(15)

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.

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(824))

print("\nNumero impreso en 13 columnas") print("----5---10---15---20")

print("{:13d}".format(-1324))

print("{:20d}".format(32)) La salida de este programa es:

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

(16)

Esta instrucción ocupa 10 columnas para imprimir el número 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.

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("{:013d}".format(-1324))

print("{:020d}".format(32)) '''

(17)

Formateo de números float

Los números reales se denominan como 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.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

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

(18)

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).

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 cantida 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 al 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 y 8 (7 posiciones) se rellenarán con 7 espacios a la

izquierda del número:

5 10 15 20 25 30 35 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))

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

(19)

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

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))

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

Lo anterior se muestra en el siguiente programa.

''' PROGRAMA pythonFormateoFloat

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

'''

print(" El valor original a imprimir es: 234.7642")

print("\n es igual a la cantidad de dígitos fraccionarios") print( "{:15.4f}".format(234.7642))

print("\nm es menor a la cantidad de dígitos fraccionarios") print("{:15.1f}".format(234.7642))

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

print("\nSi m es mayor a la cantidad de dígitos fraccionarios")

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

(20)

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 izquierLa La da 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

(21)

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 el programa que imprime una lista con los precios de gorditas llamado listaPreciosGorditas, que ahora incluye la instrucción format() para controlar completamente la manera en que se quiere mostrar la salida el formato que se diseñó al analizar la salida del problema.

'''PROGRAMA formato tablaListaPreciosGorditas

Imprime una lista de los precios de quesadillas, gorditas y refresco. Utiliza un ciclo while para imprimir la lista

PRECIO_QUESADILLA= 15.0 PRECIO_GORDITA= 20.0 PRECIO_REFRESCO= 13.0

(22)

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("{:4}".format(cant),"{:>13.2f}".format(quesadilla), "{:>14.2f}".format(gordita), "{:>14.2f}".format(refresco))

cant= cant + 1

print("Fin de lista")

Una salida para 13 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.

(23)

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 por hora). El salario neto semanal es salario bruto menos el impuesto. La salida debe ser un reporte con el siguiente formato:

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.

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;

(24)

print("{:25}".format(nombre),"{:14.2f}".format(salarioBruto), "{:11.2f}".format(impuesto), "{:11.2f}".format(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:

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

(25)

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.

Ejemplo, si

cadena1= “Hola “

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

Entonces la concatenación cadena1+cadena2+cadena3 da como resultado una sola cadena:

“Hola amigo. Bienvenidos a mi casa.”

2.1.2.1.2 CÓMO CONCATENAR EN UNA VARIABLE TODAS LAS LÍNEAS DE SALIDA DEL PROGRAMA

Al correr un programa, el resultado o salida se muestra mezclado con los datos de entrada, lo que puede dificultar visualizar la salida, que es 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 laas 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).

PORCENTAJE_IMPUESTO= 0.25;

salida= "" #Inicialmente la variable 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")

(26)

contador= 1;

while contador <= numEmpleados:

nombre= input("Nombre del empleado? ") horas= int(input("Horas trabajadas? ")) pagoHora= float(input("Pago por hora? "))

impuesto= PORCENTAJE_IMPUESTO * salarioBruto; salarioNeto= salarioBruto - impuesto

salida=salida+"{:25}".format(nombre)+”{:14.2f”}.format(salarioBruto)+”{:11.2f}”.format(impuesto)

salida= salida + "{:11.2f}".format(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.

Instrucciones que utilizan el operador de asignación (=) 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. Un ejemplo en el programa anterior es:

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

(27)

Observar que ahora los datos de entarda 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

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 las siguientes instrucciones:

salida=salida+"{:25}".format(nombre)+”{:14.2f”}.format(salarioBruto)+”{:11.2f}”.format(impuesto)

salida= salida + "{:11.2f}".format(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

)

(28)

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.

2.1.2.1.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.

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:

# fragmento de código de 5 instrucciones verifica 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. 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:

(29)

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:

''' Verifica que la calificación (valor entero) este en el rango 0 a 100, limites incluidos. Es decir, no permite 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 ejemplo utiliza la condición compuesta ((calificacion< 0) or (calificacion > 100)) que incluye las dos condiciones individuales (calificacion< 0) y (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.

(30)

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. 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

(31)

contesta con una n entonces la condición será verdadera y se volverá a entrar al ciclo para volver a pedir el nombre.