Performance discrepancy: obj.__setitem__(x,y) vs. obj[x] = y?

Question

I was writing up a simple `dict` subclass with attribute access, and I stumbled across something that seemed strange when I was optimizing. I had originally written the `__getattr__` and `__setattr__` methods as simple aliases to `self[key]` etc, but then I thought it should be faster to call `self.__getitem__` and `self.__setitem__` directly, since they would presumably be called under the hood by the `[key]` notation. Out of curiosity, I timed both implementations, and discovered some surprises. Below are the two implementations: not much going on here, as you can see. ``` # brackets class AttrDict(dict): def __getattr__(self, key): return self[key] def __setattr__(self, key, val): self[key] = val # methods class AttrDict(dict): def __getattr__(self, key): return self.__getitem__(key) def __setattr__(self, key, val): self.__setitem__(key, val) ``` Intuitively, I expected the second implementation to be slightly faster, since it presumably skips the step of going from the bracket not…

Accepted Answer

Hmm that's interesting. If I run a pared-down version of your stuff:

```
setup="""
def getbrack(a, b):
    return a[b]

def getitem(a, b):
    return a.__getitem__(b)

def setbrack(a, b, c):
    a[b] = c

def setitem(a, b, c):
    return a.__setitem__(b, c)

a = {2: 3}
"""
```

`setitem` and `getitem` are both slower than their corresponding `setbrack` and `getbrack`:

```
>>> timeit.timeit("getbrack(a, 2)", setup, number=10000000)
1.1424450874328613
>>> timeit.timeit("getitem(a, 2)", setup, number=10000000)
1.5957350730895996
>>> timeit.timeit("setbrack(a, 2, 3)", setup, number=10000000)
1.4236340522766113
>>> timeit.timeit("setitem(a, 2, 3)", setup, number=10000000)
2.402789831161499
```

However, if I run exactly your test, then I get your same results - `GET 'Brackets'` is slower than `GET 'Methods'`.

This means it has something to do with the classes you're using and not bracket vs. setitem per se.

Now, if I modify the test to not refer back to `self`...

```
brackets = '''d = {}

class AttrDict2(dict):
    def __getattr__(self, key):
        return d[key]
    def __setattr__(self, key, val):
        d[key] = val

o = AttrDict2()
o.att = 1'''

methods = '''d = {}

class AttrDict2(dict):
    def __getattr__(self, key):
        return d.__getitem__(key)
    def __setattr__(self, key, val):
        d.__setitem__(key, val)

o = AttrDict2()
o.att = 1'''
```

Then I again get the behavior that brackets is always faster than methods. So perhaps it has something to do with how `self[]` works in a `dict` subclass?

Performance discrepancy: obj.setitem(x,y) vs. obj[x] = y?

Solution

Problem