Why does `getattr(obj, "__cache")` fail when `self.__cache` works inside the class?

This question separates people who have *read* that double underscores are mangled from people who know **where** the mangling happens. The answer is: in the compiler, over identifiers in source text. Everything that reaches an attribute through a *string* at run time bypasses it entirely. ## The concrete split Consider an image-thumbnail worker that keeps a rendered-thumbnail cache running at an 83% hit rate: ```python class ThumbnailWorker: def __init__(self): self.__cache = {} def store(self, key, value): self.__cache[key] = value ``` Inside the class body the compiler rewrote both occurrences to `self._ThumbnailWorker__cache`. That is the key in the instance dictionary. Now a generic stats helper walks a list of attribute names and calls `getattr(worker, name)`; for `"__cache"` it raises `AttributeError: 'ThumbnailWorker' object has no attribute '__cache'`. Nothing rewrote the string, so nothing matched. ## The write side is worse than the read side A failed read is loud. A write is silent: ```python setattr(worker, "__cache", "unrelated") vars(worker) # {'_ThumbnailWorker__cache': {...}, '__cache': 'unrelated'} ``` The instance now carries two attributes whose names differ only by the prefix, and the class's own methods will keep using the mangled one forever. Configuration loaders, test helpers that "inject" a fake, deserializers rebuilding an object from a dict, and fixtures that patch state by string name all hit this. The object looks patched and behaves as though it was not. ## Everything reflective sees the mangled spelling * `vars(obj)` and `obj.__dict__` are keyed by the mangled name. * `dir(obj)` lists the mangled name. * `hasattr(obj, "__cache")` is `False`; `hasattr(obj, "_ThumbnailWorker__cache")` is `True`. * A `__getattr__` fallback defined on the class is called with the **mangled** name, because the failed lookup was for the mangled attribute — a `__getattr__` that dispatches on the string it receives must expect `_ThumbnailWorker__missing`, not `__missing`. * `copy`, `pickle` and any `__dict__`-walking serializer round-trip the mangled key, which means the class name is now embedded in your serialized data. Rename the class and old payloads no longer load. ## The one string that *is* mangled There is a single well-known exception, and knowing it demonstrates that you understand the boundary rather than a slogan: the entries of `__slots__` are mangled by the class-creation machinery when the slot descriptors are built. That is a deliberate special case so that `self.__buf` inside the body matches the slot declared as `"__buf"`. It is not a general rule about strings — no other string in the language is treated that way. ## How to work with it First, if reflective code must reach an attribute, do not name it with two leading underscores. A single underscore already says "internal" and stays greppable, patchable and serializable. Second, if you must reach one you do not own, build the name rather than hard-coding it — `f"_{type(obj).__name__}__cache"` is fine for a debug script, but note that it is wrong the moment the attribute was defined in a base class rather than in the object's own class, since the prefix is the *defining* class's name. Third, when reviewing framework-shaped code — anything that resolves attribute names from configuration, from a schema or from a test fixture — treat every double-underscore attribute in the target classes as a trap and say so. ## Diagnosing it in the wild The symptom is usually "the attribute exists but reflection cannot find it", or "I set it and nothing changed". One line settles both: print `vars(obj)`. A `_ClassName__` prefixed key next to a bare double-underscore key is the whole diagnosis, and the class name in the prefix tells you which class body performed the rewrite. ## The same trap through the standard library Anything in the stdlib that takes an attribute *name as a string* inherits the problem: ```python import operator operator.attrgetter("__cache")(worker) # AttributeError: 'ThumbnailWorker' object has no attribute '__cache' ``` `unittest.mock.patch.object(worker, "__cache", {})` fails the same way — it resolves its target with `getattr`, so it raises `AttributeError: ... does not have the attribute '__cache'` before any patching happens, and you have to pass `"_ThumbnailWorker__cache"` for the patch to take. `patch("pkg.mod.Cls.__cache")` in string form has exactly the same requirement. When a test cannot patch an attribute that plainly exists on the object, the mangled name is the first thing to check, and it is a good argument for giving anything a test needs to replace a single-underscore name.