在函数中引用Python控制台变量

Question

I'm not sure about the scope rules of Python. If I'm using the Python console and define a variable, then import a module and call a function in that module, is there a way to refer to the variable within the function? For instance:

>> option = 2
>> import choosingModule
>> choosingModule.choosingFunction()

And then in choosingModule:

def choosingFunction():
    if option == 0:
        doThis()
    elif option == 1:
        doThat()
    elif option == 2:
        doTheOtherOne()
    else:
        doWhateverYouFeelLike()

Obviously that is a simple example. The reason why I want to do this is that I have four different versions of a function and I want to be able to choose from the console which one should be used. The function is called fairly deep in to the code, so I don't want to have to pass a parameter through every single function call, especially as I only need to compare them at the testing stage; when this reaches the production version, only one of will be used.

So, is there any way to refer to a Python console variable in a called function? Or is there perhaps some other way to do what I need?

Answer 1

When you run the REPL, you're the __main__ module, so you can import that and use the variables from it:

def choosingFunction():
    option = __import__('__main__').option
    if option == 0:
        doThis()
    elif option == 1:
        doThat()
    elif option == 2:
        doTheOtherOne()
    else:
        doWhateverYouFeelLike()

However, a better way to do this if you don't absolutely need the variable to be defined in the console is to set it on choosingModule . Then:

def choosingFunction():
    global option
    if option == 0:
        doThis()
    elif option == 1:
        doThat()
    elif option == 2:
        doTheOtherOne()
    else:
        doWhateverYouFeelLike()

>>> import choosingModule
>>> choosingModule.option = 2
>>> choosingModule.choosingFunction()

However, you should only use either while testing. Please don't use these in production code.

Answer 2

I'd recommend you to keep that variable in the global scope and access it using the global statement.

The keyword global allows you to reference a variable in the global namespace despite the existence of another variable with the same name on the function caller.

For example: this will print "tangerine"

def foo():
    def bar():
        return fruit
    fruit = "tangerine"
    return bar2()

fruit = "banana"
print(foo()) # will print "tangerine"

But this will print "banana".

def foo2():
    def bar2():
        global fruit # fetch me the fruit in the global scope
        return fruit
    fruit = "tangerine"
    return bar2()

fruit = "banana"
print(foo2()) # will print "banana"

without the global keyword, the interpreter will follow the "LEGB rule" in order to find the variable you're trying to reference:

1. L ocal Scope: first, it'll search for the variable in the local scope, the scope in which your function statements are being executed. Local scopes are created everytime a function is called.
2. E nclosing Scopes: secondly, the interpreter will look for the variable in the "enclosing function locals", that is the functions in which your function is inserted (declared). That's where the fruit variable is found on the return fruit statement inside bar() .
3. G lobal: if the variable was not found on the namespaces above, python will try to find it among the global variables. The usage of the global statement forces python to look for it only on the global scope, thus skipping 1 and 2.
4. B uiltins: at last, python will try to find the variable among the built-in functions and constants. No magic here.

If all of the searches above fail to find the variable name, python will raise a NameError Exception:

$ NameError: name 'fruit' is not defined

Then you could do:

def choosingFunction():
    global option
    if option == 0:
        doThis()
    elif option == 1:
        doThat()
    elif option == 2:
        doTheOtherOne()
    else:
        doWhateverYouFeelLike()

>> option = 2
>> import choosingModule
>> choosingModule.choosingFunction()

Keep in mind that relying on the existence of a global variable in the module that is calling yours is considered a very bad practice, and mustn't be used in anything serious. ;)

For more information on the global statement, check the documentation: Python 3.x and Python 2.7 . And for info about the scopes and namespaces rules check here (Python 3.x) or here (Python 2.7).