Memanggil fungsi modul dengan menggunakan namanya (string)

Apa cara terbaik untuk memanggil fungsi yang diberi string dengan nama fungsi dalam program Python. Sebagai contoh, katakanlah saya memiliki modul foo, dan saya memiliki string yang isinya "bar". Apa cara terbaik untuk menelepon foo.bar()?

Saya perlu mendapatkan nilai kembali fungsi, itulah sebabnya saya tidak hanya menggunakan eval. Saya menemukan cara melakukannya dengan menggunakan evaluntuk mendefinisikan fungsi temp yang mengembalikan hasil pemanggilan fungsi itu, tapi saya berharap ada cara yang lebih elegan untuk melakukan ini.

Dengan asumsi modul foodengan metode bar:

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

Anda dapat mempersingkat garis 2 dan 3 menjadi:

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

jika itu lebih masuk akal untuk use case Anda.

Anda dapat menggunakan getattrcara ini pada metode terikat instance kelas, metode tingkat modul, metode kelas ... daftarnya berlanjut.

locals()["myfunction"]()

atau

globals()["myfunction"]()

penduduk setempat mengembalikan kamus dengan tabel simbol lokal saat ini. global mengembalikan kamus dengan tabel simbol global.

Solusi Patrick mungkin yang terbersih. Jika Anda juga perlu mengambil modul secara dinamis, Anda dapat mengimpornya seperti:

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

Kontribusi sederhana. Jika kelas yang perlu kita contoh berada di file yang sama, kita dapat menggunakan sesuatu seperti ini:

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

Sebagai contoh:

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

Dan, jika bukan kelas:

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

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

Diberikan string, dengan jalur python lengkap ke suatu fungsi, ini adalah bagaimana saya mendapatkan hasil dari fungsi tersebut:

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

Jawaban terbaik menurut FAQ pemrograman Python adalah:

functions = {'myfoo': foo.bar}

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

Keuntungan utama dari teknik ini adalah bahwa senar tidak perlu cocok dengan nama fungsi. Ini juga merupakan teknik utama yang digunakan untuk meniru konstruksi kasus

Jawabannya (saya harap) tidak ada yang mau

Perilaku seperti Eval

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

Mengapa tidak menambahkan impor otomatis

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

Jika kami memiliki kamus tambahan yang ingin kami periksa

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

Kita harus masuk lebih dalam

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

Untuk apa nilainya, jika Anda perlu meneruskan fungsi (atau kelas) nama dan nama aplikasi sebagai string, maka Anda bisa melakukan ini:

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

Coba ini. Meskipun ini masih menggunakan eval, ia hanya menggunakannya untuk memanggil fungsi dari konteks saat ini . Kemudian, Anda memiliki fungsi nyata untuk digunakan sesuai keinginan.

Manfaat utama bagi saya dari ini adalah bahwa Anda akan mendapatkan kesalahan terkait eval pada saat memanggil fungsi. Maka Anda hanya akan mendapatkan kesalahan terkait fungsi saat menelepon.

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)

tidak ada yang disarankan membantu saya. Saya memang menemukan ini.

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

Saya menggunakan python 2.66

Semoga ini membantu

Saat pertanyaan ini Bagaimana memanggil metode secara dinamis di dalam kelas menggunakan penugasan metode-nama ke variabel [duplikat] yang ditandai sebagai duplikat seperti ini, saya memposting jawaban terkait di sini:

Skenarionya adalah, sebuah metode di kelas yang ingin memanggil metode lain di kelas yang sama secara dinamis, saya telah menambahkan beberapa detail ke contoh asli yang menawarkan beberapa skenario dan kejelasan yang lebih luas:

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

Output (Python 3.7.x)

function1: 12

function2: 12

Ini adalah jawaban yang sederhana, ini akan memungkinkan Anda untuk menghapus layar misalnya. Ada dua contoh di bawah ini, dengan eval dan exec, yang akan mencetak 0 di bagian atas setelah membersihkan (jika Anda menggunakan Windows, perubahan clearuntuk cls, Linux dan Mac pengguna meninggalkan seperti misalnya) atau hanya jalankan, masing-masing.

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