Mes: agosto 2012 Página 12 de 22
Una vez utilizados algunos de los tipos internos de Python, estamos listos para crear un tipo definido por el usuario: el Punto.
Piense en el concepto de un punto matemático. En dos dimensiones, un punto es dos números (coordenadas) que se tratan colectivamente como un solo objeto.
En notación matemática, los puntos suelen escribirse entre paréntesis con una coma separando las coordenadas. Por ejemplo, (0,0) representa el origen, y (x,y) representa el punto x unidades a la derecha e y unidades hacia arriba desde el origen.
Una forma natural de representar un punto en Python es con dos valores en coma flotante. La cuestión es, entonces, como agrupar esos dos valores en un objeto compuesto. La solución rápida y burda es utilizar una lista o tupla, y para algunas aplicaciones esa podr³a ser la mejor opción.
Una alternativa es que el usuario defina un nuevo tipo compuesto, también llamado una clase. Esta aproximación exige un poco mas de esfuerzo, pero tiene sus ventajas que pronto se harán evidentes.
Una definición de clase se parece a esto:
1: class Punto:
2: pass
Las definiciones de clase pueden aparecer en cualquier lugar de un programa,
pero normalmente están al principio (tras las sentencias import). Las reglas sintácticas de la definición de clases son las mismas que para cualesquiera otras sentencias compuestas. (ver la Sección 4.4).
Esta definición crea una nueva clase llamada Punto. La sentencia pass no tiene efectos; solo es necesaria porque una sentencia compuesta debe tener algo en su cuerpo.
Al crear la clase Punto hemos creado un nuevo tipo, que también se llama Punto.
Los miembros de este tipo se llaman instancias del tipo u objetos. La creacion de una nueva instancia se llama instanciación. Para instanciar un objeto Punto ejecutamos una función que se llama (lo ha adivinado) Punto:
1: blanco = Punto()
A la variable blanco se le asigna una referencia a un nuevo objeto Punto. A una función como Punto que crea un objeto nuevo se le llama constructor.
Podemos añadir nuevos datos a una instancia utilizando la notación de punto:
1: >>> blanco.x = 3.0
2: >>> blanco.y = 4.0
Esta sintaxis es similar a la sintaxis para seleccionar una variable de un modulo, como math.pi o string.uppercase. En este caso, sin embargo, estamos seleccionando un dato de una instancia. Estos ítems con nombre se llaman atributos.
El diagrama de estados que sigue muestra el resultado de esas asignaciones:
La variable blanco apunta a un objeto Punto, que contiene dos atributos. Cada atributo apunta a un numero en coma flotante.
Podemos leer el valor de un atributo utilizando la misma sintaxis:
1: >>> print blanco.y
2: 4.0
3: >>> x = blanco.x
4: >>> print x
5: 3.0
La expresión blanco.x significa, “ve al objeto al que apunta blanco y toma el valor de x”. En este caso, asignamos ese valor a una variable llamada x. No hay conflicto entre la variable x y el atributo x. El propósito de la notación de punto es identificar de forma inequívoca a que variable se refiere.
Puede usted usar la notación de punto como parte de cualquier expresión. Así, las sentencias que siguen son correctas:
1: print '(' + str(blanco.x) + ', ' + str(blanco.y) + ')'
2: distanciaAlCuadrado = blanco.x * blanco.x + blanco.y * blanco.y
La primera línea presenta (3.0, 4.0); la segunda línea calcula el valor 25.0.
Puede tentarle imprimir el propio valor de blanco:
1: >>> print blanco
2:
El resultado indica que blanco es una instancia de la clase Punto que se definió en __main__. 80f8e70 es el identificador único de este objeto, escrito en hexadecimal. Probablemente no es esta la manera mas clara de mostrar un objeto Punto.
En breve vera como cambiarlo.
Como ejercicio, cree e imprima un objeto Punto y luego use id pa-
ra imprimir el identificador único del objeto. Traduzca el numero
hexadecimal a decimal y asegúrese de que coinciden.
Puede usted pasar una instancia como parámetro de la forma habitual. Por ejemplo:
1: def imprimePunto(p):
2: print '(' + str(p.x) + ', ' + str(p.y) + ')'
imprimePunto acepta un punto como argumento y lo muestra en formato estándar. Si llama a imprimePunto(blanco), el resultado es (3.0, 4.0).
Como ejercicio, reescriba la función distancia de la Sección 5.2 de
forma que acepte dos Puntos como parámetros en lugar de cuatro
números.
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:
1: >>> p1 = Punto()
2: >>> p1.x = 3
3: >>> p1.y = 4
4: >>> p2 = Punto()
5: >>> p2.x = 3
6: >>> p2.y = 4
7: >>> p1 == p2
8: 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:
1: >>> p2 = p1
2: >>> p1 == p2
3: 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”.
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:
1: caja = Rectangulo()
2: caja.anchura = 100.0
3: 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!
1: caja.esquina = Punto()
2: caja.esquina.x = 0.0;
3: 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:
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:
1: def encuentraCentro(caja):
2: p = Punto()
3: p.x = caja.esquina.x + caja.anchura/2.0
4: p.y = caja.esquina.y + caja.altura/2.0
5: return p
Para llamar a esta función, pase caja como argumento y asigne el resultado a una variable:
1: >>> centro = encuentraCentro(caja)
2: >>> imprimePunto(centro)
3: (50.0, 100.0)
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.