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会触发