operador modulo: Operador, señalado con un signo de tanto por ciento ( %), que trabaja sobre enteros y devuelve el resto cuando un numero se divide entre otro.

expresión booleana: Una expresión que es cierta o falsa.

operador de comparación: Uno de los operadores que comparan dos valores: ==, !=, >, = y <=.

operador lógico: Uno de los operadores que combinan expresiones booleanas: and, or y not.

sentencia condicional: Sentencia que controla el flujo de ejecución de un programa dependiendo de cierta condición.

condición: La expresión booleana de una sentencia condicional que determina que rama se ejecutara.

sentencia compuesta: Estructura de Python que esta formado por una cabecera y un cuerpo. La cabecera termina en dos puntos (:). El cuerpo tiene una sangría con respecto a la cabecera.

bloque: Grupo sentencias consecutivas con el mismo sangrado.

cuerpo: En una sentencia compuesta, el bloque de sentencias que sigue a la cabecera de la sentencia.

anidamiento: Una estructura de programa dentro de otra; por ejemplo, una sentencia condicional dentro de una o ambas ramas de otra sentencia condicional.

recursividad: El proceso de volver a llamar a la función que se esta ejecutando en ese momento.

caso base: En una función recursiva, la rama de una sentencia condicional que no ocasiona una llamada recursiva.

recursividad infinita: Función que se llama a sí misma recursivamente sin alcanzar nunca el caso base. A la larga una recursión infinita provocara un error en tiempo de ejecución.

indicador: indicador visual que invita al usuario a introducir datos.

Funciones productivas

5.1. Valores de retorno

Algunas de las funciones internas que hemos usado, como las funciones math o funciones matemáticas, han producido resultados. Llamar a la función genera un nuevo valor, que normalmente asignamos a una variable pasa usar como parte de una expresión.

   1: import math

   2: e = math.exp(1.0)

   3: altura = radio * math.sin(angulo)

Pero hasta ahora, ninguna de las funciones que hemos escrito ha devuelto un valor.

En este capítulo escribiremos funciones que devuelvan valores, que llamaremos funciones productivas, a falta de un nombre mejor. El primer ejemplo es área, que devuelve el area de un c³rculo con un radio dado:

   1: import math

   2: def area(radio):

   3: temporal = math.pi * radio**2

   4: return 

   5: temporal

Ya hemos visto antes la sentencia return, pero en una funcion productiva la sentencia return incluye un valor de retorno. Esta sentencia quiere decir “retorna inmediatamente de la funcion y usa la siguiente expresion como valor de retorno”. La expresion dada puede ser arbitrariamente complicada; así pues, podríamos haber escrito esta funcion mas concisamente:

   1: def area(radio):

   2:     return math.pi * radio**2

Por otra parte, las variables temporales como temporal suelen hacer mas fácil el depurado.

A veces es útil disponer de varias sentencias de retorno, una en cada rama de una condición:

   1: def valorAbsoluto(x):

   2:     if x < 0:

   3:         return -x

   4:     else:

   5:         return x

Puesto que estas sentencias return estan en una condicion alternativa, solo se ejecutara una de ellas. En cuanto se ejecuta una de ellas, la funcion termina sin ejecutar ninguna de las sentencias siguientes.

El codigo que aparece despues de una sentencia return o en cualquier otro lugar donde el flujo de ejecucion no pueda llegar, recibe el nombre de codigo muerto.

En una funcion productiva es una buena idea asegurarse de que cualquier posible recorrido del programa alcanza una sentencia return. Por ejemplo:

   1: def valorAbsoluto(x):

   2:     if x < 0:

   3:         return -x

   4:     elif x > 0:

   5:     return x

Este programa no es correcto porque si resulta que x vale 0, entonces no se cumple ninguna de ambas condiciones y la funcion termina sin alcanzar la sentencia return. En este caso, el valor de retorno es un valor especial llamado None:

   1: >>> print valorAbsoluto(0)

   2: None

Como actividad, escriba una funcion comparar que devuelva 1 si x>y , 0 si x == y , y -1 si x <y .

Llegados a este punto, tendría que poder mirar a funciones Python completas y adivinar que hacen. También, si ha hecho los ejercicios, habrá escrito algunas funcioncillas. Tal como vaya escribiendo funciones mayores puede empezar a experimentar mas dificultades, especialmente con los errores en tiempo de ejecución y los semánticos.

Para lidiar con programas de complejidad creciente, vamos a sugerirle una técnica que llamaremos desarrollo incremental. El objetivo del desarrollo incremental es sustituir largas sesiones de depuración por la adición y prueba de pequeñas porciones de código en cada vez.

