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.