Cesar Systems

en agosto 15, 2012

El significado de la palabra “mismo” parece totalmente claro hasta que uno se para un poco a pensarlo, y entonces se da cuenta de que hay algo mas de lo que suponía.

Por ejemplo, si dice “Pepe y yo tenemos la misma moto”, lo que quiere decir es que su moto y la de usted son de la misma marca y modelo, pero que son dos motos distintas. Si dice “Pepe y yo tenemos la misma madre”, quiere decir que su madre y la de usted son la misma persona1. Así que la idea de “identidad” es diferente según el contexto.

Cuando habla de objetos, hay una ambigüedad parecida. Por ejemplo, si dos

Puntos son el mismo, ¿significa que contienen los mismos datos (coordenadas) o que son de verdad el mismo objeto?

Para averiguar si dos referencias se refieren al mismo objeto, utilice el operador ==. Por ejemplo:

>>> p1 = Punto()
>>> p1.x = 3
>>> p1.y = 4
>>> p2 = Punto()
>>> p2.x = 3
>>> p2.y = 4
>>> p1 == p2
0

Aunque p1 y p2 contienen las mismas coordenadas, no son el mismo objeto. Si asignamos p1 a p2, las dos variables son alias del mismo objeto:

>>> p2 = p1
>>> p1 == p2
1

Este tipo de igualdad se llama igualdad superficial porque solo compara las referencias, pero no el contenido de los objetos.

Para comparar los contenidos de los objetos (igualdad profunda) podemos escribir una función llamada mismoPunto:

   1: def mismoPunto(p1, p2) :
   2: return (p1.x == p2.x) and (p1.y == p2.y)

1No todas las lenguas tienen el mismo problema. Por ejemplo, el alemán tiene palabras
diferentes para los diferentes tipos de identidad. “Misma moto” en este contexto sería “gleiche
Motorrad” y “misma madre” sería “selbe Mutter”.

12.5. Rectángulos

en agosto 15, 2012

Digamos que queremos una clase que represente un rectangulo. La pregunta es, ¿que información tenemos que proporcionar para definir un rectangulo?

Para simplificar las cosas, supongamos que el rectangulo esta orientado vertical u horizontalmente, nunca en diagonal.

Tenemos varias posibilidades: podemos señalar el centro del rectangulo (dos coordenadas) y su tamaño (anchura y altura); o podemos señalar una de las esquinas y el tamaño; o podemos señalar dos esquinas opuestas. Un modo convencional es señalar la esquina superior izquierda del rectangulo y el tamaño.

De nuevo, definiremos una nueva clase:

   1: class Rectangulo: # Prohibidos los acentos fuera de las cadenas!
   2: pass

Y la instanciaremos:

caja = Rectangulo()
caja.anchura = 100.0
caja.altura = 200.0

Este código crea un nuevo objeto Rectangulo con dos atributos en coma flotante. ¡Para señalar la esquina superior izquierda podemos incrustar un objeto dentro de otro!

caja.esquina = Punto()
caja.esquina.x = 0.0;
caja.esquina.y = 0.0;

El operador punto compone. La expresión caja.esquina.x significa “ve al objeto al que se re¯ere caja y selecciona el atributo llamado esquina; entonces ve a ese objeto y selecciona el atributo llamado x”.

La figura muestra el estado de este objeto:

12.6. Instancias como valores de retorno

Las funciones pueden devolver instancias. Por ejemplo, encuentraCentro acepta un Rectangulo como argumento y devuelve un Punto que contiene las coordenadas del centro del Rectangulo:

def encuentraCentro(caja):
    p = Punto()
    p.x = caja.esquina.x + caja.anchura/2.0
    p.y = caja.esquina.y + caja.altura/2.0
    return p

Para llamar a esta función, pase caja como argumento y asigne el resultado a una variable:

>>> centro = encuentraCentro(caja)
>>> imprimePunto(centro)
(50.0, 100.0)

12.7. Los objetos son mudables

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:

def agrandaRect(caja, danchura, daltura) :
    caja.anchura = caja.anchura + danchura
    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:

>>> bob = Rectangulo()
>>> bob.anchura = 100.0
>>> bob.altura = 200.0
>>> bob.esquina = Punto()
>>> bob.esquina.x = 0.0;
>>> bob.esquina.y = 0.0;
>>> 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.

12.8. Copiado

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:

>>> import copy
>>> p1 = Punto()
>>> p1.x = 3
>>> p1.y = 4
>>> p2 = copy.copy(p1)
>>> p1 == p2
0
>>> mismoPunto(p1, p2)
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:

def agrandaRect(caja, danchura, daltura) :
    import copy
    nuevaCaja = copy.deepcopy(caja)
    nuevaCaja.anchura = nuevaCaja.anchura + danchura
    nuevaCaja.altura = nuevaCaja.altura + daltura
    return nuevaCaja

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

12.9. Glosario

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.

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:

hora = Hora()
hora.horas = 11
hora.minutos = 59
hora.segundos = 30

El diagrama de estado del objeto Hora es así:

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