Adı verilen bir modülü dize olarak nasıl alabilirim?

Bağımsız değişken olarak komut olarak alan bir Python uygulaması yazıyorum:

$ python myapp.py command1

Uygulamanın genişletilebilir olmasını, yani ana uygulama kaynağını değiştirmek zorunda kalmadan yeni komutlar uygulayan yeni modüller ekleyebilmek istiyorum. Ağaç şuna benzer:

myapp/
    __init__.py
    commands/
        __init__.py
        command1.py
        command2.py
    foo.py
    bar.py

Uygulamanın çalışma zamanında mevcut komut modüllerini bulmasını ve uygun olanı çalıştırmasını istiyorum.

Python, bir modül adı için dize alan bir __import__ işlevini tanımlar :

__import __ (ad, globals = Yok, yerliler = Yok, listeden = (), seviye = 0)

İşlev, modül adını alır ve potansiyel olarak adın bir paket bağlamında nasıl yorumlanacağını belirlemek için verilen globalleri ve yerelleri kullanır. Fromlist adıyla verilen modülden içe aktarılması gereken nesnelerin veya alt modüllerin adlarını verir.

Kaynak: https://docs.python.org/3/library/functions.html# import

Yani şu anda bir şey var:

command = sys.argv[1]
try:
    command_module = __import__("myapp.commands.%s" % command, fromlist=["myapp.commands"])
except ImportError:
    # Display error message

command_module.run()

Bu iyi çalışıyor, sadece bu kod ile ne yaptığımızı başarmak için muhtemelen daha deyimsel bir yol olup olmadığını merak ediyorum.

Özellikle yumurta veya uzatma noktası kullanmak istemiyorum. Bu açık kaynaklı bir proje değil ve "eklenti" olmasını beklemiyorum. Mesele, ana uygulama kodunu basitleştirmek ve her yeni komut modülü eklendiğinde kodun değiştirilmesi ihtiyacını ortadan kaldırmaktır.

2.7 / 3.1'den daha eski olan Python ile bunu yapıyorsunuz.

Daha yeni sürümler importlib.import_moduleiçin bkz . Python 2 ve Python 3 .

İsterseniz de kullanabilirsiniz exec.

Veya bunu kullanarak __import__bir modül listesi içe aktarabilirsiniz:

>>> moduleNames = ['sys', 'os', 're', 'unittest'] 
>>> moduleNames
['sys', 'os', 're', 'unittest']
>>> modules = map(__import__, moduleNames)

Dalış içine Python doğruca sökük .

Python 2.7 ve 3.1 ve sonraki sürümleri için önerilen yöntem importlibmodülü kullanmaktır :

importlib.import_module (ad; paket = Yok)

Bir modülü içe aktarın. Name argümanı, hangi modülün mutlak veya göreceli olarak içe aktarılacağını belirtir (örn. Pkg.mod veya ..mod). Ad göreli terimlerle belirtilirse, paket bağımsız değişkeninin paket adını çözümlemek için bağlantı noktası olarak işlev görecek paket adı olarak ayarlanması gerekir (örneğin import_module ('.. mod', 'pkg.subpkg') pkg.mod ithal edecek).

Örneğin

my_module = importlib.import_module('os.path')

Not: imp lehine Python 3.4 beri kullanımdan kaldırıldı importlib

Belirtildiği gibi imp modülü size yükleme fonksiyonları sağlar:

imp.load_source(name, path)
imp.load_compiled(name, path)

Bunları daha önce benzer bir şey yapmak için kullandım.

Benim durumumda, gerekli tanımlı yöntemlerle belirli bir sınıf tanımladım. Modülü yükledikten sonra sınıfın modülde olup olmadığını kontrol eder ve daha sonra bu sınıfın bir örneğini yaratırım:

import imp
import os

def load_from_file(filepath):
    class_inst = None
    expected_class = 'MyClass'

    mod_name,file_ext = os.path.splitext(os.path.split(filepath)[-1])

    if file_ext.lower() == '.py':
        py_mod = imp.load_source(mod_name, filepath)

    elif file_ext.lower() == '.pyc':
        py_mod = imp.load_compiled(mod_name, filepath)

    if hasattr(py_mod, expected_class):
        class_inst = getattr(py_mod, expected_class)()

    return class_inst

