我正在阅读"有效python"书中的第31项。我不明白为什么在第97页的示例中，为什么math_grade，writing_grade和science_grade是Exam类的类(静态(变量，而不是常规的实例变量。如果它们是实例变量，则Grade类无需将实例用作其全局簿记字典中的键。在我看来，作者犯了一个明显的设计错误，只是为了说明如何使用描述符，即在年级班级中保持全球书籍，这似乎是一个坏主意。
我的另一个问题更高级：这不是一种令人困惑的，不清楚的事情吗？像等级一样，将多个对象的全球状态保持在一个单个注册表中。对我来说似乎不是可重复的，干净的设计。
这是对没有书的人的参考：
https://github.com/sigmaquan/better-python-59-ways/blob/master/master/item_31_use_descriptors.py
特别
class Grade(object):
def __get__(*args, **kwargs):
super().__getattribute__(*args, **kwargs)
def __set__(*args, **kwargs):
super().__setattr__(args, kwargs)
class Exam(object):
math_grade = Grade()
writing_grade = Grade()
science_grade = Grade()
我认为每个人都有一个很好的参考，实际上是该描述符中的官方文档如何
我设置了一个示例，但请注意，关于描述符还有很多，除非编写一个需要动态实例化和验证不同字段的框架或某些库(例如ORM(，否则您不应使用此示例例如。
对于通常的验证需求，将自己限制在物业装饰器中。
class PositionX: # from 0 to 1000
def __init__(self, x):
self.x = x
print('***Start***')
print()
print('Original PositionX class')
pos1 = PositionX(50)
print(pos1.x)
pos1.x = 100
print(pos1.x)
pos1.x = -10
print(pos1.x)
print()
# let's validate x with a property descriptor, using @property
class PositionX: # from 0 to 1000
def __init__(self, position):
self._x = position
@property
def x(self):
return self._x
@x.setter
def x(self, value):
if 0 <= value <= 1000:
self._x = value
else:
raise ValueError
print('PositionX attribute x validated with @property')
pos2 = PositionX(50)
print(pos2.x)
pos2.x = 100
print(pos2.x)
try:
pos2.x = -10
except ValueError:
print("Can't set x to -10")
print()
# Let's try instead to use __set__ and __get__ in the original class
# This is wrong and won't work. This makes the class PositionX a descriptor,
# while we wanted to protect x attribute of PositionX with the descriptor.
class PositionX: # from 0 to 1000
def __init__(self, x):
self.x = x
def __get__(self, instance):
print('Running __get__')
return self._x
def __set__(self, instance, value):
print('Running __set__')
if 0 <= value <= 1000:
self._x = value
else:
raise ValueError
print("Using __set__ and __get__ in the original class. Doesn't work.")
print("__get__ and __set__ don't even run because x is found in the pos3 instance and there is no descriptor object by the same name in the class.")
pos3 = PositionX(50)
print(pos3.x)
pos3.x = 100
print(pos3.x)
try:
pos3.x = -10
except ValueError:
print("Can't set x to -10")
print(pos3.x)
print()
# Let's define __set__ and __get__ to validate properties like x
# (with the range 0 to 1000). This actually makes the class Range0to1000
# a data descriptor. The instance dictionary of the managed class PositionX
# is always overrided by the descriptor.
# This works because now on x attribute reads and writes of a PositionX
# instance the __get__ or __set__ descriptor methods are always run.
# When run they get or set the PositionX instance __dict__ to bypass the
# trigger of descriptor __get__ or __set__ (again)
class Range0to1000:
def __init__(self, name): # the property name, 'x', 'y', whatever
self.name = name
self.value = None
def __get__(self, instance, managed_class):
print('Running __get__')
return instance.__dict__[self.name]
# same as getattr(instance, self.name) but doesn't trigger
# another call to __get__ leading to recursion error
def __set__(self, instance, value):
print('Running __set__')
if 0 <= value <= 1000:
instance.__dict__[self.name] = value
# same as setattr(instance, self.name, self.value) but doesn't
# trigger another call to __set__ leading to recursion error
else:
raise ValueError
class PositionX: # holds a x attribute from 0 to 1000
x = Range0to1000('x') # no easy way to avoid passing the name string 'x'
# but now you can add many other properties
# sharing the same validation code
# y = Range0to1000('y')
# ...
def __init__(self, x):
self.x = x
print("Using a descriptor class to validate x.")
pos4 = PositionX(50)
print(pos4.x)
pos4.x = 100
print(pos4.x)
try:
pos4.x = -10
except ValueError:
print("Can't set x to -10")
print(pos4.x)
print()
print('***End***')