Capítulo 4 – Adivina el Número 25

Capítulo 4 – Adivina el Número 26

Capítulo 4
ADIVINA EL NÚMERO
Temas Tratados En Este Capítulo:
• Sentencias import
• Módulos
• Sentencias while
• Condiciones
• Bloques
• Booleanos
• Operadores de comparación
• La diferencia entre = y ==
• Sentencias if
• La palabra reservada break
• Las funciones str(), int() y float()
• La función random.randint()
En este capítulo crearás el juego “Adivina el Número”. La computadora pensará un número
aleatorio entre 1 y 20, y te pedirá que intentes adivinarlo. La computadora te dirá si cada intento
es muy alto o muy bajo. Tú ganas si adivinas el número en seis intentos o menos.

Este es un buen juego para codificar ya que usa números aleatorios y bucles, y recibe entradas del
usuario en un programa corto. Aprenderás cómo convertir valores a diferentes tipos de datos, y
por qué es necesario hacer esto. Dado que este programa es un juego, nos referiremos al usuario
como el jugador. Pero llamarlo “usuario” también sería correcto.

Muestra de ejecución de “Adivina el Número”

Así es como el programa se muestra al jugador al ejecutarse. El texto que el jugador ingresa está
en negrita.

¡Hola! ¿Cómo te llamas?

Alberto

Bueno, Alberto, estoy pensando en un número entre 1 y 20.

Intenta adivinar.

10
Tu estimación es muy alta.
Intenta adivinar.

2
 Capítulo 4 – Adivina el Número 27

Tu estimación es muy baja.

Intenta adivinar.

4
¡Buen trabajo, Alberto! ¡Has adivinado mi número en 3 intentos!

Código Fuente de Adivina el Número

Abre una nueva ventana del editor de archivos haciendo clic en File (Archivo) ► New Window
(Nueva Ventana). En la ventana vacía que aparece, escribe el código fuente y guárdalo como
adivinaElNúmero.py. Luego ejecuta el programa pulsando F5. Cuando escribas este código en el
editor de archivos, asegúrate de prestar atención a la cantidad de espacios delante de algunas de
las líneas. Algunas líneas están indentadas por cuatro u ocho espacios.

¡NOTA IMPORTANTE! Los programas de este libro sólo podrán ejecutarse

sobre Python 3, no Python 2. Al iniciar la ventana IDLE, dirá algo como “Python
3.4.2” en la parte superior. Si tienes Python 2 instalado, es posible instalar
también Python 3 a la vez. Para descargar Python 3, dirígete a
https://python.org/download/.

Si obtienes errores luego de copiar este código, compáralo con el código del libro usando la
herramienta diff online en http://invpy.com/es/diff/adivinaElNúmero.

adivinaElNúmero.py
# Este es el juego de adivinar el número.
import random

intentosRealizados = 0

print('¡Hola! ¿Cómo te llamas?')

miNombre = input()
8.
9. número = random.randint(1, 20)

10. print('Bueno, ' + miNombre + ', estoy pensando en un número entre 1 y 20.')
11.
13. print('Intenta adivinar.') # Hay cuatro espacios delante de print.
estimación = input()
14.
15. estimación = int(estimación)
intentosRealizados = intentosRealizados + 1
16.

17.

18. if estimación < número:

19.
 Capítulo 4 – Adivina el Número 28

21.
if estimación > número:
22.
print('Tu estimación es muy alta.')
23.
24.
25. if estimación == número:
28. if estimación == número:
29. intentosRealizados = str(intentosRealizados)
30. print('¡Buen trabajo, ' + miNombre + '! ¡Has adivinado mi número en ' +
intentosRealizados + ' intentos!')
31.

32.
33. if estimación != número:
número = str(número)

34. print('Pues no. El número que estaba pensando era ' + número)

Sentencias import

1. # Este es el juego de adivinar el número.

2. import random

La primera línea es un comentario. Recuerda que Python ignorará todo lo que esté precedido por
el signo #. Esto sólo nos indica qué es lo que hace el programa.

La segunda línea es una sentencia import. Recuerda, las sentencias son instrucciones que realizan
alguna acción, pero no son evaluadas a un valor como las expresiones. Ya has visto sentencias
antes: las sentencias de asignación almacenan un valor en una variable.

Aunque Python incluye muchas funciones integradas, algunas funciones existen en programas
separados llamados módulos. Puedes usar estas funciones importando sus módulos en tu
programa con una sentencia import.

La línea 2 importa el módulo llamado random de modo que el programa pueda llamar a
random.randint(). Esta función generará un número aleatorio para que el usuario adivine.

4. intentosRealizados = 0

La línea 4 crea una nueva variable llamada intentosRealizados. Guardaremos en esta variable
el número de veces que el jugador ha intentado adivinar el número. Ya que el jugador no ha
realizado ningún intento a esta altura del programa, guardaremos aquí el entero 0.

6. print('¡Hola! ¿Cómo te llamas?')

 Capítulo 4 – Adivina el Número 29

7. miNombre = input()

Las líneas 6 y 7 son iguales a las líneas en el programa Hola Mundo que viste en el Capítulo 3.
Los programadores a menudo reutilizan código de sus otros programas para ahorrarse trabajo.

La línea 6 es una llamada a la función print(). Recuerda que una función es como un mini-
programa dentro de tu programa. Cuando tu programa llama a una función, ejecuta este mini-
programa. El código dentro de la función print() muestra en la pantalla la cadena que ha
recibido como argumento.

La línea 7 permite al usuario escribir su nombre y lo almacena en la variable miNombre.

(Recuerda, la cadena podría no ser realmente el nombre del jugador. Es simplemente cualquier
cadena que el jugador haya introducido. Las computadoras son tontas, y sólo siguen sus
instrucciones sin importarles nada más.)

La Función random.randint()

9. número = random.randint(1, 20)

La línea 9 llama a una nueva función denominada randint() y guarda el valor que ésta devuelve
en la variable número. Recuerda, las llamadas a funciones pueden ser parte de expresiones, ya que
son evaluadas a un valor.

La función randint() es parte del módulo random, por lo que debes colocar random. delante de
ella (¡no olvides colocar el punto!) para decirle a Python que la función randint() está en el
módulo random.

La función randint() devolverá un entero aleatorio en el intervalo comprendido (incluidos los

bordes) entre los dos argumentos enteros que le pases. La línea 9 pasa 1 y 20 separados por una
coma y entre los paréntesis que siguen al nombre de la función. El entero aleatorio devuelto por
randint() es almacenado en una variable llamada número; este es el número secreto que el
jugador intentará adivinar.

Sólo por un momento, vuelve a la consola interactiva y escribe import random para importar el
módulo random. Luego escribe random.randint(1, 20) para ver a qué se evalúa la llamada a la
función. Devolverá un entero entre 1 y 20. Repite el código nuevamente y la llamada a la función
probablemente devolverá un entero diferente. La función randint() devuelve un entero aleatorio
cada vez, de la misma forma en que tirando un dado obtendrías un número aleatorio cada vez:

>>> import random

>>> random.randint(1, 20)

12
 Capítulo 4 – Adivina el Número 30

>>> random.randint(1, 20)

18
>>> random.randint(1, 20)
3
>>> random.randint(1, 20)
18
>>> random.randint(1, 20)
7

Usa la función randint() cuando quieras agregar aleatoriedad a tus juegos. Y vas a usar
aleatoriedad en muchos juegos. (Piensa en la cantidad de juegos de mesa que utilizan dados.)

También puedes probar diferentes intervalos de números cambiando los argumentos. Por
ejemplo, escribe random.randint(1, 4) para obtener sólo enteros entre 1 y 4 (incluyendo 1 y
4). O prueba random.randint(1000, 2000) para obtener enteros entre 1000 y 2000.

Por ejemplo, escribe lo siguiente en la consola interactiva. Los resultados que obtienes cuando
llamas a la función random.randint() serán seguramente diferentes (después de todo es
aleatorio).

>>> random.randint(1, 4)

>>> random.randint(1000, 2000)

1294
Puedes cambiar ligeramente el código fuente del juego para hacer que el programa se comporte
de forma diferente. Prueba cambiar las líneas 9 y 10 de:

9. número = random.randint(1, 20)

10. print('Bueno, ' + miNombre + ', estoy pensando en un número entre 1 y 20.')

…a lo siguiente:

9. número = random.randint(1, 100)

