4. Condicionales
4.1. El operador módulo
El operador módulo funciona con enteros (y expresiones enteras), y devuelve el residuo
de dividir el primer operando entre el segundo. En Python, el operador módulo es el
signo de tanto por ciento (%). La sintaxis es la misma que para otros operadores:
>>>
>>>
2
>>>
>>>
1
cociente = 7 / 3
print cociente
residuo = 7 % 3
print residuo
Así que 7 dividido entre 3 da 2 con residuo 1.
El operador residuo resulta ser sorprendentemente útil. Por ejemplo, puede comprobar
si un número es divisible entre otro —si x % y es cero, entonces x es divisible entre y.
También puede usar el operador módulo para extraer el dígito más a la derecha de un
número. Por ejemplo, x % 10 devuelve el dígito más a la derecha de x (en base 10). De
manera similar, x % 100 devuelve los dos últimos dígitos.
4.2. Expresiones y valores booleanos
El almacenamiento de valores verdaderos y falsos en Python es del tipo bool, nombrado
así debido al matemático Británico George Boole. George Boole creó el Algebra
booleana, que es la base de toda la aritmética computacional moderna.
Solo hay dos valores booleanos: True y False. Las mayúsculas son importantes, ya
que true y false no son valores booleanos. La traducción al español de true y false es
verdadero y falso, respectivamente.
>>> type(True)
<type 'bool'>
>>> type(true)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name 'true' is not defined
Una expresión booleana es una expresión cuya evaluación produce un valor booleano.
El operador == compara dos valores y produce un valor booleano:
>>> 5 == 5
True
>>> 5 == 6
False
En la primera sentencia, los dos operandos son iguales, así que la evaluación de la
expresión produce True; en la segunda sentencia, 5 no es igual a 6, así que
obtenemos False.
El operador == es uno de los operadores de comparación; los otros son:
x
x
x
x
x
!= y
> y
< y
>= y
<= y
#
#
#
#
#
x
x
x
x
x
no
es
es
es
es
es igual a y
mayor que y
menor que y
mayor o igual que y
menor o igual que y
Aunque probablemente estas operaciones le resulten familiares, los símbolos en Python
son diferentes de los matemáticos. Un error habitual es utilizar un signo igual sencillo
(=) en lugar del doble (==). Recuerde que el símbolo = es un operador de asignación y
que el símbolo == es un operador de comparación. Además, en Python no existe el
símbolo =< ni el símbolo =>.
4.3. Operadores lógicos
Existen tres operadores lógicos: and, or, y not. La semántica (significado) de estos
operadores es similar a sus significados en inglés (en español “y”, “o” y “no”). Por
ejemplo, x > 0 and x < 10 es verdadero sólo si x es mayor que 0 y menor que 10.
n % 2 == 0 or n % 3 == 0 es verdadero si cualquiera de las condiciones es verdadera,
o sea, si el número es divisible por 2 o por 3.
Finalmente, el operador not niega una expresión booleana, de forma que not(x > y) es
verdadero si (x > y) es falso, o sea, si x es menor o igual que y.
4.4. Ejecución condicional
Para escribir programas útiles, casi siempre necesitamos la capacidad de comprobar
ciertas condiciones y cambiar el comportamiento del programa como corresponda.
Las sentencias condicionales nos dan esta capacidad. La forma más sencilla es
la sentencia if:
if x > 0:
print "x es positivo"
La expresión que sigue a la sentencia if se llama condición. Si es verdadera, entonces
la sentencia sangrada se ejecuta. Si no lo es, no pasa nada.
La sintaxis para una sentencia if se ve así:
if EXPRESION BOOLEANA:
SENTENCIAS
Así como la definición de función del capítulo anterior y otras sentencias compuestas,
la sentencia if consiste de un encabezado y un cuerpo. El encabezado empieza con la
palabra reservada if seguida por una expresión booleana y termina con dos puntos (:).
Al conjunto de sentencias sangradas que siguen se le llama bloque. La primera
sentencia no sangrada marca el fin del bloque. Un bloque de sentencias dentro de una
sentencia compuesta recibe el nombre de cuerpo de la sentencia.
Cada una de las sentencias dentro del cuerpo se ejecuta en orden si la expresión
booleana produce el valor True. El bloque completo es ignorado si la expresión
booleana produce el valor False.
No hay límite en el número de sentencias que puede aparecer en el cuerpo de una
sentencia if, pero debe haber al menos una. A veces, es útil tener un cuerpo sin
sentencias (normalmente como reserva de espacio para código que todavía no ha
escrito). En ese caso puede usar la sentencia pass, que no hace nada.
if True:
pass
# Esto siempre es verdadero
# por lo que esto siempre se ejecuta, pero no hace nada
4.5. Ejecución alternativa
Una segunda forma de la sentencia if es la ejecución alternativa, en la que hay dos
posibilidades, y la condición determina cuál de ellas se ejecuta. La sintaxis se ve así:
if x % 2 == 0:
print x, "es par"
else:
print x, "es impar"
Si el residuo de dividir x entre 2 es 0, entonces sabemos que x es par, y el programa
muestra un mensaje anunciando esto. Si la condición es falsa, la segunda sentencia se
ejecuta. Puesto que la condición debe ser verdadera o falsa, se ejecutará exactamente
una de las alternativas. Estas alternativas se denominan ramas, porque son ramas en el
flujo de ejecución.
Como comentario al margen, si piensa que querrá comprobar con frecuencia la paridad
(pares o nones) de números, quizá desee “envolver” este código en una función:
def muestra_paridad(x):
if x % 2 == 0:
print x, "es par."
else:
print x, "es non."
Para cualquier valor de x, la función muestra_paridad produce un mensaje apropiado.
Cuando se llama a la función, se le puede pasar cualquier expresión entera como
argumento.
>>> muestra_paridad(17)
17 es non.
>>> y = 41
>>> muestra_paridad(y+1)
42 es par.
4.6. Condicionales encadenadas
A veces hay más de dos posibilidades y necesitamos más de dos ramas. Una forma de
expresar tal cómputo es una condicional encadenada:
if x < y:
print x, "es menor que", y
elif x > y:
print x, "es mayor que", y
else:
print x, "y", y, "son iguales"
elif es una abreviatura de “else if”. De nuevo, sólo se ejecutará una rama. No hay límite
al número de sentencias elif, pero sólo se permite una sentencia else (que es
opcional) y debe ser la última rama de la sentencia:
if eleccion == 'a':
funcion_a()
elif eleccion == 'b':
funcion_b()
elif eleccion == 'c':
funcion_c()
else:
print "Elección inválida."
Las condiciones se comprueban en orden. Si la primera es falsa, se comprueba la
siguiente, y así se sigue con las demás. Si una de ellas es cierta, se ejecuta la rama
correspondiente y termina la sentencia. Incluso, si es cierta más de una condición, sólo
se ejecuta la primera rama verdadera.
4.7. Condicionales anidadas
Una condicional puede estar anidada dentro de otra. Podríamos haber escrito el
ejemplo de tricotomía como sigue:
if x == y:
print x, "y", y, "son iguales"
else:
if x > y:
print x, "es menor que", y
else:
print x, "es mayor que", y
La condicional externa contiene dos ramas. La primera rama contiene una sentencia
simple de salida. La segunda rama contiene otra sentencia if, que tiene dos ramas
propias. Estas dos ramas son ambas sentencias de salida, aunque podrían ser
igualmente sentencias condicionales.
Aunque el sangrado de las sentencias hace la estructura evidente, las condicionales
anidadas muy pronto se vuelven difíciles de leer. En general es una buena idea evitarlas
cuando pueda.
Los operadores lógicos proporcionan a menudo formas de simplificar las sentencias
condicionales anidadas. Por ejemplo, podemos reescribir el siguiente código con un
sólo condicional:
if 0 < x:
if x < 10:
print "x es un número positivo de un solo dígito."
La sentencia print sólo se ejecuta si conseguimos superar ambas condicionales, así
que podemos usar el operador and:
if 0 < x and x < 10:
print "x es un número positivo de un solo dígito."
Este tipo de condiciones son comunes, por lo que Python nos proporciona una sintaxis
alternativa similar a la notación matemática:
if 0 < x < 10:
print "x es un número positivo de un solo dígito."
Semánticamente esta condición es la misma que la expresión booleana compuesta y
que la condicional anidada.
4.8. La sentencia return
La sentencia return le permite terminar la ejecución de una función antes de alcanzar
su final. Una razón para usarla es detectar una condición de error:
def muestra_raiz_cuadrada(x):
if x <= 0:
print "Por favor, use sólo números positivos."
return
resultado = x**0.5
print "La raíz cuadrada de x es", resultado
La función muestra_raiz_cuadrada toma un parámetro llamado x. Lo primero que hace
es comprobar si x es menor o igual que cero, en cuyo caso muestra un mensaje de
error y luego usa return para salir de la función. El flujo de la ejecución vuelve
inmediatamente a la sentencia de llamada a función y no se ejecutan las líneas
restantes de la función.
4.9. Entrada por teclado
En Introducción de datos vimos las funciones de biblioteca de Python que reciben
entradas desde el teclado: raw_input e input. Veamos ahora estas funciones con mayor
detalle.
Cuando alguna de estas funciones es llamada, el programa se detiene y espera que el
usuario escriba algo. Cuando el usuario presiona la tecla Retorno o Entrar, el programa
se reanuda y raw_input devuelve como tipo cadena (str) lo que el usuario escribió:
>>> mi_entrada = raw_input()
¿Qué estás esperando?
>>> print mi_entrada
¿Qué estás esperando?
Antes de llamar a raw_input es conveniente mostrar un mensaje que le pida al usuario
el dato solicitado. Este mensaje se llama indicador. Podemos proporcionarle un
indicador a raw_input como argumento:
>>> nombre = raw_input("¿Cómo te llamas? ")
¿Cómo te llamas? Arturo, ¡Rey de los británicos!
>>> print nombre
Arturo, ¡Rey de los británicos!
Note que el indicador es una cadena, por lo que debe ir encerrada entre paréntesis.
Si esperamos que la respuesta sea un entero, podemos usar la función input que evalúa
la respuesta como una expresión de Python:
indicador = "¿Cuál es la velocidad de una golondrina sin carga?\n"
velocidad = input(indicador)
Si el usuario escribe una cadena de números, se convertirá en un entero y se asignará
a velocidad. Por desgracia, si el usuario escribe caracteres que no sean una expresión
válida de Python, el programa dará un error:
>>> velocidad = input(indicador)
¿Cuál es la velocidad de una golondrina sin carga?
¿Se refiere a la golondrina europea o a la africana?
...
SyntaxError: invalid syntax
Si en este último ejemplo el usuario hubiese escrito una expresión válida de Python
colocando comillas en su respuesta, no habría obtenido un error:
>>> velocidad = input(indicador)
¿Cuál es la velocidad de una golondrina sin carga?
"¿Se refiere a la golondrina europea o a la africana?"
>>> velocidad
'¿Se refiere a la golondrina europea o a la africana?'
>>>
Para evitar este tipo de error, es buena idea usar raw_input para obtener una cadena y
usar entonces las funciones de conversión para transformarla en otros tipos.
4.10. Conversión de tipos
Cada tipo en Python viene con un comando de biblioteca que convierte los valores de
un tipo en el tipo asociado al comando. El comando int(ARGUMENTO) , por ejemplo, toma
cualquier valor y lo convierte, si es posible, en un entero, si no, dará un mensaje de
error:
>>> int("32")
32
>>> int("Hola")
ValueError: invalid literal for int() with base 10: 'Hola'
El comando int también puede convertir valores de punto flotante en enteros, pero
recuerde que este comando trunca las fracciones:
>>>
-2
>>>
3
>>>
42
>>>
1
int(-2.3)
int(3.99999)
int("42")
int(1.0)
El comando float(ARGUMENTO) convierte enteros y cadenas en números de punto
flotante:
>>> float(32)
32.0
>>> float("3.14159")
3.14159
>>> float(1)
1.0
Pareciera extraño que Python distinga el valor entero 1 del valor en punto flotante 1.0;
son el mismo número, pero pertenecen a tipos distintos. La razón es que se
representan en la computadora de manera diferente.
El comando str(ARGUMENTO) convierte cualquier argumento dado, en tipo cadena (str):
>>> str(32)
'32'
>>> str(3.14149)
'3.14149'
>>> str(True)
'True'
>>> str(true)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name 'true' is not defined
El comando str(ARGUMENTO) trabaja con cualquier valor y lo convierte en una cadena.
Como se mencionó antes, True es un valor booleano; true no lo es.
La situación es especialmente interesante para valores booleanos:
>>> bool(1)
True
>>> bool(0)
False
>>> bool("¡No!")
True
>>> bool("")
False
>>> bool(3.14159)
True
>>> bool(0.0)
False
Python asigna valores booleanos a los valores de otros tipos. Para tipos numéricos
como enteros y de punto flotante, los valores cero son valores falsos y los valores
diferentes de cero son valores verdaderos. Para cadenas, las cadenas vacías son falsas y
las no vacías son verdaderas.
4.11. GASP
GASP (Graphics API for Students of Python - Gráficas API para Estudiantes de Python)
nos permitirá escribir programas que involucren gráficas. Antes de se puede utilizar el
GASP, se necesita instalarlo en su máquina. Si está ejecutando Ubuntu GNU/Linux,
véase GASP en Apéndice A.
Para iniciar gasp intente lo siguiente:
>>> from gasp import *
>>> begin_graphics()
>>> Circle((200, 200), 60)
Circle instance at (200, 200) with radius 60
>>> Line((100, 400), (580, 200))
Line instance from (100, 400) to (590, 250)
>>> Box((400, 350), 120, 100)
Box instance at (400, 350) with width 120 and height 100
>>> end_graphics()
>>>
Antes del último comando, que cierra la ventana de gráficos, debería verla luciendo así:
A partir de ahora estaremos usando gasp para ilustrar (en el más amplio sentido de la
palabra) los conceptos de programación de computadoras, y para divertirnos mientras
aprendemos.
4.12. Glosario
operador módulo
Operador que, denotado por el signo de tanto por ciento (%), trabaja sobre
enteros y devuelve el residuo cuando un número es dividido por otro.
valor booleano
Existen exactamente dos valores booleanos: True y False. Los valores booleanos
se obtienen cuando una expresión booleana es evaluada por el intérprete de
Python. Estos valores son del tipo bool.
expresión booleana
Una expresión que es falsa o verdadera.
operador de comparación
Uno de los operadores que comparan dos valores: ==, !=, >, <, >=, y <=.
operador lógico
Uno de los operadores que combinan expresiones booleanas: and, or, y not.
sentencia condicional
Sentencia que controla el flujo de ejecución dependiendo de cierta condición. En
Python las palabras reservadas if, elif, y else son usadas por las sentencias
condicionales.
condición
En una sentencia condicional es una expresión booleana que determina cuál
rama se ejecutará.
bloque
Grupo de sentencias consecutivas con el mismo sangrado.
cuerpo
En una sentencia compuesta es el bloque que está después del encabezado.
rama
Uno de los posibles caminos del flujo de ejecución determinado por la ejecución
condicional.
condicional encadenada
Rama condicional con más de dos posibles flujos de ejecución. En Python las
condicionales encadenadas se escriben con las
sentencias if ... elif ... else.
anidamiento
Estructura de un programa dentro de otra, tal como una sentencia condicional
dentro de una rama de otra sentencia condicional.
indicador
Indicación visual que invita al usuario a introducir datos.
conversión de tipos
Sentencia explícita que toma un valor de un tipo y calcula el valor
correspondiente a otro tipo.
4.13. Ejercicios
1. Intente evaluar
mentalmente las
siguientes
expresiones
numéricas, luego
use el intérprete
de Python para
verificar sus
respuestas:
1. >>> 5 % 2
2. >>> 9 % 5
3. >>> 15 %
4.
5.
6.
7.
12
>>>
15
>>>
>>>
>>>
12 %
6 % 6
0 % 7
7 % 0
¿Qué pasó con el
último ejemplo?
¿Por qué? Si pudo
anticipar
correctamente
todas las
respuestas de la
computadora —
excepto la última,
es el momento de
continuar con los
demás ejercicios,
si no, tómese un
tiempo para
realizar ejemplos
similares por su
cuenta. Explore el
operador módulo
hasta que tenga
plena confianza
que ha entendido
cómo funciona.
2. if x < y:
3.
print x,
"es menor que",
y
4. elif x > y:
5.
print x,
"es mayor que",
y
6. else:
7.
print x,
"y", y, "son
iguales"
8. Envuelva este
código en una
función
llamada comparar
(x, y). Llame a la
función comparar
tres veces: una en
la que el primer
argumento sea
menor que el
segundo, otra en
la que aquel sea
mayor que éste, y
una tercera en la
que los
argumentos sean
iguales.
9. Para entender
mejor las
expresiones
booleanas es útil
la construcción
de tablas de
verdad. Dos
expresiones
booleanas
son lógicamente
equivalentes si y
solo si tienen la
misma tabla de
verdad.
El siguiente guión
de Python
muestra la tabla
de verdad para
cualquier
expresión
booleana de dos
variables, p y q:
expresion =
raw_input("Intr
oduzca una
expresión
booleana de dos
variables, p y
q: ")
print " p
q
%s" %
expresion
longitud = len(
" p
q
%s" %
expresion)
print
longitud*"="
for p in True,
False:
for q in
True, False:
print
"%-7s %-7s %7s" % (p, q,
eval(expresion)
)
En capítulos
posteriores usted
aprenderá cómo
trabaja este
guión. Por ahora
lo usará para
aprender sobre
expresiones
booleanas. Copie
este programa en
un archivo
llamado p_y_q.py
, luego ejecútelo
desde la línea de
comandos, y
cuando el
indicador solicite
una expresión
booleana
escriba: p or q.
Debería obtener
la siguiente
salida:
p
q
p or q
===============
======
True
True
True
True
False
True
False
True
True
False
False
False
Ahora que
sabemos cómo
trabaja el guión,
pongámoslo en
una función para
facilitar su uso:
def
tabla_de_verdad
(expresion):
print " p
q
%s" %
expresion
longitud =
len( " p
q
%s" %
expresion)
print
longitud*"="
for p in
True, False:
for q
in True, False:
print "%-7s %7s %-7s" % (p,
q,
eval(expresion)
)
Luego podemos
importar el
archivo en una
terminal de
Python y llamar la
función tabla_de
_verdad con una
cadena que
contenga nuestra
expresión
booleana con p y
q como
argumento:
>>> from p_y_q
import *
>>>
tabla_de_verdad
("p or q")
p
q
p or q
===============
======
True
True
True
True
False
True
False
True
True
False
False
False
>>>
Use la
función tabla_de
_verdad con las
siguientes
expresiones
booleanas,
guardando la
tabla de verdad
producida cada
vez:
1. not
(p
or
q)
2. p
and
q
3. not
(p
and
q)
4. not
(p)
or
not
(q)
5. not
(p)
and
not
(q)
¿Cuáles de estas
expresiones son
lógicamente
equivalentes?
10. Introduzca las
siguientes
expresiones en la
terminal de
Python:
11. True or False
12. True and False
13. not(False) and
True
14. True or 7
15. False or 7
16. True and 0
17. False or 8
18. "feliz" and
"triste"
19. "feliz" or
"triste"
20. "" and "triste"
21. "feliz" and ""
Analice los
resultados. ¿Qué
observaciones
tiene sobre los
diferentes tipos
de valores y los
operadores
lógicos? ¿Puede
escribir sus
observaciones en
forma
de reglas simples
sobre las
expresiones que
usan and y or?
22. if eleccion ==
'a':
23.
funcion_a()
24. elif eleccion
== 'b':
25.
funcion_b()
26. elif eleccion
== 'c':
27.
funcion_c()
28. else:
29.
print
"Elección
inválida."
30. Envuelva este
código en una
función
llamada aviso(el
eccion). Luego
defina las
funciones funcio
n_a, funcion_b,
y funcion_c de
forma tal que
muestren un
aviso de que
fueron llamadas.
Por ejemplo:
31. def
funcion_a():
32.
print "la
funcion_a fue
llamada..."
Coloque las
cuatro funciones
(aviso, funcion_a
, funcion_b,
y funcion_c) en
un guión
llamado cap4ejer
5.py. Al final de
este guión
agregue una
llamada
a aviso('b'). Su
salida debería
ser:
la funcion_b
fue llamada...
Finalmente,
modifique el
guión para que el
usuario pueda
introducir ‘a’, ‘b’,
o ‘c’. Pruébelo
importando su
guión en la
terminal de
Python.
33. Escriba una
función
llamada es_divis
ible_entre_3 que
tome un valor
entero como un
argumento y
muestre “Este
número es
divisible entre
tres.” si el
argumento es
exactamente
divisible entre 3,
y que muestre
“Este número no
es divisible entre
tres.” en caso
contrario.
Ahora escriba una
función similar
llamada es_divis
ible_entre_5 .
34. Generalice las
funciones que
escribió en el
ejercicio anterior
en una función
llamada es_divis
ible_entre_n(x,
n) que tome dos
enteros como
argumentos y
muestre cuándo
el primero es
divisible por el
segundo y
cuándo no.
Guarde esta
función en un
archivo
llamado cap04e07
.py. Importe el
archivo en una
terminal y úselo.
Una muestra de
su sesión sería:
35. >>> from
cap04e07 import
*
36. >>>
es_divisible_en
tre_n(20, 4)
37. Sí, 20 es
divisible entre
4
38. >>>
es_divisible_en
tre_n(21, 8)
39. No, 21 no es
divisible entre
8
¿Cuál será la
salida de lo
siguiente?
if "¡No!":
print
'Somos los
caballeros que
dicen "¡No!"'
else:
print
"¡Basta! ¡No
más!"
if 0:
print "Y
ahora algo
completamente
diferente..."
else:
print
"Entonces, ¿qué
es todo esto?"
Explique qué
sucede y por qué
sucede.
40. El siguiente guión
de gasp — escrito
en un archivo
llamado casa.py
— dibuja una
casa simple en
una ventana de
gasp:
41. from gasp
import *
# importa todas
las funciones
del módulo gasp
42.
43. begin_graphics(
)
#
abre la ventana
de gráficos
44.
45. Box((20, 20),
100, 100)
#
la casa
46. Box((55, 20),
30, 50)
#
la puerta
47. Box((40, 80),
20, 20)
#
la ventana
izquierda
48. Box((80, 80),
20, 20)
#
la ventana
derecha
49. Line((20, 120),
(70, 160)) #
la azotea
izquierda
50. Line((70, 160),
(120, 120)) #
la azotea
derecha
51.
52. update_when('ke
y_pressed') #
mantiene la
ventana abierta
hasta que
53. end_graphics()
# presione una
tecla cierra la
ventana (lo
54.
# que pasará de
cualquier
manera puesto
que
55.
# el guión
termina aquí,
pero es mejor
ser
56.
# explícito).
Ejecute este
guión y confirme
que obtiene una
ventana que se ve
como esta:
1. Envuelva
el código
de la casa
en una
función
que se
llame dibu
ja_casa().
2. Ahora
ejecute el
guión. ¿Ve
la casa?
¿Por qué
no?
3. Agregue
una
llamada
a dibuja_c
asa() al
final del
guión, tal
que la
casa
vuelva a la
pantalla.
4. Parametric
e la
función
con los
parámetro
sxyy—
el
encabezad
o debería
ser def di
buja_casa
(x, y):,
de forma
tal que
pueda
pasar la
localizació
n de la
casa a la
ventana de
gasp.
5. Use dibuj
a_casa par
a ubicar
cinco
casas en la
ventana de
gasp en
diferentes
localizacio
nes.
