There's a fairly easy way to get this functionality without much work. Basically just do: class MyDict(dict): def __init__(self, *args, **kwargs): super(MyDict, self).__init__(*args, **kwargs) # or super().__init__ in python3 self.__dict__ = self You've now got pretty much the same thing (indeed, it's more efficient, since it doesn't have entries in 2 places for everything): >>> d= MyDict() >>> d.foo = 42 >>> d['foo'] # Prints 42 42 >>> d {'foo': 42} Admittedly, this doesn't do the "Also convert dicts which are attached as values to MyDicts", but to be honest, that seems very dangerous to me, because it's going to result in unexpected behaviour for many (suddenly, adding keys to a referenced dictionary will stop changing your referenced object, instead updating a copy), and given the issues with this approach in general (see below), I think you'd want to be in firm control of the scope of its effects if you do it at all. You also don't seem to be handling all the dict.__init__ syntax - indeed, you ignore everything except the first arg, and even then, only if it's a dict. Worse, you silently continue without error when this happens. IE. Dict(foo=42, bar=12) or dict((k,v) for (k,v) in something_generating_data()) will raise no error, but initialise an empty dict. You should either handle it all (eg. by calling dict.__init__ and then fixing things up afterwards from the keys, or else change the method signature to only take a single arg, and raise an exception if it's not a dict. However, there are issues with doing this at all. What happens when you do stuff like d['keys'] = 11. Suddenly basic operations that take a dictionary may stop working because you've overridden methods that are part of the dict interface, and if this dict is general purpose, you don't want to have to mark arbitrary keys off limits. More on reddit.com

Like properties, __dict__ is a descriptor (specifically a getset descriptor) that lives on the class, not the instance. You can see it using the class's own __dict__: instance.__dict__ returns type(instance).__dict__['__dict__'].__get__(instance). The class's __dict__, meanwhile, lives on its type. Instances of object don't have a __dict__ so as to allow custom classes that don't have a __dict__ and use __slots__ instead. However, any custom class without a __slots__ (or with an explicit __dict__ entry) automatically gains a __dict__ descriptor, as does any class inheriting from a class with a __dict__. More on reddit.com