面向对象————封装的特性（property）

什么是特性property
property是一种特殊的属性，访问它时会执行一段功能（函数）然后返回值
BMI指数（bmi是计算而来的，但很明显它听起来像一个属性而非方法，如果我们将其做成一个属性，更便于理解）
成人的BMI数值：
过轻：低于18.5
正常：18.8-23.9
过重：24-27
肥胖：28-32
非常肥胖：高于32
      体质指数（BMI）=体重（kg）/身高^2（m）
      70（kg）/（1.75*1.75）=22.86

class People
    def __init__(self,name,weight,height)
         self.name=name
         self.weight=weight
         self.height=height

     @property      #为bmi这个函数添加装饰器，将其伪装成一个数据属性
     def bmi(self):
          return self.weight/(self.height*height)

egon=People('egon',75,1.80)
print(egon.bmi)       #23.148148148148145

为什么要用property
将一个类的函数定义成特性以后，调用egon.bmi本质就是触发函数bmi的执行，从而拿到其的返回值

多态
多态指的是一类事物有多种形态
动物有多种形态：人，狗，猪

class Animal:
     def eat(self):
          pass

     def drink(self):
          pass

     def run(self):
          pass

     def bark(self):
          pass

class Cat(Animal):
    def bark(self):
        print('喵喵喵')

class Dog(Animal):
    def bark(self):
        print('汪汪汪')

class Pig(Animal):
    def bark(self):
        print('哼哼哼')

c=Cat() 
d=Dog() 
p=Pig() 
多态性：可以在不用考虑对象具体类型的前提下而直接使用对象下的方法
c.bark()   #喵喵喵
d.bark()   #汪汪汪
p.bark()   #哼哼哼

 

强制子类遵循父类的标准：导入ABC，用上装饰器@abc  #abstract class      #抽象类

import abc  
class Animal(metaclass=abc.ABCMeta):   #代表把Animal的属性改了，让它变成了抽象基类
    @abc.abstractmethod
    def eat(self):
        pass

    @abc.abstractmethod
    def drink(self):
        pass

    @abc.abstractmethod
    def run(self):
        pass

    @abc.abstractmethod
    def bark(self):
        pass

class Cat(Animal):
    def jiao(self):
        print('喵喵喵')

class Dog(Animal):
    def speak(self):
        print('汪汪汪')

class Pig(Animal):
    def han(self):
        print('哼哼哼')

c=Cat     #报错     #不能用抽象方法实例化抽象类猫：吠、喝、吃、跑

以下：

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()   #哼哼哼

 

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

import srttings         #导入配置文件

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 cle(settings.NAME,settings.AGE)

p1=people('alex',18)
p1.tell()        #alex:18

p2=People.from_conf()
p2.tell()        #从配置文件取出数据   #gao:18

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'%(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)      #30fcf512a7097504c212f4eda4bab29a egon 18

obj.tell()           #30fcf512a7097504c212f4eda4bab29a: egon：18

print(obj.create_id())       #5138e199a8e3708957dac3f19942f5e7
print(People.create_id())    #2db27a6a674703445c453b849cb1758c