Diferencia entre llamar a un método y acceder a un atributo

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.