可以在函数内部导入sys来检查是否已导入模块吗？

Question

I want a function to quickly check if a module is present before running other lines in the function. It may execute in several other programs in a large code base and I don't want to import sys at the top wherever it is run.

This answer explains the procedure to check if a module is present.

>>> import sys
>>> 'unicodedata' in sys.modules
False
>>> import unicodedata
>>> 'unicodedata' in sys.modules
True

Here a number of people voice opinions on when it is okay to import inside a function.

Is the following specific usage okay?

def some_function(foo):
    import sys
    if 'pandas' in sys.modules:
        if isinstance(foo, pd.DataFrame):
            # function continues
    else:
        print("pandas has not been imported in the code you are testing")

The use case is checking first if a pandas data frame fulfills various conditions and if so do other operations. Thing is, looking at the code base I can't always be sure if the thing I am testing the function on is a dataframe at all, so have been doing if is instance(variable, pd.DataFrame) . But what if the function is imported somewhere and run where there is no pandas at all? I'd rather it just realised that, than crashed the whole program or imported pandas unnecessarily.

Answer 1

You appear to be confused between a library being installed versus a library having been imported.

Your use-case seems to be concerned with Pandas not being installed. You can't test for this possibility with sys.modules . Just have your code import Pandas, and handle the ImportError thrown if it is not available:

try:
    import pandas as pd

    def is_dataframe(obj):
        return isinstance(obj, pd.DataFrame)
except ImportError:
    def is_dataframe(obj):
        return False

The above code codifies the test for the dataframe type that will continue to work if Pandas is not installed.

If your code needs to take into account the possibility that some third-party library returns a dataframe, just use the above code to test for that contingency (but only if you can't make your code work in some other way, like just catching the exception if something is not the type you expected to handle). Don't try to second-guess if Pandas is actually being used somewhere. Either you handle dataframes or you don't, there is no need to make this dynamic. It's not as if the isinstance(obj, pd.DataFrame) test will throw an exception if obj is not a dataframe, there is no risk here .

Note that if you do try to test for the module being imported, detect that it wasn't, and only then another module imports Pandas , you made the wrong call and your code breaks. Python is a dynamic language and imports can be done at any time during the runtime of the program.

Otherwise, if Pandas is installed, and some third-party module imports Pandas to do their work and you are worried that they might, there is no need for your code to worry about this . There is no need for you to see if a third-party module is using Pandas or not, it won't make a difference to your code. Pandas is then just an implementation detail of another module.

Lastly, if a third-party module imports Pandas, your own module won't also see it . You need to use import statements for all dependencies for that module, it doesn't matter what another module has imported here, as each module is a separate namespace. You can't just use pd.DataFrame without an import statement (or other means of binding the name pd to the module object), regardless of other modules having imported it.