10. print('Bueno, ' + miNombre + ', estoy pensando en un número entre 1 y
100.')

Y ahora la computadora pensará en un entero comprendido entre 1 y 100 en lugar de entre 1 y 20.
Cambiar la línea 9 cambiará el intervalo del número aleatorio, pero recuerda cambiar también la
línea 10 para que el juego le diga al jugador el nuevo rango en lugar del viejo.
 Capítulo 4 – Adivina el Número 31

Recibiendo al Jugador

10. print('Bueno, ' + miNombre + ', estoy pensando en un número entre 1 y 20.')

En la línea 10 la función print() recibe al jugador llamándolo por su nombre, y le dice que la
computadora está pensando un número aleatorio.

Puede parecer que hay más de un argumento cadena en la línea 10, pero observa la línea con
cuidado. El signo suma concatena las tres cadenas de modo que son evaluadas a una única
cadena. Y esa única cadena es el argumento que se pasa a la función print(). Si miras
detenidamente, verás que las comas están dentro de las comillas, por lo que son parte de las
cadenas y no un separador.

Bucles
12. while intentosRealizados < 6:

La línea 12 es una sentencia while (mientras), que indica el comienzo de un bucle while. Los
bucles te permiten ejecuta código una y otra vez. Sin embargo, necesitas aprender algunos otros
conceptos antes de aprender acerca de los bucles. Estos conceptos son bloques, booleanos,
operadores de comparación, condiciones, y la sentencia while.

Bloques
Varias líneas de código pueden ser agrupadas en un bloque. Un bloque consiste en líneas de
código que comparten mínima indentación posible. Puedes ver dónde comienza y termina un
bloque de código mirando el número de espacios antes de las líneas. Esto se llama la indentación
de la línea.

Un bloque comienza cuando la indentación de una línea se incrementa (usualmente en cuatro

espacios). Cualquier línea subsiguiente que también esté indentada por cuatro espacios es parte
del bloque. El bloque termina cuando hay una línea de código con la misma indentación que antes
de empezar el bloque. Esto significa que pueden existir bloques dentro de otros bloques. La
Figura 4-1 es un diagrama de código con los bloques delineados y numerados. Los espacios son
cuadrados negros para que sean más fáciles de contar.

En la Figura 4-1, la línea 12 no tiene indentación y no se encuentra dentro de ningún bloque. La

línea 13 tiene una indentación de cuatro espacios. Como esta indentación es mayor que la
indentación de la línea anterior, ha comenzado un nuevo bloque. Este bloque tiene la etiqueta (1)
 Capítulo 4 – Adivina el Número 32

en la Figura 4-1. Este bloque continuará hasta una línea sin espacios (la indentación original antes
de que comenzara el bloque). Las líneas vacías son ignoradas.

La línea 20 tiene una indentación de ocho espacios. Ocho espacios es más que cuatro espacios, lo
que comienza un nuevo bloque. Este bloque se señala con (2) en la Figura 4-1. Este bloque se
encuentra dentro de otro bloque.

Figura 4-1: Bloques y su indentación. Los puntos negros representan espacios.

La línea 22 sólo tiene cuatro espacios. Al ver que la indentación se ha reducido, sabes que el
bloque ha terminado. La línea 20 es la única línea del bloque. La línea 22 está en el mismo bloque
que las otras líneas con cuatro espacios.

La línea 23 incrementa la indentación a ocho espacios, de modo que otra vez comienza un nuevo
bloque. Es el que tiene la etiqueta (3) en la Figura 4-1.

Para recapitular, la línea 12 no está en ningún bloque. Las líneas 13 a 23 pertenecen al mismo
bloque (marcado como bloque 1). La línea 20 está en un bloque dentro de un bloque marcado con
(2). Y la línea 23 es la única línea en otro bloque dentro de un bloque marcado con (3).

El Tipo de Datos Booleano

El tipo de datos Booleano tiene sólo dos valores: True (Verdadero) o False (Falso). Estos valores
deben escribirse con “T” y “F” mayúsculas. El resto del nombre del valor debe estar en
minúscula. Usarás valores Booleanos (llamados bools por brevedad) con operadores de
comparación para formar condiciones. (Las condiciones serán explicadas más adelante.)

Por ejemplo:

>>> spam = True

 Capítulo 4 – Adivina el Número 33

>>> eggs = False

Los tipos de datos que han sido introducidos hasta ahora son enteros, floats, cadenas, y ahora
bools.

Operadores de Comparación
La línea 12 tiene una sentencia while:

12. while intentosRealizados < 6:

La expresión que sigue a la palabra reservada while (la parte intentosRealizados < 6)
contiene dos valores (el valor en la variable intentosRealizados, y el valor entero 6)
conectados por un operador (el símbolo <, llamado el símbolo “menor que”). El símbolo <
se llama un operador de comparación.

Los operadores de comparación comparan dos valores y se evalúan a un valor Booleano True o
False. En la Tabla 4-1 se muestra una lista de todos los operadores de comparación.

Table 4-1: Operadores de comparación.

Signo del Operador Nombre del Operador
< Menor que
> Mayor que
<= Menor o igual a
>= Mayor o igual a
== Igual a
!= Diferente a

Ya has leído acerca de los operadores matemáticos +, -, *, y /. Como cualquier operador, los
operadores de comparación se combinan con valores ara formar expresiones tales como
intentosRealizados < 6.

Condiciones
Una condición es una expresión que combina dos valores con un operador de comparación (tal
como < o >) y se evalúa a un valor Booleano. Una condición es sólo otro nombre para una
expresión que se evalúa a True o False. Las condiciones se usan en sentencias while (y en
algunas otras situaciones, explicadas más adelante.)
 Capítulo 4 – Adivina el Número 34

Por ejemplo, la condición intentosRealizados < 6 pregunta, “¿es el valor almacenado en

intentosRealizados menor que el número 6?” Si es así, entonces la condición se evalúa a True
(Verdadero). En caso contrario, la condición se evalúa a False (Falso).

En el caso del programa “Adivina el Número”, en la línea 4 has almacenado el valor 0 en

intentosRealizados. Como 0 es menor que 6, esta condición se evalúa al valor Booleano True.
La evaluación ocurre así:

intentosRealizados < 6

0 < 6

Experimentando True
con Booleans, Operadores de Comparación y Condiciones
Escribe las siguientes expresiones en la consola interactiva para ver sus resultados Booleanos:

>>> 0 < 6
True

>>> 6 < 0
>>> 50 < 10
False
>>> 10 < 11
True
>>> 10 < 10
False

La condición 0 < 6 devuelve el valor Booleano True porque el número 0 es menor que el
número 6. Pero como 6 no es menor que 0, la condición 6 < 0 se evalúa a False. 50 no es
menor que 10, luego 50 < 10 es False. 10 es menor que 11, entonces 10 < 11 es True.

Observa que 10 < 10 se evalúa a False porque el número 10 no es más pequeño que el número
10. Son exactamente del mismo tamaño. Si Alicia fuera igual de alta que Berto, no dirías que
Alicia es más alta que Berto o que Alicia más baja que Berto. Ambas afirmaciones serían falsas.

Ahora prueba introducir estas expresiones en la consola interactiva:

>>> 10 == 10
True
>>> 10 == 11
False
>>> 11 == 10
False
 Capítulo 4 – Adivina el Número 35

>>> 10 != 10

False

>>> 10 != 11

True

>>> 'Hola' == 'Hola'

True

>>> 'Hola' == 'Adios'

False

>>> 'Hola' == 'HOLA'

False
La Diferencia Entre = y ==
>>> 'Adios' != 'Hola'
True
Intenta no confundir el operador asignación (=) y el operador de comparación “igual a” (==). El
signo igual (=) se usa en sentencias de asignación para almacenar un valor en una variable,
mientras que el signo igual-igual (==) se usa en expresiones para ver si dos valores son iguales. Es
fácil usar uno accidentalmente cuando quieres usar el otro.

Sólo recuerda que el operador de comparación “igual a” (==) está compuesto por dos caracteres,
igual que el operador de comparación “diferente a” ( !=) que también está compuesto por dos
caracteres.

Cadenas y valores enteros no pueden ser iguales. Por ejemplo, prueba escribiendo lo siguiente en
la consola interactiva:

>>> 42 == 'Hola'
False

>>> 42 != '42'

True
Creabdo Bucles con sentencias while
La sentencia while (mientras) indica el comienzo de un bucle. Los bucles pueden ejecutar el
mismo código repetidas veces. Cuando la ejecución llega hasta una sentencia while, evalúa la
condición junto a la palabra reservada while. Si la condición se evalúa a True, la ejecución se
mueve dentro del bloque while. (En tu programa, el bloque while comienza en la línea 13.) Si la
condición se evalúa a False, la ejecución se mueve hasta debajo del bloque while. (En “Adivina
el Número”, la primera línea luego del bloque while es la línea 28.)

Una sentencia while siempre incluye dos punos (el signo :) después de la condición.
 Capítulo 4 – Adivina el Número 36

12. while intentosRealizados < 6:

Figura 4-2: La condición del bucle while.

La Figura 4-2 muestra como transcurre la ejecución dependiendo de la condición. Si la condición

se evalúa a True (lo cual hace la primera vez, porque el valor de intentosRealizados es 0), la
ejecución entrará al bloque while en la línea 13 y continuará moviéndose hacia abajo. Una vez
que el programa llegue al final del bloque while, en lugar de ir hacia abajo hasta la siguiente
línea, la ejecución vuelve atrás hasta la línea de la sentencia while (línea 12) y reevalúa la
condición. Como antes, si la condición es True la ejecución vuelve a entrar al bloque while.
Cada vez que la ejecución recorre el bucle se llama una iteración.

Así es como funciona el bucle. Mientras que la condición sea True, el programa sigue ejecutando
el código dentro del bloque while en forma repetida hasta la primera vez que la condición sea
False. Piensa en la sentencia while como decir, “mientras esta condición sea verdadera, sigue
iterando a través del código en este bloque”.

El Jugador Adivina

13. print('Intenta adivinar.') # Hay cuatro espacios delante de print.

14. estimación = input()

 Capítulo 4 – Adivina el Número 37

Las líneas 13 a 17 piden al jugador que adivine cuál es el númeo secreto y le permiten formular
su intento. Este número se almacena en una variable llamada estimación.

Conversión de Cadenas a Enteros con la función int(), float(),

str(), bool()

15. estimación = int(estimación)

En la línea 15, llamas a una función llamada int(). La función int() toma un argumento y
devuelve un valor entero de ese argumento. Prueba escribir lo siguiente en la consola interactiva:

>>> int('42')
42

>>> 3 + int('2')
5

La llamada a int('42') devolverá el valor entero 42. La llamada int(42) hará lo mismo (a
pesar de que no tiene mucho sentido obtener la forma de valor entero de un valor que ya es
entero). Sin embargo, aunque la función int() acepta cadenas, no puedes pasarle cualquier
cadena. Pasarle 'cuarenta-y-dos' a int() resultará en un error. La cadena que recibe int()
debe estar compuesta por números.

>>> int('cuarenta-y-dos')
Traceback (most recent call last):

File "<pyshell#5>", line 1, in <module>

int('cuarenta-y-dos')

ValueError: invalid literal for int() with base 10: 'cuarenta-y-dos'

La línea 3 + int('2') muestra una expresión que usa el valor de retorno de int() como parte
de una expresión. Se evalúa al valor entero 5:

3 + int('2')

3 + 2

5
Recuerda, la función input() devuelve una cadena de texto que el jugador ha escrito. Si el
jugador escribe 5, la función input() devolverá el valor de cadena '5', no el valor entero 5.
Python no puede usar los operadores de comparación < y > para comparar una cadena y un valor
entero:
 Capítulo 4 – Adivina el Número 38

>>> 4 < '5'

Traceback (most recent call last):

File "<pyshell#0>", line 1, in <module>

4 < '5'

TypeError: unorderable types: int() < str()

14. estimación = input()

15. estimación = int(estimación)

En la línea 14 la variable estimación contenía originalmente el valor de cadena ingresado por el

jugador. La línea 15 sobrescribe el valor de cadena en estimación con el valor entero devuelto
por int(). Esto permite al código más adelante en el programa comparar si estimación es
mayor, menor o igual al número secreto en la variable número.

Una última cosa: La llamada int(estimación) no cambia el valor de la variable estimación. El

código int(estimación) es una expresión que se evalúa a la forma de valor entero de la
cadena guardada en la variable estimación. Lo que cambia estimación es la sentencia de
asignación: estimación = int(estimación)

El float(), str(), y bool() funciona de manera similar se volverá float, str, y las versiones de
Boole de los argumentos que se pasan a ellos:

>>> float('42')
42.0

>>> float(42)
42.0

>>> str(42)
'42'

>>> str(42.0)
'42.0'

>>> str(False)
'False'

>>> bool('')
False
Incrementando las Variables
>>> bool('cualquier cadena no vacía')
True

17. intentosRealizados = intentosRealizados + 1

Una vez que el jugador ha realizado un intento, el número de intentos debería incrementarse en
uno.
 Capítulo 4 – Adivina el Número 39

En la primera iteración del bucle, intentosRealizados tiene el valor 0. Python tomará este
valor y le sumará 1. 0 + 1 se evalúa a 1, el cual se almacena como nuevo valor de
intentosRealizados. Piensa en la línea 17 como diciendo, “la variable intentosRealizados
debería ser uno más que lo que es ahora”.

Sumarle uno al valor entero o float de una variable es lo que se llama incrementar la variable.
Restarle uno al valor entero o float de una variable es decrementar la variable.

Sentencias if
19. if estimación < número:
20. print('Tu estimación es muy baja.') # Hay ocho espacios delante de
print.

La línea 19 es una sentencia if. La ejecución correrá el código en el siguiente bloque si la

condición de la sentencia if se evalúa a True. Si la condición es False, entonces el código en el
bloque if se omite. Mediante el uso de sentencias if, puedes hacer que el programa sólo ejecute
ciertas partes del código cuando tú quieras.

La sentencia if funciona casi igual que una sentencia while. Pero a diferencia del bloque while,
la ejecución no vuelve atrás hasta la sentencia if cuando termina de ejecutarse el bloque if.
Simplemente continúa en la línea siguiente. En otras palabras, las sentencias if no generan un
bucle. Mira la Figura 4-3 para ver una comparación de las dos sentencias.

Figura 4-3: Sentencias if y while.

22. if estimación > número:

23. print('Tu estimación es muy alta.')

 Capítulo 4 – Adivina el Número 40

La línea 22 comprueba si la estimación del jugador es mayor que el entero aleatorio. Si esta
condición es True, entonces la llamada a la función print() indica al jugador que su estimación
es demasiado alta.

Abandonando los Bucles Anticipadamente con la sentencia break

25. if estimación == número:
26. break

La sentencia if en la línea 25 comprueba si la estimación es igual al entero aleatorio. Si lo es, el

programa ejecuta la sentencia break de la línea 26.

Una sentencia break indica a la ejecución que salga inmediatamente del bucle while y se mueva
a la primera línea a continuación del mismo. (Las sentencias break no se molestan en volver a
revisar la condición del bucle while, sólo salen del bucle instantaneamente.)

La sentencia break es simplemente la palabra reservada break en sí misma, sin condición o dos
puntos.

Si el jugador adivinó el número no es igual al número entero aleatorio, la ejecución alcanza la

parte inferior del bloque while. Esto significa se repetirá la ejecución de nuevo a la parte
superior y vuelva a comprobar el estado de la línea 12 (intentosRealizados < 6). Recuerdo
que después de los intentosRealizados = intentosRealizados + 1 línea de código se
ejecuta, el nuevo valor de intentosRealizados es 1. Porque 1 <6 es cierto que la ejecución
entra en el bucle de nuevo.

Si el jugador continúa realizando intentos demasiado altos o bajos, el valor de

intentosRealizados cambiará a 2, luego 3, luego 4, luego 5, luego 6. Cuando
intentosRealizados tiene almacenado el número 6, la condición de la sentencia while es False,
dado que 6 no es menor que 6. Como la condición de la sentencia while es False, la ejecución se
mueve a la primera línea después del bloque while, línea 28.

Comprobar si el Jugador ha Ganado

28. if estimación == número:

La línea 28 no tiene indentación, lo que significa que el bloque while ha terminado y esta es la
primera línea luego del mismo. La ejecución ha abandonado el bloque while, sea porque la
condición de la sentencia while era False (cuando el jugador se quedó sin intentos) o porque se
ejecutó la sentencia break (cuando el jugador adivina el número correctamente).
 Capítulo 4 – Adivina el Número 41

La línea 28 comprueba a ver si el jugador ha adivinado correctamente. Si es así, la ejecución entra

al bloque if de la línea 29.

29. intentosRealizados = str(intentosRealizados)

30. print('¡Buen trabajo, ' + miNombre + '! ¡Has adivinado mi número en ' +
intentosRealizados + ' intentos!')

Las líneas 29 y 30 sólo se ejecutan si la condición en la sentencia if de la línea 28 es True (es

decir, si el jugador ha adivinado correctamente el número de la computadora).

La línea 29 llama a la nueva función str(), que devuelve la forma cadena de

intentosRealizados. Este código obtiene la forma cadena del entero en intentosRealizados
ya que sólo cadenas pueden ser concatenadas con otras cadenas.

Comprobar si el Jugador ha Perdido

32. if estimación != número:

La línea 32 usa el operador comparación != para comprobar si el último intento del jugador no es
igual al número secreto. Si esta condición se evalúa a True, la ejecución se mueve dentro del
bloque if de la línea 33.

Las líneas 33 y 34 están dentro del bloque if, y sólo se ejecutan si la condición de la línea 32 es
True.

33. número = str(número)

34. print('Pues no. El número que estaba pensando era ' + número)

En este bloque, el programa indica al jugador cuál era el número secreto que no ha podido
adivinar correctamente. Esto requiere concatenar cadenas, pero número almacena un valor entero.
La línea 33 reemplazará número con una forma cadena, de modo que pueda ser concatenada con
la cadena 'Pues no. El número que estaba pensando era ' de la línea 34.

En este punto, la ejecución ha alcanzado el final del código, y el programa termina.

¡Felicitaciones! ¡Acabas de programar tu primer juego de verdad!

Puedes cambiar la dificultad del juego modificando el número de intentos que el jugador recibe.
Para dar al jugador sólo cuatro intentos, cambia esta línea::

12. while intentosRealizados < 6:

...por esta otra:

 Capítulo 4 – Adivina el Número 42

12. while intentosRealizados < 4:

El código más adelante en el bloque while incrementa la variable intentosRealizados en 1 en

cada iteración. Al imponer la condición intentosRealizados < 4, te aseguras de que el código
dentro del bucle sólo se ejecuta cuatro veces en lugar de seis. Esto hace al juego mucho más
difícil. Para hacer el juego más fácil, cambia la condición a intentosRealizados < 8 o
intentosRealizados < 10. Esto permitirá que el bucle se ejecute algunas veces más y acepte
más intentos del jugador.

Sentencias de Control de Flujo

En capítulos anteriores, la ejecución del programa comenzaba por la instrucción de más arriba e
iba directo hacia abajo, ejecutando cada instrucción en orden. Pero con las sentencias while, if,
else, y break, puedes hacer que la ejecución repita u omita instrucciones basándose en
condiciones. Este tipo de sentencia se llama sentencia de control de flujo, ya que modifican el
“flujo” de la ejecución a medida que esta se desplaza por tu programa.

Resumen

Si alguien te preguntase “¿Qué es exactamente programar de todos modos?”, ¿qué podrías

decirle? Programar es simplemente la acción de escribir código para programas, es decir, crear
programas que puedan ser ejecutados por una computadora.

“Pero ¿qué es exactamente un programa?” Cuando ves a alguien usando un programa de

computadora (por ejemplo, jugando tu juego “Adivina el Número”), todo lo que ves es texto
apareciendo en la pantalla. El programa decide exactamente qué texto mostrar en la pantalla (las
salidas del programa), basado en instrucciones y en el texto que el jugador ha escrito mediante el
teclado (las entradas del programa). Un programa es sólo una colección de instrucciones que
actúan sobre las entradas provistas por el usuario.

“¿Qué tipo de instrucciones?” Hay sólo unos pocos tipos diferentes de instrucciones, de verdad.

1. Expresiones. Las expresiones son valores conectados por operadores. Todas las
expresiones son evaluadas a un único valor, así como 2 + 2 se evalúa a 4 o 'Hola' + '
' + 'Mundo' se evalúa a 'Hola Mundo'. Cuando las expresiones están al lado de las
palabras reservadas if y while, pueden recibir también el nombre de condiciones.
2. Sentencias de asignación. Las sentencias de asignación almacenan valores en variables
para que puedas recordar los valores más adelante en el programa.
3. Sentencias de control de flujo if, while, y break. Las sentencias de control de flujo
pueden hacer que el flujo omita instrucciones, genere un bucle sobre un bloque de
 Capítulo 4 – Adivina el Número 43

instrucciones o salga del bucle en el que se encuentra. Las llamadas a funciones también
cambian el flujo de ejecución moviéndose al comienzo de una función.
4. Las funciones print() e input(). Estas funciones muestran texto en la pantalla y
reciben texto del teclado. Esto se llama E/S (o en inglés I/O), porque tiene que ver con las
Entradas y Salidas del programa.

Y eso es todo, sólo estas cuatro cosas. Por supuesto, hay muchos detalles acerca de estos cuatro
tipos de instrucciones. En este libro aprenderás acerca de nuevos tipos de datos y operadores,
nuevas sentencias de controlo de flujo, y muchas otras funciones que vienen con Python.
También hay diferentes tipos de E/S tales como entradas provistas por el ratón o salidas de sonido
y gráficos en lugar de sólo texto.

En cuanto a la persona que usa tus programas, sólo se preocupa acerca del último tipo, E/S. El
usuario escribe con el teclado y luego ve cosas en la pantalla u oye sonidos de los altavoces. Pero
para que la computadora pueda saber qué imágenes mostrar y qué sonidos reproducir, necesita un
programa, y los programas son sólo un manojo de instrucciones que tú, el programador, has
escrito.
 Capítulo 5 – Chistes 43

Capítulo 5
CHISTES
Temas Tratados En Este Capítulo:
• Caracteres de escape
• Utilizando comillas simples y comillas dobles para las cadenas.
• Utilizando el argumento palabra clave final (end) de print() para evitar nuevas lineas
Aprovechar print() al Máximo
La mayoría de los juegos en este libro tendrán un texto simple de entrada y salida. La entrada es
escrita por el usuario desde el teclado e introducida a la computadora. La salida es el texto
mostrado en la pantalla. En Python, la función print() se puede usar para mostrar salidas de
texto en la pantalla. Pero hay más para aprender sobre cómo funcionan las cadenas y el print()
en Python.

El programa de este capítulo le cuenta chistes al usuario.

Ejecución de Muestra de Chistes

¿Qué sale de la cruza entre un mono y un pato?

¡Un monopatín!
¿Porqué vuelan los pájaros pa'l sur?

¡Porque caminando tardarían muchísimo!

¿En qué se parecen una familia, un bombero y un barco?
No sé... ¿en qué se parecen?

En que el bombero y el barco tienen casco.

Source Code-Bien,
¿Y la familia? of Jokes
gracias.

Escribe el siguiente código fuente en el editor de archivos y guárdalo como chistes.py.

¡NOTA IMPORTANTE! Los programas de este libro sólo podrán ejecutarse

sobre Python 3, no Python 2. Al iniciar la ventana IDLE, dirá algo como “Python
3.4.2” en la parte superior. Si tienes Python 2 instalado, es posible instalar
también Python 3 a la vez. Para descargar Python 3, dirígete a
https://python.org/download/.
 Capítulo 5 – Chistes 44

Si obtienes errores después de escribir este código, compáralo con el código del libro con la
herramienta diff en línea en http://invpy.com/es/diff/chistes.

chistes.py
1. print('¿Qué sale de la cruza entre un mono y un pato?')
2. input()
3. print('¡Un monopatín!')
4. print()
5. print('¿Porqué vuelan los pájaros pa\'l sur?')
6. input()
7. print('¡Porque caminando tardarían muchísimo!')
8. print()
9. print('¿En qué se parecen una familia, un bombero y un barco?')
10. input()
11. print("No sé... ¿en qué se parecen?")
12. input()
13. print('En que el bombero y el barco tienen casco.')
14. input()
15. print('¿Y la familia?', end='')
16. print(' -Bien, gracias.')

Cómo Funciona el Código

1. print('¿Qué sale de la cruza entre un mono y un pato?')

2. input()
3. print('¡Un monopatín!')
4. print()

Las líneas de la 1 a la 4 tienen tres llamadas a la función print(). No quieres que el jugador lea
de inmediato el remate del chiste, así que hay una llamada a la función print() después del
primer print(). El jugador puede leer la primera línea, presionar INTRO, y entonces leer el
remate del chiste.

El usuario todavía puede escribir una cadena y pulsar INTRO, pero esta cadena devuelta no está
siendo almacenada en ninguna variable. El programa tan solo lo olvidará y se moverá a la
siguiente línea de código.

La última llamada a la función print() no tiene argumento de cadena. Esto le indica al programa
que solamente escriba una línea en blanco. Las líneas en blanco pueden ser útiles para evitar que
el texto quede unido.
 Capítulo 5 – Chistes 45

Caracteres de Escape
5. print('¿Porqué vuelan los pájaros pa\'l sur?')
6. input()
7. print('¡Porque caminando tardarían muchísimo!')
8. print()

En el primer print() de arriba, ha una barra invertida justo antes de la comillas simple (esto es,
el apóstrofo). Nota que \ es una barra inversa, y / es una barra inclinada. Esta barra inversa
indica que la letra que está a su derecha es una caracter de escape. Un caracter de escape te
permite imprimir caracteres que son difíciles de introducir en el código fuente. En esta llamada a
print() el caracter de escape es una comilla simple.

El caracter de escape comilla simple está allí porque de otra manera Python pensaría que la
comilla indica el final de la cadena. Pero esta comilla necesita formar parte de la cadena. La
comilla simple de escape le indica a Python que la comilla simple es literalmente una parte de la
cadena en lugar de indicar el final del valor de la cadena.

Algunos Otros Caracteres de Escape

¿Qué pasa si realmente quisieras escribir una barra invertida?. Esta línea de código no
funcionaría:

>>> print('Él se fue volando en un helicóptero verde\turquesa.')

Él se fue volando en un helicóptero verde urquesa.

Esto es porque la "t" en "turquesa" fue vista como un caracter de escape debido a que estaba
después de una barra inversa. El caracter de escape t simula la pulsación de la tecla TAB de tu
teclado. Hay caracteres de escape para que las cadenas puedan tener caracteres que no se pueden
escribir.

En lugar de eso, prueba con esta línea:

>>> print('Él se fue volando en un helicóptero verde\\turquesa.')

Él se fue volando en un helicóptero verde\turquesa.

La tabla 5-1 es una lista de caracteres de escape en Python.

 Capítulo 5 – Chistes 46

Tabla 5-1: Caracteres de Escape

Caracter de Escape Lo Que Imprime

\\ Barra inversa (\)
\' Comilla simple (')
\" Comilla doble (")
\n Salto de línea
\t Tabulador

