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

1、property属性

一、什么是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)

计算胖瘦

二、为何要用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不能传值；

2、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)

3、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()

补充：

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

二、对象能够调用类方法和静态方法吗？

      能够，通常状况下，推荐用类名调用。

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

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