使用不同的参数多次运行python函数

嗨，我需要有一个函数，将采取一个函数，并返回一个函数，将运行该参数函数，例如1000次，每次评估它的参数。我有这样的想法：

def runner(f):
    def inner(*args):
        for i in xrange(1000):
            f(*args)
    return inner

>>> def runner(f, callable):
...   def inner():
...     for i in xrange(1000):
...       f(*callable())
...   return inner
... 
>>> runner(f, lambda: (random.randint(1, 1000),))()
603
385
321
etc.

>>> def runner(f, callable):
...   def inner(*args, **kwds):
...     for i in xrange(1000):
...       pos = list(callable())
...       pos.extend(args)
...       f(*pos, **kwds)
...   return inner
... 
>>> def f(a, b, c, d = 3):
...   print a, b, c, d
... 
>>> runner(f, lambda: (random.randint(1,1000),))(3, 5, d = 7)
771 3 5 7
907 3 5 7
265 3 5 7

---

但似乎这样的调用：

runner（f）（random.randint（1，上限））

使用相同的参数运行f 1000次。如何正确执行？

您需要将random.randint的计算移到函数定义中：

例如，类似这样的内容应该可以让您开始使用，

@

是装饰器语法，如果您不熟悉它，可以阅读它。厚颜无耻地从另一篇文章中窃取hello示例：

import random

UPPER_BOUND = 1000

def runner(fn):
    def wrapped():
        for i in range(0,10):
            stuff = random.randint(1,UPPER_BOUND)
            print(str(stuff) + ': ' + fn())
    return wrapped

@runner
def hello():
    return 'hello world'


if __name__=='__main__':
    hello()

---

编辑：还要了解为什么您的random.randint只执行一次（在定义时），这就是为什么您的函数每次都得到相同的参数。

您遇到的问题是，

random.randint（1，上限）

在

runner（）返回的
internal（）
函数时被计算一次

被调用。您需要的是将评估推迟到以后

您可以尝试以下方法：

def runner(f):
    def inner(*args):
        for i in xrange(1000):
            f(*args)
    return inner

>>> def runner(f, callable):
...   def inner():
...     for i in xrange(1000):
...       f(*callable())
...   return inner
... 
>>> runner(f, lambda: (random.randint(1, 1000),))()
603
385
321
etc.

>>> def runner(f, callable):
...   def inner(*args, **kwds):
...     for i in xrange(1000):
...       pos = list(callable())
...       pos.extend(args)
...       f(*pos, **kwds)
...   return inner
... 
>>> def f(a, b, c, d = 3):
...   print a, b, c, d
... 
>>> runner(f, lambda: (random.randint(1,1000),))(3, 5, d = 7)
771 3 5 7
907 3 5 7
265 3 5 7

请注意，每次调用原始函数

f

时都会调用

callable

。还要注意，

callable

必须返回序列类型，如元组或列表

Edit:如果需要将其他参数传递给

f

，可以使用以下方法：

def runner(f):
    def inner(*args):
        for i in xrange(1000):
            f(*args)
    return inner

>>> def runner(f, callable):
...   def inner():
...     for i in xrange(1000):
...       f(*callable())
...   return inner
... 
>>> runner(f, lambda: (random.randint(1, 1000),))()
603
385
321
etc.

>>> def runner(f, callable):
...   def inner(*args, **kwds):
...     for i in xrange(1000):
...       pos = list(callable())
...       pos.extend(args)
...       f(*pos, **kwds)
...   return inner
... 
>>> def f(a, b, c, d = 3):
...   print a, b, c, d
... 
>>> runner(f, lambda: (random.randint(1,1000),))(3, 5, d = 7)
771 3 5 7
907 3 5 7
265 3 5 7

---

您必须将

random.randit

调用放入循环中：

def runner(function):
    def inner(callable, args=()):
        for i in xrange(1000):
            function(callable(*args))
    return inner

你可以给跑步者打电话：

runner(f)(random.randint, args=(1, UPPER_BOND))

在我看来，这似乎是你想要做的（不要涉及丑陋的羔羊）