The Python docs say all that needs to be said, as far as I can see.

setattr(object, name, value)

This is the counterpart of getattr(). The arguments are an object, a string and an arbitrary value. The string may name an existing attribute or a new attribute. The function assigns the value to the attribute, provided the object allows it. For example, setattr(x, 'foobar', 123) is equivalent to x.foobar = 123.

Reading this question again I misunderstood what @paper.cut was asking about: the difference between classic classes and new-style classes (not an issue in Python 3+). I do not know the answer to that.

Original Answer^*

setattr(instance, name, value) is syntactic sugar for instance.__setattr__(name, value)^**.

You would only need to call object.__setattr__(...) inside a class definition, and then only if directly subclassing object -- if you were subclassing something else, Spam for example, then you should either use super() to get the next item in the heirarchy, or call Spam.__setattr__(...) -- this way you don't risk missing behavior that super-classes have defined by skipping over them directly to object.

^* applies to Python 3.0+ classes and 2.x new-style classes

^**There are two instances where setattr(x, ...) and x.__setattr__(...) are not the same:

• x itself has a __setattr__ in it's private dictionary (so x.__dict__[__setattr__] = ... (this is almost certainly an error)

• x.__class__ has a __getattribute__ method -- because __getattribute__ intercepts every lookup, even when the method/attribute exists

NB These two caveats apply to every syntactic sugar shortcut:

• setattr
• getattr
• len
• bool
• hash
• etc

Python Descriptor Methods

What does these attributes do exactly: __get/set/delattr__?

This is a hard one to start with, and fairly advanced - most Python programmers don't need to know this, they just memorize how objects (mostly methods and method decorators) that use this work.

They are special methods that make an object a "descriptor". If that object is looked up through another object, they get invoked. They are how property, classmethod, and staticmethod work. The are also how normal functions can become bound methods.

For example:

>>> class Foo:
...     def __init__(self, bar):
...         self.bar = bar
...     @property
...     def baz(self):
...         return bar * 2
>>> Foo.__init__.__get__
<method-wrapper '__get__' of function object at 0x7f1c1d23b158>

The __get__ is invoked when you do Foo.__init__ (which is invoked by Foo()). It binds the instance to the first argument (we usually call it self) to the method on the dotted lookup.

>>> Foo.baz.__set__
<method-wrapper '__set__' of property object at 0x7f1c1d225e58>

That __set__ method is what is invoked when we try to assign to the baz name on the dotted lookup on the left hand side of the assignment (since we didn't define a setter, baz is read-only) and that method raises the following error:

>>> f = Foo('bar')
>>> f.baz = 'boink'
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: can't set attribute

I wrote a canonical and very thorough answer on this subject on StackOverflow here.

Assignment versus __setattr__ (versus setattr)

Why not use just Myclass.NewAttr = value instead of __setattr__?

Yes, you should do that. __setattr__ should only be used when implementing special behavior on an object.

There is also a builtin function called setattr - it works if you need to programmatically determine the name you are assigning to, and can't just use a static name in your code.

__dict__ versus dir

Why does Python use __dict__? It keeps the attributes in the end of dir() anyway.

Actually, the attributes (data members) are stored in the dictionary - dir() just looks their names up there.