Python：调用模块时移交变量

Question

In python, I would like to call a self-built module and hand it over a certain variable (eg an integer number). By this, I would like to specify from which file a module is called, ie when I import the module XY from file A, the module shall work in a certain mode (specified by the variable) and if I import module XY from a file B, the module shall work in another mode

My first idea was to do this by defining functions; but when I have plenty of functions in my module, I would have to add this extra variable in every single function individually.

Is there a more elegant way to assign a module a certain variable/ operation mode when importing it?

import mymodule # here, I'd like to hand-over a global variable to "mymodule" which can be used in the source-code of "mymodule"

mymodule.any_function_from_it()

The module "mymodule" may have the following structure:

def any_function_from_it_independent_from_global_variable():
   print("x")
   # more code to follow here

if variable_handed_over==0:
   def any_function_from_it():
      print("xy")
      # more code to follow here

else:
   def any_function_from_it():
      print("xyz")
      # more code to follow here

Answer 1

There are dozens of different ways to achieve the general end result you seem to want - but "configuring a module to behave differently based on the value of a 'passed variable' when importing" isn't one of them.

Here is a module that shows two common approaches to doing something like what you describe. The first approach, using the class ThingDoer is an object-oriented approach. The second approach, using the function get_thing_doer is a functional approach.

Module: doers.py

class ThingDoer(object):
    def __init__(self, is_special_mode=False):
        self._is_special_mode = is_special_mode


    def _special_mode_do_it(self):
        print("I'm special!")

    def _do_it(self):
        print("I'm not special, but please accept me anyway")

    def do_the_thing(self):
        if self._is_special_mode:
            self._special_mode_do_it()
            return

        self._do_it()



def get_thing_doer(is_special_mode=False):
    def special_mode_do_it():
        print("I'm special")

    def do_it():
        print("I'm not special, but please accept me anyway")

    if is_special_mode:
        return special_mode_do_it

    return do_it

You can play with how this works by creating another module in the same directory.

Module: do_it.py

from doers import get_thing_doer, ThingDoer


if __name__ == '__main__':
    foo = ThingDoer()  # is_special_mode argument takes default value of False
    foo.do_the_thing()  # prints: "I'm not special, but please love me anyway!"

    bar = ThingDoer(is_special_mode=True)
    bar.do_the_thing()  # prints: "I'm Special!"

    bazz = get_thing_doer()  # is_special_mode argument takes default value of False
    bazz()  # prints: "I'm not special, but please love me anyway!"

    buzz = get_thing_doer(is_special_mode=True)
    buzz()  # prints "I'm special!"

Then, from the command line run: python do_it.py .

More abstractly: in python conditional behaviors are not typically managed based on stateful configuration at import time.

Instead, conditional behaviors (based on configuration, or some other application state) happens as part of the flow of your program's execution.