Python面向对象

property

property是一个装饰器函数，可以将一个方法伪装成属性，调用的时候可以不用加()。@property被装饰的方法，是不能传参数的，因为它伪装成属性了。

装饰器的使用：在要装饰的函数、方法、类上面一行加上 @装饰器名字

装饰器的分类：

　　装饰函数
　　装饰方法：property
　　装饰类

例一：BMI指数（bmi是计算而来的，但很明显它听起来像是一个属性而非方法，如果我们将其做成一个属性，更便于理解）

成人的BMI数值：

过轻：低于18.5

正常：18.5-23.9

过重：24-27

肥胖：28-32

非常肥胖, 高于32

　　体质指数（BMI）=体重（kg）÷身高^2（m）

　　EX：70kg÷（1.75×1.75）=22.86

查看我的BMI

class Person(object):
    def __init__(self,name,weight,height):
        self.name = name
        self.__weight = weight
        self.__height = height

    @property
    def bmi(self):
        return self.__weight / self.__height **2

p = Person('xiao',65,1.75)
print(p.bmi)                                        # 21.224489795918366
print(Person.__dict__)　　　　　　　　　　　　　　　　　　　
print(p.__dict__)　　　　　　　　　　　　　　　　　　　　　　# 在对象里面，并没有被当成属性

'''
执行输出：
21.224489795918366
{'__module__': '__main__', '__init__': <function Person.__init__ at 0x000002221B1EC048>, 'bmi': <property object at 0x000002221B1E8C78>, '__dict__': <attribute '__dict__' of 'Person' objects>, '__weakref__': <attribute '__weakref__' of 'Person' objects>, '__doc__': None}

{'name': 'xiao', '_Person__weight': 65, '_Person__height': 1.75}
'''

被property装饰的bmi仍然是一个方法,存在Person.__dict__。对象的.__dict__中不会存储这个属性.

下面的代码，也可以实现上面的效果

class Person(object):
    def __init__(self,name,weight,height):
        self.name = name
        self.__weight = weight
        self.__height = height
        #self.bmi = self.__weight / self.__height **2
        #self.bmi = cal_BMI()　 

# 但是计算的逻辑，不能放到init里面。初始化，不要做计算

举例：

class Person(object):
    def __init__(self,name,weight,height):
        self.name = name
        self.__weight = weight
        self.__height = height
        self.bmi = self.__weight / self.__height **2

p = Person('xiao',65,1.75)
print(p.bmi)
p._Person__weight = 70                                  # 1周之后,增加体重
print(p.bmi)

'''
执行输出：
21.224489795918366
21.224489795918366
'''

执行结果是一样的，体重增加了，但是bmi指数没有变动。因为__init__初始化之后，就不会再变动了。

在__init__里面，属性名不能和方法名重复

class Person(object):
    def __init__(self,name,weight,height,bmi):
        self.name = name
        self.__weight = weight
        self.__height = height
        self.bmi = bmi

    def bmi(self):
        return self.__weight / self.__height **2

a = Person('xiao',65,1.75)
print(a.bmi())                      # TypeError: __init__() missing 1 required positional argument: 'bmi'

那么bmi是否可以修改呢?

class Person(object):
    def __init__(self,name,weight,height):
        self.name = name
        self.__weight = weight
        self.__height = height

    @property
    def bmi(self):
        return self.__weight / self.__height **2

p = Person('xiao',65,1.75)
p.bmi = 2    # AttributeError: can't set attribute

但是它的name属性是可以改变的。

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

p = Person('Tony')
print(p.name)           # Tony
p.name = 'John'
p.name = 123

那么上面这2个例子，和直接定义name属性有什么区别？

class Person:
    def __init__(self,name):
        self.__name = name  # 私有的属性

    @property
    def name(self):
        return self.__name

    def set_name(self,new_name):
        if type(new_name) is str:
            self.__name = new_name

        else:    # 通过if判断，就可以保护属性的类型，必须是字符串
            print('您提供的姓名数据类型不合法')

p = Person('Tony')
print(p.name)
p.set_name('John')
print(p.name)
p.set_name(123)

'''
执行输出：
Tony
John
您提供的姓名数据类型不合法
'''

@property可以将python定义的函数“当做”属性访问，有时候setter/deleter也是需要的。

只有@property表示只读。
同时有@property和@x.setter表示可读可写。
同时有@property和@x.setter和@x.deleter表示可读可写可删除。

新式类中具有三种访问方式，分别将三个方法定义为对同一个属性：获取、修改、删除

class Foo:
    @property
    def AAA(self):
        print('get的时候运行我啊')

    @AAA.setter
    def AAA(self,value):
        print('set的时候运行我啊')

    @AAA.deleter
    def AAA(self):
        print('delete的时候运行我啊')

#只有在属性AAA定义property后才能定义AAA.setter,AAA.deleter
f1=Foo()
f1.AAA
f1.AAA='aaa'
del f1.AAA

'''
执行输出：
get的时候运行我啊
set的时候运行我啊
delete的时候运行我啊
'''

或者：

class Foo:
    def get_AAA(self):
        print('get的时候运行我啊')

    def set_AAA(self,value):
        print('set的时候运行我啊')

    def delete_AAA(self):
        print('delete的时候运行我啊')
    AAA=property(get_AAA,set_AAA,delete_AAA)        # 内置property三个参数与get,set,delete一一对应

f1=Foo()
f1.AAA
f1.AAA='aaa'
del f1.AAA

