Conforme los programas van creciendo de tamaño y complicándose, se vuelven mas 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 que lo hace.

Por ello es una buena idea a~nadir notas a su programa que expliquen, en un lenguaje natural, que hace el programa. Estas notas se llaman comentarios y se marcan con el símbolo #:

   1: # 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:

   1: 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 esta 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.

valor: un numero o cadena (o cualquier otra cosa que se especifique posteriormente) que puede almacenarse en una variable o calcularse en una expresión.

tipo: un conjunto de valores. El tipo de un valor determina como puede usarse en las expresiones. Hasta ahora, los tipos que hemos visto son enteros (tipo int), números de coma flotante (tipo float) y cadenas (tipo string).

coma flotante: un formato para representar números con decimales.

variable: nombre que hace referencia a un valor.

sentencia: es una porción de código que representa una orden o acción. Hasta ahora, las sentencias que hemos vistos son las asignaciones y las sentencias print.

asignación: sentencia que asigna un valor a una variable.

diagrama de estado: representación grafica de un conjunto de variables y de los valores a los que se refiere.

palabra reservada: es una palabra clave que usa el compilador para analizar sintacticamente los programas. No pueden usarse palabras reservadas, por ejemplo if, def y while como nombres de variables.

operador: un símbolo especial que representa un calculo sencillo, como la suma, la multiplicación o la concatenación de cadenas.

operando: uno de los valores sobre los que actúa un operador.

expresión: una combinación de variables, operadores y valores. Dicha combinación representa un único valor como resultado.

evaluar: simplificar una expresión ejecutando las operaciones para entregar un valor único.

división de enteros: es una operación que divide un entero entre otro y devuelve un entero. La división de enteros devuelve solo el numero entero de veces que el numerador es divisible por en denominador, y descarta el resto.

reglas de precedencia: la serie de reglas que especifican el orden en el que las expresiones con mutiles operadores han de evaluarse.

concatenar: unir dos operandos extremo con extremo.

composición: la capacidad de combinar expresiones sencillas y sentencias hasta crear sentencias y expresiones compuestas, con el fin de representar cálculos complejos de forma concisa.

comentario: un segmento de información en un programa, destinado a otros programadores (o cualquiera que lea el código fuente) y que no tiene efecto sobre la ejecución del programa.

Funciones

3.1. Llamadas a funciones

Ya hemos visto un ejemplo de una llamada a una función:

   1: >>> type("32")

   2: <type 'string'>

El nombre de la funcion es type, y muestra el tipo de un valor o de una variable.

El valor o variable, llamado el argumento de la función, ha de estar encerrado entre parentesis. Es habitual decir que una función “toma” un argumento y ”devuelve” un resultado. El resultado se llama valor de retorno.

En lugar de imprimir el valor de retorno, podemos asignarselo a una variable.

   1: >>> nereida = type("32")

   2: >>> print nereida

   3: <type 

   4: 'string'>

Otro ejemplo mas: la funcion id toma como argumento un valor o una variable y devuelve un entero que actua como identificador unico de ese valor.

   1: >>> id(3)

   2: 134882108

   3: >>> yanira = 3

   4: >>> 

   5: id(yanira)

   6: 134882108

Cada valor tiene un id, que es un valor unico relacionado con donde se almacena en la memoria del computador. El id de una variable es el id del valor al que hace referencia.

Python proporciona una colección de funciones internas que convierten valores de un tipo a otro. La función int toma un valor y lo convierte a un entero, si es posible, o da un error si no es posible.

   1: >>> int("32")

   2: 32

   3: >>> int("Hola")

   4: ValueError: invalid 

   5: literal for int(): Hola

int tambien convierte valores de coma flotante a enteros, pero recuerde que siempre redondea hacia abajo:

   1: >>> int(3.99999)

   2: 3

La funcion float que convierte enteros y cadenas en numeros en coma flotante:

   1: >>> float(32)

   2: 32.0

   3: >>> float("3.14159")

   4: 3.14159

Finalmente, esta la funcion str, que convierte a tipo string:

   1: >>> str(32)

   2: '32'

   3: >>> str(3.14149)

   4: '3.14149'

Pudiera parecer extraño que Python distinga entre el valor entero 1 y el valor  de coma flotante 1.0. Tal vez representen el mismo numero, pero pertenecen a tipos distintos. El motivo es que se representan de forma distinta dentro del computador.

Ahora que ya sabemos convertir entre tipos, tenemos otra forma de enfrentarnos a la división de enteros. Volviendo al ejemplo del capítulo anterior, suponga que queremos calcular que fracción de una hora había transcurrido. La expresión mas obvia, minuto / 60, realiza una división de enteros, por lo que el resultado es siempre 0, incluso 59 minutos después de la hora.

Una alternativa es convertir minuto a tipo float (coma flotante) y luego efectuar una división de coma flotante:

   1: >>> minuto = 59

   2: >>> float(minuto) / 60.0

   3: 0.983333333333

