Python綁定方法，未綁定方法，類方法，實例方法，靜態方法

>>> class foo():
    clssvar=[1,2] def __init__(self): self.instance=[1,2,3]  def hehe(self): print 'haha' >>> foo.hehe <unbound method foo.hehe> >>> a=foo() >>> a.hehe <bound method foo.hehe of <__main__.foo instance at 0x01D60468>>

>>> foo.hehe()

Traceback (most recent call last):
File "<pyshell#35>", line 1, in <module>
foo.hehe()
TypeError: unbound method hehe() must be called with foo instance as first argument (got nothing instead)

非綁定方法必須被實例調用

class foo():
    foovar=1
    def __init__(self):
        self.avar=3
    def method(self):
        methodvar=2
        print 'hello',methodvar
class foo1(foo):
    foo1var=4
    def __init__(self,nm):
        foo.__init__(self)
        #調用非綁定方法——父類構造器
        self.fooo=self.avar
        print self.fooo
    def method(self):
        pass
a=foo1(2)
#1.這是我根據Python核心編程上的例子寫的，我們要弄清楚一點：類里面的方法就是非綁定方法，實例里面的方法就是綁定的。
#2.既然上面說非綁定方法只能被實例調用，那么我們是如何調用一個類的非綁定方法的呢？實際上用類不能調用非綁定方法，無非是沒有給
self參數，那么我們給它就是。

>>> foo.hehe(a)
haha

#self=a
同樣的道理，調用父類構造器給子類用，那么直接給self（就是子類對象）就可以啦！
# 我們一般都是通過實例來調用，但也可以使用類來調用，比如上面通過調用父類的構造器可以避免子類調用時需要大量參數傳遞的情況

#coding=utf-8
class A(object):
    count=1
    def foo(self,x):
    #類實例方法
        print "executing foo(%s,%s)"%(self,x)
    def foo2(self):
        self.foo(5)
        foo2var=self.count
    @classmethod
    def class_foo(cls):
    #類方法
        cls.count=cls.count+1

    @staticmethod
    def static_foo(x):
    #靜態方法
        x+=1.1
        print "executing static_foo(%s)"%x,id(x)
a=A()
b=A()
a.class_foo()
print a.count,b.count,A.count
b.class_foo()
print a.count,b.count,A.count
A.class_foo()
print a.count,b.count,A.count
打印結果
2 2 2
3 3 3
4 4 4

#可以看看我前一篇博文。一個類數據屬性，只有通過類來調用時才會改變，通過實例來改變實際上不會對類產生影響。但是如果通過類方法來改，那么即便是實例調用也能改變類數據屬性，這我覺得是很危險的。
#一般其它編程語言都會不允許實例調用類方法，比如Java，這樣做的好處就是你能很輕松的利用類方法修改類屬性。但Python允許實例調用類方法，但請不要這么做！

靜態方法

#coding=utf-8
class A(object):
    count=1
    def foo(self,x):
    #類實例方法
        print "executing foo(%s,%s)"%(self,x)
    def foo2(self):
        self.foo(5)
        foo2var=self.count
    @classmethod
    def class_foo(cls):
    #類方法
        cls.count=cls.count+1

    @staticmethod
    def static_foo(self,x):
    #靜態方法
        x+=1.1
        self.count=3
        print "executing static_foo(%s)"%x,id(x)
a=A()
b=A()
a.static_foo(a,2)
print a.count,b.count,A.count
b.static_foo(b,3)
print a.count,b.count,A.count
A.static_foo(A,4)
print a.count,b.count,A.count
輸出結果
executing static_foo(3.1) 20196512
3 1 1
executing static_foo(4.1) 20196512
3 3 1
executing static_foo(5.1) 20196512
3 3 3

#一般靜態方法不要求你寫self，但你可以這么干，同類數據屬性的性質一樣，類的靜態方法修改會影響實例，實例卻只影響自身
#id(x)告訴我們靜態方法里的變量同樣是靜態的。