Gọi một chức năng của một mô-đun bằng cách sử dụng tên của nó (một chuỗi)

Cách tốt nhất để gọi hàm là một chuỗi có tên của hàm trong chương trình Python là gì. Ví dụ: giả sử tôi có một mô-đun foovà tôi có một chuỗi có nội dung "bar". Cách tốt nhất để gọi là foo.bar()gì?

Tôi cần lấy giá trị trả về của hàm, đó là lý do tại sao tôi không chỉ sử dụng eval. Tôi đã tìm ra cách thực hiện bằng cách sử dụng evalđể xác định hàm tạm thời trả về kết quả của lệnh gọi hàm đó, nhưng tôi hy vọng rằng có một cách thanh lịch hơn để làm điều này.

Giả sử mô-đun foovới phương thức bar:

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

Bạn có thể rút ngắn dòng 2 và 3 thành:

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

nếu điều đó có ý nghĩa hơn cho trường hợp sử dụng của bạn.

Bạn có thể sử dụng getattrtheo cách này trên các phương thức ràng buộc thể hiện lớp, phương thức cấp mô-đun, phương thức lớp ... danh sách sẽ tiếp tục.

locals()["myfunction"]()

hoặc là

globals()["myfunction"]()

người dân địa phương trả về một từ điển với một bảng biểu tượng địa phương hiện tại. Globals lợi nhuận một cuốn từ điển với bảng biểu tượng toàn cầu.

Giải pháp của Patrick có lẽ là sạch nhất. Nếu bạn cũng cần phải tự động chọn mô-đun, bạn có thể nhập mô-đun như sau:

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

Chỉ là một đóng góp đơn giản. Nếu lớp mà chúng ta cần thể hiện trong cùng một tệp, chúng ta có thể sử dụng một cái gì đó như thế này:

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

Ví dụ:

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

Và, nếu không phải là một lớp học:

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

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

Đưa ra một chuỗi, với một đường dẫn python hoàn chỉnh đến một hàm, đây là cách tôi đi về kết quả của hàm đã nói:

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

Câu trả lời tốt nhất theo Câu hỏi thường gặp về lập trình Python sẽ là:

functions = {'myfoo': foo.bar}

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

Ưu điểm chính của kỹ thuật này là các chuỗi không cần phải khớp với tên của các hàm. Đây cũng là kỹ thuật chính được sử dụng để mô phỏng cấu trúc trường hợp

Câu trả lời (tôi hy vọng) không ai muốn

Eval thích hành vi

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

Tại sao không thêm tự động nhập

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

Trong trường hợp chúng tôi có thêm từ điển, chúng tôi muốn kiểm tra

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

Chúng ta cần đi sâu hơn

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

Đối với giá trị của nó, nếu bạn cần truyền tên hàm (hoặc lớp) và tên ứng dụng dưới dạng chuỗi, thì bạn có thể làm điều này:

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

Thử cái này. Trong khi điều này vẫn sử dụng eval, nó chỉ sử dụng nó để triệu tập chức năng từ bối cảnh hiện tại . Sau đó, bạn có chức năng thực sự để sử dụng như bạn muốn.

Lợi ích chính cho tôi từ điều này là bạn sẽ nhận được bất kỳ lỗi nào liên quan đến eval tại điểm triệu tập hàm. Sau đó, bạn sẽ chỉ nhận được các lỗi liên quan đến chức năng khi bạn gọi.

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)

không có gì được đề nghị giúp tôi Tôi đã khám phá điều này mặc dù.

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

Tôi đang sử dụng python 2.66

Hi vọng điêu nay co ich

Như câu hỏi này Làm thế nào để tự động gọi các phương thức trong một lớp bằng cách sử dụng gán tên phương thức cho một biến [trùng lặp] được đánh dấu là trùng lặp như phương thức này, tôi sẽ đăng một câu trả lời liên quan ở đây:

Kịch bản là, một phương thức trong một lớp muốn gọi một phương thức khác trên cùng một lớp một cách linh hoạt, tôi đã thêm một số chi tiết vào ví dụ ban đầu cung cấp một số kịch bản rộng hơn và rõ ràng hơn:

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

Đầu ra (Python 3.7.x)

chức năng1: 12

chức năng 2: 12

Đây là một câu trả lời đơn giản, điều này sẽ cho phép bạn xóa màn hình chẳng hạn. Có hai ví dụ bên dưới, với eval và exec, sẽ in 0 ở trên cùng sau khi làm sạch (nếu bạn đang sử dụng Windows, thay đổi clearthành cls, người dùng Linux và Mac sẽ rời khỏi ví dụ) hoặc chỉ thực hiện nó, tương ứng.

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