Python面向对象 | 类属性

Posted summer-skr--blog

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了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面向对象 | 类属性的主要内容,如果未能解决你的问题,请参考以下文章

Python-面向对象(组合封装与多态)

Python面向对象:继承多态类属性和类方法单例

Python面向对象:继承多态类属性和类方法单例

Python面向对象基础

python面向对象的成员属性等

python之面向对象