O bien podemos sacar provecho de las reglas de la conversion automatica de tipos, llamada coercion de tipos. Para los operadores matematicos, si uno de los operandos matematicos es tipo float, el otro se convierte automáticamente en float.

   1: >>> minuto = 59

   2: >>> minuto / 60.0

   3: 0.983333333333

Al usar un denomidador que es float, obligamos a Python a hacer division de coma flotante.

Es posible que ya haya visto usted en matemáticas funciones como sin (seno) y log, y que haya aprendido a evaluar expresiones como sin(pi/2) y log(1/x).

Primero evalúa la expresión entre paréntesis, (el argumento). Por ejemplo, pi/2 es aproximadamente 1.571, y 1/x es 0.1 (si x es igual a 10.0).

Luego evalúa la función en sí misma, bien mirándola en una tabla, bien llevando a cabo diversos cálculos. El sin (seno) de 1.571 es 1, y el log de 0.1 es –1 (suponiendo que log indique el logaritmo de base 10).

Este proceso puede aplicarse repetidamente para evaluar expresiones mas complicadas como log(1/sin(pi/2)). Primero evaluamos el argumento de la función mas interna, luego se evalúa la función, y así sucesivamente.

Python dispone de un modulo matemático que proporciona la mayor³a de las funciones matemáticas habituales. Un modulo es un archivo que contiene una colección de funciones agrupadas juntas.

Antes de poder usar las funciones de un modulo, tenemos que importarlo:

   1: >>>import math

Para llamar a una de las funciones, tenemos que especificar el nombre del modulo y el nombre de la funcion, separados por un punto. A esto se le llama notación de punto:

   1: decibelio = math.log10 (17.0)

   2: angulo = 1.5

   3: altura = math.sin(angulo)

La primera sentencia da a decibelio el valor del logaritmo de 17, en base 10.

Hay tambien una funcion llamada log que toma logaritmos en base e.

La tercera sentencia halla el seno del valor de la variable angulo. sin y las otras funciones trigonometricas (cos, tan, etc.) toman sus argumentos en radianes.

Para convertir de grados a radianes, puede dividir por 360 y multiplicar por 2*pi. Por ejemplo, para hallar el seno de 45 grados, calcule primero el ángulo en radianes y luego halle el seno:

   1: grados = 45

   2: angulo = grados * 2 * math.pi / 360.0

   3: math.sin(angulo)

La constante pi tambien es parte del modulo math. Si se sabe la geometría, puede verificar el resultado comparandolo con el de la raíz cuadrada de 2, dividida entre 2.

   1: >>> math.sqrt(2) / 2.0

   2: 0.707106781187

Igual que con las funciones matemáticas, las funciones de Python se pueden componer; eso quiere decir que se usa una expresión como parte de otra. Por ejemplo, puede usar cualquier expresión como argumento de una función:

   1: x = math.cos(angulo + pi/2)

Esta sentencia toma el valor de pi, lo divide entre dos y le añade el resultado al valor de angulo. La suma se pasa luego como argumento a la funcion cos.

También puede tomar el resultado de una funcion y pasarselo como argumento a otra:

   1: x = math.exp(math.log(10.0))

Esta sentencia encuentra el logaritmo en base e de 10 y luego eleva e a ese exponente. El resultado queda asignado a x.

Hasta ahora solo hemos usado las funciones que vienen incluidas con Python, pero también es posible añadir nuevas funciones. La creación de nuevas funciones para resolver sus problemas particulares es una de las cosas mas útiles de los lenguajes de programación de propósito general.

En contextos de programación, función es una secuencia de instrucciones con nombre, que lleva a cabo la operación deseada. Esta operación se especifica en una definición de función. Las funciones que hemos usado hasta ahora las han definido por nosotros, y esas definiciones están ocultas. Eso es bueno, ya que nos permite usar funciones sin preocuparnos sobre los detalles de sus definiciones.

La sintaxis de la definición de una función es:

   1: def NOMBRE( LISTA DE PARAMETROS ):

   2:     SENTENCIAS

Puede inventarse el nombre que desee para su funcion, con la excepcion de que no puede usar las palabras reservadas de Python. La lista de parámetros especifica que informacion, en caso de haberla, ha de proporcionar para usar la función nueva.

Puede haber cualquier numero de sentencias dentro de la funcion, pero tienen que estar indentadas desde el margen izquierdo. En los ejemplos de este libro se usara una indentacion de dos espacios.

El primer par de funciones que escribiremos no tienen parametros, de manera que su sintaxis es:

   1: def nueva_linea():

   2:     print

Esta funcion se llama nueva linea. Los parentesis vac³os indican que no tiene parámetros. Contiene una unica sentencia, que muestra como salida un carácter de nueva línea (es lo que sucede cuando utiliza una orden print sin argumentos).

Llamamos entonces a la funcion nueva usando la misma sintaxis que usamos para las funciones internas:

   1: print "Primera linea."

   2: nueva_linea()

   3: print "Segunda linea."

   4: The output 

   5: of this program is

   6: Primera linea.

   7: Segunda linea.

