Day 5-5 绑定方法与非绑定方法

绑定方法与非绑定方法:

在类内部定义的绑定方法,分两大类:

classmehtod是给类用的，即绑定到类，类在使用时会将类本身当做参数传给类方法的第一个参数（即便是对象来调用也会将类当作第一个参数传入），python为我们内置了函数classmethod来把类中的函数定义成类方法

 1 #!_*_ coding:utf-8 _*_
 2 
 3 #类中绑定方法分两种:绑定给谁,就由谁来调用.默认就把调用者当作第一个参数传进去.
 4 
 5 #1.绑定到对象的方法:没有被任何装饰器修饰的方法.
 6 class F:
 7     def __init__(self, name, age):
 8         self.name = name
 9         self.age = age
10 
11     def tell(self):
12         print("name is %s " % self.name)
13 #__init__ 和tell方法都是对象p的绑定方法
14 
15 
16 p = F("JACK", 18)
17 print(p.tell)   # <bound method F.tell of <__main__.F object at 0x0044F9B0>>是一个绑定到F的方法.
18 
19 
20 
21 
22 #2.绑定到类的方法:用classmethod装饰器修饰的方法.
23 class F:
24     def __init__(self, name, age):
25         self.name = name
26         self.age = age
27 
28     def tell(self):
29         print("name is %s " % self.name)
30 
31     @classmethod
32     def func(cls):
33         print("from cls bound")
34 
35 p = F("JACK", 18)
36 
37 print(F.func) # <bound method F.func of <class '__main__.F'>> 绑定到类的方法.
38 
39 
40 #非绑定方法:
41 
42 class F:
43     def __init__(self, name, age):
44         self.name = name
45         self.age = age
46 
47     def tell(self):
48         print("name is %s " % self.name)
49 
50     @classmethod
51     def func(cls):
52         print("from cls bound")
53 
54     @staticmethod    # 加了这个装饰器,就变成了一个类中的普通工具(函数),对象和类都可以调用
55     def func1(x,y):
56         print(x * y)
57 
58 
59 
60 p = F("JACK", 18)
61 
62 p.func1(5,7)
63 F.func1(9,8)  # 类和对象都可以调用.正常传参数.
64 
65 
66 
67 
68 class F:
69     def __init__(self, name, age):
70         self.name = name
71         self.age = age
72 
73     def tell(self):
74         print("name is %s " % self.name)
75 
76     @classmethod
77     def func(cls):
78         print("from cls bound")
79 
80     @staticmethod    # 加了这个装饰器,就变成了一个类中的普通工具(函数),对象和类都可以调用
81     def func1(x,y):
82         return  x * y
83 
84 
85 
86 p = F("JACK", 18)
87 
88 print(p.func1(5,7))
89 print(F.func1(9,8))

1.凡是类中的方法和函数，都是绑定给对象使用的；

2.绑定方法都有自动传值的功能。传递进去的值，就是对象本身。

3.如果类想调用绑定方法，就必须遵循函数的参数规则，有几个参数，就必须传递几个参数。

应用场景:

#!_*_ coding:utf-8 _*_
import settings
import time
import hashlib
class People:
    def __init__(self, name, age, sex):
        self.id = self.creat_id()  #类调用了这个非绑定方法.
        self.name = name
        self.age = age
        self.sex = sex

    def tell_info(self):  # 绑定到对象的方法
        print("Name is %s Aage is %s Sex is %s,ID is %s." % (self.name,self.age,self.sex, self.id) )


    @classmethod
    def from_settings(cls):  # 绑定到类的方法
        obj = cls(
            settings.name,
            settings.age,
            settings.sex
        )
        return obj
    @staticmethod
    def creat_id():  # 非绑定方法,谁都可以调用
        time.sleep(0.00000000000000001) # 加了细微的延时,不然生成的ID都一样
        m = hashlib.md5()
        m.update(bytes(str(time.time()),encoding="utf-8"))
        return m.hexdigest()




p = People("Lu", 20 ,"女")
p.tell_info()  # 绑定给对象,就由对象来调用,把对象作为第一个参数传进去
p = People.from_settings() # 绑定给类,由类来调用,把类作为第一个参数传进去.
p.tell_info()

p1 = People("Lucy", 18 ,"女")
p2 = People("Lili", 22 ,"女")
p3 = People("Luma", 38 ,"女")
print(p1.id)
print(p2.id)
print(p3.id)