面对对象-绑定方法与非绑定方法

在类内部定义的函数，分为两大类：
一：绑定方法：绑定给谁，就应该由谁来调用，谁来调用就会把调用者当做第一个参数自动传入
    绑定到对象的方法：在类内定义的没有被任何装饰器来修饰的

    邦定到类的方法：在类内定义的被装饰器classmethod修饰的方法

二：非绑定方法:没有自动传值一说了，就是类中的普通工具
    非绑定方法：不与类或者对象绑定 staticmethon

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

    def tell(self):  # 绑定到对象
        print('名字是 %s'%self.name)

    @classmethod  # 绑定到类（类方法）
    def func(cls):  #cls=F00
        print(cls)

    @staticmethod  #（静态方法）普通函数，类与对象都能用
    def func1(x,y):
        print(x+y)

f=Foo('egon')
f.tell()  # ---> 名字是 egon
Foo.func()

Foo.func1(1,2)
f.func1(2,3)

绑定方法与非绑定方法的应用

　　

import settings
import hashlib
import time
class Pepole:
    def __init__(self,name,age,sex):
        self.id=self.create_id()
        self.name=name
        self.age=age
        self.sex=sex

    def tell_info(self):
        print("Name:%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

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

# p=Pepole('egon',18,'male')
#绑定给对象，就应该由对象来调用，自动将对象本身当做第一个参数传入
# p.tell_info()

#绑定给类，就应该由类来调用，自动将类本身当做第一参数传入
# p=Pepole.from_conf() # 从配置文件中传入的文件
# p.tell_info()
p1=Pepole('egon1',18,'male')
p2=Pepole('egon2',28,'male')
p3=Pepole('egon3',38,'male')

print(p1.id)
print(p2.id)
print(p3.id)