Jak załadować wszystkie moduły do ​​folderu?

Czy ktoś mógłby mi zapewnić dobry sposób na import całego katalogu modułów?
Mam taką strukturę:

/Foo
    bar.py
    spam.py
    eggs.py

Próbowałem po prostu przekonwertować go na pakiet, dodając __init__.pyi wykonując, from Foo import *ale nie działało to tak, jak chciałem.

Wyświetl wszystkie .pypliki python ( ) w bieżącym folderze i umieść je jako __all__zmienne w__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')]

Dodaj __all__zmienną do __init__.pyzawierającą:

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

Zobacz także http://docs.python.org/tutorial/modules.html

Aktualizacja w 2017 r .: prawdopodobnie chcesz importlibzamiast tego użyć .

Zrób katalog Foo pakietem, dodając __init__.py. W tym __init__.pydodaj:

import bar
import eggs
import spam

Ponieważ chcesz, aby był dynamiczny (co może, ale nie musi być dobrym pomysłem), wypisz wszystkie pliki py z list dir i zaimportuj je za pomocą czegoś takiego:

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

Następnie z kodu wykonaj następujące czynności:

import Foo

Możesz teraz uzyskać dostęp do modułów za pomocą

Foo.bar
Foo.eggs
Foo.spam

itp. from Foo import *nie jest dobrym pomysłem z kilku powodów, w tym z powodu konfliktów nazw i utrudniania analizy kodu.

Rozwijając odpowiedź Mihaila, uważam, że niehackerski sposób (jak w przypadku braku bezpośredniej obsługi ścieżek plików) jest następujący:

1. stwórz pusty __init__.py plik podFoo/
2. Wykonać

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

Dostaniesz:

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

Python, dołącz wszystkie pliki do katalogu:

Dla początkujących, którzy po prostu nie mogą go uruchomić i potrzebują trzymania się za ręce.

1. Utwórz folder / home / el / foo i utwórz plik main.pyw katalogu / home / el / foo Umieść tam ten kod:

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

2. Utwórz katalog /home/el/foo/hellokitty

3. Utwórz plik __init__.pyponiżej /home/el/foo/hellokittyi umieść tam kod:

   __all__ = ["spam", "ham"]

4. Utwórz dwa pliki Pythona: spam.pyi ham.pyponiżej/home/el/foo/hellokitty

5. Zdefiniuj funkcję w spam.py:

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

6. Zdefiniuj funkcję wewnątrz ham.py:

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

7. Uruchom:

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

Sam zmęczyłem się tym problemem, więc napisałem pakiet o nazwie automodinit, aby go naprawić. Możesz go pobrać ze strony http://pypi.python.org/pypi/automodinit/ .

Użycie jest takie:

1. Uwzględnij automodinitpakiet w swoich setup.pyzależnościach.
2. Zastąp wszystkie pliki __init__.py, takie jak to:

__all__ = [„Zostanie przepisany”]
# Nie modyfikuj powyższej linii ani tej linii!
import automodinit
automodinit.automodinit (__ name__, __file__, globals ())
del automodinit
# Wszystko, co chcesz, może iść tutaj, nie zostanie zmodyfikowane.

Otóż ​​to! Odtąd importowanie modułu ustawi __all__ na listę plików .py [co] w module, a także będzie importować każdy z tych plików tak, jakbyś wpisał:

for x in __all__: import x

Dlatego efekt „z importu M *” odpowiada dokładnie „importowi M”.

automodinit chętnie korzysta z archiwów ZIP i dlatego jest bezpieczny dla ZIP.

Niall

Wiem, że aktualizuję dość stary post i próbowałem go użyć automodinit, ale dowiedziałem się, że proces instalacji dla Python3 jest uszkodzony. Tak więc, w oparciu o odpowiedź Lucy, znalazłem prostszą odpowiedź - która może nie działać z .zip - na ten problem, więc pomyślałem, że powinienem ją tutaj udostępnić:

