It seems we can't assign attributes to "objet" class instances, which don't have a __dict__ :

IDLE 2.6.4      
>>> a = object()
>>> a.abc = 3

Traceback (most recent call last):
  File "<pyshell#1>", line 1, in <module>
    a.abc = 3
AttributeError: 'object' object has no attribute 'abc'
>>> 

This behaviour seems undocumented, and contradicts the documentation on AttributeError -> normally, a TypeError should be raised instead:

exception AttributeError
    Raised when an attribute reference (see Attribute references) or assignment fails. (When an object does not support attribute references or attribute assignments at all, TypeError is raised.)

The 3.x documentation[1] has this:
"object does not have a __dict__, so you can’t assign arbitrary attributes to an instance of the object class."
- 2.x doesn't have that same blurb -- it looks like it should.

AttributeError vs. TypeError seems to be the issue here.


FWIW, the way to achieve what you had in your example is something like this:
>>> a = type("my_type", (object,), {})
>>> a.abc = 3


[1] http://docs.python.org/3.1/library/functions.html#object

Allright, I suppose it's some kind of optimization ?

We get a proper error when we do :

>>> object.test=1

Traceback (most recent call last):
  File "<pyshell#6>", line 1, in <module>
    object.test=1
TypeError: can't set attributes of built-in/extension type 'object'
>>> 

So we'd need a similar error when trying to assign to object instances, too...
I fear I won't be able to help with finding a patch alas, it's a little too deep into the python core for me :p

I don't think it's an optimization. The point is that object is mostly meant to be subclassed, not to be used as a glorified dict.

OK, eligible to QOTW    :D

But an object to which you can assign attributes but which has no methods can be useful in a number of contexts.  It's not a glorified dict, because attribute-style access is different from dict-style access.  The main place I have used this (creating my own trivial object subclass) is for passing a duck-typed object in to a function that only needs to access certain attributes to get the correct quack.

Why prevent us from using an object instance for this if there's not a functional reason for it?  Python is supposed to be a Consulting Adults language, after all :).

That said, I suspect that giving object a dict would break various assumptions in the core code, and I have no problem with creating that trivial subclass.  It does have the advantage of providing a more meaningful name in error messages.

Object instances don't get a __dict__ by default to save the space the pointer and dict instance would require. Most builtins are missing that pointer. It is also the main memory saving provided by the use of __slots__.

As far as AttributeError vs TypeError goes, the CPython core is actually pretty arbitrary as to which it raises (usually for historical reasons). In this case, AttributeError is technically correct, since object.__setattr__ *does* support writable attributes. It just so happens that a bare object() instance doesn't have any (since __doc__ is read-only).

I asked Guido ages ago about cleaning some of this up (due to some discrepancies between __enter__ and __exit__ and other special methods), but he was of the opinion that the backwards compatibility hassles weren't worth the gain in consistency.

Along the lines of RDM's last post, see:
http://code.activestate.com/recipes/52308-the-simple-but-handy-collector-of-a-bunch-of-named/

Or, if you do a few web searches for terms like "bethard coghlan namespaces" or "bethard generic objects" you'll get results along the lines of:
http://mail.python.org/pipermail/python-list/2005-February/305129.html

collections.namedtuple is a simpler alternative to most of these ideas, though.