Is it a good practice to import libraries inside function bodies?

PEP 8 explicitly recommends placing imports at the top of the file.

PEP8

A couple issues off the top of my head:

1. When you call the function if the library is large it might slow down your algorithm. Whether it matters or not depends on the context and end user. This drawback could be a gain if the goal is to reduce initial script loading time.

2. If the library isn't installed your code may only fail when the function is called, which could cause a delay in failure. It is often better to fail as soon as the script is loaded so you immediately know there is a problem.

3. It's easier to read and debug code that adheres to formatting standards.

4. Potential linter implications.

In the end the drawbacks depend on the context entirely. I think the more important thing to consider is what you can accomplish by doing this, which often is very little.

It is not a good practice to import a library inside a function (if it is not a special case where the function logic is done for it), because it may affect on the duration, some libraries may do extra calculation on import and so on. Also remember the point in The Zen of Python: "Explicit is better than implicit.". PEP8 recomments keeping imports on the top as well.

If you develop your own library it is recommended to list the necessary dependencies carefully. So normally it is supposed that if you install a library it installs all the related libraries automatically. But likely in your case the dependency may be too heavy, so instead of installing it as usually, you want to have an opportunity to use the library limitedly for some simple cases. So a good practice could be a conditional import like this and checking the availability on the function call.

import warnings
try:
    import numpy
except ImportError:
    warnings.warn("numpy is not installed, some functions may not work correctly")
...
def func3():
    assert 'numpy' in globals(), "This function can't be run unless you install numpy"
    ...

Here you should not specify numpy in the dependencies, but if you access the module you will see the warning, and if you call func3 you will get a clear error.

@Kevin But it might slow down the function only on the first call, since each module is only imported once per interpreter session.

Generally, no, because you want to fail fast, i.e. if the module can't be imported, error as soon as possible, rather than erroring only when the function is first run.

For more details, see Software Engineering SE: Why should imports be made at the beginning

In your case, you might consider refactoring to put func3 in a separate module so that users don't need to import numpy in order use func1 and func2.

Personally, I believe that the only scenario where this would be acceptable is if there is a high probability that a certain function will not be used by the user.

def createapp(configfilename):
    app = Flask(name)
    app.config.frompyfile(configfilename)
    from yourapplication.model import db
    db.initapp(app)
    from yourapplication.views.admin import admin
    from yourapplication.views.frontend import frontend
    app.registerblueprint(admin)
    app.register_blueprint(frontend)
    return app