2. Variables, expresiones y sentencias¶

2.1. Valores y Tipos de Datos¶

Un valor es una de las cosas fundamentales que un programa manipula — como una letra o un número. Los valores que hemos visto hasta ahora son el número 4 (resultado de la adición de 2 + 2), y "¡Hola, todo el mundo!".

Estos valores pertenecen a diferente clases (classes) o tipos: 4 es un entero, y "¡Hola, todo el mundo!" es una cadena , llamada así porque contiene una cadena de letras. Usted (y el intérprete) puede identificar cadenas porque están encerradas entre comillas.

Si usted no está seguro de que clase se divide en un valor, Python tiene una función llamada tipo (type) la cual le incida a usted.

>>> type("Hola, todo el mundo!")
<class 'str'>
>>> type(17)
<class 'int'>

No es sorprendente que las cadenas pertenezcan al tipo str y los enteros pertenezcan al tipo int . Los números con un punto decimal pertenezcan a un tipo llamado float, porque éstos se representan en un formato denominado punto flotante. En esta etapa, se puede tratar la clase y el tipo de palabras de manera intercambiable. Volveremos a una comprensión más profunda de lo que es una clase en capítulos posteriores.

>>> type(3.2)
<type 'float'>

¿Que ocurre con valores como "17" y "3.2"? Parecen números, pero están encerrados entre comillas como las cadenas.

>>> type("17")
<type 'str'>
>>> type("3.2")
<type 'str'>

Ellos son cadenas.

