Wie lade ich alle Module in einen Ordner?

Könnte mir jemand eine gute Möglichkeit bieten, ein ganzes Verzeichnis von Modulen zu importieren?
Ich habe eine Struktur wie diese:

/Foo
    bar.py
    spam.py
    eggs.py

Ich habe versucht, es einfach durch Hinzufügen __init__.pyund Ausführen in ein Paket umzuwandeln , from Foo import *aber es hat nicht so funktioniert, wie ich es mir erhofft hatte.

Listen Sie alle python ( .py) - Dateien im aktuellen Ordner auf und fügen Sie sie als __all__Variable ein__init__.py

from os.path import dirname, basename, isfile, join
import glob
modules = glob.glob(join(dirname(__file__), "*.py"))
__all__ = [ basename(f)[:-3] for f in modules if isfile(f) and not f.endswith('__init__.py')]

Fügen Sie die __all__Variable zu folgendem hinzu __init__.py:

__all__ = ["bar", "spam", "eggs"]

Siehe auch http://docs.python.org/tutorial/modules.html

Update 2017: Sie möchten wahrscheinlich importlibstattdessen verwenden.

Machen Sie das Foo-Verzeichnis zu einem Paket, indem Sie ein hinzufügen __init__.py. Fügen Sie __init__.pyhinzu:

import bar
import eggs
import spam

Da Sie möchten, dass es dynamisch ist (was eine gute Idee sein kann oder nicht), listen Sie alle py-Dateien mit dem Listenverzeichnis auf und importieren Sie sie wie folgt:

import os
for module in os.listdir(os.path.dirname(__file__)):
    if module == '__init__.py' or module[-3:] != '.py':
        continue
    __import__(module[:-3], locals(), globals())
del module

Dann machen Sie von Ihrem Code aus Folgendes:

import Foo

Sie können jetzt mit auf die Module zugreifen

Foo.bar
Foo.eggs
Foo.spam

usw. from Foo import *ist aus mehreren Gründen keine gute Idee, einschließlich Namenskonflikten und der Schwierigkeit, den Code zu analysieren.

Ausgehend von Mihails Antwort glaube ich, dass der nicht-hackige Weg (wie in, die Dateipfade nicht direkt zu behandeln) der folgende ist:

1. Erstellen Sie eine leere __init__.pyDatei unterFoo/
2. Ausführen

import pkgutil
import sys


def load_all_modules_from_dir(dirname):
    for importer, package_name, _ in pkgutil.iter_modules([dirname]):
        full_package_name = '%s.%s' % (dirname, package_name)
        if full_package_name not in sys.modules:
            module = importer.find_module(package_name
                        ).load_module(full_package_name)
            print module


load_all_modules_from_dir('Foo')

Du wirst kriegen:

<module 'Foo.bar' from '/home/.../Foo/bar.pyc'>
<module 'Foo.spam' from '/home/.../Foo/spam.pyc'>

Python, schließen Sie alle Dateien in ein Verzeichnis ein:

Für Neulinge, die es einfach nicht zum Laufen bringen können und ihre Hände halten müssen.

1. Erstellen Sie einen Ordner / home / el / foo und erstellen Sie eine Datei main.pyunter / home / el / foo. Geben Sie diesen Code dort ein:

   from hellokitty import *
   spam.spamfunc()
   ham.hamfunc()

2. Erstellen Sie ein Verzeichnis /home/el/foo/hellokitty

3. Machen Sie eine Datei __init__.pyunter /home/el/foo/hellokittyund geben Sie diesen Code dort ein:

   __all__ = ["spam", "ham"]

4. Erstellen Sie zwei Python-Dateien: spam.pyund ham.pyunter/home/el/foo/hellokitty

5. Definieren Sie eine Funktion in spam.py:

   def spamfunc():
     print("Spammity spam")

6. Definieren Sie eine Funktion in ham.py:

   def hamfunc():
     print("Upgrade from baloney")

7. Starte es:

   el@apollo:/home/el/foo$ python main.py 
   spammity spam
   Upgrade from baloney

