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

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 c开发者_运维问答an 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__?

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

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

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