Por ejemplo, supongamos que desea encontrar la distancia entre dos puntos, dados por las coordenadas (x1; y1) y (x2; y2). Por el teorema de Pitágoras, podemos escribir la distancia es:

El primer paso es considerar que aspecto tendría una función distancia en Python. En otras palabras, ¿cuales son las entradas (parámetros) y cual es la salida (valor de retorno)?

En este caso, los dos puntos son los parámetros, que podemos representar usando cuatro parámetros. El valor de retorno es la distancia, que es un valor en coma flotante.

Ya podemos escribir un bosquejo de la función:

   1: def distancia(x1, y1, x2, y2):

   2: return 0.0

Obviamente, la funcion no calcula distancias; siempre devuelve cero. Pero es sintacticamente correcta y se ejecutara, lo que signi¯ca que podemos probarla antes de complicarla mas.

Para comprobar la nueva funcion, tenemos que llamarla con valores de ejemplo:

   1: >>> def distancia(x1, y1, x2, y2):

   2: ... return 

   3: 0.0

   4: ...

   5: >>> distancia(1, 2, 4, 6)

   6: 0.0

   7: >>>

Elegimos estos valores de tal forma que la distancia horizontal sea igual a 3 y la distancia vertical sea igual a 4; de esa manera el resultado es 5 (la hipotenusa del triangulo 3-4-5). Cuando se comprueba una funcion, es util saber la respuesta
correcta.

Hasta el momento, hemos comprobado que la funcion es sintacticamente correcta, así que podemos empezar a añadir líneas de codigo. Despues de cada cambio incremental, comprobamos de nuevo la funcion. Si en un momento dado aparece un error, sabremos donde esta exactamente: en la ultima l³nea que hayamos añadido.

El siguiente paso en el calculo es encontrar las diferencias entre x2¡x1 y y2¡y1.

Almacenaremos dichos valores en variables temporales llamadas dx y dy y las imprimiremos.

   1: def distancia(x1, y1, x2, y2):

   2:     dx = x2 - x1

   3:     dy = y2 - y1

   4:     print "dx es", 

   5:     dx

   6:     print "dy es", dy

   7:     return 0.0

Si la funcion funciona, valga la redundancia, las salidas deberían ser 3 y 4. Si es así, sabemos que la funcion recibe correctamente los parametros y realiza correctamente el primer calculo. Si no, solo hay unas pocas líneas que revisar.

Ahora calculamos la suma de los cuadarados de dx y dy:

   1: def distancia(x1, y1, x2, y2):

   2:     dx = x2 - x1

   3:     dy = y2 - y1

   4:     dalcuadrado = 

   5:     dx**2 + dy**2

   6:     print "dalcuadrado es: ", dalcuadrado

   7:     return 0.0

Fíjese en que hemos eliminado las sentencias print que escribimos en el paso anterior. Este codigo se llama andamiaje porque es util para construir el programa pero no es parte del producto final.

De nuevo querremos ejecutar el programa en este estado y comprobar la salida (que debería dar 25).

Por ultimo, si hemos importado el modulo math, podemos usar la funcion sqrt para calcular y devolver el resultado:

   1: def distancia(x1, y1, x2, y2):

   2: dx = x2 - x1

   3: dy = y2 - y1

   4: dalcuadrado = 

   5: dx**2 + dy**2

   6: resultado = math.sqrt(dalcuadrado)

   7: return resultado

Si esto funciona correctamente, ha terminado. Si no, podría ser que quisiera usted imprimir el valor de resultado antes de la sentencia return.

Al principio, deber³a a~nadir solamente una o dos l³neas de codigo cada vez.

Conforme vaya ganando experiencia, puede que se encuentre escribiendo y depurando trozos mayores. Sin embargo, el proceso de desarrollo incremental puede

ahorrarle mucho tiempo de depurado.
Los aspectos fundamentales del proceso son:

1. Comience con un programa que funcione y hagale pequeños cambios in-
crementales. Si hay un error, sabra exactamente donde esta.
2. Use variables temporales para mantener valores intermedios, de tal manera
que pueda mostrarlos por pantalla y comprobarlos.
3. Una vez que el programa este funcionando, tal vez prefiera eliminar parte
del andamiaje o aglutinar multiples sentencias en expresiones compuestas,
pero solo si eso no hace que el programa sea difícil de leer.
Como actividad, utilice el desarrollo incremental para escribir una
funcion de nombre hipotenusa que devuelva la longitud de la hipo-
tenusa de un triangulo rectangulo, dando como parametros los dos
catetos. Registre cada estado del desarrollo incremental segun vaya
avanzando.

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.”