面向对象property属性、静态方法和类方法

一、property属性

1、什么是property特性？

property是一种特殊的属性，访问它时会执行一段功能（函数）然后返回值。

from math import pi
class Circle:
    def __init__(self,r):
        self.r = r
    @property
    def perimeter(self):
        return 2*pi*self.r
    @property
    def area(self):
        return self.r**2*pi
 
c1 = Circle(5)
print(c1.area)     # 圆的面积
print(c1.perimeter) # 圆的周长

计算圆的面积和周长

class BMI:
    def __init__(self,weight,height):
        self.weight=weight
        self.height=height
    @property
    def bmi(self):
        return self.weight/self.height**2
gaoya=BMI(47,1.60)
print(gaoya.bmi)

计算胖瘦

2、为什么要用property?

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

在python中通过property方法可以实现提供set和get方法（接口）去设置和获取所有的私有数据。

class Foo:
    def __init__(self,val):
        self.__NAME=val #将所有的数据属性都隐藏起来
 
    @property
    def name(self):
        return self.__NAME #obj.name访问的是self.__NAME(这也是真实值的存放位置)
 
    @name.setter
    def name(self,value):
        if not isinstance(value,str):  #在设定值之前进行类型检查
            raise TypeError('%s must be str' %value)
        self.__NAME=value #通过类型检查后,将值value存放到真实的位置self.__NAME
 
    @name.deleter
    def name(self):
        raise TypeError('Can not delete')
 
f=Foo('egon')
print(f.name)
# f.name=10 #抛出异常'TypeError: 10 must be str'
del f.name #抛出异常'TypeError: Can not delete'

一个静态属性property本质就是实现了get，set，delete三种方法。

class Goods:
 
    def __init__(self):
        # 原价
        self.original_price = 100
        # 折扣
        self.discount = 0.8
 
    @property
    def price(self):  #不能穿参数
        # 实际价格 = 原价 * 折扣
        new_price = self.original_price * self.discount
        return new_price
 
    @price.setter
    def price(self, value):  #能传一个参数
        self.original_price = value
 
    @price.deleter
    def price(self):  #不能传参数
        del self.original_price
 
obj = Goods()
obj.price         # 获取商品价格
obj.price = 200   # 修改商品原价
print(obj.price)
del obj.price     # 删除商品原价

注意：set和get 方法使用的前提必须要有property属性；

set可以传一个值，get和property不能传值；

二、classmethod方法

把一个方法，变成一个类中的方法，这个方法就可以直接被类调用，不需要依托任何对象。

当这个方法的操作只涉及静态属性的时候 就应该使用classmethod来装饰这个方法.

class Goods:
    __discount = 0.8
    def __init__(self,name,price):
        self.name = name
        self.__price = price
    @property
    def price(self):
        return self.__price * Goods.__discount
    @classmethod   # 把一个方法 变成一个类中的方法，这个方法就直接可以被类调用，不需要依托任何对象
    def change_discount(cls,new_discount):  # 修改折扣
        cls.__discount = new_discount
apple = Goods('苹果',5)
print(apple.price)
Goods.change_discount(0.5)   # Goods.change_discount(Goods)
print(apple.price)

三、staticmethod方法

在完全面向对象的程序中，如果一个函数 既和对象没有关系 也和类没有关系 那么就用staticmethod将这个函数变成一个静态方法.

class Login:
    def __init__(self,name,password):
        self.name = name
        self.pwd = password
    def login(self):pass
 
    @staticmethod
    def get_usr_pwd():   # 静态方法
        usr = input('用户名 ：')
        pwd = input('密码 ：')
        Login(usr,pwd)
 
Login.get_usr_pwd()

补充：

1、类方法和静态方法，都是类调用的。

2、对象可以调用类方法和静态方法吗？

可以，一般情况下，推荐用类名调用。

3、类方法，有一个默认参数，cls代表这个类。

4、静态方法，没有默认的参数，就像函数一样。