在python中，如何从导入模块中定义的函数中使用/操作脚本中定义的对象？

Question

This might be a terribly simple one, but I don't know what's the "right" answer. Assume that I have a script

import utils
bar = 1
utils.foo()
print bar

Furthermore, the module utils is:

def foo():
  bar = bar+1

As given above, I ,obviously, get:

UnboundLocalError: local variable 'bar' referenced before assignment

How can I use bar inside foo() ? In my specific case, I don't really want to alter foo , but I do need to be able to use it and its state inside foo() .

One workaround would be to pass bar to foo() :

def foo(bar):
    return bar+1

And replace the third line in the script: bar = utils.foo(bar) .

However, this feels like a cumbersome solution; in particular if bar is a complex object.

I am interested in a best-practice approach the case described above.

Answer 1

Why don't you want to alter foo? If you import a module, you want to use its functionality. If the foo function is without parameters, then bar or other variables in it are used in the module utils itself. If you want to use a function with values that are not inside the module, then:

def foo(bar):
    return bar+1

is totally acceptable.

EDIT: // When you create class foo1, just set bar in the constructor. class foo1: def init (self, bar): self.bar = bar

Image this situation:

import someModule

# now you want to use a function of this module
foo()

Maybe then there would be an error like: bar is not defined or whatever --> modules are not loosely coupled. Either make the function foo as you proposed with parameters (totally acceptable) or set the bar value via a constructor or setBar method.

Answer 2

I am interested in a best-practice approach the case described above

As you describe, bar is an argument to foo , and the best practice way to pass an argument to a function is to pass it as an argument to the function.

in utils.py :

def foo(bar):
    return bar+1

And in your other script:

import utils
bar = 1
bar = utils.foo(bar)
print bar

This is the best practice approach. It follows the correct semantics. It is also testable:

import unittest
import utils

class MyTest(unittest.TestCase):

    def setUp(self):
        self.bar = 1

    def test_bar(self):
        self.assertEquals(2, utils.foo(self.bar))