Cadenas en Python puede ser incluida en cualquiera de los dos comillas simples (') o comillas dobles (") o tambien comillas triples de cada una (''' o """)

>>> type('Esta es una cadena.')
<type 'str'>
>>> type("y esta es tambien.")
<typle 'str'>
>>> type("""y esta.""")
<typle 'str'>
>>> type('''e incluso esta...''')
<class 'str'>

Cadenas de comillas doble pueden contener comilla simple dentro de ellas, como en "Bruce's Beard", y cadenas de comilla simple pueden tener comillas doble dentro de ellas tambien, como en 'Los caballeros que dicen "Ni!"'.

Cadenas cerradas con tres apariciones de los símbolos citan son llamados cuerdas triples cita. Pueden contener comillas simples o dobles:

>>> print('''"Oh no", ella exclamó, "La moto de Ben esta dañada!"''')
"Oh no", ella exclamó, "La moto de Ben esta dañada!"
>>>

Cadenas triple cita incluso puede abarcar varias líneas:

>>> mensaje = """Este mensaje
... span several
... lines."""
>>> print(mensaje)
Este mensaje
abarcar varios
líneas.
>>>

Python no le importa si usted usa comillas simples o dobles, o las citas de tres de su tipo, para rodear las cuerdas: una vez que se ha analizado el texto de su programa o comando, la forma en que almacena el valor es idéntico en todos los casos y las comillas rodean no forman parte del valor. Pero cuando el intérprete se quiere mostrar una cadena, que tiene que decidir que cita a utilizar para hacer que se vea como una cadena.

>>> "Esto es una cadena".
'Esto es una cadena'
>>> """Y asi es esto."""
'Y por lo tanto es este'

Así que los diseñadores del lenguaje Python generalmente elegido para rodear sus cadenas de comillas simples. ¿Qué crees que pasaría si la cadena que ya figuran entre comillas simples? Pruébelo usted mismo y vea.

Cuando se escribe un entero grande, que podría tener la tentación de usar comas entre grupos de tres dígitos, como en 42.000. Esto no es un entero legal en Python, pero sí quiere decir algo más, que es legal:

>>> 42000
42000
>>> 42,000
(42, 0)

Bueno, eso no es lo que esperábamos en absoluto! Debido a la coma, Python optó por tratar esto como un par de valores. Vamos a volver a aprender acerca de los pares más tarde. Pero, por el momento, recuerde no poner comas o espacios en su enteros, no importa lo grandes que son. También volver a lo que dijimos en el capítulo anterior: lenguajes formales son estrictas, la notación es concisa, e incluso el más pequeño cambio puede significar algo muy distinto de lo que pretende.

2.2. Variables¶

Una de las características más poderosas en un lenguaje de programación es la capacidad de manipular variables. Una variable es un nombre que se refiere a un valor.

La sentencia de asignación crea nuevas variables y les da valores:

>>> mensaje = "¿Qué Onda?"
>>> n = 17
>>> pi = 3.14159

Este ejemplo hace tres asignaciones. La primera asigna la cadena "¿Que Onda?" a una nueva variable denominada mensaje. La segunda le asigna el entero 17 a n, y la tercera le da el número de punto flotante 3.14159 a pi.

No debe confundirse el operador de asignación, =, con el signo de igualdad (aún y cuando se usa el mismo símbolo). El operador de asignación enlaza un nombre, en el lado izquierdo del operador, con un valor en el lado derecho. Esta es la razón por la que obtendrá un error si escribe:

>>> 17 = n

Tip

Al leer or escribir código, digase a si mismo “n se le asigna 17” o “n se obtiene el valor de 17”. No diga “n es igual a 17”

Note

En caso de que usted se este preguntando, un token o también llamado componente léxico es un carácter o cadena de caracteres que ha significado sintáctico de una lengua. En python los operadores, `palabras clave <http://es.wikipedia.org/wiki/Palabra_clave`__, literales y los espacios en blanco todos forman tokens or componente léxicos de una lengua.

Una manera común de representar variables en el papel es escribir el nombre de la variable con una flecha apuntando a su valor. Esta clase de dibujo se denomina diagrama de estado porque muestra el estado de cada una de las variables (piense en los valores como el estado mental de las variables). Este diagrama muestra el resultado de las sentencias de asignación anteriores:

Si le preguntas a el intérprete para evaluar una variable, se producirá el valor que está vinculado a la variable:

>>> print mensaje
'What's up, Doc?'
>>> print n
17
>>> print pi
3.14159

En cada caso el resultado es el valor de la variable. Las variables también tienen tipos; nuevamente, le podemos preguntar al intérprete cuáles son.

>>> type(mesaje)
<type 'str'>
>>> type(n)
<type 'int'>
>>> type(pi)
<type 'float'>

El tipo de una variable es el tipo del valor al que se refiere.

Usamos las variables en un programa para “recordar” las cosas, al igual que la punctuación actual en el partido de fútbol. Sin embargo, las variables son variables. Esto significa que pueden cambiar con el tiempo, al igual que el marcador de un partido de fútbol. Se puede asignar un valor a una variable, y luego asignar un valor diferente a la misma variable.

Note

Esto es diferente que en matemáticas. En matemáticas, si se le da x el valor 3, no puede cambiar un enlace a un valor diferente a medio camino a través de sus cálculos!

>>> dia = "Jueves"
>>> dia
'Jueves'
>>> dia = "Viernes"
>>> dia
'Viernes'
>>> dia = 21
>>> dia
21

Usted notará que nosotros cambiamos el valor del dia en tres ocasiones, y en la tercera asignación nosotros le dimos un valor que era de un tipo diferente.

Una gran parte de la programación se trata de que la computadora pueda recordar las cosas, por ejemplo, el número de llamadas perdidas es su teléfono, y la organización de alguna actualizacion o cambio de la variable cuando se olvida otra llamada.

2.3. Nombres de variables y palabras claves¶

Nombres de variables válidos en Python debe ajustarse a las siguientes tres simples reglas:

Son secuencias arbitrariamente largas de letras y dígitos.
La secuencia debe empezar con una letra.
Además de a..z, y A..Z, el guión bajo (_) es una letra.

Los programadores generalmente escogen nombres significativos para sus variables — que especifiquen para qué se usa la variable.

Aunque es permitido usar letras mayúsculas, por convención no lo hacemos. Si usted lo hace, recuerde que las letras mayúsculas importan, Pedro y pedro son variables diferentes.

El carácter subrayado (_) puede aparecer en un nombre. A menudo se usa en nombres con múltiples palabras, tales como mi_nombre ́ó precio_de_la_porcelana_en_china.

Hay algunas situaciones en las que los nombres que comienzan con un guión tienen un significado especial, por lo que una regla segura para los principiantes es empezar todos los nombres con una letra que no sea un guión.

Si usted le da un nombre inválido a una variable obtendrá un error de sintaxis:

>>> 76trombones = "gran desfile"
SyntaxError: invalid syntax
>>> mas$ = 1000000
SyntaxError: invalid syntax
>>> class = "Informática 101"
SyntaxError: invalid syntax

76trombones es inválido porque no empieza con una letra. mas$ es inválido porque contiene un carácter ilegal, por el símbolo de dolar $. PerPero, ¿Que sucede con class?

Resulta que class es una de las palabras claves de Python. Las palabras claves definen las reglas del lenguaje y su estructura, y no pueden ser usadas como nombres de variables.

Python tiene treinta y tantas palabras clave ( y todas son mejoradas de vez en cuando para que Python introdusca o elimine una o dos):

and	as	assert	break	class	continue
def	del	elif	else	except	exec
finally	for	from	global	if	import
in	is	lambda	nonlocal	not	or
pass	raise	return	try	while	with
yield	True	False	None

Usted puede mantener esta lista a mano. Si el intéprete se queja por alguno de sus nombres de variables, y usted no sabe por qué, búsquelo en esta lista.

Los programadores generalmente eligen nombres para sus variables que son significativas para los lectores humanos del programa — que ayudan a los documentos de programación, o recordar, lo que la variable se utiliza.

Caution

Los principiantes a veces se confunden “con sentido para los lectores humanos” con “significativo de la computadora”. Por lo que ellos erróneamente piensan que porque han llamado algunas variable promedio o pi, de alguna manera automágicamente calcula un promedio, o automágicamente asocia la variable pi con el valor de 3,14159. ¡No! La computadora no se fija el significado semántico de los nombres de las variables.

Por lo que encontrarás algunos instructores que deliberadamente no eligen nombres significativos cuando enseñan a los principiantes — no porque ellos no piensen que sea un buen hábito, sino porque está tratando de reforzar el mensaje que usted, el programador, tiene que escribir el código del programa para calcular el promedio, o tiene que escribir una instrucción de asignación a una variable del valor que desea que tenga.

2.4. Sentencias¶

Una sentencia es una instrucción que el intérprete de Python puede ejecutar. Hemos visto otras clases de sentencias hasta el momento. Otros tipos de sentencias que se verá en breve son la sentencias de while, for, if, y de import. (Hay otros tipos también!)

Cuando usted escriba una sentencia en la línea de comandos, Python la ejecuta. Las sentencias de asignación no producen un resultado.

2.5. Evaluación de expresiones¶

Una expresión es una combinación de valores, variables, operadores, y llamadas funciones. Si escribe una expresión en la línea de comandos de python, el intérprete la evalúa y despliega el resultado:

>>> 1 + 1
2
>>> len("hola")
5

En este ejemplo len es una función integrada de Python que devuelve el número de caracteres de una cadena. Hemos visto anteriormente las funciones de print y el type, por lo que este es nuestro tercer ejemplo de una función!

La evaluación de una expresión produce un valor, esta es la razón por la que las expresiones pueden aparecer en el lado derecho de las sentencias de asignación. Un valor, por si mismo, se considera como una expresión, lo mismo ocurre para las variables.

>>> 17
17
>>> y = 3.14
>>> x = len("hello")
>>> x
5
>>> y
3.14

2.6. Operadores y operandos¶

Los operadores son símbolos especiales que representan cómputos como la suma y la multiplicación. Los valores que el operador usa se denominan operandos.

Los siguientes son expresiones válidas en Python cuyo significado es más o menos claro:

20 + 32   hora - 1   hora * 60 + minuto   minuto / 60   5 ** 2
(5 + 9) * (15 - 7)

Los símbolos +, - y *, y los paréntesis para agrupar, significan en Python lo mismo que en matemáticas. El asterisco (*) es el símbolo para la multiplicación, y ** es el símbolo para la potenciación.

>>> 2 ** 3
8
>>> 3 ** 2
9

Cuando el nombre de una variable aparece en la posición de un operando, se reemplaza por su valor antes de realizar la operación.

La suma, resta, multiplicación y potenciación realizan lo que usted esperaría.

Ejemplo: así que vamos a convertir 645 minutos en horas:

>>> minutos = 645
>>> horas = minutos / 60
>>> horas
10.75

¡Uy! En Python 3, el operador de división / siempre da un resultado de punto flotante (float). Lo que hubiera querido saber cuantas horas enteras hay y cuantos minutos quedan. Python nos da dos versiones diferentes del operador de división. La segunda, es llamada división entera utilizando el símbolo //. Siempre se trunca su resultado hasta el número entero inmediatamente inferior (a la izquierda en la recta numérica).

>>> 7 / 4
1.75
>>> 7 // 4
1
>>> minutos = 645
>>> horas = minutos // 60
>>> horas
10

Tenga cuidado en elegir el sabor correcto del operador de división. Si está trabajando con expresiones que usted necesita valores de punto flotante, utilice el operador de división que realiza la división de precisión.

2.7. Funciones de tipo convertidor¶

Aquí vamos a ver otras tres funciones de Python como int, float, y str. que (intenta de) convertir sus argumentos en tipos int, float y str respectivamente. Nostros llamamos funciones de tipo convertidor.

La función int puede tomar un número de punto flotante o una cadena, y convertirlo en un int. Para los números de punto flotante, descarta la parte decimal del número - un proceso que llamamos truncamiento a cero en la recta numérica. Vamos a ver esto en acción:

>>> int(3.14)
3
>>> int(3.9999)        # This doesn't round to the closest int!
3
>>> int(3.0)
3
>>> int(-3.999)        # Note that the result is closer to zero
-3
>>> int(minutes/60)
10
>>> int("2345")        # parse a string to produce an int
2345
>>> int(17)            # int even works if its argument is already an int
17
>>> int("23 bottles")
Traceback (most recent call last):
File "<interactive input>", line 1, in <module>
ValueError: invalid literal for int() with base 10: '23 bottles'

El ultimo caso muestra que una cadena tiene que ser un número sintácticamente legal, de lo contrario obtendrá uno de esos molestos errores de ejecución.

El convertidor de tipo float puede convertir un número entero, en floar, o una cadena sintácticamente en un float.

>>> float(17)
17.0
>>> float("123.45")
123.45

El convertidor de tipo str convierte su argumento en una cadena:

>>> str(17)
'17'
>>> str(123.45)
'123.45'

2.8. Orden de las operaciones¶

Cuando hay más de un operador en una expresión, el orden de evaluación depende de las reglas de precedencia. Python sigue las mismas reglas de precedencia a las que estamos acostumbrados para sus operadores matemáticos. El acrónimo PPMDAS es útil para recordar el orden de las operaciones:

Los Paréntesis tienen la precedencia más alta y pueden usarse para forzar la evaluación de una expresión en el orden que usted desee. Ya que las expresiones en paréntesis se evalúan primero , 2 * (3-1) es 4, y (1+1)**(5-2) es 8. También puede usar paréntesis para que una expresión quede más legible, como en (minute * 100) / 60, aunque esto no cambie el resultado.
La Exponenciación tiene la siguiente precedencia más alta, así que 2**1+1 es 3 y no 4, y 3*1**3 es 3 y no 27.
La Multiplicación y División tienen las misma precedencia, que es más alta que la de la Adición y la Subtracción, que también tienen la misma precedencia. Así que 2*3-1 da 5 en lugar de 4, y 5-2*2 es 1, no 6.
Los operadores con la misma precedencia se evalúan de izquierda a derecha. En álgebra nos dicen que están asociados por la izquierda. Así, que en la expresión 6-3+2, la resta se hace primero, produciendo 3. A continuacion, añadiremos 2 para obtener el número 5. Si las operaciones había sido evaluada de derecha a izquierda, el resultado habría sido 6-(3 + 2), que es 1. (La siglas PEDMAS podría inducir un error a pensar que la división tiene mayor precedencia que la multiplicación, y además se lleva a cabo antes de la sustracción - No se deje engañar suma y resta se encuentran en la misma precendencia, y se aplica la regla de izquierda a derecha.)

Note

Debido a un capricho histórico, una excepción a la izquierda a derecha - izquierda asociativa regla es el operador de exponenciación **, asi que un consejo útil es utilizar siempre paréntesis para forzar el orden exacto que usted desea cuando se trata de la exponenciación:

>>> 2 ** 3 ** 2     # el operador más a la derecha ** se hace primero!
512
>>> (2 ** 3) ** 2   # Utilizar paréntesis para forzar el orden que desea!

El indicador de modo de mando inmediato de Python es ideal para explorar y experimentar con expresiones como esta.

2.9. Operaciones sobre cadenas¶

En general, usted no puede realizar operaciones matemáticas sobre cadenas, incluso si las cadenas están compuestas por números. Las siguientes operaciones son inválidas (suponiendo que mensaje tiene el tipo cadena):

mensaje-1   "Hola"/123   mensaje*"Hola"   "15"+2

Sin embargo, el operador + funciona con cadenas, aunque no calcula lo que usted esperaría. Para las cadenas el operador + representa la operación de concatenación, que significa unir los dos operandos enlazándolos en el orden en que aparecen. Por ejemplo:

bien_cocinado = "pan de nuez y"
fruta = "plátano"
print(bien_cocinado + fruta)

La salida de este programa es pan de nuez y plátano. El espacio antes de la palabra plátano es parte de la cadena y sirve para producir el espacio entre las cadenas concatenadas.

El operador * también funciona con las cadenas; hace una operación de repetición. Por ejemplo, 'Ja'*3 resulta en 'JaJaJa'. Uno de los operandos tiene que ser una cadena, el otro tiene que ser un entero.

Estas interpretaciones de + y * tienen sentido por la analogía existente con la suma y la multiplicación. Así como 4*3 es equivalente a 4+4+4, esperamos que "Ja"*3 sea lo mismo que "Ja"+"Ja"+"Ja", y lo es. Sin embargo, las operaciones de concatenación y repetición sobre cadenas tienen una diferencia significativa con las operaciones de suma y multiplicación. ¿Puede usted pensar en una propiedad que la suma y la multiplicación tengan y que la concatenación y repetición no?

2.10. Entrada (Input)¶

Hay una función integrada en Python para obtener la entrada (input) del usuario

name = input ("Por favor entre su nombre: ")

El usuario del programa puede introducir el nombre y pulsar return (volver). Cuando esto suceda, el texto que se ha introducido es devuelto por la función de input (entrada) y en este caso asignado a la variable de nombre.

Incluso si se le pregunta al usuario que introduzca su edad, debe regresar una cadena como "17". Sería su trabajo, ya que el programador, para convertir esa cadena en un int o un float, utilizando el int o float de las funciones que vimos anteriormente.

2.11. Composición¶

Hasta aquí hemos visto aisladamente los elementos de un programa — variables, expresiones, y sentencias — sin especificar cómo combinarlos.

Una de las características más útiles de los lenguajes de programación es su capacidad de tomar pequeños bloques para componer con ellos.

Por ejemplo, sabemos cómo hacer que el usuario introduzca alguna entrada (input), sabemos cómo convertir la cadena de entrada en un flotador (float), que sabemos cómo escribir una expresión compleja, y tambien sabemos cómo imprimir los valores. Vamos a poner las fotos en un pequeño programa de cuatro pasos que le pide al usuario que introduzca un valor para el radio de un círculo, y luego calcular el área del círculo de la fórmula

En primer lugar, vamos a hacer los cuatro pasos de uno en uno:

response = input(¿Cuál es su radio?)
r = float(respuesta)
area = 3.14159 * r**2
print("El area es ", area)

Ahora vamos a componer las primeras dos líneas en una sola línea de código, y componer las segundas dos líneas en otra línea de código.

r = float(input("¿Cuál es su radio?"))
print("El area es ", 3.14159 * r**2)

Si de verdad queremos que se ha complicado, se podría escribir todo en un solo comunicado:

print("El area es ", 3.14159*float(input("¿Cuál es su radio?"))**2)

Como el código campacto no podrá ser más comprensible para los seres humanos, pero sirve para ilustrar cómo se puede componer grandes pedazos de bloques de nuestro efificio.

Si alguna vez le entra la duda sobre si se debe escribir código o fragmento en pasos más pequeños, trate de hacerlo lo más simple posible para el ser humano pueda seguirlo. Mi elección sería el primer caso, con cuatro pasos separados.

2.12. Glosario¶

cadena: Un tipo de dato en Python que tiene una “cadena” de caracteres.
comentario: Información que se incluye en un programa para otro programador (o lector del código fuente) que no tiene efecto en la ejecución.
composición: La capacidad de combinar expresiones y sentencias simples dentro de sentencias y expresiones compuestas para representar concisamente cálculos complejos.
concatenar: Unir dos operandos, en el orden en que aparecen.
diagrama de estado: Una representación gráfica de un conjunto de variables y los valores a los que se refieren.
división entera: Una operación que divide un entero por otro y retorna un entero. La división entera retorna el número de veces que el denominador cabe en el numerador y descarta el residuo.
entero: Un tipo de dato en Python que tiene números enteros postivos y negativos.
evaluar: Simplificar una expresión ejecutando varias operaciones hasta obtener un sólo valor.
expresión: Una combinación de variables, operadores y valores cuyo resultado se representa por un único valor.
nombre de variable: Es el nombre dado a una variable. Los nombres de variables en Python consisten en una secuencia de letras (a..z, A..Z, and _) y dígitos (0..9) que empiezan con una letra. De acuerdo con las buenas prácticas de la programación, los nombres de variables se eligen, de forma tal, que describan su uso en el programa haciéndolo autodocumentado.
operador: Un símbolo especial que representa cálculos simples como la suma, multiplicación, o concatenación de cadenas.
operador de asignación: El símbolo = es el operador de asignación de Python, que no debe confundirse con el <em>signo igual</em>, utilizado para indicar la igualdad matemática.
operando: Uno de los valores sobre el cual actúa un operador.

2.13. Ejercicios¶

Tome la siguiente oración: Sólo trabajo y nada de juegos hacen de Juan un niño aburrido. Almacene cada palabra en variables separadas, después muestre la oración en una sola línea usando la sentencia print.
Incluya paréntesis a la expresión 6 * 1 - 2 para cambiar su resultado de 4 a -6.
Coloque un comentario antes de una línea de código donde había trabajado, y grabe lo que sucede cuando se vuelve a ejecutar el programa.
Inicie el intérprete de Python y escriba bruno + 4 en el indicador. Esto dará un error:
```
NameError: name 'bruno' is not defined (nombre 'bruno' no esta definido)
```
Asigne un valor a bruno tal que bruno + 4 de 10.
La fórmula para calcular el importe final si se está ganando el interés compuesto es:

Escriba un programa en Python que asigna la cantidad principal de $100 a la variable p, asigna a n el valor de 12, y asigna a r la tasa de interés del 8% (como un flotador). Luego que el programa pide al usuario el número de años, t, para lo cual se suma el dinero. Calcule e imprimala cantidad final después de t años.

Tip

Recuerde usar el convertidor de tipo de funciones para cenvertir las cadenas devueltas por la función de entrada en números.

Cree un archivo llamado cap02e06.py que contenga lo siguiente .. literalinclude:: recursos/cap02/cap02e06.py

Guarde este archivo y despues ejecutelo (click aqui para descargar el archivo de prefabricados). Cuando se ejecute este programa, se le dará el siguiente error:

File "ch02e06.py", line 2, in __main__
Failed example:
    n
Exception raised:
    Traceback (most recent call last):
      File "/usr/lib/python3.2/doctest.py", line 1248, in __run
        compileflags, 1), test.globs)
      File "<doctest __main__[0]>", line 1, in <module>
        n
    NameError: name 'n' is not defined

Usted se va a familiarizar con los seguimientos al trabajar con Python. La cosa más importante aquí es la última línea, que le dice que el nombre n no está definido.

Para definir n, asignale un valor, añadiendo lo siguiente en la línea inmediatamente después de # Coloque el código de la solución en la linea después de esta... linea en el programa.

n = 11

Ejecute el programa de nuevo, y confirma que ahora salga este error:

File "ch02e06.py", line 2, in __main__
Failed example:
    n
Expected:
    42
Got:
    11

n esta ahora definida, pero nuestro doctest estába esperando que su valor fuera 42, no 11. Resuelva el problema cambiando la asignación de n que es

n = 42

Cuando se ejecute el programa de neuvo, no debe tener ningun error. De heccho, usted no verá ningún resultado en lo absoluto. Si está ejecutando el programa desde un símbolo del sistema, puede añadir -v al final del comando para ver los resultados detallados en la salida:

  $ python cap02e06.py -v
  Trying:
      n
  Expecting:
      42
  ok
  1 items passed all tests:
     1 tests in __main__
  1 tests in 1 items.
  1 passed and 0 failed.
  Test passed.

.. index:: doctest

.. note::

   Estos ejercicios y los ejercicios que siguen, hacen uso de Python
   incorporado en las pruebas de instalación automática de llamadas
   ``doctest``. Para cada ejercicio, se creará un archivo que contiene lo
   siguiente en la parte inferior:

   .. sourcecode:: python
                                                                                    if__name__== '__main__':
       import doctest
       doctest.testmod()

   Las "pruebas" se escribirá en la parte superior del archivo en las
   cadenas de triple cita, y se van a parecer a las interacciones con el
   shell de Python. Su tarea consistirá en hacer pasar las pruebas (sin
   dejar de correr o de regresar y error).

Cree un archivo llamado cap02e07.py que contiene lo siguiente .. literalinclude:: recursos/cap02/cap02e07.py

Hacer pasar la prueba con lo que aprendió en el ejercicio anterior.

Cree un archivo llamado cap02e08.py que contiene lo siguiente

"""
  >>> x + y
  42
  >>> type(message)
  <class 'str'>
  >>> len(message)
  13
"""


if __name__ == '__main__':
    import doctest
    doctest.testmod()

Esta vez hay 3 pruebas en lugar de uno. Usted necesitará más de una instrucción de asignación para hacer que estas pruebas pasen.

A partir de aquí nos limitaremos a dar la prueba unitaria (doctests) para cada ejercicio. Al igual que en los ejercicios anteriores, tendrá que crear un archivo para cada uno y poner las tres líneas de Python inferior del archivo para hacer que las pruebas se ejecuten.
```
"""
  >>> n + m
  15
  >>> n - m
  5
"""
```

Usted tendrá que crear las variables del tipo adecuado para hacer que estas pruebas pasen.

"""
  >>> type(thing1)
  <class 'float'>
  >>> type(thing2)
  <class 'int'>
  >>> type(thing3)
  <class 'str'>
"""

Recuerde que ** es el operador de exponenciación para éste.
```
"""
  >>> x ** n
  100
"""
```
Hay soluciones sin límites para esto. Sólo tiene que encontrar uno que haga pasar las pruebas.
```
"""
  >>> a + b + c
  50
  >>> a - c
  10
"""
```

Revise el enlance de la cadena antes de intentar este.

"""
  >>> s1 + s2 + s3
  'Tres cadenas se enlanza para crear esta cadena.'
"""

Navigation

2. Variables, expresiones y sentencias¶

2.1. Valores y Tipos de Datos¶

2.2. Variables¶

2.3. Nombres de variables y palabras claves¶

2.4. Sentencias¶

2.5. Evaluación de expresiones¶

2.6. Operadores y operandos¶

2.7. Funciones de tipo convertidor¶

2.8. Orden de las operaciones¶

2.9. Operaciones sobre cadenas¶

2.10. Entrada (Input)¶

2.11. Composición¶

2.12. Glosario¶

2.13. Ejercicios¶

Navigation