Comillas Simples y Dobles

La cadenas en Python no tienen que estar siempre entre comillas simples. También puedes
ponerlas entre comilas dobles. Estas dos líneas imprimen lo mismo:

>>> print('Hola mundo')

Hola mundo

>>> print("Hola mundo")

Hola mundo

Pero no puedes mexzclar las comillas. Esta línea devolverá un error si intentas utilizarla:

>>> print('Hola mundo")

SyntaxError: EOL while scanning single-quoted string

Me gusta utilizar las comillas simples, así no tengo que pulsar la tecla shift (mayúsculas) para
escribirlas. Es más fácil de escribir, y a Python le da igual de cualquier manera.

Del mismo modo en que necesitas el caracter de escape \' para obtener una comilla simple en
una cadena rodeada de comillas simples, se necesita un caracter de escape \" para imprimir una
comilla doble en una cadena rodeada de comillas dobles. Por ejemplo, mira estas dos líneas:

>>> print('Le pedí prestado el carro a Pedro pa\'ir al pueblo. El dijo,

"Seguro."')

Le pedí prestado el carro a Pedro pa'ir al pueblo. El dijo, "Seguro."

>>> print("Él dijo, \"No puedo creer que lo dejaste llevarse el carro pa'l
pueblo\"")

Él dijo, "No puedo creer que lo dejaste llevarse el carro pa'l pueblo"
En las cadenas de comillas simples no necesitas escapar las comillas dobles, y en las cadenas de
comillas dobles no necesitas escapar las comillas simples. El intérprete de Python tiene
inteligencia suficiente para saber que si una cadena comienza con un tipo de comillas, el otro tipo
de comillas no significa que la cadena está terminada.
 Capítulo 5 – Chistes 47

El Argumento de Palabra end

9. print('¿En qué se parecen una familia, un bombero y un barco?')
10. input()
11. print("No sé... ¿en qué se parecen?")
12. input()
13. print('En que el bombero y el barco tienen casco.')
14. input()
15. print('¿Y la familia?', end='')
16. print(' -Bien, gracias.')

¿Te diste cuenta del segundo parámetro en el print de la línea 15?. Normalmente, print() añade
un salto de línea al final de la cadena que imprime. Por esta razón, una función print() en
blanco tan solo imprimirá una nueva línea. Pero la función print() tiene la opción de un
segundo parámetro (que tiene nombre “end” (fin)).

La cadena en blanco dada se llama argumento de palabra clave. El parámetro final tiene un
nombre específico, y para pasar un argumento a ese parámetro en particular necesitamos utilizar
la sintáxis end=.

Pasando una cadena en blanco usando end, la función print() no añadirá un salto de linea al
final de la cadena, en lugar de esto añadirá una cadena en blanco. Por esta razón ' -Bien,
gracias.' aparece junto a la línea anterior, en lugar de sobre una nueva línea. No hubo salto de
línea después de la cadena '¿Y la familia?'.

Resumen
Este capítulo explora las diferentes formas en las que se puede utilizar la función print(). Los
caracteres de escape se utilizan para los caracteres que son difíciles o imposibles de escribir en
código usando el teclado. Los caracteres de escape se escriben en las cadenas comienzando con
una barra inversa \ seguida de una sola letra para el carácter de escape. Por ejemplo, \n sería un
salto de línea. Para incluir una barra invertida en una cadena, deberás utilizar el carácter de escape
\\.

La función print() añade automáticamente un carácter de salto de línea al final de la cadena que
se pasa para imprimr en pantalla. La mayor parte del tiempo, es un atajo útil. Pero a veces no
quieres un carácter de salto de línea al final. Para cambiar esto, puedes pasar el argumento de
palabra clave end con una cadena en blanco. Por ejemplo, para imprimir “spam” en la pantalla sin
un carácter de salto de línea, podrías hacer el llamado print('spam', end='').

Al añadir este nivel de control sobre el texto que mostraremos en la pantalla, puedes tener formas
más flexibles para hacerlo.
 Capítulo 5 – Chistes 48

Capítulo 6
REINO DE DRAGONES
Temas Tratados En Este Capítulo:
• La función time.sleep()
• Creando nuestras propias funciones con la palabra reservada def
• La palabra reservada return
• Los operadores Booleanos and, or y not
• Tablas de verdad
• Entorno de variables (Global y Local)
• Parámetros y Argumentos
• Diagramas de Flujo
Las Funciones
Ya hemos usado dos funciones en nuestros programas anteriores: input() y print(). En los
programas anteriores, hemos llamado a estas funciones para ejecutar el código dentro de ellas. En
este capítulo, escribiremos nuestras propias funciones para que sean llamadas por programas. Una
función es como un mini-programa dentro de nuestro programa.

El juego que crearemos para presentar las funciones se llama "Reino de Dragones", y permite al
jugador elegir entre dos cuevas, en una de las cuales encontrará un tesoro y en la otra su
perdición.

Cómo Jugar a Reino de Dragones

En este juego, el jugador está en una tierra llena de dragones. Todos los dragones viven en cuevas
junto a sus grandes montones de tesoros encontrados. Algunos dragones son amigables, y
compartirán sus tesoros contigo. Otros son codiciosos y hambrientos, y se comerán a cualquiera
que entre a su cueva. El jugador se encuentra frente a dos cuevas, una con un dragón amigable y
la otra con un dragón hambriento. El jugador tiene que elegir entre las dos.

Abre una nueva ventana del editor de archivos haciendo clic en el menú File (Archivo) ► New
Window (Nueva Ventana). En la ventana vacía que aparece escribe el código fuente y guárdalo
como dragón.py. Luego ejecuta el programa pulsando F5.
 Capítulo 6 – Reino de Dragones 49

Prueba de Ejecución de Reino de Dragones

Estás en una tierra llena de dragones. Frente a tí

hay dos cuevas. En una de ellas, el dragón es generoso y amigable

y compartirá su tesoro contigo. El otro dragón

es codicioso y está hambriento, y te devorará inmediatamente.

¿A qué cueva quieres entrar? (1 ó 2)

Te aproximas a la cueva...
Es oscura y espeluznante...

¡Un gran dragon aparece súbitamente frente a tí! Abre sus fauces y...

¡Te engulle de un bocado!

El Código Fuente de Reino de Dragones
¿Quieres jugar de nuevo? (sí or no)

no
¡NOTA IMPORTANTE! Los programas de este libro sólo podrán ejecutarse
sobre Python 3, no Python 2. Al iniciar la ventana IDLE, dirá algo como “Python
3.4.2” en la parte superior. Si tienes Python 2 instalado, es posible instalar
también Python 3 a la vez. Para descargar Python 3, dirígete a
https://python.org/download/.

Si obtienes errores luego de copiar este código, compáralo con el código del libro usando la
herramienta diff online en http://invpy.com/es/diff/dragón.

dragón.py
import random
import time

def mostrarIntroducción():
5. print('Estás en una tierra llena de dragones. Frente a tí')
print('hay dos cuevas. En una de ellas, el dragón es generoso y')
6.
print('amigable y compartirá su tesoro contigo. El otro dragón')
7.
print('es codicioso y está hambriento, y te devorará inmediatamente.')
8.

9. def elegirCueva():
11.
12. cueva = ''
13. while cueva != '1' and cueva != '2':

14. print('¿A qué cueva quieres entrar? (1 ó 2)')

15.
return cueva
16.
 Capítulo 6 – Reino de Dragones 50

18.
19. def explorarCueva(cuevaElegida):
20. print('Te aproximas a la cueva...')
time.sleep(2)
21.
22. print('Es oscura y espeluznante...')
time.sleep(2)
23.
24. print()
y...') time.sleep(2)
25.

26.
cuevaAmigable = random.randint(1, 2)
27.
28.
if cuevaElegida == str(cuevaAmigable):
29. print('¡Te regala su tesoro!')
30.
35. jugarDeNuevo = 'sí'
36. while jugarDeNuevo == 'sí' or jugarDeNuevo == 's':
37.
38. mostrarIntroducción()

39.
númeroDeCueva = elegirCueva()
40.
41.
explorarCueva(númeroDeCueva)
42.
43.

Cómo Funciona el Código

Veamos el código fuente en más detalle.

1. import random
2. import time

El programa importa dos módulos. El módulo random proveerá la función random.randint()

como lo hizo en el juego “Adivina el Número”. También precisarás funciones relacionadas con
tiempo, que están incluidas en el módulo time, de modo que también importaremos este módulo.
 Capítulo 6 – Reino de Dragones 51

Sentencias def

4. def mostrarIntroducción():
5. print('Estás en una tierra llena de dragones. Frente a tí')
print('hay dos cuevas. En una de ellas, el dragón es generoso y')
6.
print('amigable y compartirá su tesoro contigo. El otro dragón')
7.
print('es codicioso y está hambriento, y te devorará inmediatamente.')
8.

La línea 4 es una sentencia def. La sentencia def crea, es decir, una nueva función que puede ser
llamada más adelante en el programa. Luego de haber definido esta función, puedes llamarla de
la misma forma en que llamas a otras funciones. Cuando llamas a esta función, el código dentro
del bloque def se ejecuta.

La Figura 6-1 muestra las partes de una sentencia def. Comienza con la palabra reservada def
seguida por un nombre de función con paréntesis y luego dos puntos. El bloque a continuación de
la sentencia def se llama el bloque def.

Figura 6-1: Las partes de una sentencia def.

Recuerda, la sentencia def no ejecuta el código. Sólo define qué código se ejecutará cuando
llames a la función. Cuando la ejecución llega a una sentencia def, omite lo que sigue hasta la
primera línea a continuación del bloque def.

Pero cuando la función mostrarIntroducción() es llamada (como en la línea 38), la ejecución

entra a la función mostrarIntroducción() y se posiciona en la primera línea del bloque def.

38. mostrarIntroducción()

Entonces todas las llamadas a print() se ejecutan, y se muestra la introducción “Estás en una
tierra llena de dragones...”.
 Capítulo 6 – Reino de Dragones 52

Dónde Colocar las Definiciones de Funciones

La sentencia def y el bloque def de una función deben aparecer antes de llamar a la función. Esto
es igual que cuando tienes que asignarle un valor a una variable antes de usar la variable. Si
colocas la llamada a la función antes que la definición de la función, obtendrás un error. Por
ejemplo, mira este código:

decirAdios()

def decirAdios():
print('¡Adios!')

Si tratas de ejecutarlo, Python te dará un mensaje de error como este:

Traceback (most recent call last):

File "C:\Python34\spam.py", line 1, in <module>

decirAdios()

NameError: name 'decirAdios' is not defined

Para arreglar esto, coloca la definición de la función antes de llamar a la función:

def sayGoodbye():
print('Goodbye!')

sayGoodbye()

Definiendo la Función elegirCueva()

11. def elegirCueva():

La línea 11 define otra función llamada elegirCueva(). El código de esta función pregunta al
jugador a qué cueva quiere entrar, 1 ó 2.

12. cueva = ''

13. while cueva != '1' and cueva != '2':

Esta función necesita asegurar que el jugador haya respondido 1 ó 2, y no otra cosa. Un bucle
aquí seguirá preguntando al jugador hasta que escriba alguna de estas dos respuestas válidas. Esto
se llama validación de entrada.

La línea 12 crea una nueva variable llamada cueva y guarda en ella una cadena vacía. Luego un
bucle while comienza en la línea 13. La condición contiene un nuevo operador que no has visto
 Capítulo 6 – Reino de Dragones 53

antes llamado and (y). Igual que los signos - o * son operadores matemáticos y los signos == o !=
son operadores de comparación, el operador and es un operador Booleano.

Operadores Booleanos
La lógica Booleana se ocupa de enunciados que son verdaderas ( True) o falsos (False ). Los
operadores Booleanos comparan dos valores Booleanos y se evalúan a un único valor Booleano.

Piensa en este enunciado, “Los gatos tienen bigotes y los perros tienen colas.” “Los gatos tienen
bigotes” es verdadero y “los perros tienen colas” también es verdadero, luego el enunciado
completo “Los gatos tienen bigotes y los perros tienen colas” es verdadero.

Pero el enunciado “Los gatos tienen bigotes y los perros tienen alas” sería falso. Incluso si “los
gatos tienen bigotes” es verdadero, los perros no tienen alas, luego “los perros tienen alas” es
falso. En lógica Booleana, los enunciados sólo pueden ser completamente verdaderos o
completamente falsos. Debido a la conjunción “y”, el enunciado completo es verdadero sólo si
ambas partes son verdaderas. Si una o ambas partes son falsas, entonces el enunciado completo
es falso.

Los operadores and y or

El operador and en Python es igual que la conjunción “y”. Si los valores Booleanos a ambos
lados de la palabra reservada and son True, entonces la expresión se evalúa a True. Si alguno o
ambos valores Booleanos es False, la expresión se evalúa a False.

Prueba escribir las siguientes expresiones con el operador and en la consola interactiva:

>>> True and True

True

>>> True and False

False

>>> False and True

False

>>> False and False

False

>>> spam = 'Hola'

>>> 10 < 20
El operador orand spam al
es similar ==operador
'Hola' and, excepto que se evaluará a True si cualquiera de los
True
dos valores Booleanos es True. La única vez en que el operador or se evalúa a False es si los dos
valores Booleanos son False.

Prueba escribir lo siguiente en la consola interactiva:

 Capítulo 6 – Reino de Dragones 54

>>> True or True

True

>>> True or False

True

>>> False or True

True

>>> False or False

False

>>> 10 > 20 or 20 > 10

El Operador not
True

El operador not sólo actúa sobre un valor, en lugar de combinar dos valores. El operador not (no)
se evalúa al valor Booleano opuesto. La expresión not True se evaluará a False y not False se
evaluará a True.

Prueba escribir lo siguiente en la consola interactiva:

>>> not True

False

>>> not False

True

>>> not ('negro' == 'blanco')

True
Tablas de Verdad

Si alguna vez te olvidas cóno funcionan los operadores Booleanos, puedes mirar estas tablas de
verdad:

Tabla 6-1: La tabla de verdad del operador and.

A and B is Enunciado completo
True and True es True
True and False es False
False and True es False
False and False es False
 Capítulo 6 – Reino de Dragones 55

Tabla 6-2: La tabla de verdad del operador or.

A or B es Enunciado completo
True or True es True
True or False es True
False or True es True
False or False es False

Table 6-3: La tabla de verdad del operador not.

not A es Enunciado completo
not True es False
not False es True

Evaluando Operadores Booleanos

Miremos otra vez la línea 13:

13. while cueva != '1' and cueva != '2':

La condición tiene dos partes conectadas por el operador Booleano and. La condición es True
sólo si ambas partes son True.

La primera vez que se comprueba la condición de la sentencia while, cueva está definida como
la cadena vacía, ''. La cadena vacía no es igual a la cadena '1', luego el lado izquierdo se evalúa
a True. La cadena vacía tampoco es igual a la cadena '2', por lo que el lado derecho se evalúa a
True.

Entonces la condición se transforma en True and True. Como ambos valores Booleanos son
True, la condición finalmente se evalúa a True. Luego la ejecución del programa entra al bloque
while.

Así es como se ve la evaluación de la condición (si el valor de cueva es la cadena vacía):

while cueva != '1' and cueva != '2':

▼ cueva != '2':
and

▼
while True
and cueva != '2':
while True
▼
 Capítulo 6 – Reino de Dragones 56

while True and True:

while ▼

Obteniendo la Entrada de Datos del Jugador

13. while cueva != '1' and cueva != '2':

14. print('¿A qué cueva quieres entrar? (1 ó 2)')

15. cueva = input()

La línea 14 pregunta al jugador qué cueva quiere elegir. La línea 15 permite al jugador escribir la
respuesta y pulsar INTRO. Esta respuesta es almacenada en cueva. Después de ejecutar este
código, la ejecución vuelve a la parte superior de la sentencia while y vuelve a comprobar la
condición.

Si el jugador ha ingresado 1 ó 2, entonces cueva será '1' or '2' (ya que input() siempre
devuelve cadenas). Esto hace que la condición sea False, y la ejecución del programa continuará
debajo del bucle while. Por ejemplo, si el usuario escribiese '1' la evaluación se vería así:

while cueva != '1' and cueva != '2':

while '1' != '1' and cueva != '2':

and cueva != '2':
▼
▼
while
False and '1' != '2':
while False and True:

Pero si el jugador hubiese escrito 3 o 4 o HOLA, esa respuesta habría sido inválida. La condición
seguiría siendo True y entrando al bloque while para preguntar de nuevo al jugador. El programa
simplemente continúa preguntando hasta que el jugador responda 1 or 2. Esto garantiza que
cuando la ejecución continúe avanzando la variable cueva contendrá una respuesta válida.

Retorno de Valores
17. return cueva

Esta es una sentencia return, la cual sólo aparece dentro de bloques def. ¿Recuerdas como la
función input() devuelve un valor de cadena que el jugador ha ingresado? La función
 Capítulo 6 – Reino de Dragones 57

elegirCueva() también devuelve un valor. La línea 17 devuelve la cadena almacenada en cueva,

sea '1' o '2'.

Una vez ejecutada la sentencia return, la ejecución del programa sale inmediatamente del bloque
def. (Esto es como cuando la sentencia break hace que la ejecución salga de un bloque while.)
La ejecución del programa vuelve a la línea que contiene la llamada a la función. La llamada a la
función será entonces evaluada al valor de retorno.

Ve ahora hacia abajo y observa la línea 40 por un momento:

40. númeroDeCueva = elegirCueva()

Cuando elegirCueva() es llamada más adelante por el programa en la línea 40, el valor
de retorno es almacenado en la variable númeroDeCueva. El bucle while garantiza que
elegirCueva() devolverá sólo '1' o '2' como valor de retorno.

Entonces cuando la línea 17 devuelve una cadena, la llamada a la función en la línea 40 es

evaluada a esa cadena, la cual se almacena en númeroDeCueva.

Entorno Global y Entorno Local

Las variables de tu programa son olvidadas en cuanto el programa termina. Lo mismo ocure con
estas variables creadas mientras la ejecución está dentro de la llamada a una función. Las
variables se crean cuando la función es llamada y se olvidan cuando la función devuelve un valor.
Recuerda, las funciones son como mini-programas dentro de tu programa.

Cuando la ejecución está dentro de una función, no puedes modificar las variables fuera de la
función, incluidas variables de otras funciones. Esto es porque esas variables existen en un
“entorno” diferente. todas las variables existen en el entorno global o en el entorno local de la
llamada a una función.

El entorno exterior a todas las funciones se llama entorno global. El entorno dentro de una
función (por la duración de una llamada específica a la función) se llama entorno local.

El programa entero tiene un solo entorno global. Las variables definidas en el entorno global
puede ser leídas fuera y dentro de las funciones, pero sólo pueden ser modificadas fuera de todas
las funciones. Las variables creadas en la llamada a una función sólo pueden ser leídas o
modificadas durante esa llamada a la función.

Puedes leer el valor de las variables globales desde el entorno local, pero intentar modificar una
variable global desde el entorno local no funcionará. Lo que Python hace en ese caso es crear una
variable local con el mismo nombre que la variable global. Sería posible, por ejemplo, tener una
 Capítulo 6 – Reino de Dragones 58

variable local llamada spam al mismo tienpo que existe una variable global llamada spam. Python
las considerará dos variables distintas.

Mira el siguiente ejemplo para ver qué pasa cuando intentas modificar una variable global desde
dentro de un entorno local. Los comentarios explican qué es lo que está ocurriendo:

def bacon():

# Creamos una variable local llamada "spam"

# en lugar de cambiar el valor de la

# variable global "spam":

spam = 99

# El nombre "spam" se refiere ahora sólo a la

# variable local por el resto de esta

# función:
print(spam) # 99

spam = 42 # Una variable global llamada "spam":

print(spam) # 42

bacon() # Llamaeste
Al ser ejecutado, a código
la función bacon():
mostrará las siguientes salidas:
# La variable global no fue cambiada en bacon():
42
print(spam) # 42
99

42
Dónde se crea una variables determina en qué entorno se encuentra. Cuando el programa Reino
de Dragones ejecuta por primera vez la línea:

12. cueva = ''

...la variable cueva se crea dentro de la función elegirCueva(). Esto significa que es creada en el
entorno local de la función elegirCueva(). Será olvidada cuando elegirCueva() finalice, y será
recreada si elegirCueva() es llamada por segunda vez. El valor de una variable local no es
recordado entre una llamada a una función local y otra.

Parámetros
19. def explorarCueva(cuevaElegida):
 Capítulo 6 – Reino de Dragones 59

La siguiente función que el programa define se llama explorarCueva(). Nota el texto

cuevaElegida entre paréntesis. Esto es un parámetro: una variable local a la que se asigna el
argumento pasado cuando esta función es llamada.

Recuerda cómo para algunas llamadas a funciones como str() o randint(), pasarías un
argumento entre paréntesis:

>>> str(5)
'5'

>>> random.randint(1, 20)

14
También pasarás un argumento al llamar a explorarCueva(). Este argumento es almacenado en
una nueva variable llamada cuevaElegida. Estas variables también se denominan parámetros.

Por ejemplo, aquí hay un pequeño programa que demuestra cómo se define una función con un
parámetro:

def decirHola (nombre):

print(Hola, ' + nombre + '. Tu nombre tiene ' + str(len(nombre)) +

'letras.')

sayHello('Alicia')
sayHello('Berto')
spam = 'Carolina'
sayHello(spam)
Si ejecutas este programa, verás algo así:

Hola, Alicia. Tu nombre tiene 6 letras.

Hola, Berto. Tu nombre tiene 5 letras.
Hola, Carolina. Tu nombre tiene 8 letras.

Cuando llamas a decirHola(), el argumento se asigna al parámetro nombre. Los parámetros son
simplemente variables locales ordinarias. Como todas las variables locales, los valores en los
parámetros serán olvidados cuando la llamada a la función retorne.

Mostrando los Resultados del Juego

Volviendo al código fuente del juego:

20. print('Te aproximas a la cueva...')

21. time.sleep(2)
 Capítulo 6 – Reino de Dragones 60

El módulo time tiene una función llamada sleep() que pone al programa en pausa. La línea 21
pasa el valor entero 2 de modo que time.sleep() pondrá al programa en pausa por 2 segundos.

22. print('Es oscura y espeluznante...')

23. time.sleep(2)

Aquí el código imprime algo más de texto y espera por otros 2 segundos. Estas pequeñas pausas
agregan suspenso al juego, en lugar de mostrar todo el texto a la vez. En el programa Chistes del
capítulo anterior, has llamado a la función input() para poner el juego en pausa hasta que el
jugador pulsara la tecla INTRO. Aquí, el jugador no tiene que hacer nada excepto esperar un par de
segundos.

24. print('¡Un gran dragon aparece súbitamente frente a tí! Abre sus fauces
y...')
25. print()

26. time.sleep(2)

¿Qué ocurre a continuación? ¿Y cómo decide el programa? Esto se explica en la siguiente

sección.

Decidiendo Qué Cueva tiene el Dragón Amigable

28. cuevaAmigable = random.randint(1, 2)

La línea 28 llama a la función random.randint() que devolverá 1 ó 2. Este valor entero se

almacena en cuevaAmigable y representa la cueva con el dragón amigable.

30. if cuevaElegida == str(cuevaAmigable):

31. print('¡Te regala su tesoro!')

La línea 30 comprueba si la cueva elegida por el jugador en la variable cuevaElegida ('1' or

'2') es igual a la cueva del dragón amistoso.

Pero el valor en cuevaAmigable es un entero porque random.randint() devuelve enteros. No

puedes comparar cadenas y enteros con el signo ==, porque siempre resultarán distintas. '1'
no es igual a 1 y '2' no es igual a 2.

Entonces se pasa cuevaAmigable a la función str(), la cual devuelve el valor de cadena de

cuevaAmigable. De esta manera los valores serán el mismo tipo de datos y pueden ser
comparados en forma relevante. También podríamos haber usado el siguiente código para
convertir cuevaElegida a un valor entero:
 Capítulo 6 – Reino de Dragones 61

if int(cuevaElegida) == cuevaAmigable:

Si la condición es True, la línea 31 comunica al jugador que ha ganado el tesoro.

32. else:

33. print('¡Te engulle de un bocado!')

La línea 32 es una sentencia else (si no). La palabra reservada else siempre viene a continuación
del bloque if. El bloque else se ejecuta si la condición de la sentencia if fue False. Piensa en esto
como la forma del programa de decir, “Si esta condición es verdadera entonces ejecuta el bloque
if, en caso contrario ejecuta el bloque else.”

Recuerda colocar los dos puntos (el signo : ) luego de la palabra reservada else.

Donde Comienza la Parte Principal

35. jugarDeNuevo = 'sí'

36. while jugarDeNuevo == 'sí' or jugarDeNuevo == 's':

La línea 35 es la primera línea que no es una sentencia def ni pertenece a un bloque def. Esta
línea es donde la parte principal del programa comienza. Las sentencias def anteriores sólo
definen las funciones, pero sin ejecutarlas.

Las líneas 35 y 36 configuran un bucle que contiene al resto del juego. Al final del juego, el
jugador puede escribir si desea jugar de nuevo. Si es así, la ejecución vuelve a entrar al bucle
while para ejecutar todo el juego otra vez. En caso contrario, la condición de la sentencia while
será False y la ejecución continuará hasta el final del programa y terminará.

La primera vez que la ejecución llega a esta sentencia while, la línea 35 ha acabado de asignar
'sí' a la variable jugarDeNuevo. Esto significa que la condición será True. De esta forma se
garantiza que la ejecución entrará al bucle al menos una vez.

Llamando a las Funciones en el Programa

38. mostrarIntroducción()

La línea 38 llama a la función mostrarIntroducción(). Esta no es una función de Python, es la

función que has definido anteriormente en la línea 4. Cuando se llama a esta función, la ejecución
del programa salta a la primera línea en la función mostrarIntroducción() en la línea 5.
Cuando todas las líneas en la función han sido ejecutadas, la ejecución vuelve a la línea 38 y
continúa bajando.
 Capítulo 6 – Reino de Dragones 62

40. númeroDeCueva = elegirCueva()

La línea 40 también llama a una función que tú has definido. Recuerda que la función
elegirCueva() permite al jugador elegir la cueva a la que desea entrar. Cuando se ejecuta
return cueva en la línea 17, la ejecución del programa vuelve a la línea 40, y la llamada a
elegirCueva() se evalúa al valor de retorno. Este valor de retorno es almacenado en una nueva
variable llamada númeroDeCueva. Entonces la ejecución del programa continúa en la línea 42.

42. explorarCueva(númeroDeCueva)

La línea 42 llama a tu función explorarCueva(), pasándole el valor en númeroDeCueva como

argument. No sólo la ejecución salta a la línea 20, sino que el valor en númeroDeCueva se copia al
parámetro cuevaElegida dentro de la función explorarCueva(). Esta es la función que
mostrará '¡Te regala su tesoro!' o '¡Te engulle de un bocado!' dependiendo de la
cueva que el jugador elija.

Preguntando al Jugador si quiere Jugar de Nuevo

44. print('¿Quieres jugar de nuevo? (sí o no)')

45. jugarDeNuevo = input()

Sin importar si el jugador gana o pierde, se le pregunta si quiere jugar de nuevo. La variable
jugarDeNuevo almacena lo que haya ingresado el jugador. La línea 45 es la última línea del
bloque while, de modo que el programa vuelve a la línea 36 para comprobar la condición del
bucle while: jugarDeNuevo == 'sí' or jugarDeNuevo == 's'

Si el jugador ingresa la cadena 'sí' o 's', la ejecución entrará nuevamente al bucle en la línea
38.

Si el jugador ingresa 'no' o 'n', o una tontería como 'Abraham Lincoln', entonces la condición
será False. La ejecución del programa continúa a la línea a continuación del bloque while. Pero
dado que no hay más líneas después del bloque while, el programa termina.

Una cosa a tener en cuenta: la cadena 'SÍ' no es igual a la cadena 'sí'. Si el jugador ingresa la
cadena 'SÍ', entonces la condición de la sentencia while se evaluará a False y el programa
terminará igualmente. Otros programas más adelante en este libro te mostrarán cómo evitar este
problema.

¡Acabas de completar tu segundo juego! En Reino de Dragones, has usado mucho de cuanto
aprendiste en el juego “Adivina el Número” y has aprendido unos cuantos trucos nuevos. Si no
 Capítulo 6 – Reino de Dragones 63

entendiste algunos de los conceptos en este programa, recorre cada línea del código fuente otra
vez e intenta modificar el código fuente viendo cómo cambia el programa.

En el siguiente capítulo no crearás un juego, pero aprenderás cómo usar una funcionalidad de
IDLE llamada depurador.

Diseñando el Programa
Reino de Dragones es un juego simple. El resto de los juegos en este libro serán un poco más
complicados. A veces ayuda escribir en papel todo lo que quieres que tu juego o programa haga
antes de comenzar a escribir el código. Esto se llama “diseñar el programa”.

Por ejemplo, puede ayudar dibujar un diagrama de flujo. Un diagrama de flujo es una ilustración
que muestra cada posible acción que puede ocurrir en el juego, y qué acciones llevan a qué otras
acciones. La Figura 6-2 es un diagrama de flujo para Reino de Dragones.

Para ver qué pasa en el juego, coloca tu dedo sobre el recuadro “Inicio”. Luego sigue una flecha
desde ese recuadro hasta otro recuadro. Tu dedo es como la ejecución del programa. El programa
termina cuando tu dedo llega al recuadro “Fin”.

Cuando llegas al recuadro “Comprobar dragón amistoso o hambriento”, puedes ir al recuadro

“Jugador gana” o al recuadro “Jugador pierde”. Esta bifurcación muestra cómo el programa
puede hacer diferentes cosas. De cualquier forma, ambos caminos conducirán al recuadro “Ofrece
jugar de nuevo”.

Resumen
En el juego “Reino de Dragones”, has creado tus propias funciones. Las funciones son un mini-
programa dentro de tu programa. El código dentro de la función se ejecuta cuando la función es
llamada. Al descomponer tu código en funciones, puedes organizar tu código en secciones más
pequeñas y fáciles de entender.

Los argumentos son valores pasados al código de la función cuando la función es llamada. La
propia llamada a la función se evalúa al valor de retorno.
 Capítulo 6 – Reino de Dragones 64

Figura 6-2: Diagrama de flujo para el juego Reino de Dragones.

También has aprendido acerca de entornos de variables. Las variables creadas

dentro de una función existen en el entorno local, y las variables creadas fuera
de todas las funciones existen en el entorno global. El código en el entorno
global no puede usar las variables locales. Si una variable local tiene el mismo
nombre que una variable en el entorno global, Python la considera una variables
separada y asignar nuevos valores a la variable local no cambiará el valor de la
variable global.

Los entornos de variables pueden parecer complicados, pero son útiles para
organizar funciones como fragmentos de código separados del resto del
programa. Dado que cada función tiene su propio entorno local, puedes estar
seguro de que el código en una función no ocasionará errores en otras
funciones.

Las funciones son tan útiles que casi todos los programas las usan. Entendiendo
cómo funcionan las funciones, podemos ahorrarnos escribir muchas líneas de
código y hacer que los errores sean más fáciles de arreglar.