Right. If there's already a way to have attributes with these
"non-standard" names (which is a good thing)
No it is not a good thing. It is a bad thing, and completely an accident
of implementation that it works at all.
Python does not support names (variable names, method names, attribute
names, module names etc.) which are not valid identifiers except by
accident. The right way to handle non-identifier names is to use keys in
a dictionary, which works for any legal string.
As you correctly say in another post:
"attribute is quite a different beast then key in a dictionary"
attributes are intended to be variables, not arbitrary keys. In some
languages, they are even called "instance variables". As they are
variables, they should be legal identifiers:
spam = 42 # legal identifier name
spam\n-ham\n = 42 # illegal identifier name
Sticking a dot in front of the name doesn't make it any different.
Variables, and attributes, should be legal identifiers. If I remember
correctly (and I may not), this issue has been raised with the Python-Dev
core developers, including Guido, and their decision was:
- allowing non-identifier attribute names is an accident of
implementation;
- Python implementations are allowed to optimize __dict__ to prohibit non-
valid identifiers;
- but it's probably not worth doing in CPython.
getattr already enforces that the attribute name is a string rather than
any arbitrary object.
You've also raised the issue of linking attribute names to descriptors.
Descriptors is certainly a good reason to use attributes, but it's not a
good reason for allowing non-identifier names. Instead of writing:
obj.'#$^%\n-\'."'
just use a legal identifier name! The above is an extreme example, but
the principle applies to less extreme examples. It might be slightly
annoying to write obj.foo_bar when you actually want of obj.'foo.bar' or
obj.'foo\nbar' or some other variation, but frankly, that's just too bad
for you.
As far as descriptors go, you can implement descriptor-like functionality
by overriding __getitem__. Here's a basic example:
class MyDict(dict):
def __getitem__(self, key):
obj = super(MyDict, self).__getitem__(key)
if hasattr(obj, '__get__'):
obj = obj.__get__(self)
which ought to be close to (but not identical) to the semantics of
attribute descriptors.
While I can see that there is some benefit to allowing non-identifier
attributes, I believe such benefit is very small, and not enough to
justify the cost by allowing non-identifier attributes. If I wanted to
program in a language where #$^%\n-\'." was a legal name for a variable,
I'd program in Forth.
