guxh的python笔记六：类的属性

1，私有属性

class Foo:

    def __init__(self, x):
        self.x = x

类的属性在实例化之后是可以更改的：

f = Foo(1)
print(f.x)   # 1
f.x = 2
print(f.x)   # 2

如果想禁止访问属性，即让属性私有，可以用“双下划线” 或者“单下划线”：

class Foo:

    def __init__(self, x, y):
        self._x = x
        self.__y = y

    def __repr__(self):
        return 'f._x = {}, f.__y = {}'.format(self._x, self.__y)

区别是“双下划线”解释器会对属性就行“名称更改”，而“单下划线”不会有更改，只是约定成俗。

但是知道规则还是可以轻松访问：

f = Foo(1, 1)
f._x = 2
f._Foo__y = 2
print(f)   # f._x = 2, f.__y = 2

所以如果只是为了属性私有，用“单下划线”和“双下划线”没有什么区别。

但“双下划线”在继承时可以避免基类属性被子类的属性覆盖，即想实现对子类的隐藏时，可以用双下划线。

2，只读属性

为类的方法添加@property，但不实现该属性对应property类的setter方法，就可以让该方法变成只读属性。

2.1，让实例化时的属性变成只读（私有属性 + @property）

私有属性 + property可以让属性变的只读：

class Foo:

    def __init__(self, x):
        self._x = x

    @property
    def x(self):
        return self._x

此时对Foo进行实例化后，可以访问对象的属性x，但无法给x赋值：

f = Foo(1)
print(f.x)  # 1
f.x = 2   # AttributeError: can't set attribute

因为实例化时的x存在私有属性self._x中，当然可以用1中提到的访问私有属性的方法去修改，但这被认为是粗略的行为：

f = Foo(1)
f._x= 2
print(f.x)  # 2 

如果__init__函数还是用x属性赋值，会有什么后果呢？

class Foo:
    def __init__(self, x):
        self.x = x

    @property
    def x(self):
        return 123

f = Foo(1)   # AttributeError: can't set attribute

self.x会无法完成赋值，因为没有对应的x.setter方法。

2.2，把函数变属性 （@property）

把函数变属性，可以实现根据需要完成计算，从而无需在实例化时就完成计算。

class Circle:
    def __init__(self, radius):
        self.radius = radius

    @property
    def perimeter(self):
        print('computing')    # 每次调用都会打印
        return 2 * math.pi * self.radius

c = Circle(10)
print(c.perimeter)   # ‘computing’  ， 62.83185307179586
print(c.perimeter)   # ‘computing’  ， 62.83185307179586

但存在问题是如果多次调用，就会多次计算。

如果在__init__函数中增加一条self.p = self.perimeter，然后访问实例的p属性，就不会多次计算，但这样又变成实例化时就完成了计算。

标准的做法是利用描述符将计算结果缓存起来：

class lazyproperty:
    def __init__(self, func):
        self.func = func

    def __get__(self, instance, cls):
        if instance is None:
            return self
        else:
            value = self.func(instance)   # 计算被装饰函数的运算结果
            setattr(instance, self.func.__name__, value)  # 将运算结果缓存，保存为func的name
            return value  # 返回运算结果

class Circle:
    def __init__(self, radius):
        self.radius = radius

    @lazyproperty
    def perimeter(self):
        print('computing')    # 每次调用都会打印
        return 2 * math.pi * self.radius

c = Circle(10)
print(c.perimeter)   # ‘computing’  ， 62.83185307179586
print(c.perimeter)   # 62.83185307179586

3，属性管理

3.1，属性管理 ：init

可以通过__init__完成属性管理：

class Foo:

    def __init__(self, x):
        if x < 0:
            raise ValueError('x must be >= 0')
        self.x = x

看看有什么效果？

f = Foo(-1)  # ValueError: x must be >= 0
f = Foo(1)
print(f.x)  # 1
f.x = -1
print(f.x)  # -1

发现实例化时能对属性进行管理，但是实例化后的对属性的操作就无法管理了。

3.2，属性管理：property

对属性的操作有：get，set，del。

property只是完成了get操作，剩下的get / del分配由setter / delettr完成，组合起来就可以实现对属性的管理：

class Foo:

    def __init__(self, x):
        self.x = x

    @property
    def x(self):
        return self._x

    @x.setter
    def x(self, val):
        if val < 0:
            raise ValueError('x must be >= 0')
        self._x = val

    @x.deleter
    def x(self):
        del self.__dict__['_x']

再看看对x属性的访问情况：

f = Foo(1)
print(f.x)      # 1
f.x = 2
print(f.x)      # 2
f = Foo(-1)   # ValueError: x must be >= 0
f.x = -1        # ValueError: x must be >= 0
del f.x
print(f.x)      # AttributeError: 'Foo' object has no attribute '_x'

如果__init__中使用self._x = x会出现什么后果？

class Foo:

    def __init__(self, x):
        self._x = x
    ......

