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