Ich habe dieses Problem selbst satt und schrieb ein Paket namens automodinit, um es zu beheben. Sie können es von http://pypi.python.org/pypi/automodinit/ erhalten .

Die Verwendung ist wie folgt:

1. Fügen Sie das automodinitPaket in Ihre setup.pyAbhängigkeiten ein.
2. Ersetzen Sie alle __init__.py-Dateien wie folgt:

__all__ = ["Ich werde umgeschrieben"]
# Ändern Sie nicht die obige Zeile oder diese Zeile!
Automodinit importieren
automodinit.automodinit (__ name__, __file__, globals ())
del automodinit
# Alles andere, was Sie wollen, kann hier nachgehen, es wird nicht geändert.

Das ist es! Von nun an setzt das Importieren eines Moduls __all__ auf eine Liste von .py [co] -Dateien im Modul und importiert auch jede dieser Dateien so, als hätten Sie Folgendes eingegeben:

for x in __all__: import x

Daher stimmt der Effekt von "von M import *" genau mit "import M" überein.

automodinit läuft gerne in ZIP-Archiven und ist daher ZIP-sicher.

Niall

Ich weiß, dass ich einen ziemlich alten Beitrag aktualisiere, und ich habe versucht, ihn zu verwenden automodinit, aber festgestellt, dass der Einrichtungsprozess für Python3 unterbrochen ist. Basierend auf Lucas Antwort habe ich eine einfachere Antwort auf dieses Problem gefunden, die mit .zip möglicherweise nicht funktioniert. Deshalb habe ich mir vorgenommen, sie hier zu teilen:

innerhalb des __init__.pyModuls von yourpackage:

#!/usr/bin/env python
import os, pkgutil
__all__ = list(module for _, module, _ in pkgutil.iter_modules([os.path.dirname(__file__)]))

und in einem anderen Paket unten yourpackage:

from yourpackage import *

Dann werden alle Module, die im Paket enthalten sind, geladen. Wenn Sie ein neues Modul schreiben, wird es ebenfalls automatisch importiert. Verwenden Sie solche Dinge natürlich mit Sorgfalt, mit großen Kräften geht eine große Verantwortung einher.

import pkgutil
__path__ = pkgutil.extend_path(__path__, __name__)
for imp, module, ispackage in pkgutil.walk_packages(path=__path__, prefix=__name__+'.'):
  __import__(module)

Ich bin auch auf dieses Problem gestoßen und dies war meine Lösung:

import os

def loadImports(path):
    files = os.listdir(path)
    imps = []

    for i in range(len(files)):
        name = files[i].split('.')
        if len(name) > 1:
            if name[1] == 'py' and name[0] != '__init__':
               name = name[0]
               imps.append(name)

    file = open(path+'__init__.py','w')

    toWrite = '__all__ = '+str(imps)

    file.write(toWrite)
    file.close()

Diese Funktion erstellt eine Datei (im bereitgestellten Ordner) mit dem Namen __init__.py, die eine __all__Variable enthält , die jedes Modul im Ordner enthält.

Zum Beispiel habe ich einen Ordner mit dem Namen Test :

Foo.py
Bar.py

In das Skript, in das die Module importiert werden sollen, schreibe ich:

loadImports('Test/')
from Test import *

Dadurch wird alles importiert Testund die __init__.pyDatei Testenthält nun:

__all__ = ['Foo','Bar']

Anurags Beispiel mit ein paar Korrekturen:

import os, glob

modules = glob.glob(os.path.join(os.path.dirname(__file__), "*.py"))
__all__ = [os.path.basename(f)[:-3] for f in modules if not f.endswith("__init__.py")]

Anurag Uniyal Antwort mit Verbesserungsvorschlägen!

#!/usr/bin/python
# -*- encoding: utf-8 -*-

import os
import glob

all_list = list()
for f in glob.glob(os.path.dirname(__file__)+"/*.py"):
    if os.path.isfile(f) and not os.path.basename(f).startswith('_'):
        all_list.append(os.path.basename(f)[:-3])

__all__ = all_list  

Sehen Sie, dass Ihre __init__.pyDefinitionen __all__. Das Modul - Pakete doc sagt