f = Foo(-1)
print(c.x)   #  -1
f.x = -1   # ValueError: x must be >= 0

self.x = x在实例化时会触发set，如果没有set就无法完成赋值（参考2.只读属性中的例子）。

而self._x = x在实例化时绕过了set，也就是不会对实例化时的参数做检查。

另外，del可以不定义，del f.x会触发AttributeError: can't delete attribute，这里pass演示，del f.x没什么效果。

3.3，属性管理：property工厂函数

虽然内置的property经常用作装饰器，实际上是个类，python中函数和类可以互换，因为都是可调用对象。

property类完整的构造方法：property(fget=None, fset=None, fdel=None, doc=None)

下面不用property装饰器，而用经典形式property：

class Foo:

    def __init__(self, x):
        self.x = x

    def qty_get(self):
        return self._x    # 如果return self.x，变无限递归，因为self.x就是从qty_get拿值的

    def qty_set(self, val):
        if val >= 0:
            self._x = val
        else:
            raise ValueError('value must be >= 0')

    x = property(qty_get, qty_set)   # 经典形式property

属性很多时，通过@property， setter代码会就大量增加，可以利用property工厂函数实现管理：

def quantity(attr):

    def qty_get(instance):
        return instance.__dict__[attr]

    def qty_set(instance, val):
        if val >= 0:
            instance.__dict__[attr] = val
        else:
            raise ValueError('value must be >= 0')

    return property(qty_get, qty_set)

class Foo:
    x = quantity('x')

    def __init__(self, x):
        self.x = x

可以接受参数，并且使用了getattr和setattr（避免使用__dict__）的工厂函数：

def typed_property(name, expected_type):
    storage_name = '_' + name   # 这里如果不换个名字，后面就不能用getattr和setattr，只能用__dict__，否则无限递归

    def prop_get(instance):
        return getattr(instance, storage_name)

    def prop_set(instance, value):
        if not isinstance(value, expected_type):
            raise TypeError('{} must be a {}'.format(name, expected_type))
        setattr(instance, storage_name, value)

    return property(prop_get, prop_set)

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

p = Person(123)

3.4，属性管理：描述符

描述符是个实现了特定协议的类，即实现了一些特殊方法的类，这些特殊方法包括__get__，__set__，__delete__。

之前使用的property类实现了完整的描述符协议。这里自定义描述符相当于抛弃了property，自己去定义实现一个类似property的类。

可以只实现一部分协议，大多数描述符只实现了__get__和__set__。

设置属性可以通过setattr(instance, name, value)或者instance.__dict__[name] = value，但需要注意有时用setattr会无限递归，有时些场景不适用dict，例如使用了__slots__或者描述符的类。

版本一：描述符声明时需要传入名称（不建议用）

class Quantity:

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

    def __set__(self, instance, value):
        if value >= 0:
            instance.__dict__[self.name] = value # self是描述符Quantity的实例，instance是Foo的实例，所以需要对instance设置
            # setattr(instance, self.name, value)  # 这里如果使用setattr会无限递归
        else:
            raise ValueError('value must be >= 0')

class Foo:
    x = Quantity('x')

    def __init__(self, x):
        self.x = x

版本二：描述符声明时无需传入名称

声明描述符时，需要明确指明Quantity实例的名称，不仅麻烦，还可能造成覆盖错误，可以对描述符进行改造，支持不需要输入名称。

class Quantity:
    __counter = 0

    def __init__(self):
        cls = self.__class__  # 等效于type(self),获取类的引用
        prefix = cls.__name__
        index = cls.__counter
        self.storage_name = '_{}#{}'.format(prefix, index)
        cls.__counter += 1

    def __get__(self, instance, value):
        if instance is None:
            return self  # 通过类访问返回时，返回自身
        else:
            return getattr(instance, self.storage_name)

    def __set__(self, instance, value):
        if value >= 0:
            setattr(instance, self.storage_name, value)  # 这里如果使用setattr不会无限递归,因为托管属性和存储属性名称不同
        else:
            raise ValueError('value must be >= 0')

class Foo:
    x = Quantity()
    y = Quantity()

    def __init__(self, x, y):
        self.x = x
        self.y = y

版本三：多种属性管理时，有基类的描述符，可以实现描述符的参数输入

x属性和y属性的管理中，有很多是相同的，例如建立存储属性_counter#0，get访问属性等等，差异部分只是对输入值的验证。

可以提取相同部分作为基类，差异部分对输入值的验证由子类实现。

class Descriptor:  # 基类
    __counter = 0  # 类变量会被所有实例共享

    def __init__(self, **opts):  # 因为MaxSized需要输入输入键值对，基类需要支持
        cls = self.__class__
        self.name = '_{}#{}'.format(cls.__name__, cls.__counter)
        cls.__counter += 1
        for key, value in opts.items():
            setattr(self, key, value)

    def __get__(self, instance, value):
        if instance is None:
            return self  # 通过类访问返回时，返回自身
        else:
            return getattr(instance, self.name)

    def __set__(self, instance, value):
        setattr(instance, self.name, value)  # 也可以instance.__dict__[self.storage_name] = value

