动态定义函数名和函数体，并在python中使用变量

Question

我有以下职能

def foo_001(para):
    tmp = para + 2
    return tmp

def foo_002(para):
    tmp = para * 2
    return tmp

def foo_003(para):
    tmp = para / 2
    return tmp

def foo_004(para):
    tmp = para - 2
    return tmp

这些函数只有不同的函数名，而算法行(如"tmp =par-2“)则是相同的。

所以，我能不能做这样的事：

def $fooname (para):         # $ is borrowed try to say fooname is a variable
    $alog                    # $algo is also variable
    return tmp

lst = [
      ['tmp = para + 2', "foo_001"],
      ['tmp = para * 2', "foo_002"],
      ['tmp = para / 2', "foo_003"],
      ['tmp = para - 2', "foo_004"],
      ]

在运行时，我可以在某种程度上使用lst[0][0]分配给$algo，使用lst[0][1]分配给$fooname，并且可以通过lst内部的lst[0][x]调用函数？

在这里我的问题更具体

文件foo.py

def foo_001(para): tmp = para + 2 return tmp
def foo_002(para): tmp = para * 2 return tmp
def foo_003(para): tmp = para / 2 return tmp
...
def foo_100(para): tmp = #complex algo, return tmp

main.py

from foo import *
fun_name = ["foo_001","foo_002","foo_002" ... "foo_100"]

src = 1
rzt = [] 
for i in fun_name:
    rzt.extent(eval(i)(src)) 

以下是我的问题：

1. 我可以在运行时获得fun_name列表吗？我想把它们保存在文本文件中。
2. 我发现函数定义中有一个共同的部分，即tmp = #algo。我可以从这些定义中提取它们，而在运行时可以定义函数吗？我想要这样的东西：

文件foo.py

def foo_factory(): 
    # in somehow
    return adict      #function_name/function pair 

template = [
["foo_001","tmp = para + 2"],
["foo_002","tmp = para * 2"],
["foo_002","tmp = para * 2"],
...
["foo_100","tmp = #complex algo"]

main.py

from foo import *
dic = foo_factory(template)
fun_name = dic.keys()
src = 1
rzt = [] 
for i in fun_name:
    rzt.extent(eval(i)(src)) 
        #or
    rzt.extent(dic(i)())

Answer 1

如果您在“创建时间”不知道这些函数的名称，您将如何调用它们？

如果你认为合适的话，用参数化的函数数组(闭包)不是更好的方法吗？

即(没有测试，但应该有效)：

def make_foo_func(op):
  def func(para):
    tmp = op(para, 2) 
    return tmp
  return func

然后：

import operator
foo_001 = make_foo_func(operator.add)
foo_oo2 = make_foo_func(operator.mul)
...

Answer 2

您考虑的是字符串操作和命名函数，应该从高阶未命名函数的角度来考虑。他们把这变成了一件轻而易举的事，而没有利用任何活力;) (实际上，哈斯克尔的等价物会更短、更干净。)

示例：

import operator as op

def algo_factory(f):
    def algo(para):
        return f(para, 2)
    #maybe, for nicer debugging output: algo.__name__ = "..."
    return algo

algorithms = [
    mkAlgo(op.add),
    mkAlgo(op.mul),
    mkAlgo(op.truediv),
    mkAlgo(op.sub),
    #...
]

而且，根据您正在做的事情，您可能希望algorithms成为一个白痴。

Answer 3

我认为您真正想要做的是将函数本身保存在一个列表中，并从列表中检索您想要的函数。

foo_container = [foo_001,foo_002,foo_003,foo_004]

然后，从那里，呼叫：

foo_container[0](3)

将与下列相同：

foo_001(3)