Ver índice de contenidos del libro

2.3. Piezas de un programa Python

Para poder empezar a programar en Python es necesario que conocer los elementos que constituyen un programa en dicho lenguaje y las reglas para construirlos.

Nota Cuando empezamos a hablar en un idioma extranjero es posible que nos entiendan pese a que cometamos errores. No sucede lo mismo con los lenguajes de programación: la computadora no nos entenderá si nos desviamos un poco de alguna de las reglas.

2.3.1. Nombres

Ya hemos visto que se usan nombres para denominar a los programas (ametrico) y para denominar a las funciones dentro de un módulo (main). Cuando queremos dar nombres a valores usamos variables (millas, pies, pulgadas, metros). Todos esos nombres se llaman identificadores y Python tiene reglas sobre qué es un identificador válido y qué no lo es.

Un identificador comienza con una letra o con guión bajo (_) y luego sigue con una secuencia de letras, números y guiones bajos. Los espacios no están permitidos dentro de los identificadores.

Los siguientes son todos identificadores válidos de Python:

  • hola
  • hola12t
  • _hola
  • Hola

Python distingue mayúsculas de minúsculas, así que Hola es un identificador y hola es otro identificador.

Nota Por convención, no usaremos identificadores que empiezan con mayúscula.

Los siguientes son todos identificadores inválidos de Python:

  • hola a12t
  • 8hola
  • hola\%
  • Hola*9

Python reserva 31 palabras para describir la estructura del programa, y no permite que se usen como identificadores. Cuando en un programa nos encontramos con que un nombre no es admitido pese a que su formato es válido, seguramente se trata de una de las palabras de esta lista, a la que llamaremos de palabras reservadas. Esta es la lista completa de las palabras reservadas de Python:

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

2.3.2. Expresiones

Una expresión es una porción de código Python que produce o calcula un valor (resultado).

  • Un valor es una expresión (de hecho es la expresión más sencilla). Por ejemplo el resultado de la expresión 111 es precisamente el número 111.
  • Una variable es una expresión, y el valor que produce es el que tiene asociado en el estado (si x → 5 en el estado, entonces el resultado de la expresión x es el número 5).
  • Usamos operaciones para combinar expresiones y construir expresiones más complejas:
    • Si x es como antes, x + 1 es una expresión cuyo resultado es 6.
    • Si en el estado millas → 1, pies → 0 y pulgadas → 0, entonces 1609.344 * millas + 0.3048 * pies + 0.0254 * pulgadas es una expresión cuyo resultado es 1609.344.
    • La exponenciación se representa con el símbolo **. Por ejemplo, x**3 significa x^3.
    • Se pueden usar paréntesis para indicar un orden de evaluación: ((b * b) - (4 * a * c))
    • Igual que en la matemática, si no hay paréntesis en la expresión primero se agrupan las exponenciaciones, luego los productos y cocientes, y luego las sumas y restas.
    • Sin embargo, hay que tener cuidado con lo que sucede con los cocientes. Si x / y se calcula como la división entera entre x y y, entonces si x se refiere al valor 12 e y se refiere al valor 9, entonces x / y se refiere al valor 1.
    • Si x e y son números enteros, entonces x % y se calcula como el resto de la división entera entre x e y. Si x se refiere al valor 12 e y se refiere al valor 9, entonces x % y se refiere al valor 3.

Nota Los números pueden ser tanto enteros (111, -24), como reales (12.5, 12.0, -12.5). Dentro de la computadora se representan de manera diferente, y se comportan de manera diferente frente a las operaciones.

Conocemos también dos expresiones muy particulares:

  • input, que devuelve el valor ingresado por teclado tal como se lo digita (en particular sirve para ingresar valores numéricos).
  • raw_input, que devuelve lo ingresado por teclado como si fuera un texto.

Ejercicio 2.1. Aplicando las reglas matemáticas de asociatividad, decidir cuáles de las siguientes expresiones son iguales entre sí:

  • ((b * b) - (4 * a * c)) / (2 * a), b) (b * b - 4 * a * c) / (2 * a)
  • b * b - 4 * a * c / 2 * a
  • (b * b) - (4 * a * c / 2 * a)
  • 1 / 2 * b
  • b / 2

Ejercicio 2.2. En Python hagan lo siguiente: Denle a a, b y c los valores 10, 100 y 1000 respectivamente y evalúen las expresiones del ejercicio anterior.

Ejercicio 2.3. En Python hagan lo siguiente: Denle a a, b y c los valores 10.0, 100.0 y 1000.0 respectivamente y evalúen las expresiones del punto anterior.

Copyright (c) 2011-2014 Rosita Wachenchauzer, Margarita Manterola, Maximiliano Curia, Marcos Medrano, Nicolás Paez. La copia y redistribución de esta página se permite bajo los términos de la licencia Creative Commons Atribución - Compartir Obras Derivadas Igual 3.0 siempre que se conserve esta nota de copyright.