TL;DR) Use importlib.util.find_spec(module_name) (Python 3.4+)。

import imp
try:
    imp.find_module( eggs )
    found = True
except ImportError:
    found = False

import imp
try:
    spam_info = imp.find_module( spam )
    spam = imp.load_module( spam , *spam_info)
    imp.find_module( eggs , spam.__path__) # __path__ is already a list
    found = True
except ImportError:
    found = False

import pkgutil
eggs_loader = pkgutil.find_loader( eggs )
found = eggs_loader is not None

import importlib
spam_loader = importlib.find_loader( spam )
found = spam_loader is not None

import importlib
spam_loader = importlib.find_loader( spam )
# only accept it as valid if there is a source file for the module - no bytecode only.
found = issubclass(type(spam_loader), importlib.machinery.SourceFileLoader)

http://docs.python.org/3/library/importlib.html 涂 Python文件,改成importlib.util.find_spec。 建议的方法是<编码> 进口校准。 还有其他一些问题,如:importlib.pednery.FileFinder,如果你在具体档案之后再加装,那是有用的。 证明如何使用这些工具超出了这一范畴。

import importlib.util
spam_spec = importlib.util.find_spec("spam")
found = spam_spec is not None

这还涉及相对进口,但你必须提供一揽子起点,因此,你还可以:

import importlib.util
spam_spec = importlib.util.find_spec("..spam", package="eggs.bar")
found = spam_spec is not None
spam_spec.name == "eggs.spam"

虽然我确信有这样做的理由,但我不敢肯定会做些什么。

Warning

在试图找到一个小单元时,它将进口母体模块(用于ALL上述方法)。

food/
  |- __init__.py
  |- eggs.py

## __init__.py
print("module food loaded")

## eggs.py
print("module eggs")

were you then to run
>>> import importlib
>>> spam_spec = importlib.util.find_spec("food.eggs")
module food loaded
ModuleSpec(name= food.eggs , loader=<_frozen_importlib.SourceFileLoader object at 0x10221df28>, origin= /home/user/food/eggs.py )

接下<>

import pip


if __name__ ==  __main__ :
    for package in pip.get_installed_distributions():
        pack_string = str(package).split(" ")[0]
        try:
            if __import__(pack_string.lower()):
                print(pack_string + " loaded successfully")
        except Exception as e:
            print(pack_string + " failed with error code: {}".format(e))

zope.interface loaded successfully
zope.deprecation loaded successfully
yarg loaded successfully
xlrd loaded successfully
WMI loaded successfully
Werkzeug loaded successfully
WebOb loaded successfully
virtualenv loaded successfully
...

警告词:这将试图进口everything,因此,你看像PyYAML”这样的物品有误: 由于实际进口名称仅为yaml,因此没有称为pyyaml的模块。 只要知道你的进口,这就应该为你们 do。

如果“配制的模块”在进口时不进口母体,则没有任何可靠检查的方法。 由此可见,有许多解决办法可以解决“如果存在“灰尘”问题。

下面的解决办法涉及进口模块即使存在也会产生进口出价的问题。 我们要区分这种局面与单元不存在的情况。

<><>Python 2:>

import importlib
import pkgutil
import sys

def find_module(full_module_name):
    """
    Returns module object if module `full_module_name` can be imported.

    Returns None if module does not exist.

    Exception is raised if (existing) module raises exception during its import.
    """
    module = sys.modules.get(full_module_name)
    if module is None:
        module_path_tail = full_module_name.split( . )
        module_path_head = []
        loader = True
        while module_path_tail and loader:
            module_path_head.append(module_path_tail.pop(0))
            module_name = ".".join(module_path_head)
            loader = bool(pkgutil.find_loader(module_name))
            if not loader:
                # Double check if module realy does not exist
                # (case: full_module_name ==  paste.deploy )
                try:
                    importlib.import_module(module_name)
                except ImportError:
                    pass
                else:
                    loader = True
        if loader:
            module = importlib.import_module(full_module_name)
    return module

<>Python 3

import importlib

