I'm just tossing the "static block" idea out for discussion, but if you
want a justification here are two differences between capture/static
and global/nonlocal which suggest they aren't that similar and so we
shouldn't feel obliged to use the same syntax.

(1) global and nonlocal operate on *names*, not values. E.g. after
"global x", x refers to a name in the global scope, not the local scope.

But "capture"/"static" doesn't affect the name, or the scope that x
belongs to. x is still a local, it just gets pre-initialised to the
value of x in the enclosing scope. That makes it more of a binding
operation or assignment than a declaration.

(2) If we limit this to only capturing the same name, then we can only
write (say) "static x", and that does look like a declaration. But maybe
we want to allow the local name to differ from the global name:

    static x = y

or even arbitrary expressions on the right:

    static x = x + 1

Now that starts to look more like it should be in a block of code,
especially if you have a lot of them:

    static x = x + 1
    static len = len
    static data = open("data.txt").read()

versus:

    static:
        x = x + 1
        len = len
        data = open("data.txt").read()


I acknowledge that this goes beyond what the OP asked for, and I think
that YAGNI is a reasonable response to the static block idea. I'm not
going to champion it any further unless there's a bunch of interest from
others.

(I'm saving my energy for Eiffel-like require/ensure blocks
*wink*).