Muszę wiedzieć, czy istnieje moduł Pythona, bez importowania go.

Importowanie czegoś, co może nie istnieć (nie tego, czego chcę):

try:
    import eggs
except ImportError:
    pass

Python2

Aby sprawdzić, czy import może znaleźć coś w python2, użyj imp

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

Aby znaleźć import z kropkami, musisz zrobić więcej:

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

Możesz także użyć pkgutil.find_loader(mniej więcej tego samego, co część python3

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

Python3

Python3 ≤ 3,3

Powinieneś użyć importlib, jak sobie z tym radziłem:

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

Oczekuję, że jeśli znajdziesz do tego ładowarkę, to ona istnieje. Możesz też podejść do tego nieco sprytniej, na przykład odfiltrowywać, które programy ładujące zaakceptujesz. Na przykład:

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)

Python3 ≥ 3.4

W importlib.find_loader Pythonie 3.4 dokumentacja pythona została wycofana na korzyść importlib.util.find_spec. Zalecaną metodą jest importlib.util.find_spec. Istnieją inne importlib.machinery.FileFinder, które są przydatne, jeśli chcesz załadować określony plik. Ustalenie, jak ich używać, wykracza poza zakres tego.

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

Działa to również w przypadku importu względnego, ale musisz dostarczyć pakiet startowy, więc możesz również:

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

Chociaż jestem pewien, że istnieje powód, aby to zrobić - nie jestem pewien, co by to było.

OSTRZEŻENIE

Próbując znaleźć podmoduł, zaimportuje on moduł nadrzędny (dla wszystkich powyższych metod)!

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.find_spec("food.eggs")
module food loaded
ModuleSpec(name='food.eggs', loader=<_frozen_importlib.SourceFileLoader object at 0x10221df28>, origin='/home/user/food/eggs.py')

mile widziane komentarze dotyczące obejścia tego problemu

Podziękowanie

• @rvighne dla importlib
• @ lucas-guido dla Pythona3.3 + depricating find_loader
• @enpenax dla zachowania pkgutils.find_loader w pythonie2.7

Po użyciu odpowiedzi yarbelk zrobiłem to, aby nie musieć importować ìmp.

try:
    __import__('imp').find_module('eggs')
    # Make things with supposed existing module
except ImportError:
    pass

Przydatne settings.pyna przykład w Django .

Python 3> = 3.6: ModuleNotFoundError

ModuleNotFoundErrorZostał wprowadzony w Pythonie 3.6 i mogą być wykorzystane do tego celu

try:
    import eggs
except ModuleNotFoundError:
    # Error handling
    pass

Błąd jest zgłaszany, gdy nie można znaleźć modułu lub jednego z jego elementów nadrzędnych . Więc

try:
    import eggs.sub
except ModuleNotFoundError as err:
    # Error handling
    print(err)

wypisze komunikat, który wygląda tak, No module named 'eggs'jakby eggsnie można było znaleźć modułu; ale wypisze coś takiego No module named 'eggs.sub', jak gdyby subnie można było znaleźć modułu, ale można znaleźć eggspakiet.

Zobacz dokumentację systemu importu, aby uzyskać więcej informacji na tematModuleNotFoundError

Python 2, bez polegania na ImportError

Dopóki aktualna odpowiedź nie zostanie zaktualizowana, oto sposób na Python 2

import pkgutil
import importlib

if pkgutil.find_loader(mod) is not None:
    return importlib.import_module(mod)
return None

Dlaczego inna odpowiedź?

Wiele odpowiedzi wykorzystuje przechwycenie pliku ImportError. Problem w tym, że nie wiemy, co rzuca ImportError.

Jeśli zaimportujesz istniejący moduł i zdarzy się, że ImportErrorw Twoim module znajduje się jakiś (np. Literówka w linii 1), to spowoduje, że moduł nie istnieje. Zajmie ci to sporo czasu, aby dowiedzieć się, że twój moduł istnieje, ImportErrorzostał złapany i powoduje cichą awarię.

odpowiedź go_as jako jedna linijka

 python -c "help('modules');" | grep module

