Jak zaimportować wszystkie moduły podrzędne?

Jest to oparte na odpowiedzi, którą dostarczył kolypto, ale jego odpowiedź nie wykonuje rekurencyjnego importu pakietów, podczas gdy ta. Chociaż nie jest to wymagane przez główne pytanie, uważam, że import rekurencyjny ma zastosowanie i może być bardzo przydatny w wielu podobnych sytuacjach. Ja, na przykład, znalazłem to pytanie podczas wyszukiwania na ten temat.

Jest to przyjemny, czysty sposób na zaimportowanie modułów podpakietu, powinien być również przenośny i używa standardowego lib dla python 2.7+ / 3.x.

import importlib
import pkgutil


def import_submodules(package, recursive=True):
    """ Import all submodules of a module, recursively, including subpackages

    :param package: package (name or actual module)
    :type package: str | module
    :rtype: dict[str, types.ModuleType]
    """
    if isinstance(package, str):
        package = importlib.import_module(package)
    results = {}
    for loader, name, is_pkg in pkgutil.walk_packages(package.__path__):
        full_name = package.__name__ + '.' + name
        results[full_name] = importlib.import_module(full_name)
        if recursive and is_pkg:
            results.update(import_submodules(full_name))
    return results

Użycie:

# from main.py, as per the OP's project structure
import scripts
import_submodules(scripts)

# Alternatively, from scripts.__init__.py
import_submodules(__name__)

Po prostu działa i umożliwia względny import wewnątrz pakietów:

def import_submodules(package_name):
    """ Import all submodules of a module, recursively

    :param package_name: Package name
    :type package_name: str
    :rtype: dict[types.ModuleType]
    """
    package = sys.modules[package_name]
    return {
        name: importlib.import_module(package_name + '.' + name)
        for loader, name, is_pkg in pkgutil.walk_packages(package.__path__)
    }

Użycie:

__all__ = import_submodules(__name__).keys()

Nie tak czysto, jak bym chciała, ale żadna z czystszych metod nie zadziałała. Uzyskuje się w ten sposób określone zachowanie:

Struktura katalogu:

| pkg
|--| __init__.py
   | main.py
   | scripts
   |--| __init__.py
      | script1.py
      | script2.py
      | script3.py

Gdzie pkg/scripts/__init__.py jest puste, a pkg/__init__.py zawiera:

import importlib as _importlib
import pkgutil as _pkgutil
__all__ = [_mod[1].split(".")[-1] for _mod in
           filter(lambda _mod: _mod[1].count(".") == 1 and not 
                               _mod[2] and __name__ in _mod[1],
                  [_mod for _mod in _pkgutil.walk_packages("." + __name__)])]
__sub_mods__ = [".".join(_mod[1].split(".")[1:]) for _mod in
                filter(lambda _mod: _mod[1].count(".") > 1 and not 
                                    _mod[2] and __name__ in _mod[1],
                       [_mod for _mod in 
                        _pkgutil.walk_packages("." + __name__)])]
from . import *
for _module in __sub_mods__:
    _importlib.import_module("." + _module, package=__name__)

Sam miałem dość tego problemu, więc napisałem pakiet o nazwie automodinit, aby go naprawić. Możesz go pobrać z http://pypi.python.org/pypi/automodinit / . użycie wygląda tak:

1. Dołącz pakiet automodinit do swoich zależności setup.py.
2. Dodaj następujący tekst na początku pliku __init__.py:

__all__ = ["I will get rewritten"]
# Don't modify the line above, or this line!
import automodinit
automodinit.automodinit(__name__, __file__, globals())
del automodinit
# Anything else you want can go after here, it won't get modified.

for x in __all__: import x

Dlatego efekt from M import * pasuje dokładnie import M.

Automodinit jest zadowolony z działania z archiwów ZIP i dlatego jest bezpieczny dla ZIP.

Pisałem małą bibliotekę osobistą i cały czas dodawałem nowe moduły, więc napisałem skrypt powłoki, aby szukać skryptów i tworzyć __init__.py ' s. skrypt jest uruchamiany tuż poza głównym katalogiem mojego pakietu, pylux.

Wiem, że prawdopodobnie nie jest to odpowiedź, której szukasz, ale to servered swój cel dla mnie i może być przydatna dla kogoś innego, zbyt.

#!/bin/bash

echo 'Traversing folder hierarchy...'

CWD=`pwd`


