Como seguramente a estas alturas ya supondrá, se puede llamar a una función desde dentro de otra. Esta habilidad se llama composición .

Como ejemplo, escribiremos una función que tome dos puntos, el centro del círculo y un punto del per³metro, y calcule el área del círculo.

Supongamos que el punto central esta almacenado en las variables xc e yc, y que el punto del perímetro lo esta en xp e yp. El primer paso es hallar el radio del círculo, que es la distancia entre los dos puntos. Afortunadamente hay una función, distancia, que realiza esta tarea:

   1: radio = distancia(xc, yc, xp, yp)

El segundo paso es encontrar el area de un círculo con ese radio y devolverla:

   1: resultado = area(radio)

   2: return resultado

Envolviendo todo esto en una funcion, obtenemos:

   1: def area2(xc, yc, xp, yp):

   2:     radio = distancia(xc, yc, xp, yp)

   3:     resultado = area(radio)

   4:     return resultado

Hemos llamado a esta funcion area2 para distinguirla de la funcion area definida anteriormente. Solo puede haber una unica funcion con un determinado nombre dentro de un modulo.

Las variables temporales radio y area son utiles para el desarrollo y el depurado, pero una vez que el programa esta funcionando, podemos hacerlo mas conciso integrando las llamadas a las funciones en una sola línea:

   1: def area2(xc, yc, xp, yp):

   2: return area(distancia(xc, yc, xp, yp))

Como actividad, escriba una funcion pendiente(x1, y1, x2, y2) que devuelva la pendiente de la l³nea que atraviesa los puntos (x1,y1) y (x2, y2). Luego use esta funcion en una funcion que se llame intercepta(x1, y1, x2, y2) que devuelva la [[y-intercepta]] de la línea a traves de los puntos (x1, y1) y (x2, y2).

Las funciones pueden devolver valores booleanos, lo que a menudo es conveniente para ocultar complicadas comprobaciones dentro de funciones. Por ejemplo:

   1: def esDivisible(x, y):

   2:     if x % y == 0:

   3:         return 1 # it's  true

   4:     else:

   5:         return 0 # it's false

La funcion lleva por nombre esDivisible. Es habitual dar a las funciones booleanas nombres que suenan como preguntas s³/no. Devuelve 1 o 0 para indicar si la x es o no divisibelo por y.

Podemos reducir el tama~no de la funcion aprovechandonos del hecho de que la sentencia condicional que hay despues del if es en s³ misma una expresión booleana. Podemos devolverla directamente, evitando a la vez la sentencia if:

   1: def esDivisible(x, y):

   2:     return x % y == 0

La siguiente sesion muestra a la nueva funcion en acción:

   1: >>> esDivisible(6, 4)

   2: 0

   3: >>> esDivisible(6, 3)

   4: 1

El uso mas comun para las funciones booleanas es dentro de sentencias condicionales:

   1: if esDivisible(x, y):

   2:     print "x es divisible entre y"

   3: else:

   4:     print "x no es divisible entre y"

Puede parecer tentador escribir algo como:

   1: if esDivisible(x, y) == 1:

Pero la comparacion extra es innecesaria.

Como actividad, escriba una funcion estaEntre(x, y, z) que devuelva 1 en caso de que y <= x <= z y que devuelva 0 en cualquier otro caso.

Hasta ahora, usted ha aprendido solamente un pequeño subconjunto de Python, pero puede que le interese saber que ese subconjunto es ya un lenguaje de programación completo; con esto queremos decir que cualquier cosa que pueda computarse se puede expresar en este lenguaje. Cualquier programa que se haya escrito alguna vez puede reescribirse utilizando únicamente las características del lenguaje que ha aprendido hasta el momento (de hecho, necesitaría algunas ordenes para controlar dispositivos como el teclado, el ratón, los discos, etc. pero  eso es todo).

Probar tal afirmación es un ejercicio nada trivial, completado por primera vez por Alan Turing, uno de los primeros científicos informáticos (algunos argumentaran que era un matemático, pero muchos de los científicos informáticos pioneros comenzaron como matemáticos). En correspondencia, se la conoce como la tesis de Turing. Si estudia un curso de Teoría de la Computación, tendrá oportunidad de ver la prueba.

Para darle una idea de lo que puede hacer con las herramientas que ha aprendido hasta ahora, evaluaremos una serie de funciones matemáticas que se definen recursivamente. Una definición recursiva es semejante a una definición circular, en el sentido de que la definición contiene una referencia a lo que se define. Una definición verdaderamente circular no es muy útil: fangoso: adjetivo que describe algo que es fangoso.

