Variables, expresiones y

sentencias

2.1. Valores y tipos

El valor es uno de los elementos fundamentales (como por ejemplo una letra o un numero) que manipula un programa. Los valores que hemos visto hasta el momento son 2 (el resultado de sumar 1 + 1) y Hola, mundo.

Estos valores son de distintos tipos: 2 es un entero y Hola, mundo es una cadena, llamada así porque contiene una “cadena” de letras. Usted (y el interprete) puede identificar las cadenas porque están encerradas entre comillas.

La sentencia print también funciona con enteros:

>>> print 4

4

Si no esta seguro del tipo que tiene un determinado valor, puede preguntárselo al interprete de Python.

>>> type("Hola, mundo")

<type 'string'>

>>> 

type(17)

<type 'int'>

No es sorprendente que las cadenas sean de tipo string (cadena en ingles) y los enteros sean de tipo int (por integer en ingles). De forma menos obvia, los números con decimales (separados por medio de un punto en ingles) son de tipo float debido a la representacion de estos numeros en el formato llamado de coma °otante (°oating-point).

   1: >>> type(3.2)

   2: <type 'float'>

¿Que ocurre con los valores como “17” y “3.2”? Parecen numeros, pero están entre comillas como las cadenas.

   1: >>> type("17")

   2: <type 'string'>

   3: >>> 

   4: type("3.2")

   5: <type 'string'>

   6: Son cadenas.

Cuando escriba un entero largo, podría estar tentado de usar comas entre grupos de tres dígitos, como en 1,000,000. Este no es un entero legal en Python, pero es una expresion legal:

   1: >>> print 1,000,000

   2: 1 0 0

En fin, no era eso lo que queríamos. Python interpreta 1,000,000 como una lista de tres numeros que debe imprimir. Así que recuerde no insertar comas en sus enteros.

Una de las características mas potentes de los lenguajes de programación es la capacidad de manipular variables. Una variable es un nombre que hace referencia a un valor.

La sentencia de asignación crea nuevas variables y les asigna un valor:

>>> mensaje = "Que onda?"

>>> n = 17

>>> pi = 

3.14159

Este ejemplo muestra tres asignaciones. La primera de ellas asigna el valor “Que onda?” a una variable nueva, de nombre mensaje. La segunda le da el valor entero 17 a n, y la tercera le da el valor de numero en coma flotante 3.14159 a pi.

Una forma habitual de representar variables sobre el papel es escribir el nombre con una flecha se~nalando al valor de la variable. Este tipo de representación se llama diagrama de estado, ya que muestra en que estado se halla cada una de las variables (considerelo como el estado de animo” de la variable”).

El siguiente diagrama muestra el efecto de las tres sentencias de asignación anteriores:

La sentencia print tambien funciona con variables.

>>> print mensaje

"Que onda?"

>>> print 

n

17

>>> print pi

3.14159

En cada caso, el resultado es el valor de la variable. Las variables tambien tienen tipo. De nuevo, podemos preguntar al interprete lo que son.

>>> type(mensaje)

<type 'string'>

>>> 

type(n)

<type 'int'>

>>> type(pi)

<type 

'float'>

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

Como norma general, los programadores eligen nombres significativos para sus variables: esto permite documentar para que se usa la variable.

Los nombres de las variables pueden tener una longitud arbitraria. Pueden estar formados por letras y números, pero deben comenzar con una letra. Aunque es aceptable usar mayúsculas, por convención no lo hacemos. Si lo hace, recuerde que la distinción es importante: Bruno y bruno son dos variables diferentes.

El guion bajo ( ) también es legal y se utiliza a menudo para separar nombres con múltiples palabras, como mi nombre o precio del cafe colombiano.

Si intenta darle a una variable un nombre ilegal, obtendrá un error de sintaxis.

   1: >>> 76trombones = "gran desfile"

   2: SyntaxError: invalid 

   3: syntax

   4: >>> mas$ = 1000000

   5: SyntaxError: invalid 

   6: syntax

   7: >>> class = "Curso de Programacion 101"

   8: SyntaxError: 

   9: invalid syntax

76trombones es ilegal porque no comienza por una letra. mas$ es ilegal porque contiene un caracter ilegal, el signo del dolar. Pero ¿que tiene de malo class?

Resulta que class es una de las palabras reservadas de Python. El lenguaje usa las palabras reservadas para definir sus reglas y estructura, y no pueden usarse como nombres de variables.

Python tiene 28 palabras reservadas:

and     continue     else     for    import     not     raise

assert  def          except   from   in         or      return

break   del          exec     global is         pass    try

class   elif         finally  if     lambda     print   while

Tal vez quiera mantener esta lista a mano. Si el interprete se queja de alguno de sus nombres de variable, y usted no sabe por que, compruebe si esta en esta lista.

