循环的函数中的模块导入会循环导入吗？

Question

I am not yet at the level where I have tools (or know how to develop or use them) for testing and profiling seemingly simple things like my questions so I turn to you.

I have a function that checks a condition and based on that condition picks the best mathematical tool to work with (different modules) but this function is applied on windows of an array and so is looped. Different imports may occur from window to window but this leads me to wonder if the imports are actually being looped and if this is a performance issue at all.

Here is an example from the matplotlib source

def pause(interval):
    """
    Pause for *interval* seconds.

    If there is an active figure it will be updated and displayed,
    and the GUI event loop will run during the pause.

    If there is no active figure, or if a non-interactive backend
    is in use, this executes time.sleep(interval).

    This can be used for crude animation. For more complex
    animation, see :mod:`matplotlib.animation`.

    This function is experimental; its behavior may be changed
    or extended in a future release.

    """
    backend = rcParams['backend']
    if backend in _interactive_bk:
        figManager = _pylab_helpers.Gcf.get_active()
        if figManager is not None:
            canvas = figManager.canvas
            canvas.draw()
            show(block=False)
            canvas.start_event_loop(interval)
            return

    # No on-screen figure is active, so sleep() is all we need.
    import time
    time.sleep(interval)

If I in a loop alternate opening and closing figures will time be imported every other iteration? Or just imported the first time the import is called on and subsequent imports ignored?

Thanks

Answer 1

After an import completes successfully, the imported module is cached in sys.modules and subsequent import statements will find the module in sys.modules so the module will not be reimported. You can force a module reimport with the reload builtin function.

Fromthe documentation :

The first place checked during import search is sys.modules . This mapping serves as a cache of all modules that have been previously imported, including the intermediate paths. So if foo.bar.baz was previously imported, sys.modules will contain entries for foo , foo.bar , and foo.bar.baz .

PEP 8 (the Python style guide) recommends that imports should be at the top of the file, not within methods. Valid reasons to break this rule (giving a "late import") are if a module import is expensive and used only rarely in your program (and not at all in a typical execution), or to resolve a circular import dependency (though in that case you should try to resolve the circularity by splitting module functionality better). For a module like time , that is built in to Python, there's very little reason to use a late import.

Answer 2

The actual action of import only happens once (which is why you explicitly need to reload when you do want it to be imported again) -- the interpreter checks to see if it's already been imported.

But it is usually more pythonic to put all of your imports at the top of the module.