Métodos especiales avanzados de las Clases en Python

Más métodos especiales.

__repr__(self):

Es un método especial que se invoca cuando llamamos a “repr(instancia)” y busca emular la funcionalidad de la función interna repr(), para devolver la representación textual de nuestro objeto.

Podemos definir nuestro método especial __repr__ en nuestra clase “Clientes” así:

def __repr__(self): return repr(self.data)

__len__(self):

Es un método especial que se invoca cuando llamamos a “len(instancia)” y busca emular la funcionalidad de la función interna len(). Funciona sobre cualquier objeto del que se pueda pensar razonablemente que tiene longitud. La función len() de una “cadena” es su número de caracteres; len() para un “diccionario” es su número de claves; len() de una lista o tupla es su número de elementos. Para instancias de clases; defina el método __len__ y programe usted mismo el cálculo de la longitud, y luego llame a len(instancia) para que Python invoque a su método especial __len__. P. e. para nuetra clase “Clientes” podemos crear nuestro método especial __len__ así:

def __len__(self): return len(self.data)

__cmp__(self, other):

Es un método que se invoca cuando realizamos operaciones de comparación con una instancias de una clase y busca emular la funcionalidad de la función interna cmp(). La función interna cmp(x,y), retorna 1 si x>y, retorna -1 si x<y, y retorna 0 si x==y. Hay reglas que definen cuándo se consideran iguales dos tipos de datos incorporados; por ejemplo, los diccionarios son iguales cuando tienen todas las mismas claves y valores, y las cadenas son iguales cuando tienen la misma longitud y contienen la misma secuencia de caracteres. Para instancias de clases, podemos definir el método __cmp__ y programar la lógica de la comparación nosotros mismos, y entonces puede usar == para comparar instancias de sus clases y Python invocará a su método especial __cmp__ por usted.

>>> class Clientes:
... def __init__(self, dict=None):
... self.data = {}
... if dict is not None:
... self.update(dict)
... def update(self, dict=None): self.data.update(dict)
... def __len__(self): return len(self.data)
... def __cmp__(self, dict):
... return cmp(self.data, dict)
>>>
>>> c = Clientes({'nombre':'Jorge', 'apellidos':'Toro', 'nit':'100244235', 'cargo':'aseador', 'telefono':None})
>>> len(c)
5
>>>
>>> d = {1:'uno', 2:'dos', 3:'tres'}
>>> len(d)
3
>>> cmp('124', '33')
-1
>>> d == c
False
>>> c > d
True
>>> c < d
False
>>> cmp(c, d)
1
>>> b = Clientes({'nombre':'Jorge', 'apellidos':'Toro', 'nit':'100244235', 'cargo':'aseador', 'telefono':None})
>>> cmp(c, b)
0
>>> f = {1:'uno', 2:'dos', 3:'tres', 4:'cuatro', 5:'cinco'}
>>> cmp(c,f)
1
>>> h = {'nombre':'Jorge', 'apellidos':'Toro', 'nit':'100244235', 'cargo':'aseador', 'telefono':None}
>>> cmp(c,h)
0
>>> j = {'nombre':'Ferz', 'apellidos':'Benitez', 'nit':934034, 'cargo':None, 'telefono':None}
>>> cmp(c,j)
1
>>> v = {'n':'Jorge', 'a':'Toro', 'n':'100244235', 'c':'aseador', 't':None}
>>> cmp(c,v)
1
>>>

Qué pasa si no tenemos definido el método especial __cmp__ y realizamos comparaciones con los operadores de “comparación”.

>>> class Clientes:
... def __init__(self, dict=None):
... self.data = {}
... if dict is not None: self.update(dict)
... def update(self, dict=None): self.data.update(dict)
... def __len__(self): return len(self.data)
... 
>>> c = Clientes({'nombre':'Jorge', 'apellidos':'Toro', 'nit':'100244235', 'cargo':'aseador', 'telefono':None})
>>> len(c)
5
>>> d = {1:'uno', 2:'dos', 3:'tres'}
>>> len(d)
3
>>> d == c # Esto siempre es False.
False
>>> c == {'nombre':'Jorge', 'apellidos':'Toro', 'nit':'100244235', 'cargo':'aseador', 'telefono':None}
False
>>> d > c # Esto debe ser False!!.
True
>>> len(d) > len(c)
False
>>> c > d # Esto debe ser True!!.
False
>>>

__delitem__:

Es un método especial que se invoca cuado llamamos a “del instancia[key]” y que busca emular la función interna “del”. Cuando se usa del contra una instancia de clase, Python invocará al método especial __delitem__. para nuestra clase “Clientes” podemos crear nuestro método especial __delitem__ así:

def __delitem__(self, key): del self.data[key]

Los métodos especiales implican que cualquier clase puede almacenar pares clave/valor como un diccionario. Cualquier clase puede actuar como una secuencia, simplemente definiendo el método __getitem__. Cualquier clase que defina el método __cmp__ puede compararse con ==. Y si su clase representa algo que tenga una longitud, no defina un método GetLength; defina el método __len__ y use len(instancia).

 

Para ver el resto de Métodos especiales con que cuenta Python revisar la documentación: http://docs.python.org/reference/datamodel.html#specialnames

Algunos apartes fueron tomados de Dive Into Python.

 

Autor: Jolth

Anuncios

Responder

Introduce tus datos o haz clic en un icono para iniciar sesión:

Logo de WordPress.com

Estás comentando usando tu cuenta de WordPress.com. Cerrar sesión / Cambiar )

Imagen de Twitter

Estás comentando usando tu cuenta de Twitter. Cerrar sesión / Cambiar )

Foto de Facebook

Estás comentando usando tu cuenta de Facebook. Cerrar sesión / Cambiar )

Google+ photo

Estás comentando usando tu cuenta de Google+. Cerrar sesión / Cambiar )

Conectando a %s