the global keyword:

[eryk sun]

On Fri, Jun 24, 2016 at 1:00 AM, Steven D'Aprano <steve at pearwood.info> wrote:
> To be precise, for the builtins module specifically, you can *read* the
> value of the variable using just x, but you cannot *assign* to it unless
> you use the fully-qualified name builtins.x.

FWIW, you can execute code in any dict:

    >>> import builtins
    >>> exec(r'''
    ... foo = 'bar'
    ... ''', vars(builtins))
    >>> builtins.foo
    'bar'

The frame for an unoptimized CPython code object (used for modules and
the class statement) uses f_builtins, f_globals, and f_locals dicts
(or possibly a mapping in the case of f_locals) respectively for its
builtin, global, and local scopes. The frame for an optimized code
object uses a fast locals array instead of f_locals, in which case the
locals() function stores a snapshot of the locals to the f_locals
dict. A frame may also have a freevars array, which has cell objects
for closures (i.e. the nonlocal scope). For optimized code (i.e. a
function, but not a class body), locals() also includes a snapshot of
nonlocals, even though this doesn't make literal sense.

The above example executes code with all 3 scopes set to the same
dict. For example:

    >>> exec(r'''
    ... import sys
    ... f = sys._getframe()
    ... print(f.f_builtins is f.f_globals is f.f_locals)
    ... ''', vars(builtins))
    True

The CPython VM doesn't have an operation to store to the builtin
scope, since the language doesn't have a statement such as "builtin"
to declare a variable in this scope. The builtin scope is used as a
fallback for operations such as LOAD_NAME and LOAD_GLOBAL -- for
loading constants such as built-in functions, exceptions, __debug__,
and also the "_" attribute that gets updated by sys.displayhook.