Difference between importing python library within function versus importing globally?

问题

Suppose I want to import a python library for use inside a function. Is it better to import the library within the function or import it globally?

Do this

def test_func:
    import pandas as pd
    # code implementation

or have the line below at the top of the python file to import globally?

import pandas as pd

What are the pros and cons of each approach? Which is the best practice in python?

I am using python v3.6

EDIT: Some clarifications to make.

Suppose I have 2 functions.

def func1:
    import pandas as pd
    # code implementation   

def func2:
    import pandas as pd
    # code implementation

The python script runs both functions. Will the library be imported twice or is the python compiler smart enough to import it only once? This has performance implications.

回答1:

It's a difference in name-visibility and execution time-point. The module-level import is imported when the file you are loading is imported or run itself. The function local one obviously only if the function is run. The imported names are either visible to all things in the file, or just within the function the import is executed in.

As there is a cost for hitting the import statement (albeit a small one, but still), the local one will always execute, not just once. It will not fully re-import the module though, python caches modules once they are imported the first time (see reload and sys.modules).

The best practice clearly is to use module level imports, and that's what you see in 99.999% of code. A huge reason is maintainability - if you want to understand what dependencies a module has, it's convenient to just look at the top, instead of having to comb through all code.

So when to use function local imports?

There are three scenarios:

you can't use the import earlier. This happens when e.g. a backend for a db or other system/functionality is chosen at runtime through configuration or system inspection.
you otherwise have circular imports. This is a rare case and also a code-smell, so if that is necessary, consider refactoring.
reducing startup-time by deferring module imports. This is very rarely useful though.

So for your case, the answer is a quick and simple "don't do it".

回答2:

The module will be loaded when you import it, so if you need to import a rarely used module but cost a lot of time to initialize, you should import it when you need it.

Actually, if we just care about performance but not readability, it maybe always better to import module when we really need it.

But we need to keep our program maintainable. Importing all modules on the top is the most explicit way to tell others and author himself which modules are used.

To sum up, if you really have a very costly but rarely used module, you should import it locally. Otherwise you should import them on the top.

来源：https://stackoverflow.com/questions/46662422/difference-between-importing-python-library-within-function-versus-importing-glo

标签

python

python-3.x

python-import