Observe el espacio a~nadido que hay entre las dos l³neas. Si quisieramos mas espacios, entre las l³neas, >que har³amos? Podemos llamar varias veces a la misma función:

   1: print "Primera 

   2: linea."

   3: nueva_linea()

   4: nueva_linea()

   5: nueva_linea()

   6: print "Segunda 

   7: linea."

O bien podemos escribir una nueva funcion que llamaremos tresLineas, y que imprima tres nuevas líneas:

   1: def tresLineas():

   2:     nueva_linea()

   3:     nueva_linea()

   4:     nueva_linea()

   5:     print 

   6:     "Primera Linea."

   7:     tresLineas()

   8:     print "Segunda Linea."

   9:     

Esta funcion contiene tres sentencias, las cuales estan todas indentadas con dos espacios. Puesto que la siguiente sentencia no esta indentada, Python sabe que no es parte de la funcion.

Observe los siguientes puntos con respecto a este programa:

1. Se puede llamar al mismo procedimiento repetidamente. De hecho es bastante util hacerlo, ademas de habitual.
2. Se puede llamar a una funcion desde dentro de otra funcion: en este caso tresLineas llama a nueva linea.

Hasta ahora puede no haber quedar claro por que vale la pena crear todas estas funciones nuevas. En realidad hay much³simas razones, pero este ejemplo demuestra dos:

Crear una nueva funcion le da la oportunidad de dar un nombre a un grupo de sentencias. Las funciones simplifican su programa al ocultar cálculos complejos detras de ordenes sencillas, y usar palabras de su propia lengua
en vez de codigo arcano.

Crear una nueva funcion hace que el programa sea mas pequeño, al eliminar codigo repetitivo. Por ejemplo, una manera de imprimir nueve líneas consecutivas es llamar a tresLineas tres veces.

Como actividad, escriba una funcion llamada nueveLineas que use tresLineas para imprimir nueve líneas en blanco. ¿Como imprimiría 27 líneas nuevas?

Juntando los fragmentos de código de la sección anterior, el programa completo queda de la siguiente manera:

   1: def nueva_linea():

   2:     print

   3: def 

   4:     tresLineas():

   5:     nueva_linea()

   6:     nueva_linea()

   7:     nueva_linea()

   8:     print 

   9:     "Primera Linea."

  10:     tresLineas()

  11:     print "Segunda Linea."

El presente programa contiene dos definiciones de funciones: nueva linea y tresLineas. Las de¯niciones de funciones se ejecutan como el resto de sentencias, pero el efecto es crear una nueva funcion. Las sentencias del interior de la funcion no se ejecutan hasta que se llama a la funcion, y la definición de la función no genera salida.

Como era de esperar, tiene que crear una funcion antes de poder ejecutarla.

En otras palabras, la definición de la funcion tiene que ejecutarse antes de la primera vez que se la invoque.

Como actividad, pruebe a ejecutar este programa moviendo las tres ultimas sentencias al principio del programa. Registre que mensaje de error obtiene usted.

Como segunda actividad, pruebe a tomar la version del programa que funcionaba y a mover la definición de nueva linea mas abajo que la definición de tresLineas .

¿Que ocurre cuando ejecuta el programa?

Para asegurarse de que una función se define antes de su primer uso, tiene que conocer el orden en el que se ejecutan las sentencias; a esto se le llama flujo de ejecución.

La ejecución comienza siempre por la primera sentencia del programa. Las sentencias se ejecutan a razón de una cada vez, en orden, hasta que se alcanza una llamada a una función.

Las definiciones de funciones no alteran el flujo de ejecución del programa, pero recuerde que las sentencias que hay dentro de la función no se ejecutan hasta que se hace la llamada a la función. Aunque no es habitual, puede definir una función dentro de otra. En este caso, la definición de función interior no se ejecuta hasta que no se llama a la función exterior.

Las llamadas a funciones son como un desvío en el flujo de ejecución. En lugar de ir a la siguiente sentencia, el flujo salta hasta la primera línea de la función a la que se llama, ejecuta todas las sentencias que encuentre allí, y vuelve a
retomar la ejecución en el punto donde lo dejo.

Esto suena bastante sencillo… hasta que se acuerda de que una función puede llamar a otra. Mientras estamos en medio de una función, podríamos vernos obligados a abandonarla e ir a ejecutar sentencias en otra función mas. Pero mientras estamos en esta nueva función, ¡podríamos salirnos y ejecutar otra función mas!

Afortunadamente, a Python se le da bien tomar nota de donde esta, de manera que cada vez que se completa una función, el programa retoma el punto en donde lo dejo en la función que hizo la llamada. Cuando llega al final del programa, termina.

¿Cual es la moraleja de toda esta historia?

Cuando este leyendo un programa, no lo lea desde la parte superior a la inferior. En lugar de eso, siga el flujo de ejecución.