w __init__.pymodule od yourpackage:

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

oraz w ramach innego pakietu poniżej yourpackage:

from yourpackage import *

Następnie załadujesz wszystkie moduły umieszczone w pakiecie, a jeśli napiszesz nowy moduł, zostanie on również zaimportowany automatycznie. Oczywiście, używaj tego rodzaju rzeczy ostrożnie, z wielkimi mocami wiąże się wielka odpowiedzialność.

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

Zetknąłem się również z tym problemem i to było moje rozwiązanie:

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

Ta funkcja tworzy plik (w podanym folderze) o nazwie __init__.py, który zawiera __all__zmienną, która przechowuje każdy moduł w folderze.

Na przykład mam folder o nazwie, Test który zawiera:

Foo.py
Bar.py

Więc w skrypcie chcę, aby moduły zostały zaimportowane, napiszę:

loadImports('Test/')
from Test import *

Spowoduje to zaimportowanie wszystkiego, Testa __init__.pyplik w Testbędzie teraz zawierać:

__all__ = ['Foo','Bar']

Przykład Anuraga z kilkoma poprawkami:

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

Odpowiedź Anurag Uniyal z sugerowanymi ulepszeniami!

#!/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  

Zobacz, jakie są Twoje __init__.pydefinicje __all__. Moduły - pakiety doc mówi

Te __init__.pypliki są wymagane, aby Pythona traktować jak katalogi zawierające pakiety; Ma to na celu zapobieżenie przypadkowemu ukryciu przez katalogi o wspólnej nazwie, takiej jak łańcuch, prawidłowych modułów pojawiających się później na ścieżce wyszukiwania modułów. W najprostszym przypadku __init__.pymoże być tylko pustym plikiem, ale może również wykonać kod inicjujący pakiet lub ustawić__all__ zmienną, opisaną później.

...

Jedynym rozwiązaniem jest podanie przez autora jawnego indeksu pakietu. Instrukcja importu używa następującej konwencji: jeśli __init__.pykod pakietu definiuje nazwaną listę __all__, przyjmuje się, że jest to lista nazw modułów, które powinny zostać zaimportowane po napotkaniu z importu pakietu *. Od autora pakietu zależy, czy ta lista będzie aktualna, kiedy zostanie wydana nowa wersja pakietu. Autorzy pakietów mogą również zdecydować, że nie będą go obsługiwać, jeśli nie widzą potrzeby importowania * ze swojego pakietu. Na przykład plik sounds/effects/__init__.pymoże zawierać następujący kod:

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

Oznaczałoby to, from sound.effects import *że zaimportujemy trzy nazwane podmoduły pakietu dźwiękowego.

To najlepszy sposób, jaki do tej pory znalazłem:

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

Korzystanie importlibjedyną rzeczą, którą muszę dodać jest

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

Spójrz na moduł pkgutil ze standardowej biblioteki. Pozwoli ci to robić dokładnie to, co chcesz, o ile masz __init__.pyplik w katalogu. __init__.pyPlik może być pusty.

Stworzyłem do tego moduł, który nie polega na __init__.py(ani na żadnym innym pliku pomocniczym) i każe mi pisać tylko następujące dwie linie:

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

Zapraszam do ponownego użycia lub współtworzenia: http://gitlab.com/aurelien-lourot/importdir

Wystarczy zaimportować je za pomocą importlib i dodać je __all__( addakcja jest opcjonalna) w rekursie w __init__.pypakiecie.

/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

Gdy from . import *nie jest wystarczająco dobry, jest to poprawa w stosunku do odpowiedzi Teda . W szczególności zastosowanie __all__tego podejścia nie jest konieczne.

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

Należy pamiętać, że module_name not in globals()ma to na celu uniknięcie ponownego importowania modułu, jeśli jest już zaimportowany, ponieważ może to spowodować ryzyko cyklicznego importu.