Herramientas Informaticas

Mes: agosto 2012 Página 13 de 22

Capítulo 13

Clases y funciones

13.1. Hora

Como otro ejemplo de un tipo definido por el usuario, definiremos una clase llamada Hora que registra la hora del día. La definición de la clase es como sigue:

   1: class Hora:

   2: pass

Podemos crear un nuevo objeto Hora y asignar atributos para contener las horas, minutos y segundos:

   1: hora = Hora()

   2: hora.horas = 11

   3: hora.minutos = 59

   4: hora.segundos = 30

El diagrama de estado del objeto Hora es así:

Sin título

A modo de ejercicio, escriba una función imprimeHora que acepte un objeto Hora como argumento y lo imprima en el formato horas:minutos:segundos.

Como un segundo ejercicio, escriba una función booleana después que tome dos objetos Hora, t1 y t2, como argumentos y devuelva verdadero (1) si t1 sigue cronológicamente a t2 y falso (0) en caso contrario.

13.2. Funciones puras

En las próximas secciones, escribiremos dos versiones de una función llamada sumaHora que calcule la suma de dos Horas. Mostraran dos tipos de funciones: funciones puras y modificadores.

Este es un esbozo de sumaHora:

   1: def sumaHora(t1, t2):

   2:     suma = Hora()

   3:     suma.horas = t1.horas + t2.horas

   4:     suma.minutos = t1.minutos + t2.minutos

   5:     suma.segundos = t1.segundos + t2.segundos

   6:     return suma

La función crea un nuevo objeto Hora, inicializa sus atributos y devuelve una referencia al nuevo objeto. A esto se le llama función pura porque no modifica ninguno de los objetos que se le pasan y no tiene efectos laterales, como mostrar un valor o tomar una entrada del usuario.

Aquí tiene un ejemplo de como usar esta función. Crearemos dos objetos Hora: horaActual, que contiene la hora actual, y horaPan, que contiene la cantidad de tiempo que necesita un panadero para hacer pan. Luego usaremos sumaHora
para averiguar cuando estará hecho el pan. Si aun no ha terminado de escribir imprimeHora, eche un vistazo a la Sección 14.2 antes de probar esto:

   1: >>> horaActual = Hora()

   2: >>> horaActual.horas = 9

   3: >>> horaActual.minutos = 14

   4: >>> horaActual.segundos = 30

   5: >>> horaPan = Hora()

   6: >>> horaPan.horas = 3

   7: >>> horaPan.minutos = 35

   8: >>> horaPan.segundos = 0

   9: >>> horaHecho = sumaHora(horaActual, horaPan)

  10: >>> imprimeHora(horaHecho)

La salida de este programa es 12:49:30, lo que es correcto. Por otra parte, hay casos en los que el resultado no es correcto. ¿Puede imaginar uno?

El problema es que esta función no trata los casos en los que el numero de segundos o minutos suma mas que sesenta.

Cuando ocurre eso, debemos “llevar” los segundos sobrantes a la columna de los minutos o los minutos extras a la columna de las horas.

He aquí una versión corregida de la función:

 

   1: def sumaHora(t1, t2):

   2:     suma = Hora()

   3:     suma.horas = t1.horas + t2.horas

   4:     suma.minutos = t1.minutos + t2.minutos

   5:     suma.segundos = t1.segundos + t2.segundos

   6:         if suma.segundos >= 60:

   7:         suma.segundos = suma.segundos - 60

   8:         suma.minutos = suma.minutos + 1

   9:         if suma.minutos >= 60:

  10:         suma.minutos = suma.minutos - 60

  11:         suma.horas = suma.horas + 1

  12:     return suma

Aunque esta función es correcta, empieza a ser grande. Mas adelante sugeriremos una aproximación alternativa que nos dará un código mas corto.

 

 

13.3. Modificadores

Hay veces en las que es útil que una función modifique uno o mas de los objetos que recibe como parámetros.

Normalmente, el llamante conserva una referencia a los objetos que pasa, así que cualquier cambio que la función haga será visible para el llamante. Las funciones que trabajan así se llaman modificadores.

