class, dict, self, init, args ?

Question

class attrdict(dict):
    def __init__(self, *args, **kwargs):
        dict.__init__(self, *args, **kwargs)
        self.__dict__ = self

a = attrdict(x=1, y=2)
print a.x, a.y

b = attrdict()
b.x, b.y  = 1, 2
print b.x, b.y

Could somebody explain the first four lines in words? I read about classes and methods. But here it seems very confusing.

Answer 1

Here's a good article that explains __dict__:

The Dynamic dict

The attrdict class exploits that by inheriting from a dictionary and then setting the object's __dict__ to that dictionary. So any attribute access occurs against the parent dictionary (i.e. the dict class it inherits from).

The rest of the article is quite good too for understanding Python objects:

Python Attributes and Methods

Answer 2

My shot at a line-by-line explanation:

class attrdict(dict):

This line declares a class attrdict as a subclass of the built-in dict class.

def __init__(self, *args, **kwargs): 
    dict.__init__(self, *args, **kwargs)

This is your standard __init__ method. The call to dict.__init__(...) is to utilize the super class' (in this case, dict) constructor (__init__) method.

The final line, self.__dict__ = self makes it so the keyword-arguments (kwargs) you pass to the __init__ method can be accessed like attributes, i.e., a.x, a.y in the code below.

Hope this helps clear up your confusion.

Answer 3

You are not using positional arguments in your example. So the relevant code is:

class attrdict(dict):
    def __init__(self, **kwargs):
        dict.__init__(self, **kwargs)
        self.__dict__ = self

in first line you define class attrdict as a subclass of dict. in the second line you define the function that automatically will initialize your instance. You pass keyword arguments (**kargs) to this function. When you instantiate a:

 a = attrdict(x=1, y=2)

you are actually calling

attrdict.__init__(a, {'x':1, 'y':2})

dict instance core initialitation is done by initializing the dict builtin superclass. This is done in the third line passing the parameters received in attrdict.init. Thus,

dict.__init__(self,{'x':1, 'y:2'})

makes self (the instance a) a dictionary:

self ==  {'x':1, 'y:2'}

The nice thing occurs in the last line: each instance has a dictionary holding its attributes. This is self.dict (i.e. a.dict).

for example if

a.__dict__ = {'x':1, 'y:2'} 

we could write a.x or a.y and get values 1 or 2 respectively.

So, this is what line 4 does:

self.__dict__ = self

is equivalent to:

a.__dict__ = a  where a = {'x':1, 'y:2'}

Then I can call a.x and a.y

hope is not too messy