class Typed(Descriptor):  # 基类2：实现type验证
    expected_type = type(None)

    def __set__(self, instance, value):
        if not isinstance(value, self.expected_type):
            raise TypeError('Expected ' + str(self.expected_type))
        super().__set__(instance, value)

class Unsigned(Descriptor):  # 基类3：实现数值验证
    def __set__(self, instance, value):
        if value < 0:
            raise ValueError('Expected >= 0')
        super().__set__(instance, value)

class MaxSized(Descriptor):  # 基类4：实现str长度验证
    def __init__(self, **opts):
        if 'size' not in opts:
            raise TypeError('Missing size option')
        super().__init__(**opts)

    def __set__(self, instance, value):
        if len(value) >= self.size:
            raise ValueError('size must be < ' + str(self.size))
        super().__set__(instance, value)

class Inter(Typed):
    expected_type = int

class String(Typed):
    expected_type = str

class UnsignedInteger(Inter, Unsigned):   # 整型 + >=0
    pass

class SizedString(String, MaxSized):  # string + 最大长度8
    pass

class Foo:
    x = UnsignedInteger()
    y = SizedString(size=8)

    def __init__(self, x, y):
        self.x = x
        self.y = y

对Foo实例化：

f1 = Foo(-1, 'a')  # ValueError: value must be >= 0
f2 = Foo(1, 'abcdefghi')  # ValueError: size must be < 8

描述符总结：

Foo：托管类。把描述符的实例声明为类属性的类(即x = Quantity())。

Foo的x：托管属性，Foo的类属性，Quantity描述符类的实例。由描述符实例处理的公开属性。

Quantity：描述符类。实现了描述符的类。

Quantity的storeage_name：存储属性。

覆盖型与非覆盖型描述符：

待补充

4，property的本质

4.1，property是个类

propery本质上含有装饰器方法的类

如下例，Foo多了个x属性，并且x属性是个property类：property(fget, fset, fdel)

class FooNoPro:
    def __init__(self, x):
        self.x = x

class Foo:
    def __init__(self, x):
        self._x = x

    @property
    def x(self):
        return self._x

>>>set(dir(Foo)) - set(dir(FooNoPro))
{‘x'}
>>>type(Foo.x)
<class 'property'>

4.2，property装饰过程

装饰前，x是个Foo类的方法：

class Foo:
    def __init__(self, x):
        self._x = x

    def x(self):
        return self._x

>>>s = Foo(10)
>>>dir(s)  # 实例s包括了属性_x和方法x
[......,  '_x', 'x']
>>>Foo.x   # x是个Foo类的方法
<function Foo.x at 0x005174B0>
>>>s.x     # 访问实例s.x，返回的也是Foo类的x方法
<bound method Foo.x of <__main__.Foo object at 0x008CEE90>>

使用猴子补丁，装饰x方法：

Foo.x = property(Foo.x)  # 打猴子补丁，相当于@property装饰，property类实例化时第一个参数是fget=Foo.x

装饰后，Foo.x变成了property类的实例，再次访问s.x返回的是10而不是函数地址了：

>>>type(Foo.x)
type(Foo.x)
>>>s.x
10

为什么访问s.x能拿到10？

property背后实现了__get__，调用时s.x相当于调用：

>>>Foo.x.__get__(s, Foo) # 相当于s.x
10

5，动态存取属性

setattr：设置属性时会触发，类的实例化时也会触发

getattr：当访问不存在的属性时会触发，访问已经存在的属性时不会触发

class Foo:

    def __init__(self, x):
        self.x = x

    def __setattr__(self, key, value):
        self.__dict__[key] = value + 1  # 如果调用self.key = value + 1 会无限递归

    def __getattr__(self, item):
        return 'not valid attribute'　 

调用属性：

f = Foo(1)
f.y = 5
print(f.x)   # 2
print(f.y)   # 6
print(f.z)   # not valid attribute

注意与动态存取分量的区别：__getitem__，__setitem__

6，处理属性的内置函数和特殊方法

6.1，处理属性的内置函数

dir：列出对象大多数属性，静态属性只会列出__dict__属性键值对中的键

vars：获取对象的__dict__属性键值对，如果定义了__slots__元组形式保存属性，则无法处理该对象，此时可以靠dir可列出

getattr：获取对象属性

hasattr：判断对象有无属性

setattr：设置对象的属性

delattr：删除对象的属性

上述get, has, set, del可以动态的实现属性的增删改查。

6.2，处理属性的特殊方法

__delattr__：删除属性，通过del触发

__dir__：供dir调用

__getattr__：获取指定属性失败后，getattr和hasattr可能会触发

__getattribute__: 获取指定属性时总会调用，点号 / getattr / hasattr会触发

__setattr__：设置指定属性时总会调用，点号 / setattr会触发