Python-如何使用單個函式呼叫呼叫串列中的每個函式

我正在嘗試創建一個字典，其中每個值都是呼叫該值時應該執行的函式串列。這是一些偽代碼：

functions = {
    "A": (execute() for execute in [func1(param1), func2(param1)]),
    "B": (execute() for execute in [func1(param2), func2(param2)]),
}

但是，如果我嘗試使用functions["A"]()例外呼叫它，則會拋出“TypeError：'generator' object is not callable”。

我應該如何解決這個問題？

編輯：澄清一下，這些函式不是生成器，也沒有任何回傳型別。他們只是根據引數執行一些動作。

uj5u.com熱心網友回復：

因此，您的偽代碼存在一些問題！

[func1(param1), func2(param1)]實際上會呼叫 func1并將func2它們的回傳值存盤在串列中，這不是您想要的。然后這些回傳值必須是可呼叫的，否則該execute()部分將沒有任何意義。

因此，您需要一個要呼叫的函式串列，以及一個要發送到這些函式的引數串列。

所以如果我們有一個元組串列可以使用，我們可以做類似的事情

to_call = [(len, "hello"), (len, "world!")]

for func, param in to_call:
    func(param)

將列印 5 和 6，所以一切都很好。

然后要在一個函式呼叫中執行此操作并回傳它們的回傳值，我們可以將其包裝在一個函式中

from typing import Sequence, Tuple, Callable, Any # Typing is cool now kids.

def call_list(functions: Sequence[Tuple[Callable, Any]]) -> list[Any]: 
    results = list()
    for func, param in functions:
        results.append(func(param))
    return results

現在我們可以呼叫該函式

>>> call_list([(len, "hello"), (len, "world!")])
-> [5, 6]

并帶有一些串列理解

def call_list(functions: Sequence[Tuple[Callable, Any]]) -> list[Any]: 
    return [func(param) for func, param in functions]

現在我們可以做

functions = {
    "A": [(func1, param1), (func2, param1)],
    "B": [(func1, param2), (func2, param2)],
}

call_list(functions["A"])

然后由您的 api 設計決定您希望它的實際外觀，例如，如果引數是外部的并且您想應用它的一系列功能，跳過元組并只擁有一個功能串列

def call_list(functions: Sequence[Callable], *args: Any) -> list[Any]: 
    return [func(*args) for func in functions]

functions = {
    "A": [func1, func2],
    "B": [(func3, func4],
}

call_list(functions["A"], param1)
call_list(functions["A"], param1, param2, param3)

uj5u.com熱心網友回復：

我認為您根本不想創建生成器。

你可以嘗試這樣的事情：

# A function that returns a different function that calls each function in functions in sequence
def call_functions(functions, param):
    # Define a inner function
    def _inner():
        # For each function
        for function in functions:
            # Call it
            function(param)
    # return the inner function
    return _inner

# Define a dict mapping strings to functions.
to_call = {
    "A": call_functions([func1, func2], param1),
    "B": call_functions([func1, func2], param2)
}

to_call["A"]()
# This will do basically the same as:
# > func1(param1)
# > func2(param1)

uj5u.com熱心網友回復：

正如已經指出的那樣，使用生成器是有缺陷的。

此外，在原始代碼中，func1 和 func2 都必須回傳對其他函式的參考才能使其作業

您需要的更有可能是這樣的：

def func1(p):
    pass

def func2(p):
    pass

functions = {
    "A": [func1, func2]
}

param1 = 0

for func in functions['A']:
    func(param1)

uj5u.com熱心網友回復：

只需省略括號：

param1 = 5
param2 = 10

def func1(a):
    return a   a

def func2(a):
    return a * a

functions = {
    'A': [func1(param1), func2(param1)],
    'B': [func1(param2), func2(param2)]
}

print(functions['A']) 
###output: [10, 25]

uj5u.com熱心網友回復：

接受的答案：

感謝您的所有建議，我想出了一個解決方案。我只是將代碼留在這里：

def move(params):  # params is a list of 5 parameters of different types
    # Execute move

def rotate(params):  # params is a list of 2 parameters of different types
    # Execute rotation


moves: {
    "A": [(move, [param1, param2 etc...]), (rotate, [other_param1, other_param2])
    "B": [(move, [param3, param4 etc...]), (rotate, [other_param3, other_param4])
}


def execute_move(move):
    for func, params in moves[move]:
        func(params)


# Example use
execute_move("A")
execute_move("B")
execute_move("A")

這真的很好，所以謝謝大家的幫助。

標籤：Python列表功能字典

上一篇：Python回傳陳述句未提供預期結果

下一篇：如何多次呼叫函式？