Si usted viera esa definición en el diccionario, se quedaría confuso. Por otra parte, si ha buscado la definición de la función matemática factorial, habrá visto algo semejante a lo siguiente:

0! = 1
n! = n ¢ (n ¡ 1)!

Esta definición establece que el factorial de 0 es 1, y que el factorial de cualquier otro valor, n, es n multiplicado por el factorial de n ¡ 1.
Así pues, 3! es 3 veces 2!, que es 2 veces 1!, que es una vez 0!. Juntándolos todos, , 3! es igual a 3 veces 2 veces 1 vez 1, que es 6.

Si puede escribir una definición recursiva de algo, normalmente podrá escribir un programa de Python para evaluarlo. El primer paso es decidir cuales son los parámetros para esta función. Con poco esfuerzo llegara a la conclusión de que factorial toma un único parámetro:

   1: def factorial(n):

   2:     Si resultase que el argumento fuese 0, todo lo que hemos de hacer es devolver 1:

   3: def factorial(n):

   4:     if n == 0:

   5:     return 1

   6:     

En otro caso, y he aquí la parte interesante, tenemos que hacer una llamada recursiva para hallar el factorial de n ¡ 1 y luego multiplicarlo por n:

   1: def factorial(n):

   2:     if n == 0:

   3:         return 1

   4:     else:

   5:         recursivo = 

   6:         factorial(n-1)

   7:         resultado = n * recursivo

   8:         return resultado

El flujo de ejecucion de este programa es similar al de cuenta atras de la Sección 4.9. Si llamamos a factorial con el valor 3:

Puesto que 3 no es 0, tomamos la segunda rama y calculamos el factorial de n-1…

Puesto que 2 no es 0, tomamos la segunda rama y calculamos el factorial de n-1…

Puesto que 1 no es 0, tomamos la segunda rama y calculamos el factorial de n-1…

Puesto que 0 es 0, tomamos la primera rama y devolvemos el valor 1 sin hacer mas llamadas recursivas.

El valor de retorno (1) se multiplica por n, que es 1, y se devuelve el resultado.

El valor de retorno (1) se multiplica por n, que es 2, y se devuelve el resultado.

El valor de retorno (2) se multiplica por n, que es 3, y el resultado 6, se convierte en el valor de retorno de la llamada a la funcion que comenzo todo el proceso.

He aquí el aspecto que tiene el diagrama de pila para esta secuencia de llamadas a función:

Los valores de retorno se muestran segun se pasan hacia la parte superior de la pila. En cada marco, el valor de retorno es el valor de resultado, que es el producto de n por recursivo.

Nótese que en el ultimo marco las variables locales recursivo y resultado no existen porque la rama que las crea no se ejecuta.

Seguir el flujo de ejecución es una de las maneras de leer programas; pero puede volverse rápidamente una tarea laberíntica. La alternativa es lo que llamamos el “acto de fe“. Cuando llegamos a una función, en lugar de seguir el flujo de ejecución, damos por sentado que la función trabaja correctamente y devuelve el valor apropiado.

De hecho, usted ya practica dicho salto de fe cuando usa funciones internas.

Cuando llama a math.cos o a math.exp, no examina la implementación de dichas funciones. Simplemente da por sentado que funcionan porque los que escribieron las bibliotecas internas de Python son buenos programadores.

Lo mismo se aplica cuando llama a una de las funciones programadas por usted.

Por ejemplo en la Sección 5.4, escribimos una función llamada esDivisible que determina si un numero es divisible por otro. Una vez que nos hayamos convencido de que dicha función es correcta, comprobando y examinando el código, podremos usar la función sin tener siquiera que volver a mirar el código otra vez.

Lo mismo vale para los programas recursivos. Cuando llegue a la llamada recursiva, en lugar de seguir el flujo de ejecución, tendría que dar por supuesto que la llamada recursiva funciona (es decir, devuelve el resultado correcto) y luego preguntarse: “suponiendo que puedo hallar el factorial de n – 1, ¿puedo hallar el factorial de n?” En este caso, esta claro que sí puede, multiplicándolo por n.

Por supuesto, es un tanto extraño dar por supuesto que la función esta bien cuando ni siquiera ha acabado de escribirla, pero precisamente por eso se llama acto de fe.”