incremento, que añade un numero dado de segundos a un objeto Hora, se escribiría de forma natural como un modificador. Un esbozo rápido de la función podría ser este:

   1: def incremento(hora, segundos):

   2:     hora.segundos = hora.segundos + segundos

   3:     if hora.segundos >= 60:

   4:         hora.segundos = hora.segundos - 60

   5:         hora.minutos = hora.minutos + 1

   6:     if hora.minutos >= 60:

   7:         hora.minutos = hora.minutos - 60

   8:         hora.horas = hroa.horas + 1

La primera l³nea realiza la operación básica, las restantes tratan con los casos especiales que vimos antes.

¿Es correcta esta función?

¿Que ocurre si el parámetro segundos es mucho mayor que sesenta? En tal caso, no es suficiente con acarrear una vez; debemos seguir haciéndolo hasta que segundos sea menor que sesenta. Una solución es sustituir las sentencias if por sentencias while:

   1: def incremento(hora, segundos):

   2:     hora.segundos = hora.segundos + segundos

   3:     while hora.segundos >= 60:

   4:         hora.segundos = hora.segundos - 60

   5:         hora.minutos = hora.minutos + 1

   6:     while hora.minutos >= 60:

   7:         hora.minutos = hora.minutos - 60

   8:         hora.horas = hora.horas + 1

Ahora esta función es correcta, pero no es la solución mas eficiente.

Como ejercicio, reescriba esta función de modo que no contenga tantos bucles.

Como un segundo ejercicio, reescriba incremento como una funcion pura, y escriba una función que llame a ambas versiones.

13.4. ¿Qué es mejor?

Todo lo que se pueda hacer con modificadores puede hacerse también con funciones puras. En realidad, algunos lenguajes de programación solo permiten funciones puras. Hay ciertas evidencias de que los programas que usan funciones puras son mas rápidos de desarrollar y menos propensos a los errores que los programas que usan modificadores.

Sin embargo, a veces los modificadores son útiles, y en algunos casos los programas funcionales son menos eficientes.

En general, recomendamos que escriba funciones puras siempre que sea razonable hacerlo así y recurra a los modificadores solo si hay una ventaja convincente.

Este enfoque podría llamarse estilo funcional de programación.

13.5. Desarrollo de prototipos frente a planificación

En este capítulo mostramos una aproximación al desarrollo de programas a la que llamamos desarrollo de prototipos. En cada caso, escribimos un esbozo basto (o prototipo) que realizaba el calculo básico y luego lo probamos sobre unos cuantos casos, corrigiendo los fallos tal como los encontrábamos.

Aunque este enfoque puede ser efectivo, puede conducirnos a código que es innecesariamente complicado, ya que trata con muchos casos especiales, y poco fiable, porque es difícil saber si encontró todos los errores.

Una alternativa es el desarrollo planificado, en el que una comprensión del problema en profundidad puede hacer la programación mucho mas fácil. En este caso, el enfoque es que un objeto Hora es en realidad un numero de tres dígitos
en base 60! El componente segundo es la “columna de unidades”, el componente
es la columna de las sesentas” y el componente hora es la columna de las tresmilseiscentenas“.

Cuando escribimos sumaHora e incremento, en realidad estábamos haciendo una suma en base 60, que es por lo que debíamos acarrear de una columna a la siguiente.

Esta observación sugiere otro enfoque para el problema. Podemos convertir un objeto Hora en un simple numero y sacar provecho del hecho de que la maquina sabe la aritmética necesaria. La siguiente función convierte un objeto Hora en un entero:

   1: def convierteASegundos(t):

   2: minutos = t.horas * 60 + t.minutos

   3: segundos = minutos * 60 + t.segundos

   4: return segundos

 

Ahora, solo necesitamos una forma de convertir un entero en un objeto Hora:

 

   1: def haceHora(segundos):

   2:     hora = Hora()

   3:     hora.horas = segundos/3600

   4:     segundos = segundos - hora.horas * 3600

   5:     hora.minutos = segundos/60

   6:     segundos = segundos - hora.minutos * 60

   7:     hora.segundos = segundos

   8:     return hora

Puede que tenga usted que pensar un poco para convencerse de que esta técnica para convertir de una base a otra es correcta. Suponiendo que esta usted convencido, puede usar estas funciones para reescribir sumaHora:

   1: def sumaHora(t1, t2):

   2: segundos = convierteASegundos(t1) + convierteASegundos(t2)

   3: return haceHora(segundos)

