Bir modülün işlevini adını (dize) kullanarak çağırma

Bir Python programında işlevin adıyla bir dize verilen bir işlevi çağırmanın en iyi yolu nedir? Örneğin, foobir modülüm olduğunu ve içeriği olan bir dizem olduğunu varsayalım "bar". Aramanın en iyi yolu nedir foo.bar()?

Fonksiyonun dönüş değerini almam gerekiyor, bu yüzden sadece kullanmıyorum eval. evalBu işlev çağrısının sonucunu döndüren bir geçici işlev tanımlamak için kullanarak nasıl yapılacağını anladım , ancak bunu yapmanın daha zarif bir yolu olduğunu umuyorum.

Modül fooyöntemiyle varsayılırsa bar:

import foo
method_to_call = getattr(foo, 'bar')
result = method_to_call()

2. ve 3. satırları aşağıdakileri kısaltabilirsiniz:

result = getattr(foo, 'bar')()

kullanım durumunuz için daha mantıklıysa.

Sen kullanabilirsiniz getattrsınıf örneği bağımlı yöntemleri, modül düzeyinde yöntemden, sınıf yöntemleri bu şekilde ... liste uzayıp gidiyor.

locals()["myfunction"]()

veya

globals()["myfunction"]()

locals , geçerli bir yerel sembol tablosuna sahip bir sözlük döndürür. globals global sembol tablosuyla bir sözlük döndürür.

Patrick'in çözümü muhtemelen en temiz çözümdür. Modülü de dinamik olarak almanız gerekiyorsa, aşağıdaki gibi içe aktarabilirsiniz:

module = __import__('foo')
func = getattr(module, 'bar')
func()

Sadece basit bir katkı. Örneklememiz gereken sınıf aynı dosyadaysa, şöyle bir şey kullanabiliriz:

# Get class from globals and create an instance
m = globals()['our_class']()

# Get the function (from the instance) that we need to call
func = getattr(m, 'function_name')

# Call it
func()

Örneğin:

class A:
    def __init__(self):
        pass

    def sampleFunc(self, arg):
        print('you called sampleFunc({})'.format(arg))

m = globals()['A']()
func = getattr(m, 'sampleFunc')
func('sample arg')

# Sample, all on one line
getattr(globals()['A'](), 'sampleFunc')('sample arg')

Ve eğer bir sınıf değilse:

def sampleFunc(arg):
    print('you called sampleFunc({})'.format(arg))

globals()['sampleFunc']('sample arg')

Bir işleve tam bir python yolu olan bir dize verildiğinde, ben bu işlevin sonucunu almak için gitti:

import importlib
function_string = 'mypackage.mymodule.myfunc'
mod_name, func_name = function_string.rsplit('.',1)
mod = importlib.import_module(mod_name)
func = getattr(mod, func_name)
result = func()

Python programlama SSS'ye göre en iyi cevap :

functions = {'myfoo': foo.bar}

mystring = 'myfoo'
if mystring in functions:
    functions[mystring]()

Bu tekniğin birincil avantajı, dizelerin işlevlerin adlarıyla eşleşmesi gerekmemesidir. Bu aynı zamanda bir vaka yapısını taklit etmek için kullanılan birincil tekniktir

Umarım kimse istemez.

Benzer davranışı değerlendirin

getattr(locals().get("foo") or globals().get("foo"), "bar")()

Otomatik içe aktarma neden eklenmiyor?

getattr(
    locals().get("foo") or 
    globals().get("foo") or
    __import__("foo"), 
"bar")()

Ekstra sözlüklerimiz olması durumunda kontrol etmek istiyoruz

getattr(next((x for x in (f("foo") for f in 
                          [locals().get, globals().get, 
                           self.__dict__.get, __import__]) 
              if x)),
"bar")()

Daha derine inmemiz lazım

getattr(next((x for x in (f("foo") for f in 
              ([locals().get, globals().get, self.__dict__.get] +
               [d.get for d in (list(dd.values()) for dd in 
                                [locals(),globals(),self.__dict__]
                                if isinstance(dd,dict))
                if isinstance(d,dict)] + 
               [__import__])) 
        if x)),
"bar")()

Değer için, işlev (veya sınıf) adını ve uygulama adını bir dize olarak iletmeniz gerekiyorsa, bunu yapabilirsiniz:

myFnName  = "MyFn"
myAppName = "MyApp"
app = sys.modules[myAppName]
fn  = getattr(app,myFnName)

Bunu dene. Bu hala eval'i kullanırken, onu sadece mevcut bağlamdan işlevi çağırmak için kullanır . Ardından, istediğiniz gibi kullanmak için gerçek bir işleve sahipsiniz.

Bundan benim için en büyük yararı, fonksiyonu çağırma noktasında eval ile ilgili herhangi bir hata elde etmenizdir. Ardından, aradığınızda yalnızca işle ilgili hatalar alırsınız.

def say_hello(name):
    print 'Hello {}!'.format(name)

# get the function by name
method_name = 'say_hello'
method = eval(method_name)

# call it like a regular function later
args = ['friend']
kwargs = {}
method(*args, **kwargs)

önerilenlerin hiçbiri bana yardımcı olmadı. Bunu ben de keşfettim.

<object>.__getattribute__(<string name>)(<params>)

Python 2.66 kullanıyorum

Bu yardımcı olur umarım

Bu soru olarak Bu bir kopya olarak işaretlenmiş bir değişken [yineleme] yöntem-adı ataması kullanarak bir sınıf içindeki yöntemleri dinamik olarak çağırmak için , ben burada ilgili bir yanıt gönderiyorum:

Senaryo, bir sınıftaki bir yöntem dinamik olarak aynı sınıfta başka bir yöntem çağırmak istiyorum, bazı daha geniş senaryo ve netlik sunan orijinal örneğe bazı ayrıntılar ekledim:

class MyClass:
    def __init__(self, i):
        self.i = i

    def get(self):
        func = getattr(MyClass, 'function{}'.format(self.i))
        func(self, 12)   # This one will work
        # self.func(12)    # But this does NOT work.


    def function1(self, p1):
        print('function1: {}'.format(p1))
        # do other stuff

    def function2(self, p1):
        print('function2: {}'.format(p1))
        # do other stuff


if __name__ == "__main__":
    class1 = MyClass(1)
    class1.get()
    class2 = MyClass(2)
    class2.get()

Çıktı (Python 3.7.x)

işlev1: 12

fonksiyon2: 12

Bu basit bir cevap, örneğin ekranı temizlemenizi sağlayacaktır. Temizledikten sonra üstündeki 0 yazdırır eval ve exec ile aşağıda iki örnek, vardır (Windows, değiştirme kullanıyorsanız cleariçin cls, Linux ve Mac kullanıcıları olarak örneğin olduğunu bırakın) ya da sadece sırasıyla çalıştırmak.

eval("os.system(\"clear\")")
exec("os.system(\"clear\")")