What does Python's -OO remove beyond -O, and what breaks when it does?

Python's optimization level is an integer, not a boolean. `-O` sets it to 1, `-OO` sets it to 2, and `PYTHONOPTIMIZE` sets it from the environment. Level 2 is a strict superset of level 1: assertions and `if __debug__:` blocks are still compiled out, and on top of that **docstrings are not stored**. ## What exactly is dropped A docstring is the first statement of a module, class or function when that statement is a bare string literal. The compiler normally stores it as the code object's `__doc__`. At level 2 it stores nothing, and the attribute reads back as `None`. Everything else about the string is unremarkable: a string literal anywhere else in the body is a perfectly ordinary constant and survives. Type annotations survive. Comments were never in the bytecode to begin with, so there is nothing for the flag to remove. You can observe the transformation without any flags at all, because the built-in `compile()` takes the same optimization level as an argument: ```python src = 'def f():\n "the docstring"\n return 1\n' ns = {} exec(compile(src, "<demo>", "exec", optimize=2), ns) print(ns["f"].__doc__) # None ``` ## Why the blast radius is bigger than it looks The level applies to every module compiled in the process, not just to your own code. A dependency deep in the tree that reads `__doc__` will see `None` too, and it has no way to opt out. Three families of breakage show up in practice. **Introspection.** `help()` and the `pydoc` module have nothing to print but signatures. For an interactive tool or a support workflow that leans on `help()`, that is a real regression. **Docstring-driven tests.** `doctest` scans `__doc__` for interactive examples. Under `-OO` it finds none — and, importantly, it does not *fail*; it reports that zero tests ran. A suite that silently drops to zero tests is worse than one that errors. **Docstrings used as data.** Some libraries parse a docstring into something functional: usage text for a command-line interface, a description attached to an API operation, help strings assembled into a schema. Those features do not degrade gracefully; they produce empty or malformed output, often far from the flag that caused it. ## The cost/benefit is thinner than people expect The pitch for `-OO` is memory: docstrings are strings held for the life of the process, and dropping them shrinks the resident set of a large dependency tree by a few megabytes. That can matter in a constrained container or a function-as-a-service image, and it is the only honest reason to reach for it. It is not a speed flag — nothing runs faster because a string was not loaded. Weigh it against the fact that a level-2 process is not the process your tests ran in unless CI also runs at level 2. If you adopt `-OO`, adopt it everywhere, and treat "does anything in our dependency graph read `__doc__`?" as a question to answer before shipping rather than after. ## Caching and reversibility Cached bytecode is written per level, with `opt-1` and `opt-2` in the file name, and level 0 has no tag at all. That means running at level 2 does not poison the caches used by an unoptimized run: drop the flag and the interpreter reads (or rebuilds) the untagged cache and the docstrings are back. Nothing is destroyed on disk, so the failure mode is a confusing runtime, not a corrupted checkout. ## What a good answer sounds like Name the level, name the single extra thing it removes, and name a concrete casualty — `help()`, `doctest`, or a docstring-driven CLI. Then add the judgement: the only real payoff is memory, the risk is behaviour you did not test, and if you use it, the whole pipeline uses it. ## A related lever that is not a flag Because `compile()` exposes the level directly, a tool that builds code objects itself — a template engine, a plugin loader, a cache of generated functions — chooses its own level independent of how the interpreter was started. That is occasionally useful (generated helpers whose docstrings nobody will ever read) and occasionally a surprise, because such code does not follow the process-wide setting unless the caller passes it along. The same argument exists on `py_compile.compile()`, and the `compileall` command line takes `-o` to write caches for a chosen level ahead of time. ## Docstrings are not the only introspection casualty Worth saying explicitly at interview: the attribute is `None`, not missing. Code written as `func.__doc__.strip()` raises `AttributeError` under level 2 rather than returning an empty string, and code written as `func.__doc__ or ""` degrades quietly. When you harden a library against being imported into a level-2 process, that defensive `or ""` is the shape you want — never assume a docstring is present just because you wrote one.