类的 propert，classmethod，ataticmethod 方法 与 多态

一 、property

        将一个类的函数定义成特性以后，对象再去使用的时候obj.name,根本无法察觉自己的name是执行了一个函数
        然后计算出来的，这种特性的使用方式遵循了统一访问的原则

        egon.bmi背后对应的是一个函数，所以不能赋值
            class People:
                def __init__(self,name):
                    self.__name=name

                @property
                def name(self): #obj.name
                    print('您现在访问的是用户名。。。')
                    return self.__name

                @name.setter #obj.name='EGON'
                def name(self,x):
                    # print('=================',x)
                    if type(x) is not str:
                        raise TypeError('名字必须是str类型，傻叉')
                    self.__name=x

                @name.deleter
                def name(self):
                    # print('就不让你删')
                    del self.__name

            obj=People('egon')

            print(obj.name)
            print(obj.name())

            print(obj.name)

            obj.name='EGON'

            print(obj.name)

            obj.name=123

            del obj.name
            obj.name

二、多态
        多态指的是同一种事物多种形态
    2、为什要用多态
        用基类创建一套统一的规则，强制子类去遵循（使用抽象类实现），这样便可以
        在不用考虑对象具体类型的前提下而直接使用对象下的方法

    3、如何用多态
         多态性：可以在不用考虑对象具体类型的前提下而直接使用对象下的方法
        class Cat(Animal):
            def eat(self):
                print('cat eat')

            def drink(self):
                print('cat drink')

            def run(self):
                print('cat run')

            def bark(self):
                print('喵喵喵')

        class Dog(Animal):
            def eat(self):
                print('dog eat')

            def drink(self):
                print('dog drink')

            def run(self):
                print('dog run')

            def bark(self):
                print('汪汪汪')

        class Pig(Animal):
            def eat(self):
                print('pig eat')

            def drink(self):
                print('pig drink')

            def run(self):
                print('pig run')

            def bark(self):
                print('哼哼哼')

        c=Cat()
        d=Dog()
        p=Pig()

        c.bark()
        d.bark()
        p.bark()

    注意：
      抽象基类本身不能被实例化

三、绑定方法与非绑定方法

        1 绑定方法：
            在类内部定义的函数，默认就是给对象来用，而且是绑定给对象用的,称为对象的绑定方法
            绑定对象的方法特殊之处：
                应该由对象来调用，对象来调用，会自动将对象当作第一个参数传入

            绑定到类的方法特殊之处：
                应该由类来调用，类来调用，会自动将类当作第一个参数传入

            import settings

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

                def tell(self):
                    print('%s：%s' %(self.name,self.age))

                @classmethod
                def from_conf(cls):
                    return cls(settings.NAME,settings.AGE)

            p=People('egon',19)

            print(People.from_conf)
            p4=People.from_conf(People)
            print(People.from_conf)
            p4=People.from_conf()
            p4.tell()

        2、staticmethod:非绑定方法，就是一个普通函数
        #特性：既不跟类绑定，也不跟对象绑定，这意味着谁都能用
        #谁来用都是一个普通函数，也就是说没有自动传值的特性了
            import settings
            import hashlib
            import time

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

                def tell(self):
                    print('%s: %s：%s' %(self.uid,self.name,self.age))

                @classmethod
                def from_conf(cls):
                    return cls(settings.NAME,settings.AGE)

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

            obj=People('egon',18)
            print(obj.uid,obj.name,obj.age)
            obj.tell()

            print(obj.create_id)
            print(People.create_id)

            print(obj.create_id())
            print(People.create_id())