Die __init__.pyDateien sind erforderlich, damit Python die Verzeichnisse als Pakete enthaltend behandelt. Auf diese Weise wird verhindert, dass Verzeichnisse mit einem allgemeinen Namen, z. B. eine Zeichenfolge, unbeabsichtigt gültige Module verbergen, die später im Modul-Suchpfad auftreten. Im einfachsten Fall __init__.pykann es sich nur um eine leere Datei handeln, es kann jedoch auch der Initialisierungscode für das Paket ausgeführt oder die __all__später beschriebene Variable festgelegt werden.

...

Die einzige Lösung besteht darin, dass der Paketautor einen expliziten Index des Pakets bereitstellt. Die import-Anweisung verwendet die folgende Konvention: Wenn der __init__.pyCode eines Pakets eine Liste mit dem Namen definiert __all__, wird davon ausgegangen , dass es sich um die Liste der Modulnamen handelt, die importiert werden sollen, wenn ein Paketimport * auftritt. Es ist Sache des Paketautors, diese Liste auf dem neuesten Stand zu halten, wenn eine neue Version des Pakets veröffentlicht wird. Paketautoren entscheiden sich möglicherweise auch dafür, es nicht zu unterstützen, wenn sie keine Verwendung für den Import * aus ihrem Paket sehen. Beispielsweise sounds/effects/__init__.pykönnte die Datei den folgenden Code enthalten:

__all__ = ["echo", "surround", "reverse"]

Dies würde bedeuten, dass from sound.effects import *die drei genannten Submodule des Soundpakets importiert würden.

Dies ist der beste Weg, den ich bisher gefunden habe:

from os.path import dirname, join, isdir, abspath, basename
from glob import glob
pwd = dirname(__file__)
for x in glob(join(pwd, '*.py')):
    if not x.startswith('__'):
        __import__(basename(x)[:-3], globals(), locals())

Mit importlibdas einzige , was du hast hinzuzufügen ist

from importlib import import_module
from pathlib import Path

__all__ = [
    import_module(f".{f.stem}", __package__)
    for f in Path(__file__).parent.glob("*.py")
    if "__" not in f.stem
]
del import_module, Path

Schauen Sie sich das pkgutil-Modul aus der Standardbibliothek an. Damit können Sie genau das tun, was Sie wollen, solange Sie eine __init__.pyDatei im Verzeichnis haben. Die __init__.pyDatei kann leer sein.

Ich habe dafür ein Modul erstellt, das nicht auf __init__.py(oder einer anderen Zusatzdatei) basiert und mich nur die folgenden zwei Zeilen eingeben lässt:

import importdir
importdir.do("Foo", globals())

Fühlen Sie sich frei, wiederzuverwenden oder beizutragen: http://gitlab.com/aurelien-lourot/importdir

Importieren Sie sie einfach per importlib und fügen Sie sie __all__( addAktion ist optional) rekursiv im __init__.pyof-Paket hinzu.

/Foo
    bar.py
    spam.py
    eggs.py
    __init__.py

# __init__.py
import os
import importlib
pyfile_extes = ['py', ]
__all__ = [importlib.import_module('.%s' % filename, __package__) for filename in [os.path.splitext(i)[0] for i in os.listdir(os.path.dirname(__file__)) if os.path.splitext(i)[1] in pyfile_extes] if not filename.startswith('__')]
del os, importlib, pyfile_extes

Wenn from . import *es nicht gut genug ist, ist dies eine Verbesserung gegenüber der Antwort von Ted . Insbesondere ist die Verwendung von __all__bei diesem Ansatz nicht erforderlich.

"""Import all modules that exist in the current directory."""
# Ref https://stackoverflow.com/a/60861023/
from importlib import import_module
from pathlib import Path

for f in Path(__file__).parent.glob("*.py"):
    module_name = f.stem
    if (not module_name.startswith("_")) and (module_name not in globals()):
        import_module(f".{module_name}", __package__)
    del f, module_name
del import_module, Path

Beachten Sie, dass module_name not in globals()das Modul nicht erneut importiert werden soll, wenn es bereits importiert wurde, da dies zu zyklischen Importen führen kann.