|
|
|
|
|
|
|
El valor es uno de los elementos fundamentales (como por ejemplo una letra o un número) 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 intérprete) puede identificar las cadenas porque están encerradas entre comillas.
La sentencia print también funciona con enteros:
>>> print 4
4
Si no está seguro del tipo que tiene un determinado valor, puede preguntárselo al intérprete de Python.
>>> type("Hola, mundo")
<type 'string'>
>>> type(17)
<type 'int'>
No es sorprendente que las cadenas sean de tipo string (cadena en inglés) y los enteros sean de tipo int (por integer en inglés). De forma menos obvia, los números con decimales (separados por medio de un punto en inglés) son de tipo float debido a la representación de estos números en el formato llamado de coma flotante (floating-point).
>>> type(3.2)
<type 'float'>
¿Qué ocurre con los valores como "17" y "3.2"? Parecen números, pero están entre comillas como las cadenas.
>>> type("17")
<type 'string'>
>>> type("3.2")
<type 'string'>
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. Éste no es un entero legal en Python, pero es una expresión legal:
>>> print 1,000,000
1 0 0
En fin, no era eso lo que queríamos. Python interpreta 1,000,000 como una lista de tres números que debe imprimir. Así que recuerde no insertar comas en sus enteros. * Note
Una de las características más 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 número en coma flotante 3.14159 a pi.
Una forma habitual de representar variables sobre el papel es escribir el nombre con una flecha señalando al valor de la variable. Este tipo de representación se llama diagrama de estado, ya que muestra en qué estado se halla cada una de las variables (considérelo como el "estado de ánimo" de la variable"). El siguiente diagrama muestra el efecto de las tres sentencias de asignación anteriores:
La sentencia print también 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 también tienen tipo. De nuevo, podemos preguntar al intérprete 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 qué 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 guión 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.
>>> 76trombones = "gran desfile"
SyntaxError: invalid syntax
>>> mas$ = 1000000
SyntaxError: invalid syntax
>>> class = "Curso de Programación 101"
SyntaxError: invalid syntax
76trombones es ilegal porque no comienza por una letra. mas$ es ilegal porque contiene un carácter ilegal, el signo del dólar. Pero ¿qué 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 intérprete se queja de alguno de sus nombres de variable, y usted no sabe por qué, compruebe si está en esta lista.
Una sentencia es una instrucción que puede ejecutar el intérprete 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 guión contiene una secuencia de sentencias. Si hay más de una sentencia, los resultados aparecen de uno en uno tal como se van ejecutando las sentencias.
Por ejemplo, el guión
print 1
x = 2
print x
prsenta la salida
1
2
De nuevo, la sentencia de asignación no produce ninguna salida.
Una expresión es una combinación de valroes, variables y operadores. Si teclea una expresión en la línea de comandos, el intérprete la evalúa y muestra el resultado:
>>> 1 + 1
2
Un valor, y también una variable, se considera una expresión por sí mismo.
>>> 17
17
>>> x
2
Para complicar las cosas, evaluar una expresión no es del todo lo mismo que imprimir un valor.
>>> mensaje = "Que onda?"
>>> mensaje
"Que onda?"
>>> print mensaje
Que onda?
Cuando Python muestra el valor de una expresión, 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 expresión, lo que en este caso es el contenido de la cadena.
En un guión, una expresión sin más es una sentencia válida, pero no hace nada. El guión
17
3.2
"Hola, mundo"
1 + 1
no presenta ninguna salida. ¿Cómo cambiaría usted el guión 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 expresione son legales en Python y su 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 el uso de los paréntesis para el agrupamiento, se usan todos de la misma forma que en matemáticas. El asterisco (*) es el signo de multiplicación y ** el símbolo para exponenciación.
Cuando aparece el nombre de una variable en el lugar de un operando, se sustituye con su valor antes de realizar la operación.
La suma, resta, multiplicación y exponenciación hacen lo esperado, pero la división le puede sorprender. La operación que sigue tiene un resultado inesperado:
>>> minuto = 59
>>> minuto/60
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 está llevando a cabo una división de enteros.
Cuando ambos operandos son enteros, el resultado ha de ser también un entero; por convención, la división de enterios simpre se redondea a la baja, incluso en casos como estos en los que el siguiente entero está muy próximo.
Una alternativa posible en este caso es el cálculo de un porcentaje y no el de una fracción:
>>> minuto*100/60
98
De nuevo se redondea el resultado a la baja, pero al menos ahora la respuesta es aproximadamente correcta. Otra alternativa es la división de coma flotante, que veremos en el Capítulo 3.
Cuando aparece 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 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:
En general no es posible realizar operaciones matemáticas con cadenas, incluso si las cadenas parecen números. Las siguientes sentencias son ilegales (suponiendo que mensaje sea de tipo string)
mensaje-1 "Hola"/123 mensaje*"Hola" "15"+2
Es curioso que el operador + funcione con cadenas, aunque no haga exactamente lo que usted esperaría. Para cadenas, el operador +representa la concatenación, lo que significa que se unen los dos operandos uniéndolos extremo con extremo. Por ejemplo:
fruta = "plátano"
bizcochoBueno = " pan de leche"
print fruta + bizcochoBueno
La salida del programa es plátano pan de leche. El espacio delante de pan es parte de la cadena, y es necesario para introducir el espacio que separa las cadenas concatenadas.
El operador * también funciona con cadenas; lleva a cabo la repetición. Por ejemplo 'Chiste'*3 es 'ChisteChisteChiste'. Uno de los operandos ha de ser una cadena, el otro ha de ser un entero.
Por un lado, esta interpretación de + y * cobra sentido por analogía con la suma y la multimplicación. Igual que 4*3es equivalente a 4+4+4, esperamos que 'Chiste'*3 sea lo mismo que 'Chiste'+'Chiste'+'Chiste', y así es. Por otro lado, la concatenación y la repetición son de alguna manera muy diferentes de la adición y la multiplicación de enteros. ¿Puede encontrar una propiedad que tienen la suma y la multiplicación de enteros y que no tengan la concatenación y la repetición de cadenas?
Hasta ahora hemos examinado los elementos de un programa (variables, expresiones y sentencias) por separado, sin hablar de 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 de construcción y ensamblarlos. Por ejemplo, sabemos cómo sumar números y cómo imprimirlos; resulta que podemos hacer las dos cosas a un tiempo:
>>> print 17 + 3
20
En realidad, no debemos decir "al mismo tiempo", puesto que en realidad la suma tiene que realizarse antes de la impresión, pero la cuestión es que cualquier expresión relacionada con números, cadenas y variables puede usarse dentro de una sentencia print. Ya hemos visto un ejemplo de ello:
print "Número de minutos desde la medianoche: ", hora*60+minuto
Y también puede poner expresiones arbitrarias en la parte derecha de una sentencia de asignación:
porcentaje = (minuto * 100) / 60
Esta capacidad puede no resultar muy sorprendente, pero ya veremos otros ejemplos donde la composición hace posible expresar cálculos complejos con limpieza y brevedad.
ATENCIÓN: Hay límites al lugar donde pueden usarse ciertas expresiones. Por ejemplo, la parte izquierda de una sentencia de asignación tiene que ser un nombre de variable, no una exrpresión. Por tanto es ilegal lo siguiente: minute+1 = hour.
Conforme los programas van creciendo de tamaño y complicándose, se vuelven más complicados de leer. Los lenguajes formales son densos y con frecuencia es difícil observar un trozo de código y averiguar lo que hace, o por qué lo hace.
Por ello es una buena idea añadir notas a su programa que expliquen, en un lenguaje natural, qué hace el programa. Estas notas se llaman comentarios y se marcan con el símbolo #:
# calcula el porcentaje de la hora que ha pasado ya
porcentaje = (minuto * 100) / 60
En este caso, el comentario aparece en una línea propia. También puede poner comentarios al final de otras líneas:
porcentaje = (minuto * 100) / 60 # ojo: división de enteros
Todo lo que va del # al final de la línea se ignora (no tiene efecto sobre el programa). El mensaje está destinado al programador, o a futuros programadores que podrían tener que usar el código. En este caso avisa al lector sobre el sorprendente comportamiento de la división de enteros.
|
|
|
|
|
|
|