Python面向对象4：属性、成员修饰符

1、属性：

+@property的函数，具有属性，可以直接取值。属性具有方法的写作形式，同时具有字段的访问形式，访问时不需要加()。

案例1：不加属性的调用普通方法，需要方法+()

class pager:
    def __init__(self,totalcnt):
        self.totalcnt=totalcnt

    def allpage(self):#普通方法#10个一分页
        a1,a2=divmod(self.totalcnt,10)
        if a2==0:
            return a1
        else:
            t=a1+1
        return str(t)
#创建对象并执行
obj=pager(95)
print('调用普通字段，总页数：',obj.totalcnt)
print('调用普通方法，分页数：',obj.allpage())#方法+()

执行结果：

案例2:加属性的调用，只需要方法即可，不需要()

class pager:
    def __init__(self,totalcnt):
        self.totalcnt=totalcnt

    @property  # 加属性
    def allpage(self):
        a1,a2=divmod(self.totalcnt,10)
        if a2==0:
            return a1
        else:
            t=a1+1
        return str(t)
#创建对象并执行
obj=pager(95)
print('调用普通字段，总页数：',obj.totalcnt)
print('调用属性的方式，分页数：',obj.allpage)#此处无方法+()

执行结果：

案例3：如果要更改赋值，比如设置新的数，或者执行删除方法，需要使用其他的装饰器。

• 函数名+setter，重新设置新的值

• 函数名+deleter，可以设置成删除方法，并不一定是真的删除，也可以伪造成其他的方法
  

class pager:
    def __init__(self,totalcnt):
        self.totalcnt=totalcnt

    @property # 加属性，取值
    def all_pager(self):#10个一分页
        a1,a2=divmod(self.totalcnt,10)
        if a2==0:
            return a1
        else:
            return a1+1
   @all_pager.setter#重新设置新的值，格式为原方法+setter
    def all_pager(self,value):
        print("重新设置")

    @all_pager.deleter #删除，格式为原方法+deleter
    def all_pager(self):
        print("del value")

#实例化
obj=pager(95)
print('-------使用属性直接取值---------')
print(obj.all_pager)#此处无方法+()
print('-------设置新的值---------')
obj.totalcnt=113#修改一下值，使用allpage.setter
print(obj.all_pager)#打印新的值
print('-------可以删除，也可以伪造成其他的形式，比如打印---------')
del obj.all_pager

执行结果：

2、成员修饰符

成员修饰符，公有的、私有的。私有的只能在内部访问，外部无法访问。

类成员有：字段、方法、属性；

案例1：公有字段的访问途径：一是直接打印字段，一是通过方法。

class c1:
    def __init__(self,name):
        self.name=name
    def f1(self):
        print(self.name)

obj=c1('hh')
print('途径1,直接打印name：',obj.name)
print('途径22，通过方法实现打印name')
obj.f1()

执行结果：

案例2:创建类中的私有动态字段；

• 字段前加两个下划线，比如__XXX，表示的是私有类型(private)的变量；

• 访问时，只能通过方法访问

• 私有字段只能允许这个类本身进行访问, 连子类也不可以。

class foo:
    def __init__(self,value):
        self.__value=value#私有字段

    def f1(self):#10个一分页
        print(self.__value)
#定义对象
obj=foo(95)
#访问私有字段
obj.f1()#可以通过方法调用

• 但不能像公有字段一样，通过print(obj.value)访问

• 如果实在想强制访问，也可用print(obj._foo__value)，类名前面死一个下划线，字段名前是俩下划线，下划线为英文状态的。

• 即使继承也无法访问，比如obj.f2()是不能访问下面的例子的

class foo:
    def __init__(self,value):
        self.__value=value

    def f1(self):#10个一分页
        print(self.__value)
class bar(foo):#集成foo类，
    def f2(self):
        print(self.__value)#无法继承foo的私有字段
obj=bar(95)#创建对象
obj.f1()#可以通过方法调用，而不能通过obj.f2()访问

案例3：创建类中的私有静态字段。

• 可以通过对象的方法访问

class foo:
    __coo="gtt"#静态私有字段
    def __init__(self,value):
        self.__value=value

    def f1(self):
        print(self.__value)

    def f2(self):
        print(foo.__coo)#静态私有字段
obj=foo("123")
obj.f2()#通过普通方法访问

• 通过静态方法访问
  

class foo:
    __coo="gtt"#静态私有字段
    def __init__(self,value):
        self.__value=value

    def f1(self):
        print(self.__value)
    @staticmethod
    def f2():
        print(foo.__coo)#静态私有字段
foo.f2()

案例4：受保护的变量

    _xxx，单下划线开头的变量，标明是一个受保护(protected)的变量，原则上不允许直接访问，但外部类还是可以访问到这个变量。这只是程序员之间的一个约定，用于警告说明这是一个私有变量，外部类不要去访问它。

class Student:
    def __init__(self, name, age):
        self._name = name#一个下划线定义
        self.age=age

stu=Student('hh','30')#实例化
print(stu._name)#受保护的变量访问
print(stu.age)

执行结果：

案例链接：https://pan.baidu.com/s/1miGcPRE 密码：uwi8