'''
执行输出：
get的时候运行我啊
set的时候运行我啊
delete的时候运行我啊
'''

商品实例

class Goods(object):

    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, value):
        del self.original_price

obj = Goods()
print(obj.price)    # 获取商品价格 80.0

obj.price = 200     # 修改商品原价
print(obj.price)    # 获取商品价格 160.0

# del obj.price     # 删除商品原价 TypeError: price() missing 1 required positional argument: 'value'

class Person:
    def __init__(self,name):
        self.__name = name      # 私有的属性

    @property
    def name(self):
        return self.__name

    @name.setter
    def name(self,new_name):
        print('---',new_name)

p = Person('Tony')
p.name = 'John'                 # 修改name属性

'''
执行输出：
--- John
'''

上面的代码，3个name必须是相同的。三位一体。@name.settet有且并只有一个参数

class Person:
    def __init__(self,name):
        self.__name = name  # 私有的属性

    @property
    def name(self):
        return self.__name

    @name.setter
    def name(self,new_name):
        print('---',new_name)

p = Person('Tony')
print(p.name)

p.name = 'John'     # 修改name属性
print(p.name)

'''
执行输出：
Tony
--- John
Tony
'''

从结果上来看，并没有改变Tony的值那么如何改变呢？看下面的代码

class Person:
    def __init__(self,name):
        self.__name = name                  # 私有的属性

    @property
    def name(self):
        return self.__name

    @name.setter
    def name(self,new_name):
        self.__name = new_name              # 更改__name属性

p = Person('Tony')
print(p.name)

p.name = 'John'     # 修改name属性
print(p.name)

'''
执行输出：
Tony
John
'''

但是这样，不能保证修改的数据类型是固定的

class Person:
    def __init__(self,name):
        self.__name = name  # 私有的属性

    @property
    def name(self):
        return self.__name

    @name.setter
    def name(self,new_name):
        if type(new_name) is str:
            self.__name = new_name

        else:
            print('您提供的姓名数据类型不合法')

p = Person('Tony')
print(p.name)

p.name = 'John'     # 修改name属性
print(p.name)

p.name = 123        # 不合法
print(p.name)

'''
执行输出：
Tony
John
您提供的姓名数据类型不合法
John
'''

非法类型，不允许修改，这样就可以保护属性的类型

方法伪装成的属性删除操作

class Person:
    def __init__(self,name):
        self.__name = name  # 私有的属性

    @property
    def name(self):
        return self.__name

p = Person('alex')
print(p.name)
del p.name    # AttributeError: can't delete attribute

# 为什么不能删除？因为name被@property伪装了，此时name是只读的。

那么如何删除呢？看下面的代码

class Person:
    def __init__(self,name):
        self.__name = name  # 私有的属性

    @property
    def name(self):
        return self.__name

    @name.deleter
    def name(self):
        del self.__name

p = Person('Tony')
print(p.name)

del p.name
print(p.__dict__)  # 查看属性

'''
执行输出：
Tony
{}
'''

p对象返回的是空字典，说明删除成功了！

3个装饰器的重要程度

@property****
@name.setter ***
@name.deleter *

再讲一个列子：商品的折扣我想看折后价

class Goods:
    def __init__(self,name,origin_price,discount):
        self.name = name
        self.__price = origin_price                 # 原价
        self.__discount = discount                  # 折扣价

    @property
    def price(self):
        return self.__price * self.__discount

apple = Goods('apple',5,0.8)
print(apple.price)                          # 4.0

修改苹果的原价

class Goods:
    def __init__(self,name,origin_price,discount):
        self.name = name
        self.__price = origin_price  # 原价
        self.__discount = discount  # 折扣价

    @property
    def price(self):  # 价格
        return self.__price * self.__discount

    @price.setter
    def price(self,new_price):
        if type(new_price) is int or type(new_price) is float:
            self.__price = new_price

apple = Goods('apple',5,0.8)
print(apple.price)              # 4.0

apple.price = 8                 # # 修改苹果的原价
print(apple.price)              # 6.4

被property装饰的方法，不能修改，只能查看

圆形类，有半径，面积，周长。要求：将方法伪装成属性，方法中一般涉及的都是一些计算过程

from math import pi
class Circle:  # 圆形
    def __init__(self, r):
        self.r = r

    @property
    def area(self):  # 面积
        return pi * self.r ** 2

    @property
    def perimeter(self):  # 周长
        return pi * self.r * 2

c = Circle(10)
print(c.area)
print(c.perimeter)

c.r =15                 # 修改半径
print(c.area)
print(c.perimeter)

'''
执行输出：
314.1592653589793
62.83185307179586
706.8583470577034
94.24777960769379
'''

总结：

@property --> func 将方法伪装成属性，只观看的事儿
@func.setter --> func 对伪装的属性进行赋值的时候调用, 一般情况下用来做修改
@func.deleter --> func 在执行del 对象.func的时候调用,一般情况下用来做删除.基本不用

property的作用：

将一些需要随着一部分属性的变化而变化的值的计算过程从方法伪装成属性
将私有的属性保护起来，让修改的部分增加一些约束，来提高程序的稳定性和数据的安全性

在一个类加载的过程中，会先加载这个类的名字，包括被property装饰的。

在实例化对象的时候，python解释器会先到类的空间里看看有没有这个被装饰的属性，如果有就不能再在自己对象的空间中创建这个属性了

巴特西

Python面向对象 | 类属性

property

最新文章

热门文章