Kullanım imp modül veya daha doğrudan __import__()işlevi.

Bugünlerde importlib kullanmalısınız .

Kaynak dosyayı içe aktarma

Docs aslında bunun için bir reçete sunmak ve bu böyle gider:

import sys
import importlib.util

file_path = 'pluginX.py'
module_name = 'pluginX'

spec = importlib.util.spec_from_file_location(module_name, file_path)
module = importlib.util.module_from_spec(spec)
spec.loader.exec_module(module)

# check if it's all there..
def bla(mod):
    print(dir(mod))
bla(module)

Bu şekilde üyelere (örn., " hello" İşlevi ) modülünüzden pluginX.py- çağrılan bu snippet'te module- ad alanının altında erişebilirsiniz ; Ör module.hello().

Üyeleri (örn. " hello") İçe aktarmak istiyorsanız, bellek içi modül listesine module/ ekleyebilirsiniz pluginX:

sys.modules[module_name] = module

from pluginX import hello
hello()

Bir paketi içe aktarma

Geçerli dizininiz altında bir paketi ( ör . pluginX/__init__.py) İçe aktarmak aslında oldukça basittir:

import importlib

pkg = importlib.import_module('pluginX')

# check if it's all there..
def bla(mod):
    print(dir(mod))
bla(pkg)

Yerlilerinizde istiyorsanız:

>>> mod = 'sys'
>>> locals()['my_module'] = __import__(mod)
>>> my_module.version
'2.6.6 (r266:84297, Aug 24 2010, 18:46:32) [MSC v.1500 32 bit (Intel)]'

aynı şekilde çalışmak globals()

Şunları kullanabilirsiniz exec:

exec("import myapp.commands.%s" % command)

@Monkut'un çözümüne benzer, ancak burada açıklanan yeniden kullanılabilir ve hataya dayanıklılık http://stamat.wordpress.com/dynamic-module-import-in-python/ :

import os
import imp

def importFromURI(uri, absl):
    mod = None
    if not absl:
        uri = os.path.normpath(os.path.join(os.path.dirname(__file__), uri))
    path, fname = os.path.split(uri)
    mname, ext = os.path.splitext(fname)

    if os.path.exists(os.path.join(path,mname)+'.pyc'):
        try:
            return imp.load_compiled(mname, uri)
        except:
            pass
    if os.path.exists(os.path.join(path,mname)+'.py'):
        try:
            return imp.load_source(mname, uri)
        except:
            pass

    return mod

Aşağıdaki parça benim için çalıştı:

>>>import imp; 
>>>fp, pathname, description = imp.find_module("/home/test_module"); 
>>>test_module = imp.load_module("test_module", fp, pathname, description);
>>>print test_module.print_hello();

kabuk betiğinde içe aktarmak istiyorsanız:

python -c '<above entire code in one line>'

Örneğin, modül isimlerim jan_module/ feb_module/ gibidir mar_module.

month = 'feb'
exec 'from %s_module import *'%(month)

Aşağıdakiler benim için çalıştı:

import sys, glob
sys.path.append('/home/marc/python/importtest/modus')
fl = glob.glob('modus/*.py')
modulist = []
adapters=[]
for i in range(len(fl)):
    fl[i] = fl[i].split('/')[1]
    fl[i] = fl[i][0:(len(fl[i])-3)]
    modulist.append(getattr(__import__(fl[i]),fl[i]))
    adapters.append(modulist[i]())

Modülleri 'modus' klasöründen yükler. Modüller, modül adıyla aynı ada sahip tek bir sınıfa sahiptir. Örneğin modus / modu1.py dosyası şunları içerir:

class modu1():
    def __init__(self):
        self.x=1
        print self.x

Sonuç, dinamik olarak yüklenen sınıf "bağdaştırıcıları" listesidir.