Esta versión es mucho mas corta que la original, y es mucho mas fácil de demostrar que es correcta (suponiendo, como es habitual, que las funciones a las que llama son correctas).

Como ejercicio, reescriba incremento de la misma forma.

13.6. Generalización

De algún modo, convertir de base 60 a base 10 y de vuelta es mas difícil que simplemente manejarse con las horas. La conversión de base es mas abstracta; nuestra intuición para tratar con las horas es mejor.

Pero si tenemos la comprensión para tratar las horas como números en base 60, y hacer la inversión de escribir las funciones de conversión (convierteASegundos y haceHora), obtenemos un programa que es mas corto, mas fácil de leer y
depurar y mas fiable.

También es mas fácil añadir funcionalidades mas tarde. Por ejemplo, imagine restar dos Horas para hallar el intervalo entre ellas. La aproximación ingenua sería implementar la resta con acarreo. Con el uso de las funciones de conversión será mas fácil y con mayor probabilidad, correcto.

Irónicamente, a veces hacer un problema mas complejo (o mas general) lo hace mas fácil (porque hay menos casos especiales y menos oportunidades de error).

13.7. Algoritmos

Cuando escribe una solución general para una clase de problemas, en contraste con una solución específica a un problema concreto, ha escrito un algoritmo.

Mencionamos esta palabra antes pero no la definimos con precisión. No es fácil de definir, así que probaremos un par de enfoques.

Primero, piense en algo que no es un algoritmo. Cuando usted aprendió a multiplicar números de una cifra, probablemente memorizo la tabla de multiplicar.

En efecto, memorizo 100 soluciones específicas. Ese tipo de conocimiento no es algorítmico.

Pero si usted era “haragán” probablemente hizo trampa aprendiendo algunos trucos.
Por ejemplo, para encontrar el producto de n por 9, puede escribir n-1 como el primer dígito y 10 – n como el segundo dígito. Este truco es una solución general para multiplicar cualquier numero de una cifra por 9.  ¡Eso es un algoritmo!

De forma similar, las tecnicas que aprendió para la suma y la resta con acarreo y la división larga son todas algoritmos. Una de las características de los algoritmos es que no requieren inteligencia para llevarse a cabo. Son procesos mecánicos en los que cada paso sigue al anterior de acuerdo a un conjunto simple de reglas.

En nuestra opinión, es un poco vergonzoso que los humanos pasen tanto tiempo en la escuela aprendiendo a ejecutar algoritmos que, de forma bastante similar, no exigen inteligencia.

Por otra parte, el proceso de diseñar algoritmos es interesante, un desafío intelectual y una parte primordial de lo que llamamos programar.

Algunas de las cosas que la gente hace naturalmente, sin dificultad ni pensamiento consciente, son las mas difíciles de expresar algorítmicamente. Entender el lenguaje natural es un buen ejemplo. Todos lo hacemos, pero hasta el momento nadie ha sido capaz de explicar como lo hacemos, al menos no en la forma de un algoritmo.

Nomas te vengo avisar

Nomas te vengo avisar, que no puedo venir a verte
y que un mañana quizás, yo sufra por no tenerte.
Te vengo a pedir perdón, perdón porque yo me alejo
Por causas tal vez ajenas, y que me marcan esta condena.

TE QUIERO TANTO Y TENGO MIEDO,
DE QUE ME OLVIDES POR QUE NO PUEDO
VENIR A VERTE COMO QUEDAMOS,
POR QUE MAÑANA MARCHAR ME DEBO.

Te vengo a pedir perdón, perdón porque yo me alejo
Por causas tal vez ajenas, y que me marcan esta condena.

TE QUIERO TANTO Y TENGO MIEDO,
DE QUE ME OLVIDES POR QUE NO PUEDO
VENIR A VERTE COMO QUEDAMOS,
POR QUE MAÑANA MARCHAR ME DEBO.

TE QUIERO TANTO Y TENGO MIEDO,
DE QUE ME OLVIDES POR QUE NO PUEDO
VENIR A VERTE COMO QUEDAMOS,
POR QUE MAÑANA MARCHAR ME DEBO.

 

Página 13 de 22

Creado con WordPress & Tema de Anders Norén