Natknąłem się na to pytanie, szukając sposobu na sprawdzenie, czy moduł jest ładowany z linii poleceń i chciałbym podzielić się przemyśleniami na temat tych, którzy idą za mną i szukają tego samego:

Metoda pliku skryptu Linux / UNIX : utwórz plik module_help.py:

#!/usr/bin/env python

help('modules')

Następnie upewnij się, że jest wykonywalny: chmod u+x module_help.py

I zadzwoń pipedo grep:

./module_help.py | grep module_name

Wywołaj wbudowany system pomocy . (Ta funkcja jest przeznaczona do użytku interaktywnego .) Jeśli nie podano żadnego argumentu, system pomocy interaktywnej uruchamia się na konsoli interpretera. Jeśli argument jest ciągiem znaków , wówczas ciąg jest wyszukiwany jako nazwa modułu , funkcji, klasy, metody, słowa kluczowego lub tematu dokumentacji, a na konsoli jest drukowana strona pomocy. Jeśli argumentem jest obiekt innego rodzaju, generowana jest strona pomocy dotycząca tego obiektu.

Metoda interaktywna : w konsoli loadpython

>>> help('module_name')

Jeśli zostanie znaleziony, zakończ czytanie, wpisując q
Aby wyjść z sesji interaktywnej Pythona, naciśnij Ctrl+D

Metoda pliku skryptu Windows również kompatybilna z Linux / UNIX i ogólnie lepsza :

#!/usr/bin/env python

import sys

help(sys.argv[1])

Wywołanie go z polecenia, takiego jak:

python module_help.py site  

Wynikałoby:

Pomoc na stronie modułu:

NAME witryna - Dołącz ścieżki wyszukiwania modułów dla pakietów innych firm do sys.path.

FILE /usr/lib/python2.7/site.py

MODULE DOCS http://docs.python.org/library/site

DESCRIPTION
...
:

i musiałbyś nacisnąć, qaby wyjść z trybu interaktywnego.

Korzystanie z nieznanego modułu:

python module_help.py lkajshdflkahsodf

Wynikałoby:

nie znaleziono dokumentacji Pythona dla 'lkajshdflkahsodf'

i wyjdź.

Użyj jednej z funkcji z pkgutil , na przykład:

from pkgutil import iter_modules

def module_exists(module_name):
    return module_name in (name for loader, name, ispkg in iter_modules())

Prostsza instrukcja if z AskUbuntu: Jak sprawdzić, czy moduł jest zainstalowany w Pythonie?

import sys
print('eggs' in sys.modules)

Możesz po prostu napisać mały skrypt, który spróbuje zaimportować wszystkie moduły i powie Ci, które z nich nie działają, a które działają:

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))

Wynik:

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
...

Słowo ostrzeżenia, że ​​spróbuje zaimportować wszystko, więc zobaczysz rzeczy, takie jak PyYAML failed with error code: No module named pyyamlfaktyczna nazwa importu to po prostu yaml. Tak długo, jak wiesz, że importujesz, powinno to załatwić sprawę.

Napisałem tę funkcję pomocniczą:

def is_module_available(module_name):
    if sys.version_info < (3, 0):
        # python 2
        import importlib
        torch_loader = importlib.find_loader(module_name)
    elif sys.version_info <= (3, 3):
        # python 3.0 to 3.3
        import pkgutil
        torch_loader = pkgutil.find_loader(module_name)
    elif sys.version_info >= (3, 4):
        # python 3.4 and above
        import importlib
        torch_loader = importlib.util.find_spec(module_name)

    return torch_loader is not None

Możesz również użyć importlibbezpośrednio

import importlib

try:
    importlib.import_module(module_name)
except ImportError:
    # Handle error

Nie ma sposobu, aby wiarygodnie sprawdzić, czy „moduł z kropkami” jest możliwy do zaimportowania bez importowania jego pakietu nadrzędnego. Mówiąc to, istnieje wiele rozwiązań problemu „jak sprawdzić, czy istnieje moduł Pythona”.

Poniższe rozwiązanie rozwiązuje problem polegający na tym, że importowany moduł może wywołać ImportError, nawet jeśli istnieje. Chcemy odróżnić tę sytuację od takiej, w której moduł nie istnieje.

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

w 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