Importing in functions instead of at the beginning or the script?

Question

Quick background: writing a module. One of my objects has methods that may or may not be successfully completed - depending on the framework used underneath my module. So a few methods first need to check what framework they actually have under their feet. Current way of tackling this is:

def framework_dependent_function():
    try:
        import module.that.may.not.be.available
    except ImportError:
        # the required functionality is not available
        # this function can not be run
        raise WrongFramework 
        # or should I just leave the previous exception reach higher levels?

[ ... and so on ... ]

Yet something in my mind keeps telling me that doing imports in the middle of a file is a bad thing. Can't remember why, can't even come up with a reason - apart from slightly messier code, I guess.

So, is there anything downright wrong about doing what I'm doing here? Perhaps other ways of scouting what environment the module is running in, somewhere near __init__?

Fred Foo · Accepted Answer · 2011-07-06 12:41:33Z

This version may be faster, because not every call to the function needs to try to import the necessary functionality:

try:
    import module.that.may.not.be.available
    def framework_dependent_function():
        # whatever
except ImportError:
    def framework_dependent_function():
        # the required functionality is not available
        # this function can not be run
        raise NotImplementedError

This also allows you to do a single attempt to import the module, then define all of the functions that might not be available in a single block, perhaps even as

def notimplemented(*args, **kwargs):
    raise NotImplementedError
fn1 = fn2 = fn3 = notimplemented

Put this at the top of your file, near the other imports, or in a separate module (my current project has one called utils.fixes). If you don't like function definition in a try/except block, then do

try:
    from module.that.may.not.be.available import what_we_need
except ImportError:
    what_we_need = notimplemented

If these functions need to be methods, you can then add them to your class later:

class Foo(object):
    # assuming you've added a self argument to the previous function
    framework_dependent_method = framework_dependent_function

Jakob Bowyer · Accepted Answer · 2011-07-06 12:33:18Z

1

Similar to larsmans suggestion but with a slight change

def NotImplemented():
    raise NotImplementedError

try:
    import something.external
except ImportError:
    framework_dependent_function = NotImplemented

def framework_dependent_function():
    #whatever
    return

I don't like the idea of function definitions in the try: except: of the import

answered Jul 6, 2011 at 12:33

Jakob Bowyer

34.8k8 gold badges80 silver badges93 bronze badges

2 Comments

Fred Foo Over a year ago

This shadows the first definition of the framework_dependent_function.

John Y Over a year ago

@Jakob: You have to put both def blocks ahead of the try, otherwise your NotImplemented version will always get rebound to the def below.

MartinStettner · Accepted Answer · 2011-07-06 12:33:50Z

1

You could also use imp.find_module (see here) in order to check for the presence of a specific module.

answered Jul 6, 2011 at 12:33

MartinStettner

29.3k15 gold badges84 silver badges106 bronze badges

Collectives™ on Stack Overflow

Importing in functions instead of at the beginning or the script?

3 Answers 3

Comments

2 Comments

Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

3 Answers 3

Comments

2 Comments

Comments

Your Answer

Sign up or log in

Post as a guest

Related