3 ms·
So python still has to look at the class for each attribute access on an instance of Foo (to find the descriptor). Any unknown attribute (say, Foo.ham) will sti
by icebraining 9y ago
So python still has to look at the class for each attribute access on an instance of Foo (to find the descriptor). Any unknown attribute (say, Foo.ham) will still result in Python looking through the class MRO to search for that attribute, and that includes dictionary searches.
Yes, it has to lookup, but the lookup is cached (see typeobject.c).
- chubot 9y agoWhere in typeobject.c? I looked, and there's a lot of stuff related to slots, but I don't see any caching. Also I did a speed test on my machine. My results are the same as the ones I've found through Google: __slots__ is not much faster. It's maybe 20% faster, whereas if it was really a dict lookup vs. index lookup I would expect it to be an order magnitude faster, or at least 5 times faster. To be clear, I'm claiming that every time you do "p.x" with a class with __slots__, at least one dictionary lookup occurs. It's not like p.x in C or Java. I could be wrong, but I've never heard the claim you're making, and I don't see any evidence it's true.
- chubot 9y agoHm I did a test with an coverage-instrumented Python binary, and you are right. I counted the number of times lookdict_string in dictobject.c is called -- call that number D. And then I made N attribute accesses like 'p.x'. Without slots, if N goes up, then D goes up. With slots, as N goes up, D stays constant. Thanks for the information -- I'll look into this more. (However, as mentioned, slots are not more than 20-30% faster on my machine, in this limited benchmark. I feel like this is a double mystery. Or maybe it's just that interpreter loop overhead or some other overhead is the bottleneck, and not dict access.)
- chubot 9y agoI'm talking to myself at this point, but I think the problem with the caching is that every attribute lookup p.x has to consult the type, not just the object. That's not true in Java. So you avoid the dictionary lookup, but you're still following extra pointers.