Cesar Systems

Podemos cambiar el estado de un objeto efectuando una asignación sobre uno de sus atributos. Por ejemplo, para cambiar el tamaño de un rectangulo sin cambiar su posición, podemos cambiar los valores de anchura y altura:

   1: caja.anchura = caja.anchura + 50

   2: caja.altura = caja.altura + 100

Podemos encapsular este código en un metodo y generalizarlo para agrandar el rectangulo en cualquier cantidad:

   1: def agrandaRect(caja, danchura, daltura) :

   2:     caja.anchura = caja.anchura + danchura

   3:     caja.altura = caja.altura + daltura

Las variables danchura y daltura indican cuanto debe agrandarse el rectangulo en cada dirección. Invocar este método tiene el efecto de modificar el Rectangulo que se pasa como argumento.
Por ejemplo, podemos crear un nuevo Rectangulo llamado bob y pasárselo a agrandaRect:

   1: >>> bob = Rectangulo()

   2: >>> bob.anchura = 100.0

   3: >>> bob.altura = 200.0

   4: >>> bob.esquina = Punto()

   5: >>> bob.esquina.x = 0.0;

   6: >>> bob.esquina.y = 0.0;

   7: >>> agrandaRect(bob, 50, 100)

Mientras agrandaRect se esta ejecutando, el parámetro caja es un alias de bob.

Cualquier cambio que haga a caja afectara también a bob.

A modo de ejercicio, escriba una función llamada mueveRect que
tome un Rectangulo y dos parámetros llamados dx y dy. Tiene que
cambiar la posición del rectangulo añadiendo dx a la coordenada x
de esquina y añadiendo dy a la coordenada y de esquina.

El uso de alias puede hacer que un programa sea difícil de leer, porque los cambios hechos en un lugar pueden tener efectos inesperados en otro lugar. Es difícil estar al tanto de todas las variables a las que puede apuntar un objeto
dado.

Copiar un objeto es, muchas veces, una alternativa a la creación de un alias. El modulo copy contiene una función llamada copy que puede duplicar cualquier
objeto:

   1: >>> import copy

   2: >>> p1 = Punto()

   3: >>> p1.x = 3

   4: >>> p1.y = 4

   5: >>> p2 = copy.copy(p1)

   6: >>> p1 == p2

   7: 0

   8: >>> mismoPunto(p1, p2)

   9: 1

Una vez que hemos importado el modulo copy, podemos usar el metodo copy para hacer un nuevo Punto. p1 y p2 no son el mismo punto, pero contienen los mismos datos.

Para copiar un objeto simple como un Punto, que no contiene objetos incrustados, copy es suficiente. Esto se llama copiado superficial.

Para algo como un Rectangulo, que contiene una referencia a un Punto, copy no lo hace del todo bien. Copia la referencia al objeto Punto, de modo que tanto el Rectangulo viejo como el nuevo apuntan a un único Punto.

Si creamos una caja, b1, de la forma habitual y entonces hacemos una copia, b2, usando copy, el diagrama de estados resultante se ve así:

Es casi seguro que esto no es lo que queremos. En este caso, la invocación de agrandaRect sobre uno de los Rectángulos no afectaría al otro, ¡pero la invocación de mueveRect sobre cualquiera afectaría a ambos! Este comportamiento es confuso y propicia los errores.

Afortunadamente, el modulo copy contiene un metodo llamado deepcopy que copia no solo el objeto sino también cualesquiera objetos incrustados. No le sorprenderá saber que esta operación se llama copia profunda (deep copy).

   1: >>> b2 = copy.deepcopy(b1)

Ahora b1 y b2 son objetos totalmente independientes.

Podemos usar deepcopy para reescribir agrandaRect de modo que en lugar de modificar un Rectangulo existente, cree un nuevo Rectangulo que tiene la misma localización que el viejo pero nuevas dimensiones:

   1: def agrandaRect(caja, danchura, daltura) :

   2:     import copy

   3:     nuevaCaja = copy.deepcopy(caja)

   4:     nuevaCaja.anchura = nuevaCaja.anchura + danchura

   5:     nuevaCaja.altura = nuevaCaja.altura + daltura

   6:     return nuevaCaja

Como ejercicio, rescriba mueveRect de modo que cree y devuelva un nuevo Rectangulo en lugar de modificar el viejo.

clase: Un tipo compuesto definido por el usuario. También se puede pensar en una clase como una plantilla para los objetos que son instancias de la misma.

instanciar: Crear una instancia de una clase.

instancia: Un objeto que pertenece a una clase.

objeto: Un tipo de dato compuesto que suele usarse para representar una cosa o concepto del mundo real.

constructor: Un metodo usado para crear nuevos objetos.

atributo: Uno de los elementos de datos con nombre que constituyen una instancia.

igualdad superficial: Igualdad de referencias, o dos referencias que apuntan al mismo objeto.

igualdad profunda: Igualdad de valores, o dos referencias que apuntan a objetos que tienen el mismo valor.

copia superficial: Copiar el contenido de un objeto, incluyendo cualquier referencia a objetos incrustados; implementada por la función copy del modulo copy.

copia profunda: Copiar el contenido de un objeto así como cualesquiera objetos incrustados, y los incrustados en estos, y así sucesivamente; implementada por la función deepcopy del modulo copy.

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

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.

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.

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.

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.

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.