【Python笔记】属性@property，零基础

私有成员

• 1.作用：无需向类外提供的成员，可以通过私有化进行屏蔽。
• 2.做法：命名使用双下划线开头。
• 3.本质：障眼法，实际也可以访问。 私有成员的名称被修改为：_类名__成员名，可以通过_dict_属性或dir函数查看。
  类的私有属性
• __private_attrs：两个下划线开头，声明该属性为私有，不能在类的外部被使用或直接访问。在类内部的方法中使用时 self.__private_attrs。

属性@property

公开的实例变量，缺少逻辑验证。私有的实例变量与两个公开的方法相结合，又使调用者的操作略显复杂。而属性可以将两个方法的使用方式像操作变量一样方便。
　　1.定义：
　　　 　　 @property
　  　　　　 def name(self):
      　　　　　　 return self.__name

                    @name.setter
　　　  　　 def name(self, name):
       　　　　　　 self.__name = name
2.调用：
　        　　对象.属性名 = 数据
　        　　变量 = 对象.属性名
3.说明：
　– 通常两个公开的属性，保护一个私有的变量。
　– @property 负责读取，@属性名.setter 负责写入
　– 只写：属性名= property(None, 写入方法名)

格式：

属性

class D:
    def __init__(self,name):
        # 写入操作
        self.name = name

    # 拦截读取操作
    # 本质:创建property对象,name 存储对象地址.
    # 注意: 创建对象时,会指定读取方法
    # 相当于: name  = property(读取方法,None)
    @property
    def name(self):
        # 逻辑判断
        return self.__name

    # 拦截写入操作
    @name.setter  # 本质:name.setter(写入方法)
    def name(self,value):
        # 逻辑判断
        self.__name = value


d01 = D("张三")
d01.name = "老三"  # 写入操作
print(d01.name) # 读取操作

只读属性

class E:
    def __init__(self, a):
        self.__a = a

    # 拦截读取操作
    @property
    def a(self):
        # 逻辑判断
        return self.__a


e01 = E(100)
# e01.a = 10 # 错误
print(e01.a)

属性本质

class F:
    def __init__(self,a):
        # 写入操作
        self.a = a

    def get_a(self):
        print("读取变量喽")
        return self.__a

    def set_a(self, value):
        print("设置变量喽")
        self.__a = value

    # 拦截对变量a的读写操作
    # 创建property对象,a存储的是对象地址.
    # 注意:创建对象时,需要传递读写方法
    a = property(get_a,set_a)


f01 = F(10)
f01.a = 200 # 写入
print(f01.a) # 读取

只写属性

class G:
    def __init__(self,a):
        # 写入操作
        self.a = a

    def set_a(self, value):
        print("设置变量喽")
        self.__a = value

    # 拦截对变量a的写入操作
    a = property(None,set_a)


g01 = G(100)
g01.a = 200
# print(g01.a) # 错误
print(g01._G__a)

实例

class Wife:
    def __init__(self, name, age):
        self.name = name
        # 缺点：缺乏对象数据的封装，外界可以随意赋值．
        self.age = age


w01 = Wife("丫头", 24)
w02 = Wife("晓蒂", 86)
w02.age = 25

封装私有化后：

class Wife:
    def __init__(self, name="", age=0):
        self.name = name  # 调用 @name.setter 修饰的方法
        # 私有成员：障眼法(解释器会改变双下划线开头的变量名)
        self.age = age  # 调用 @age.setter 修饰的方法

    @property  # 拦截读取变量的操作
    def name(self):  # get_name()
        return self.__name

    @name.setter  # 拦截写入变量的操作
    def name(self, value):  # set_name()
        self.__name = value

    @property
    def age(self):
        return self.__age

    @age.setter
    def age(self, value):
        if 20 <= value <= 30:
            self.__age = value
        else:
            self.__age = 0
            print("我不要")


w01 = Wife("丫头", 24)
# 找不到双下划线开头的数据
# print(w01.__age)
# 通过下划线　＋　类名 可以访问双下划线开头的数据
# print(w01._Wife02__age)
print(w01.name)
print(w01.age)

纯属个人的Python笔记，恳请各位大佬的批评指正.喜欢的记着点赞评论。