for directory in `find pylux -type d -exec echo {} \;`;
do
    cd $directory
    #echo Entering $directory
    echo -n "" > __init__.py

    for subdirectory in `find . -type d -maxdepth 1 -mindepth 1`;
    do
        subdirectory=`echo $subdirectory | cut -b 3-`
        #echo -n '    ' ...$subdirectory
        #echo -e '\t->\t' import $subdirectory
        echo import $subdirectory >> __init__.py
    done

    for pyfile in *.py ;
    do
        if [ $pyfile = $(echo __init__.py) ]; then
            continue
        fi
        #echo -n '    ' ...$pyfile
        #echo -e '\t->\t' import `echo $pyfile | cut -d . -f 1`
        echo import `echo $pyfile | cut -d . -f 1` >> __init__.py
    done
    cd $CWD

done


for directory in `find pylux -type d -exec echo {} \;`;
do
    echo $directory/__init__.py:
    cat $directory/__init__.py | awk '{ print "\t"$0 }'
done

Bawiłem się odpowiedzią Joe Kingtona i zbudowałem rozwiązanie, które wykorzystuje globals i get/setattr, a więc nie potrzebuje evalu. Drobna modyfikacja polega na tym, że zamiast bezpośrednio używać packages __path__ dla walk_packages, używam katalogu nadrzędnego packages, a następnie importuję tylko Moduły zaczynające się od __name__ + ".". Zostało to zrobione, aby niezawodnie pobrać wszystkie podpakiety z walk_packages - w moim przypadku użycia miałem podpakiet o nazwie test, który spowodował, że pkgutil iterował nad test pakietem z Pythona biblioteka; ponadto użycie __path__ nie spowoduje rekurencji do podkatalogów packages. Wszystkie te problemy zostały zaobserwowane przy użyciu jython i python2. 5, poniższy kod jest testowany tylko w jython do tej pory.

Zauważ również, że pytanie OPs mówi tylko o importowaniu wszystkich modułów z pakietu, ten kod rekurencyjnie importuje również wszystkie pakiety.

from pkgutil import walk_packages
from os import path

__all__ = []
__pkg_prefix = "%s." % __name__
__pkg_path = path.abspath(__path__[0]).rsplit("/", 1)[0] #parent directory

for loader, modname, _ in walk_packages([__pkg_path]):
    if modname.startswith(__pkg_prefix):
        #load the module / package
        module = loader.find_module(modname).load_module(modname)
        modname = modname[len(__pkg_prefix):] #strip package prefix from name
        #append all toplevel modules and packages to __all__
        if not "." in modname:
            __all__.append(modname)
            globals()[modname] = module
        #set everything else as an attribute of their parent package
        else:
            #get the toplevel package from globals()
            pkg_name, rest = modname.split(".", 1)
            pkg = globals()[pkg_name]
            #recursively get the modules parent package via getattr
            while "." in rest:
                subpkg, rest = rest.split(".", 1)
                pkg = getattr(pkg, subpkg)
            #set the module (or package) as an attribute of its parent package
            setattr(pkg, rest, module)

Jako przyszłe ulepszenie postaram się wprowadzić tę dynamikę za pomocą __getattr__ Hooka na pakiecie, więc rzeczywiste moduły są tylko importowane, gdy są dostępne...

To działa mi ładnie w Pythonie 3.3. Zauważ, że działa to tylko dla podmoduł, które znajdują się w plikach w tym samym katalogu co __init__.py. Z pewną pracą można go jednak ulepszyć do obsługi podmoduł w katalogach.

from glob import iglob
from os.path import basename, relpath, sep, splitext

def import_submodules(__path__to_here):
    """Imports all submodules.
    Import this function in __init__.py and put this line to it:
    __all__ = import_submodules(__path__)"""
    result = []
    for smfile in iglob(relpath(__path__to_here[0]) + "/*.py"):
        submodule = splitext(basename(smfile))[0]
        importstr = ".".join(smfile.split(sep)[:-1])
        if not submodule.startswith("_"):
            __import__(importstr + "." + submodule)
            result.append(submodule)
    return result

W Pythonie 3, możesz umieścić następujący kod w pliku scripts.__init__.py:

import os
import os.path as op

__all__ = [
    op.splitext(f)[0]  # remove .py extension
    for f in os.listdir(BASE_DIR)  # list contents of current dir
    if not f.startswith('_') and
    ((op.isfile(op.join(BASE_DIR, f)) and f.endswith('.py')) or
     (op.isdir(op.join(BASE_DIR, f)) and op.isfile(op.join(BASE_DIR, f, '__init__.py'))))
]

from . import *  # to make `scripts.script1` work after `import script`

Aby uzyskać więcej informacji na temat importu Pythona, polecam wystąpienie Davida Beazleya na PyCon 2015: https://youtu.be/0oTh1CXRaQ0