Alan Ristow wrote:
I would like to have three classes, ClassA, ClassB, and ClassC, that are
essentially the same, the only difference being that each class has a
different range of valid values for its properties. Thus, the obvious
solution is to create a base class, then subclass from that and include
the required error-checking during initialization and when property
values change. The base class might look something like this:
[...]
However, instead of rewriting my validation code in several different
places, I would prefer to write it one time and keep it in one place. I
can write a function or method that I call each time I need to do
validation, which is the approach I would take in most languages.
However, since I am basically writing several small variations on one
theme, it seems like in Python this might be an ideal application for
decorators and/or metaclasses.
So my question is, what is the most sensible way to write a set of
classes such as these in Python? I am not afraid to experiment with
decorators or metaclasses -- indeed, I would love to learn more about
them -- but in this particular project I do not want to use them just
for the sake of learning to use them. If there is a good reason to use
them, I am all for it, though.
All advice appreciated,
Thanks,
Alan
There's probably a number of ways to do it, but Descriptors spring to mind:
class x_validator(object):
def __get__(self, instance, cls):
return instance._x
def __set__(self, instance, val):
if instance.is_valid_x(val):
instance._x = val
else:
raise ValueError("'%s' is an invalid value for 'x'" % val)
class Base(object):
_x = None
x = x_validator()
def __init__(self, x):
self.x = x
class A(Base):
def is_valid_x(self, val):
return val < 10
class B(Base):
def is_valid_x(self, val):
return val > 0
a = A(2)
print(a.x)
print(a._x)
a.x = 12
b = B(-2)
(you might not want to define _x at the class-level).
--
http://mail.python.org/mailman/listinfo/python-list
