Question

在Python 2.7中，我有几个无法修改的功能，只能使用。其中三个是“前”的，三个是“后”的；让我们称它们为f1（），f2（），f3（），r1（），r2（），r3（）。而且我还有17个函数，这些函数具有不同的数量和具有不同名称关键字的参数类型，例如：

// fabric.Line.prototype
_getNonTransformedDimensions: function() {
  var dim = this.callSuper('_getNonTransformedDimensions');
  if (this.strokeLineCap === 'butt') {
    if (this.width === 0) {
      dim.y -= this.strokeWidth;
    }
    if (this.height === 0) {
      dim.x -= this.strokeWidth;
    }
  }
  return dim;
},

以此类推。

我需要这样称呼所有17个人：

function01( par1='hello' , par2=847, par3=True , par4=17.821 , ........... )
function02( par43=(8.3+17.9i) , par21='august' )

该代码块17次（对于NN = 1到17）！

是否有一种狡猾的方法可以完成而无需编写17个块？

***添加的信息... 我现在拥有的是可怕的代码：

f1()
f2()
f3()
functionNN(............................)
r1()
r2()
r3()

这17个函数之一具有“无名”参数。：-S

Answer 1

为什么不使用循环，像这样：

for i in range(17):
    f1()
    f2()
    ....

Answer 2

函数就像对象一样，您可以将它们全部打包到一个列表中并从中调用它们。

例如：

def fun0():
    print(0)

def fun1():
    print(1)

def fun2():
    print(2)

def fun3():
    print(3)

funlist = [fun0, fun1, fun2, fun3]

for fun in funlist:
    fun()

在您的情况下，您还需要打包参数，因此您将必须使用以下内容：

N = 4 

funlist = [fun0, fun1, fun2, fun3]

paramlist = [[params0], [params1], [params2], [params3]]

for i in range(4):
    funlist[i](*paramlist[i])

Answer 3

由于函数接受不同的参数，因此您必须将它们至少一次与它们各自的参数一起写入一次。但是，您可以在包装外的函数中或以列表的形式在该块之外的某个地方执行此操作，以提高可读性。

例如：

fn_list = [function01, function02...]
[fn() for fn in fn_list]

或

def wrapping_func(args_list): (or use *args, **kwargs syntax)
    function01(args_list[0])
    function02(args_list[1])

Answer 4

您也可以像这样使用globlas()：

for i in range(1, 18):
    f1()
    f2()
    f3()
    globals()['function' + str(i).zfill(2)]() # pass the par here, but I dont know the rules
    r1()
    r2()
    r3()

globals()返回一个字典，该字典将全局范围内的函数作为该字典的可访问形式。有关globals()的更多信息，请阅读Here。

Answer 5

看看contextlib module。非常简单的例子

from contextlib import ContextDecorator

def front1():
    print('print from front1')

def front2():
    print('print from front2')

def front3():
    print('print from front3')


def rear1():
    print('print from rear1')

def rear2():
    print('print from rear2')

def rear3():
    print('print from rear3')

class mycontext(ContextDecorator):
    def __enter__(self):
        front1()
        front2()
        front3()
        return self

    def __exit__(self, *exc):
        rear1()
        rear2()
        rear3()
        return False

@mycontext()
def foo():
    print('print from foo')

@mycontext()
def bar():
    print('print from bar')

if __name__ == '__main__':
    foo()
    bar()

    # or as alternative
    # my_funcs = [foo, bar]
    # for func in my_funcs:
        # func()

输出

print from front1
print from front2
print from front3
print from foo
print from rear1
print from rear2
print from rear3
print from front1
print from front2
print from front3
print from bar
print from rear1
print from rear2
print from rear3

Answer 6

列出包含函数及其参数的列表：

ff=[ [function01, [10,20,"something"],  dict(par1='hello', par2=847, par3=True, par4=17.821)],
     [function02, [],                   dict(par43=(8.3+17.9i), par21='august')],
     [function03, [1,2,"hello"],        {}],
     ...
    ]

for  i in range(17):
        f1()
        f2()
        f3()

        posargs=ff[i][1]        # positional args
        kw=ff[i][2]             # keyword args for function_i
        ff[i][0](*posargs,**kw) # calling function_i

        r1()
        r2()
        r3()

您也可以稍后更改参数。例如：

ff[1][2]["par21"]="december"

new_kw_func02= dict(par43=(1+2i), par21='december'])
ff[1][2]= new_kw_func02

new_pargs_func03=[10,20,"World"]
ff[2][1]= new_pargs_func03

是否有巧妙的方法来调用一个函数，然后依次调用具有不同数量和类型的参数的多个函数？

6 个答案: