Cap. 2 - Variables, expresiones y sentencias

2.1) Valores y tipos de datos

Los valores son los ladrillos básicos que un programa manipula. Ejemplos: 2, 3+7, "Hola mundo"

Se los clasifica en clases llamadas tipos de datos. Ejemplos: integer, string, float

Se puede usar la función type para identificar el tipo de un valor:

>>> type("Hola mundo")
<class 'str'>
>>> type(17)
<class 'int'>
>>> type(3.2)
<class 'float'>

Valores como "3.2" o "17" son strings si se definen entre comillas.

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

Los strings en Python se pueden encerrar en comillas dobles o simples, o en tres de ellas, así:

>>> type('This is a string.')
<class 'str'>
>>> type("And so is this.")
<class 'str'>
>>> type("""and this.""")
<class 'str'>
>>> type('''and even this...''')
<class 'str'>

Los definidos con doble comilla pueden contener comillas simples y los definidos con comillas simples pueden contener dobles comillas:

>>> print('''"Oh no", she exclaimed, "Ben's bike is broken!"''')
"Oh no", she exclaimed, "Ben's bike is broken!"

Los definidos con triple comilla pueden extenderse por varias líneas:

>>> message = """This message will
... span several
... lines."""
>>> print(message)
This message will
span several
lines.

Independientemente de cómo se definan, Python suele expresar los strings como "single quote", a menos que justo incluyan una comilla dentro, caso en que los mostrará como "doble quote"

>>> "Hola qu'e tal"
"Hola qu'e tal"
>>> "Hola que tal"
'Hola que tal'

No poner espacios o comas entre los enteros (sí es válido un punto como coma decimal), porque los interpreta de un modo sintácticamente específico (como varios valores).

2.2) Variables

La posibilidad de definir y utilizar variables es una de las características más poderosas de los lenguajes de programación.

Una instrucción de asignación permite definir variables:

>>> message = "What's up, Doc?"
>>> n = 17
>>> pi = 3.14159

El token de asignación = no debe ser confundido con el de comparación == . El de asignación asocia un valor a un nombre (el nombre de la variable)

Si se le pide al intérprete que evalúe la variable, devolverá el valor que le hemos asignado

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

Utilizamos las variables para "recordar" cosas (por ejemplo, el resultado actual de un partido de fútbol). Como su nombre indica, son variables, cambian con el tiempo. Se les puede actualizar el valor a medida que corre el programa (a diferencia de lo que pasa en matemáticas, en que una vez asignado el valor de una variable, no se puede cambiar).

>>> day = "Thursday"
>>> day
'Thursday'
>>> day = "Friday"
>>> day
'Friday'
>>> day = 21
>>> day
21

En el último ejemplo incluso cambiamos el tipo de la variable (algo que se puede hacer en Python, pero no en todo lenguaje).

2.3) Nombres de variables y palabras clave

Los nombres de variable pueden ser arbitrariamente largos. Pueden contener letras o dígitos (e infraguión), pero deben comenzar con letra o infraguión.

Si se utiliza un nombre ilegal de variable se obtiene un syntax error:

>>> 76trombones = "big parade"
SyntaxError: invalid syntax
>>> more$ = 1000000
SyntaxError: invalid syntax
>>> class = "Computer Science 101"
SyntaxError: invalid syntax

El nombre "class" está prohibido porque es una palabra clave de Python.

Python tiene unas 30 y pocos nombres reservados (varían con el tiempo, y a veces se elimina alguno). Lista actual:

Es recomendable utilizar nombres de variables que recuerden (al lector humano) de qué se trata la variable. Es importante recordar en este punto que la computadora no comprende esos nombres, y no va a actuar adecuadamente con una variable sólo porque le dimos tal o cual nombre. No va a interpretar que una variable llamada "promedio" es un promedio, por ejemplo.

2.4) Sentencias

Una sentencia (statement) es una instrucción que el intérprete de Python puede ejecutar. Hemos visto la asignación. Otros, que veremos más adelante, son: while, for, if, import, etc.

Las sentencias son acciones que se ejecutan (no son valores, no producen un resultado).

2.5) Evaluando expresiones

Una expresión es una combinación de valores, variables, operadores y llamados a función. Si se escribe una expresión en el prompt, el intérprete la evalúa y muestra el resultado:

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

En el ejemplo, len es una función Python "built-in" que devuelve la cantidad de caracteres del string. Ya habíamos visto otras funciones (print, type).

Como la evaluación de una expresión produce un valor, puede aparecer del lado derecho de una asignación, por ejemplo:

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

2.6) Operadores y operandos

Operadores: tokens especiales que simbolizan suma, multiplicación, división, etc.. Se llama operandos a los valores que se usan con ellos.

Las siguientes son expresiones válidas en Python:

20+32   	hour-1   	hour*60+minute   	minute/60   	5**2   		(5+9)*(15-7)

Los tokens +, -, / se usan y se combinan con paréntesis exactamente igual que en matemáticas. El token * significa multiplicación, y el ** es potencia.

Si se utiliza un nombre de variable junto a operandos, se toma de la variable su valor antes de hacer la operación.

>>> minutes = 645 >>> hours = minutes / 60 >>> hours 10.75

La división puede ser float / o bien entera // (si es entera, devuelve siempre el floor).

>>> 6/4
1.5
>>> 6//4
1
>>> -6/3
-2.0
>>> -6/4
-1.5
>>> -6//4
-2
>>> -4//4
-1
>>> 0//4
0
>>> -7//4
-2
>>> -5//4
-2
>>> -5.5//4
-2.0
>>> -5.5/4
-1.375

Es cuestión de elegir cuál de los operadores convienen, según el caso:

>>> 7 / 4
1.75
>>> 7 // 4
1
>>> minutes = 645
>>> hours = minutes // 60
>>> hours
10

2.7) Funciones para conversión de tipos

Veremos aquí tres funciones conversoras de tipo: int, float y str

La función int puede recibir un float o un string, y lo convierte en int. Si recibe un float, descarta la parte decimal (es decir, trunca hacia el cero)

>>> 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)                 # It even works if arg is already an int
17
>>> int("23 bottles")

En el último caso el output es un mensaje de error (ya que no logra convertir el string a entero)

El conversor float convierte un entero en un float, o un string sintácticamente correcto en float.

>>> float(17)
17.0
>>> float("123.45")
123.45
>>> float(3e5)
300000.0

El conversor int convierte el argumento (entero o float) en un string

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

2.8) Orden de las operaciones

En caso de aparecer múltiples operadores en una expresión, las reglas de precedencia deciden en qué orden se evalúan.

Python usa las mismas reglas que las matemáticas, las cuales pueden expresarse por el acrónimo PEMDAS

  1. Paréntesis tienen la precedencia más alta y fuerzan a una expresión a evaluarse como queramos. También puede usarse para simplificar la lectura.
  2. Exponenciaciones
  3. Multiplicaciones y Divisiones (con la misma precedencia), tras los cuales vienen Adición y Sustracción (con la misma precedencia)
  4. Operadores con la misma precedencia se evalúan de izquierda a derecha

    Por razones históricas, con potenciación se asocia de derecha a izquierda por defecto (si se quiere forzar izquierda-derecha habrá que usar paréntesis)

>>> 2 ** 3 ** 2     # The right-most ** operator gets done first!
512
>>> (2 ** 3) ** 2   # Use parentheses to force the order you want!
64

2.9) Operaciones sobre strings

No se pueden hacer operaciones matemáticas con strings, incluso si se ven como números

>>> message - 1        # Error
>>> "Hello" / 123      # Error
>>> message * "Hello"  # Error
>>> "15" + 2           # Error

El operador + funciona con strings, pero como operador de concatenación

>>> fruit = "banana"
>>> baked_good = " nut bread"
>>> print(fruit + baked_good)
'banana nut bread'

El operador * permite hacer repeticiones de strings (es necesario que uno de los operadores sea un string y el otro sea un número)

>>> 'Fun' * 3
'FunFunFun'

Observar que hay cierta analogía: "Fun" * 3 es lo mismo que "Fun" + "Fun" + "Fun". Sin embargo, no todas las propiedades se mantienen (por ejemplo, la concatenación no es conmutativa).

2.10) Input

Python provee la función input para obtener input del usuario

>>> n = input("ingresa tu nombre: ")
ingresa tu nombre: Cualquiera
>>> n
'Cualquiera'
>>> edad = input("ingresa tu edad")
ingresa tu edad: 23
>>> edad
'23'

En el momento de llamar a input aparece un mensaje popup, que el usuario llena dando ok. Si el usuario hace click en "cancel", se obtiene un mensaje de error. Queda pendiente ver cómo se trata este caso.

La función devuelve siempre un string. Es responsabilidad del programador convertirlo en un int o un float en caso de ser necesario.

2.11) Composición

Lo que hace poderoso a un lenguaje de programación es la posibilidad de combinar pequeños pasos atómicos para conseguir una interacción más sofisticada.

Ejemplo: sabemos cómo recibir input, cómo convertir un string en un float, cómo escribir una expresión compleja y cómo mostrar valores en pantalla. Combinando todo esto, escribamos un pequeño programa que recibe el radio de un círculo y devuelve el área del círculo a partir de la fórmula: A = pi.r2

Primero, hagamos los 4 pasos por separado:

radio = input("What is your radius? ")
r = float(radio)
area = 3.14159 * r**2
print("El área es ", area)

Ahora, compongamos los pasos anteriores, reduciendo cada par de líneas a una sola:

r = float(input("What is your radius? "))
print("El área es ", 3.14159 * r**2)

Podríamos incluso haber reducido todo a una sola línea:

print("El área es ", 3.14159 * float(input("What is your radius? "))**2)

Tal vez no sea el ejemplo más fácil de leer, pero el ejemplo muestra cómo podemos reducir código (a costa de facilidad de lectura). Para un programador principiante, lo recomendable es el primer modo (el de las 4 líneas), pero no hay que olvidar que con el tiempo es posible ir pasando a los modos más compactos.

2.12) El operador módulo

El operador módulo se aplica a enteros (y a expresiones enteras) y devuelve el módulo (resto) de la división entera. En Python, se representa con el símbolo de porcentaje (%)

La sintaxis es similar a la de otros operadores y tiene la misma precedencia que la multiplicación.

>>> q = 7 // 3     # This is integer division operator
>>> print(q)
2
>>> r  = 7 % 3
>>> print(r)
1

El operador módulo es muy útil. Permite saber si un número es divisible por otro (caso en que el módulo de su división entera da 0).

También, permite extraer los dígitos finales de un número (si utilizamos %10 o %100)

También es muy útil para hacer conversiones, por ejemplo de segundos a horas, minutos y segundos. Un ejemplo (programa L2):

total_secs = int(input("How many seconds, in total?"))
hours = total_secs // 3600
secs_still_remaining = total_secs % 3600
minutes =  secs_still_remaining // 60
secs_finally_remaining = secs_still_remaining  % 60

print("Hrs=", hours, "  mins=", minutes, "  secs=", secs_finally_remaining)

2.13) Glosario

2.14) Ejercicios

1) Toma la frase: All work and no play makes Jack a dull boy. Guarda cada palabra en una variable separada, luego impríme la frase en una línea mediante la sentencia print. (hacerla)

2) Agregar un paréntesis a 6 * 1 - 2 para cambiar su valor de 4 a -6

6 * (1 - 2)

3) Poner un comentario antes de una línea de código que estuviera funcionando, y ver qué pasa al volver a correr el programa (no pasa nada, sigue todo igual)

4) Poner bruce + 4 en el prompt. Debería dar error. Luego dar un valor a bruce para que bruce + 4 evalúa a 10.

5) La fórmula para calcular el monto final aplicando interés compuesto se puede encontrar en Wikipedia como fórmula del interés compuesto:

M = C(1 + r/100n)^nt

Escribe un programa Python que asigne el capital inicial de $10000 a una variable C, asigne a n el valor 12, y asigne a r la tasa de interés del 8%. Luego haz que el programa pida al usuario por la cantidad de años t que el dinero va a ser depositado. Calcula e imprime el monto final tras los t años. (hacerla)

6) Evaluar las siguientes expresiones mentalmente, luego chequear los resultados en el Python prompt:

>>> 5 % 2
>>> 9 % 5
>>> 15 % 12
>>> 12 % 15
>>> 6 % 6
>>> 0 % 7
>>> 7 % 0

El último da error - ¿por qué? (división por cero)

7) Miras el reloj y son exactamente las 2pm. Pones la alarma para sonar en 51 horas. ¿A qué hora sonará la alarma? (Pista: podrías contar con tus dedos, pero no es lo que buscamos. Si te ves tentado a contar con tus dedos, cambia el 51 por un 5100.) (hacerla - es un ejercicio para verificar si se comprendió bien el concepto de módulo)

8) Escribe un programa Python que implemente la versión general del problema anterior. Pregunta al usuario la hora actual (en horas) y pregúntale por el número de horas que hay que esperar. Tu programa debería entonces mostrar a qué hora va a estar el reloj cuando suene la alarma. (hacerlo)