Una sentencia es una instrucción que puede ejecutar el interprete de Python.

Hemos visto dos tipos de sentencias: print y la asignación.

Cuando usted escribe una sentencia en la l³nea de comandos, Python la ejecuta y muestra el resultado, si lo hay. El resultado de una sentencia print es un valor.

Las sentencias de asignación no entregan ningún resultado.

Normalmente un guion contiene una secuencia de sentencias. Si hay mas de una sentencia, los resultados aparecen de uno en uno tal como se van ejecutando las sentencias.
Por ejemplo, el guion

   1: print 1

   2: x = 2

   3: print x

   4: prsenta la salida

   5: 1

   6: 2

De nuevo, la sentencia de asignacion no produce ninguna salida.

Una expresión es una combinación de valores, variables y operadores. Si teclea una expresión en la línea de comandos, el interprete la evalúa y muestra el resultado:

   1: >>> 1 + 1

   2: 2

Un valor, y también una variable, se considera una expresión por sí mismo.

   1: >>> 17

   2: 17

   3: >>> x

   4: 2

Para complicar las cosas, evaluar una expresion no es del todo lo mismo que imprimir un valor.

   1: >>> mensaje = "Que onda?"

   2: >>> mensaje

   3: "Que 

   4: onda?"

   5: >>> print mensaje

   6: Que onda?

Cuando Python muestra el valor de una expresion, usa el mismo formato que usted usaría para introducir un valor. En el caso de las cadenas, eso significa que incluye las comillas. Pero la sentencia print imprime el valor de la expresion, lo que en este caso es el contenido de la cadena.

En un guion, una expresion sin mas es una sentencia valida, pero no hace nada.

El guion 17 3.2 “Hola, mundo” 1 + 1
no presenta ninguna salida. ¿Como cambiaría usted el guion para mostrar los valores de estas cuatro expresiones?

Los operadores son símbolos especiales que representan cálculos simples, como la suma y la multiplicación. Los valores que usa el operador se llaman operandos.

Las siguientes expresiones son legales en Python y su significado es mas o menos claro:

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

Los símbolos +, -, /, y el uso de los parentesis para el agrupamiento, se usan todos de la misma forma que en matematicas. El asterisco (*) es el signo de multiplicación y ** el s³mbolo para exponenciacion.

Cuando aparece el nombre de una variable en el lugar de un operando, se sustituye con su valor antes de realizar la operacion.

La suma, resta, multiplicacion y exponenciacion hacen lo esperado, pero la división le puede sorprender. La operacion que sigue tiene un resultado inesperado:

   1: >>> minuto = 59

   2: >>> minuto/60

   3: 0

El valor de la variable minuto es 59, y 59 dividido entre 60 es 0.98333 y no 0. El motivo de la discrepancia reside en que Python esta llevando a cabo una división de enteros.

Cuando ambos operandos son enteros, el resultado ha de ser tambien un entero; por convencion, la division de enterios simpre se redondea a la baja, incluso en casos como estos en los que el siguiente entero esta muy proximo.

Una alternativa posible en este caso es el calculo de un porcentaje y no el de una fracción:

   1: >>> minuto*100/60

   2: 98

De nuevo se redondea el resultado a la baja, pero al menos ahora la respuesta es aproximadamente correcta. Otra alternativa es la division de coma flotante, que veremos en el Capítulo 3.

Cuando aparece mas 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 que los propios matemáticos para sus operaciones matemáticas.

• Los ingleses usan el acrónimo PEMDAS como regla parea recordar el orden de las operaciones:
• Paréntesis: tienen la precedencia mas alta y pueden usarse para forzar que una expresión se evalué en el orden que queramos nosotros.
• Puesto que las expresiones entre paréntesis se evalúan primero, 2 * (3-1) es igual a 4, y (1+1)**(5-2) es igual a 8. También puede usar paréntesis para que una expresión sea mas legible; por ejemplo (minuto * 100) / 60, aunque el resultado no cambie de todas formas.
• Exponenciación tiene la siguiente precedencia mas alta; as³ pues 2**1+1 es igual a 3 y no a 4, y 3*1**3 es igual a 3 y no a 27.
• La Multiplicación y la División tienen la misma precedencia, que es mas alta que la de la Adición y la Sustracción, que tienen también la misma precedencia. Por tanto 2*3-1 devuelve 5 y no 4, y 2/3-1 da -1, y no 1 (recuerde que en la división de enteros 2/3 da 0).
  Los operadores que tienen la misma precedencia se evalúan de izquierda a derecha. As³, en la expresión minuto*100/60, tiene lugar primero la
  multiplicación, devolviendo tt 5900/60, que a su vez da como resultado 98.

Si las operaciones se hubiesen realizado de derecha a izquierda, el resultado habría sido 59/1 que da 59, y que es incorrecto.