Soy muy nuevo en Python, y estoy usando Python 3.3.1.
class Parent: # define parent class parentAttr = 100 age = 55 def __init__(self): print ("Calling parent constructor") def setAttr(self, attr): Parent.parentAttr = attr class Child(Parent): def childMethod(self): print ('Calling child method')
Ahora voy a crear
c=child c.[here every thing will appear methods and attr (age,setAttr)]
¿Cómo puedo distinguir entre métodos y atributos? Quiero decir, ¿cuándo uso c.SetAtrr(Argument)
y c.SetAtrr=value
?
Los métodos también son atributos. Simplemente resultan ser objetos que se pueden llamar.
Puede detectar si un objeto se puede llamar usando la función callable()
:
>>> def foo(): pass ... >>> callable(foo) True >>> callable(1) False
Cuando llama a un método, busca el atributo (una operación getattr()
) y luego llama al resultado:
c.setAttr(newvalue)
es de dos pasos; encontrar el atributo (que en este caso busca el atributo en la clase y lo trata como un descriptor), luego llama al objeto resultante, un método.
Cuando asigna un atributo, vuelve a vincular ese nombre a un nuevo valor:
c.setAttr = 'something else'
Sería una operación setattr()
.
Si desea interceptar los atributos de obtención y configuración en las instancias de su clase, puede proporcionar los atributos de acceso a los atributos , __getattr__
, __setattr__
y __delattr__
.
Si quisiera agregar un método a una instancia , tendría que tratar la función como un objeto descriptor , que produce un objeto de método:
>>> class Foo: pass ... >>> foo = Foo() # instance >>> def bar(self): pass ... >>> bar >>> bar.__get__(foo, Foo) >
El valor de retorno de la function.__get__()
, cuando se le da una instancia y una clase, es un método enlazado. Al llamar a ese método, se llamará a la función subyacente con self
enlace self
a la instancia.
Y hablando de descriptores, la función property()
devuelve un descriptor, lo que hace posible tener funciones que se comportan como atributos; pueden interceptar las getattr()
, setattr()
y delattr()
para ese atributo y convertirlo en una llamada de función:
>>> class Foo: ... @property ... def bar(self): ... return "Hello World!" ... >>> foo = Foo() >>> foo.bar "Hello World!"
El acceso a .bar
invocó la propiedad de bar
get hook, que luego llama al método de bar
original.
En casi todas las situaciones, no va a necesitar la función callable()
; usted documenta su API y proporciona métodos y atributos, y el usuario de su API lo resolverá sin probar todos y cada uno de los atributos para ver si es invocable. Con las propiedades, tiene la flexibilidad de proporcionar atributos que son realmente reclamables en cualquier caso.