[Python-ideas] Shorthand syntax for get/set/delattr (was Re: Dict-like object with property access)
Terry Reedy
tjreedy at udel.edu
Sun Feb 5 02:13:19 CET 2012
On 2/4/2012 7:20 PM, Nick Coghlan wrote:
> Rather than throwing out random ideas in a popularity contest, it's
> important to carefully review what it is that people don't like about
> the current state of affairs.
>
> Currently, when dealing with attributes that are statically
> determined, your code looks like this:
>
> x.attr # Reference
> x.attr = y # Bind
> del x.attr # Unbind
>
> Now, suppose for some reason we want to determine the attributes
> *dynamically*. The reason for doing this could be as simple as wanting
> to avoid code duplication when performing the same operation on
> multiple attributes (i.e. "for attr in 'attr1 attr2 attr3'.split():
> ...").
>
> At this point, dedicated syntactic support disappears and we're now
> using builtin functions instead:
>
> getattr(x, attr) # Reference
> setattr(x, attr, y) # Bind
> delattr(x, attr) # Unbind
> hasattr(x, attr) # Existence query (essentially a shorthand for
> getattr() in a try/except block)
>
> So, that's the status quo any proposals are competing against. It's
> easy enough to write, easy to read and easy to look up if you don't
> already know what it does (an often underestimated advantage of
> builtin operations over syntax is that the former are generally *much*
> easier to look up in the documentation).
Also, functions can be passed as arguments, whereas syntax cannot, which
is why we have the operator module.
> However, it can start to look rather clumsy when multiple dynamic
> attribute operations are chained together.
>
> Compare this static code:
>
> x.attr1 = y.attr1
> x.attr2 = y.attr2
> x.attr3 = y.attr3
>
> With the following dynamic code:
>
> for attr in "attr1 attr2 attr3".split():
> setattr(x, attr, getattr(y, attr))
>
> The inner assignment in that loop is *very* noisy for a simple
> assignment. Splitting out a temporary variable cleans things up a bit,
> but it's still fairly untidy:
>
> for attr in "attr1 attr2 attr3".split():
> val = getattr(y, attr)
> setattr(x, attr, val)
>
> It would be a *lot* cleaner if we could just use a normal assignment
> statement instead of builtin functions to perform the name binding. As
> it turns out, for ordinary instances, we can already do exactly that:
>
> for attr in "attr1 attr2 attr3".split():
> vars(x)[attr] = vars(y)[attr]
>
> In short, I think proposals for dedicated syntax for dynamic attribute
> access are misguided - instead, such efforts should go into enhancing
> vars() to return objects that support *full* dict-style access to the
> underlying object's attribute namespace (with descriptor protocol
> support and all).
>
> Cheers,
> Nick.
>
--
Terry Jan Reedy
More information about the Python-ideas
mailing list