def find_module(full_module_name):
    """
    Returns module object if module `full_module_name` can be imported.

    Returns None if module does not exist.

    Exception is raised if (existing) module raises exception during its import.
    """
    try:
        return importlib.import_module(full_module_name)
    except ImportError as exc:
        if not (full_module_name +  . ).startswith(exc.name +  . ):
            raise

在django.utils.module_loading.module_has_submodule:

import sys
import os
import imp

def module_has_submodule(package, module_name):
    """
    check module in package
    django.utils.module_loading.module_has_submodule
    """
    name = ".".join([package.__name__, module_name])
    try:
        # None indicates a cached miss; see mark_miss() in Python/import.c.
        return sys.modules[name] is not None
    except KeyError:
        pass
    try:
        package_path = package.__path__   # No __path__, then not a package.
    except AttributeError:
        # Since the remainder of this function assumes that we re dealing with
        # a package (module with a __path__), so if it s not, then bail here.
        return False
    for finder in sys.meta_path:
        if finder.find_module(name, package_path):
            return True
    for entry in package_path:
        try:
            # Try the cached finder.
            finder = sys.path_importer_cache[entry]
            if finder is None:
                # Implicit import machinery should be used.
                try:
                    file_, _, _ = imp.find_module(module_name, [entry])
                    if file_:
                        file_.close()
                    return True
                except ImportError:
                    continue
            # Else see if the finder knows of a loader.
            elif finder.find_module(name):
                return True
            else:
                continue
        except KeyError:
            # No cached finder, so try and make one.
            for hook in sys.path_hooks:
                try:
                    finder = hook(entry)
                    # XXX Could cache in sys.path_importer_cache
                    if finder.find_module(name):
                        return True
                    else:
                        # Once a finder is found, stop the search.
                        break
                except ImportError:
                    # Continue the search for a finder.
                    continue
            else:
                # No finder found.
                # Try the implicit import machinery if searching a directory.
                if os.path.isdir(entry):
                    try:
                        file_, _, _ = imp.find_module(module_name, [entry])
                        if file_:
                            file_.close()
                        return True
                    except ImportError:
                        pass
                # XXX Could insert None or NullImporter
    else:
        # Exhausted the search, so the module cannot be found.
        return False

如果你知道档案的位置,并想要核实有关“灰色”密码档案是否有该单元,那么你可以简单地通过>在A/63/1中进行包装。 这方面的例子很迅速:

"""
Check if a module function exists or not without importing a Python package file
"""
import ast
import astor

tree = astor.parse_file( handler.py )
method_to_check =  handle 
for item in tree.body:
    if isinstance(item, ast.FunctionDef):
        if item.name == method_to_check:
            print( method exists )
            break

http://askubuntu.com/questions/588390 我如何检查一个单元是否安装在:

import sys
print( eggs  in sys.modules)

我测试了这里提供的一些解决办法,但有些解决办法截至今天已经过时:12/22/2023。 这里,我为jupyter lab下的Pyton 3.12.1实施和测试:

""" Downloads competition files from Kaggle assuming you previously downloaded the 
kaggle.json file and put in the location indicated here: 
https://github.com/Kaggle/kaggle-api?tab=readme-ov-file#api-credentials. 
It unzips the files and place them in th e dataDir location. If the folder contains 
information it deletes it before, Once the information is unziped, 
it removes the zip file"""
def downloadInputData(competitionName, dataDir= input ):
  import os,importlib.util
  if importlib.util.find_spec( kaggle ) is not None:
    ! pip install kaggle --quiet
  import kaggle
  kaggle.api.authenticate() # raise an error if the kaggle.json is not the expected location

  # download and unzip competition data
  ! rm -rf {dataDir}  # removing data files if they exist
  ! kaggle competitions download -q {competitionName} # -q for quite download
  ! mkdir -p {dataDir}
  zipFile = competitionName +  .zip 
  if not os.path.exists(zipFile):
    print(f"Error: , {zipFile}, not found.")
  else:
    # -q silent option (no output), concatenate rm to remove the zip file
    ! unzip -q {zipFile} -d {dataDir} && rm {zipFile}

# Testing
competitionName =  titanic 
downloadInputData(competitionName=competitionName)

here is the output: