Py003-01-10绑定方法与非绑定方法

绑定方法与非绑定方法

在类内部定义的方法，分为两类

  1. 绑定方法:绑定给谁，就应该由谁来调用，谁来调用就会把调用者当作第一个参数自动传入

    • 绑定到对象的方法：在类内定义的没有被任何装饰器修饰的

      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      class Foo:
          def __init__(self,name):
              self.name = name
          def tell(self):
              print('名字是：%s'%self.name)

      f = Foo('hjx')
      print(Foo.tell)  # <function Foo.tell at 0x0000027D2DE7AEA0>
      Foo.tell(f) # 类可以调用tell方法，需要传递实例对象

      print(f.tell) # <bound method Foo.tell of <__main__.Foo object at 0x00000197433C95C0>>

    • 绑定到类的方法:在类内定义的同时被装饰器classmethod修饰的方法

      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      class Foo:
          def __init__(self,name):
              self.name = name
        
          @classmethod
          def func(cls):
              print(cls)
      f = Foo('hjx')
             
      print(Foo.func) # <bound method Foo.func of <class '__main__.Foo'>>
      Foo.func() # <class '__main__.Foo'>

  2. 非绑定方法：没有自动传值那么一说

    • 非绑定方法：不与类和对象绑定

      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      15
      16
      17
      18
      19
      20
      21
      class Foo:
          def __init__(self,name):
              self.name = name
          
          @staticmethod
          def sum(x,y):
              return x+y

      f = Foo('hjx')

      print(f.sum)
      print(Foo.sum)
      f.sum(1,2)
      Foo.sum(2,5)

      '''
      <function Foo.sum at 0x000002240B6A2378>
      <function Foo.sum at 0x000002240B6A2378>
      3
      7
      '''

使用场景

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
import hashlib
import time
settings = {
    "name":"hjx2",
    "age":28,
    "sex":'man'
}

class People:
    def __init__(self,name,age,sex):
        self.id = self.create_id()
        self.name = name
        self.age = age
        self.sex = sex

    def tellInfo(self): # 绑定到对象的方法
        print('name is %s,age: %s,sex :%s'%(self.name,self.age,self.sex))

    @classmethod
    def from_conf(cls):
        obj = cls(
            settings["name"],
            settings["age"],
            settings["sex"]
        )
        return obj

    @staticmethod
    def create_id():
        m = hashlib.md5(str(time.time()).encode('utf-8'))
        return m.hexdigest()


p = People('hjx',18,'man')

# 绑定给对象，就应该由对象调用，自动将对象本身当第一个参数传入
p.tellInfo()

# 绑定给类，就应该由类来调用，自动将类本身当作第一个参数传入
p2 = People.from_conf()
p2.tellInfo()

# 非绑定方法，不与类和对象绑定，谁都可以调用，没有自动传值一说
p3 = People.from_conf()
print(p3.id)