Python 学习笔记（十五）Python类拓展（二）方法

方法

绑定方法和非绑定方法

绑定方法和非绑定方法在创建时没有任何区别，同一方法，既可以为绑定方法，也可以为非绑定方法，一切不同都只在调用时的手法上有所区别。

绑定方法即该方法绑定类的一个实例上，必须将self作为第一个参数传入，而这个过程是由Python自动完成。可以通过实例名.方法名（参数列表）来调用。

非绑定方法因为不绑定到实例上，所以在引用时通过类来进行引用。该过程不是 Python 自动完成，如果忘记传入实例，那么直接调用是肯定会出问题的。所以要调用类的非绑定方法时应该显示地提供一个实例作为第一个参数。使用类名.非绑定方法名(参数列表)的形式来进行引用

>>> class Foo(object):
    def bar(self):
        print "normal class"

        
>>> f =Foo()
>>> f.bar() #实例方法调用，不用显示的传入第一个参数self.
normal class
>>> Foo.bar(f) #类名.方法名 必须传入参数f
normal class
>>> Foo.bar
<unbound method Foo.bar> #非绑定方法的对象
>>> f.bar  #绑定方法
<bound method Foo.bar of <__main__.Foo object at 0x0000000003370B00>>
>>> dir(Foo)#查看类的属性的名称
['__class__', '__delattr__', '__dict__', '__doc__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'bar']
>>> Foo.__dict__ #特殊属性__dict__,作用查看类的属性，是字典形式，key是属性的名称，value相应属性对象的数据值
dict_proxy({'__dict__': <attribute '__dict__' of 'Foo' objects>, '__weakref__': <attribute '__weakref__' of 'Foo' objects>, '__module__': '__main__', 'bar': <function bar at 0x0000000003FC5EB8>, '__doc__': None})
>>> Foo.__dict__['bar'] #查看bar是一个函数对象
<function bar at 0x0000000003FC5EB8>
　　#desr.__get__(self,obj,type=None)

   #get、set、 del有人称为黑魔法，我们叫它描述器

>>> Foo.__dict__['bar'].__get__(None,Foo) #第一个参数self赋值为None，意思是没有给定的实例，非绑定方法
<unbound method Foo.bar> #非绑定方法
>>> f.bar #绑定方法
<bound method Foo.bar of <__main__.Foo object at 0x0000000003370B00>>
>>> Foo.bar  #非绑定方法
<unbound method Foo.bar>
>>> Foo.__dict__['bar'].__get__(f,Foo) #第一个参数self 给定一个实例，绑定方法
<bound method Foo.bar of <__main__.Foo object at 0x0000000003370B00>> 
>>> 
#小结：通过类来获取方法的时候，得到的是非绑定方法对象；通过实例来获取方法的时候，得到的是绑定方法对象

静态方法和类方法

语法上面的区别:

• 静态方法不需要传入self参数，类成员方法需要传入代表本类的cls参数；
• 静态方法是无法访问实例变量和类变量的，类成员方法无法访问实例变量但是可以访问类变量

使用的区别：

由于静态方法无法访问类属性，实例属性，相当于一个相对独立的方法，跟类其实并没有什么关系。这样说来，静态方法就是在类的作用域里的函数而已。

类方法：实例方法类似，不过其第一个参数一般是 cls （约定俗成）而不是 self。但是，如果我们直接将 self 换成 cls 来创建类方法是不对的，因为实例方法的首个参数也是任意的，只是统一使用 self 。python的解释器并没有说看见第一个参数是 cls 就知道这个是类方法，它还是将其当作是实例方法来对待，所以我们需要通过内建函数： classmethod() 来创建类方法。

示例：类方法

#! /usr/bin/env python
#coding:utf-8

class Foo(object):

      one = 0

      def __init__(self): #初始化函数
            Foo.one =Foo.one + 1  #类属性+1

      @classmethod   #创建类方法
      def get_class_attr(cls):#传递一个参数
            return cls.one  #参数对象的属性one


if __name__ =="__main__":
      f1 =Foo()
      print "f1:",Foo.one
      f2 =Foo()
      print "f2:",Foo.one

      print f1.get_class_attr()
      print "f1.one:",f1.one
      print Foo.get_class_attr()

      print "*"*10
      f1.one = 8  #实例one属性
      Foo.one = 9 #类的one属性
      print f1.one
      print f1.get_class_attr()
      print Foo.get_class_attr()


#output
#f1: 1
#f2: 2
#2
#f1.one: 2
#2
#**********
#8
#9
#9
#小结：类方法的定义其实就是在方法前面要写上@classmethod,在定义方法时，跟一般方法一样，参数采用cls,目的是通过cls把类这个对象传入

静态方法

静态方法：就是类中的一个普通函数，它并没有默认传递的参数，在创建静态方法的时候，需要用到内置函数： staticmethod() 。

#! /usr/bin/env python
#coding:utf-8

T =1

class Foo(object):

      def __init__(self,name):
            self.name = name

      @staticmethod
      def check_t():
          T =1
          return T

      def get_name(self):
          if self.check_t():
                return self.name
          else:
                return "no person"

if __name__ == "__main__":

      f = Foo("cc")
      name =f.get_name()
      print name