On Nov 24, 12:54 am, Steven D'Aprano <[EMAIL PROTECTED]
cybersource.com.au> wrote:
> The correct solution to your example is to get rid of the attribute
> lookups from the expression completely:
>
> def abs(self):
> x, y, z = self.x, self.y, self.z
> return math.sqrt(x**2 + y**2 + z**2)
>
> It's probably also faster, because it looks up the attributes only once
> each, instead of twice.
>
> --
> Steven.
I like this pattern but less much I like the boilerplate. What about
an explicit unpacking protocol and appropriate syntax?
def abs(self):
x, y, z by self
return math.sqrt(x**2 + y**2 + z**2)
expands to
def abs(self):
x, y, z = self.__unpack__("x","y","z")
return math.sqrt(x**2 + y**2 + z**2)
This would have another nice effect on expression oriented programming
where people use to create small "domain specific languages" using
operator overloading:
x,y,z by Expr
class Expr(object):
def __init__(self, name):
self.name = name
self._sexpr = ()
def __unpack__(self, *names):
if len(names)>1:
return [Expr(name) for name in names]
elif len(names) == 1:
return Expr(names[0])
else:
raise ValueError("Nothing to unpack")
def __add__(self, other):
e = Expr("")
e._sub = ('+',(self, other))
return e
def __repr__(self):
if self._sexpr:
return self._sexpr[0].join(str(x) for x in self._sexpr[1])
return self.name
>>> x,y by Expr
>>> x+y
x+y
>>> 4+x
4+x
--
http://mail.python.org/mailman/listinfo/python-list
