Bir klasöre tüm modüller nasıl yüklenir?

Birisi bana bütün bir modül dizini almanın iyi bir yolunu sağlayabilir mi?
Ben böyle bir yapı var:

/Foo
    bar.py
    spam.py
    eggs.py

Sadece ekleyerek __init__.pyve yaparak bir pakete dönüştürmeyi denedim from Foo import *ama umduğum şekilde çalışmadı.

.pyGeçerli klasördeki tüm python ( ) dosyalarını listele ve __all__değişken olarak__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')]

__all__Değişkeni __init__.pyiçerenlere ekleyin :

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

Ayrıca bkz. Http://docs.python.org/tutorial/modules.html

2017'de güncelleme: muhtemelen importlibbunun yerine kullanmak istersiniz .

Bir ekleyerek Foo dizinini bir paket yapın __init__.py. Bu __init__.pyekte:

import bar
import eggs
import spam

Dinamik olmasını istediğinizden (iyi bir fikir olabilir veya olmayabilir), tüm py dosyalarını list dir ile listeleyip aşağıdaki gibi bir şeyle içe aktarın:

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

Ardından, kodunuzdan bunu yapın:

import Foo

Artık modüllere

Foo.bar
Foo.eggs
Foo.spam

vs. from Foo import *, isim çakışmaları ve kodun analizini zorlaştırmak gibi çeşitli nedenlerle iyi bir fikir değildir.

Mihail'in cevabını genişleterek, hackish olmayan yolun (dosya yollarını doğrudan işlememe gibi) aşağıdaki olduğuna inanıyorum:

1. __init__.pyaltında boş bir dosya oluşturFoo/
2. gerçekleştirmek

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

Alacaksınız:

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

Python, bir dizinin altındaki tüm dosyaları dahil et:

Ellerini tutması gereken işe yaramayan yeni başlayanlar için.

1. Bir klasör / home / el / foo yapın ve main.py/ home / el / foo altında bir dosya oluşturun. Bu kodu buraya yerleştirin:

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

2. Bir dizin oluşturun /home/el/foo/hellokitty

3. __init__.pyAltında bir dosya oluşturun /home/el/foo/hellokittyve bu kodu buraya yerleştirin:

   __all__ = ["spam", "ham"]

4. İki python dosyası oluşturun: spam.pyve ham.pyaltı/home/el/foo/hellokitty

5. Spam.py içinde bir işlev tanımlayın:

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

6. Ham.py içinde bir işlev tanımlayın:

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

7. Çalıştır:

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

Bu sorundan kendim bıktım, bu yüzden düzeltmek için automodinit adlı bir paket yazdım. Http://pypi.python.org/pypi/automodinit/ adresinden edinebilirsiniz .

Kullanımı şöyle:

1. automodinitPaketi setup.pybağımlılıklarınıza dahil edin .
2. Tüm __init__.py dosyalarını şu şekilde değiştirin:

__all__ = ["Yeniden yazacağım"]
# Yukarıdaki satırı veya bu satırı değiştirmeyin!
içe aktarma otomatiği
automodinit.automodinit (__ name__, __file__, globaller ())
del automodinit
# İstediğiniz başka bir şey buradan sonra gidebilir, değiştirilmez.

Bu kadar! Şu andan itibaren bir modül içe aktarıldığında __all__ modüldeki .py [co] dosyaları listesine ayarlanacak ve bu dosyaların her biri siz yazmışsınız gibi içe aktarılacaktır:

for x in __all__: import x

Bu nedenle, "M içe aktarımından *" etkisi tam olarak "içe aktarma M" ile eşleşir.

automodinit ZIP arşivlerinin içinden koşmaktan mutlu olduğu için ZIP güvenlidir.

Niall

Oldukça eski bir automodinitgönderiyi güncellediğimi biliyorum ve kullanmayı denedim , ancak kurulum işleminin python3 için bozulduğunu öğrendim. Bu nedenle, Luca'nın cevabına dayanarak, bu konuya .zip ile çalışmayabilir - daha basit bir cevap buldum, bu yüzden burada paylaşmam gerektiğini düşündüm:

__init__.pymodül içinde yourpackage:

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

ve aşağıdaki başka bir paket içinde yourpackage:

from yourpackage import *

Daha sonra paketin içine yerleştirilen tüm modüller yüklenir ve yeni bir modül yazarsanız, otomatik olarak da içe aktarılır. Tabii ki, bu tür şeyleri dikkatle kullanın, büyük güçlerle büyük sorumluluklar gelir.

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

Ayrıca bu sorunla karşılaştım ve bu benim çözümüm oldu:

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

Bu işlev, klasördeki her modülü tutan __init__.pybir __all__değişken içeren bir dosya (sağlanan klasörde) oluşturur .

Örneğin, adında bir klasör var Test :

Foo.py
Bar.py

Komut dosyasında modüllerin içe aktarılmasını istiyorum:

loadImports('Test/')
from Test import *

Bu, her şeyi içeri aktarır Testve içindeki __init__.pydosya Testşimdi şunları içerir:

__all__ = ['Foo','Bar']

Anurag'ın birkaç düzeltmeyle örneği:

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

Önerilen iyileştirmelerle Anurag Uniyal cevabı !

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

Senin o Bkz __init__.pytanımlayıp __all__. Modülleri - paketler doc diyor

__init__.pyDosyaları Python tedavi paket içeren dizinleri yapmaları gerekmektedir; bu, dize gibi ortak bir ada sahip dizinlerin, daha sonra modül arama yolunda gerçekleşen geçerli modülleri yanlışlıkla gizlemesini önlemek için yapılır. En basit durumda, __init__.pyboş bir dosya olabilir, ancak paket için başlatma kodunu yürütebilir veya __all__daha sonra açıklanan değişkeni ayarlayabilir .

...

Tek çözüm, paket yazarının paketin açık bir dizinini sağlamasıdır. İmport deyimi aşağıdaki kuralı kullanır: bir paketin __init__.pykodu adlı bir liste tanımlarsa __all__, paket içe aktarma * ile karşılaşıldığında alınması gereken modül adlarının listesi olarak alınır. Paketin yeni bir sürümü çıktığında bu listeyi güncel tutmak paket yazarına bağlıdır. Paket yazarları, paketlerinden * içe aktarma için bir kullanım görmüyorlarsa desteklememeye de karar verebilirler. Örneğin, dosya sounds/effects/__init__.pyaşağıdaki kodu içerebilir:

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

Bu from sound.effects import *, ses paketinin adlandırılmış üç alt modülünü içe aktaracağı anlamına gelir .

Bu şimdiye kadar bulduğum en iyi yol:

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

Eklemeniz importlibgereken tek şey şu:

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

Standart kütüphaneden pkgutil modülüne bakın. Dizinde bir __init__.pydosya olduğu sürece tam olarak istediğinizi yapmanıza izin verecektir . __init__.pyDosya boş olabilir.

Bunun için bir modül oluşturdum, bu da __init__.py(veya başka bir yardımcı dosyaya) güvenmiyor ve sadece aşağıdaki iki satırı yazmamı sağlıyor:

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

Tekrar kullanmaktan veya katkıda bulunmaktan çekinmeyin: http://gitlab.com/aurelien-lourot/importdir

Sadece importlib ile içe aktarın ve paketteki geri çekilişe__all__ ( addeylem isteğe bağlıdır) ekleyin __init__.py.

/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

Ne zaman from . import *yeterince iyi değil, bu üzerinde bir gelişmedir ted tarafından cevap . Özellikle, __all__bu yaklaşımda kullanımı gerekli değildir.

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

module_name not in globals()Döngüsel içe aktarma riskini taşıyabileceğinden, zaten içe aktarılmışsa modülün yeniden içe aktarılmasını önleme amaçlı olduğunu unutmayın .