什么是method？
function就是可以通过名字可以调用的一段代码,我们可以传参数进去，得到返回值。所有的参数都是明确的传递过去的。
method是function与对象的结合。我们调用一个方法的时候，有些参数是隐含的传递过去的。下文会详细介绍。
instancemethod
in [5]: class human(object):
…: def __init__(self, weight):
…: self.weight = weight
…: def get_weight(self):
…: return self.weight
…:
in [6]: human.get_weight
out[6]:
这告诉我们get_weight是一个没有被绑定方法，什么叫做未绑定呢？继续看下去。
in [7]: human.get_weight()
—————————————————————————
typeerror traceback (most recent call last)
/home/yao/learn/insight_python/ in ()
—-> 1 human.get_weight()
typeerror: unbound method get_weight() must be called with human instance as first argument (got nothing instead)
未绑定的方法必须使用一个human实例作为第一个参数来调用啊。那我们来试试
in [10]: human.get_weight(human(45))
out[10]: 45
果然成功了，但是一般情况下我们习惯这么使用。
in [11]: person = human(45)
in [12]: person.get_weight()
out[12]: 45
这两种方式的结果一模一样。我们看下官方文档是怎么解释这种现象的。
when an instance attribute is referenced that isn’t a data attribute, its class is searched.
if the name denotes a valid class attribute that is a function object, a method object is
created by packing (pointers to) the instance object and the function object just found together
in an abstract object: this is the method object. when the method object is called with an
argument list, a new argument list is constructed from the instance object and the argument list,
and the function object is called with this new argument list.
原来我们常用的调用方法(person.get_weight())是把调用的实例隐藏的作为一个参数self传递过去了, self 只是一个普通的参数名称,不是关键字。
in [13]: person.get_weight
out[13]:
in [14]: person
out[14]:
我们看到get_weight被绑定在了 person 这个实例对象上。
总结下
instance method 就是实例对象与函数的结合。
使用类调用，第一个参数明确的传递过去一个实例。
使用实例调用，调用的实例被作为第一个参数被隐含的传递过去。
classmethod
in [1]: class human(object):
…: weight = 12
…: @classmethod
…: def get_weight(cls):
…: return cls.weight
in [2]: human.get_weight
out[2]:
我们看到get_weight是一个绑定在 human 这个类上的method。调用下看看
in [3]: human.get_weight()
out[3]: 12
in [4]: human().get_weight()
out[4]: 12
类和类的实例都能调用 get_weight 而且调用结果完全一样。
我们看到 weight 是属于 human 类的属性，当然也是 human 的实例的属性。那传递过去的参数 cls 是类还是实例呢？
in [1]: class human(object):
…: weight = 12
…: @classmethod
…: def get_weight(cls):
…: print cls
in [2]: human.get_weight()
in [3]: human().get_weight()
我们看到传递过去的都是 human 类,不是 human 的实例，两种方式调用的结果没有任何区别。cls 只是一个普通的函数参数，调用时被隐含的传递过去。
总结起来
classmethod 是类对象与函数的结合。
可以使用类和类的实例调用，但是都是将类作为隐含参数传递过去。
使用类来调用 classmethod 可以避免将类实例化的开销。
staticmethod
in [1]: class human(object):
…: @staticmethod
…: def add(a, b):
…: return a + b
…: def get_weight(self):
…: return self.add(1, 2)
in [2]: human.add
out[2]:
in [3]: human().add
out[3]:
in [4]: human.add(1, 2)
out[4]: 3
in [5]: human().add(1, 2)
out[5]: 3
我们看到 add 在无论是类还是实例上都只是一个普通的函数，并没有绑定在任何一个特定的类或者实例上。可以使用类或者类的实例调用，并且没有任何隐含参数的传入。
in [6]: human().add is human().add
out[6]: true
in [7]: human().get_weight is human().get_weight
out[7]: false
add 在两个实例上也是同一个对象。instancemethod 就不一样了，每次都会创建一个新的 get_weight 对象。
总结下
当一个函数逻辑上属于一个类又不依赖与类的属性的时候，可以使用 staticmethod。
使用 staticmethod 可以避免每次使用的时都会创建一个对象的开销。
staticmethod 可以使用类和类的实例调用。但是不依赖于类和类的实例的状态。