The simple but handy "collector of a bunch of named stuff" class (Python recipe) by Alex Martelli

ActiveState Code (http://code.activestate.com/recipes/52308/)

Even shorter Bunch.

class Bunch:
    __init__ = lambda self, **kw: setattr(self, '__dict__', kw)
<pre>

You could also accept *args and put them in a sequence accessible
with [].

When python 2.2 permits the above dynamic __dict__ this could be
be something like:

<pre>
class Bunch(list):
    def __init__(*args, **kw):
        self[:] = list(args)
        setattr(self, '__dict__', kw)
<pre>

</pre></pre></pre>

Using a bunch as a dictionary. Quite simple extension of the original Bunch, just one extra line:

class BunchDict(dict):
    def __init__(self,**kw):
        dict.__init__(self,kw)
        self.__dict__.update(kw)

This has the added benefit that it can directly be printed and it shows its contents in interactive environments like ipython.

Using a bunch as a dictionary. Quite simple extension of the original Bunch, just one extra line:

class BunchDict(dict):
    def __init__(self,**kw):
        dict.__init__(self,kw)
        self.__dict__.update(kw)

This has the added benefit that it can directly be printed and it shows its contents in interactive environments like ipython.

One dictionary is better than two. How about just replacing self.__dict__ with self, since self is a dict?

class Bunch(dict):
    def __init__(self,**kw):
        dict.__init__(self,kw)
        self.__dict__ = self

Then any deletions, modifications, etc. are accessible via both the dict and attribute interfaces.

String representation. For debugging purposes, it's nice to have a meaningful string representation. This works for me:

def __str__(self):
    state = ["%s=%r" % (attribute, value)
             for (attribute, value)
             in self.__dict__.items()]
    return '\n'.join(state)

Using dict functionality. You could simply do something like this, given the current functionality of dict (with kwd args etc.):

class bunch(dict):
    __getattr__ = dict.__getitem__

Of course, you won't get the right exceptions etcl., and simply setting __setattr__ the same way won't really work. But it seems to be about as simple as this recipe can get :)

Improvement to handle pickling. As written, pickling and unpickling such an object breaks the equivalence between self and self.__dict__. Adding the methods __getstate__ and __setstate__ used by the pickle protocol fixes this:

class Bunch(dict):
    def __init__(self, **kw):
        dict.__init__(self, kw)
        self.__dict__ = self

    def __getstate__(self):
        return self

    def __setstate__(self, state):
        self.update(state)
        self.__dict__ = self

(Perhaps there's a better way to do this, but it seems to have the desired effect.)

Ugh; follow-up in wrong place. Apologies; that was supposed to be a comment on

"One dictionary is better than two", Graham Fawcett

CAUTION. this one leaks memory just try:

>>> for i in range(10**9):
...     a = Bunch()

you need to stay away from circular references

CAUTION. this one leaks memory

just try:

>>> for i in range(10**9):

... a = Bunch()

you need to stay away from circular references

CAUTION. as noted before - this leaks memory!

Is there an issue with using the type builtin for this ? If your use case is accessing **kw using dot notation then how about:

kw=type('bunch',(), kw)

Or, more closely following the 'utility helper' style of the original:

def bunch(**kw):
    return type('bunch',(), kw)

B=bunch(apples=1,pears=2)
b=B()
assert B.apples == b.apples and b.apples=1

class Y(B)
    bannanas=3
    pears=19

y=Y()

assert y.pears == Y.pears and y.pears != b.pears

class Bunch(dict):

def __init__(self,**kw):
    dict.__init__(self,kw)
    self.__dict__ = self

fruit = Bunch(apples = 1, pears = 2)
for k,v in fruit.iterkeys():
    print k,v

The above results in the below error. Is there a way to get the ease of use AND the ability to iterate through the values? ValueError: too many values to unpack

You are using iterkeys, which iterates over keys, not over key-value pairs. That’s what produces the ValueError: The first element from “fruit.iterkeys()” is not a sequence, so Python cannot unpack it to “k, v”.

Cheers