在Python中，是否可以使用内部函数体内的外部函数变量？

Question

The pattern of the code that I try to build is:

def OuterFunction():
    theVariable = 0

    def InnerFunction():
        # use theVariable from OuterFunction somehow

    # the solution is not to use InnerFunction(theVariable) due to the reasons given in the text
    InnerFunction()

My hopes were there is some keyword (like global) or a way to tell the interpreter to use theVariable from the outer method's scope.

Why I need it this way: A Python script that we run before has to become module now (the collection of methods).

OuterFunction did not exist before and InnerFunction is just an example for a big number of very complex methods that bear an already existing logic.

theVariable is just an example for multiple global variables that were used in the script in all of methods that InnerFunction represents.

I do not want to change signatures of all methods, that are, by the way, nested.

EDIT:

Here is the code that crashes for me in every interpreter, with "local variable 'theVariable' referenced before assignment" error (so I could not just reference the variable):

def OuterFunction():

    theVariable = 5

    def InnerFunction():
        theVariable = theVariable + 1
        print(theVariable)

    InnerFunction()

OuterFunction()

EDIT2:

Seems trying to change the variable leads to the exception, which gives a wrong description. If InnerFunction() is changed to contain only print(theVariable) statement it works.

Answer 1

You could simply reference the 'theVariable' inside the nested InnerFunction, if you don't want to pass it's value as a parameter:

def OuterFunction():
    # Declare the variable
    theVariable = 42

    def InnerFunction():
        # Just reference the 'theVariable', using it, manipulating it, etc...
        print(theVariable)

    # Call the InnerFunction inside the OuterFunction
    InnerFunction()

# Call the OuterFunction on Main
OuterFunction()

# It will print '42' as result

Answer 2

You can just reference the variable directly, as follows;

def outer():
    x = 1
    def inner():
        print(x + 2)
    inner()
outer()

Prints: 3

Answer 3

Would this be okay with you:

def OuterFunction():
    theVariable = 0
    def InnerFunction(value):
        return value + 1
    theVariable = InnerFunction(theVariable)
    return theVariable

This way you don't have to mess with scopes and your functions are pure .