Wie kann ich eine Funktion n mal wiederholen?

Ich versuche, eine Funktion in Python zu schreiben, die wie folgt ist:

def repeated(f, n): ... 

Wobei f eine Funktion ist, die ein Argument annimmt und n eine positive ganze Zahl ist.

Zum Beispiel, wenn ich das Quadrat als:

 def square(x): return x * x 

Und ich rief an

 repeated(square, 2)(3) 

Das würde Platz 3, 2 mal.

    6 Solutions collect form web for “Wie kann ich eine Funktion n mal wiederholen?”

    Das sollte es tun:

      def repeated(f, n): def rfun(p): return reduce(lambda x, _: f(x), xrange(n), p) return rfun def square(x): print "square(%d)" % x return x * x print repeated(square, 5)(3) 

    Ausgabe:

      square(3) square(9) square(81) square(6561) square(43046721) 1853020188851841 

    Oder lambda -less

     def repeated(f, n): def rfun(p): acc = p for _ in xrange(n): acc = f(acc) return acc return rfun 

    Mit reduce und lamba. Erstellen Sie ein Tupel, das mit Ihrem Parameter beginnt, gefolgt von allen Funktionen, die Sie anrufen möchten:

     >>> path = "/a/b/c/d/e/f" >>> reduce(lambda val,func: func(val), (path,) + (os.path.dirname,) * 3) "/a/b/c" 

    Etwas wie das?

     def repeat(f, n): if n==0: return (lambda x: x) return (lambda x: f (repeat(f, n-1)(x))) 

    Ich denke, Sie wollen Funktionszusammensetzung:

     def compose(f, x, n): if n == 0: return x return compose(f, f(x), n - 1) def square(x): return pow(x, 2) y = compose(square, 3, 2) print y 

    Hier ist ein Rezept mit reduce :

     def power(f, p, myapply = lambda init, g:g(init)): ff = (f,)*p # tuple of length p containing only f in each slot return lambda x:reduce(myapply, ff, x) def square(x): return x * x power(square, 2)(3) #=> 81 

    Ich nenne diese power , denn das ist wörtlich das, was die Machtfunktion tut, mit Komposition, die die Multiplikation ersetzt.

    (f,)*p erzeugt ein Tupel der Länge p gefüllt mit f in jedem Index. Wenn du Lust haben wolltest, würdest du einen Generator benutzen, um eine solche Sequenz zu erzeugen (siehe itertools ) – aber merke, dass es im Lambda erstellt werden müsste.

    myapply ist in der Parameterliste so definiert, dass es nur einmal erstellt wird.

    Mit reduzieren und itertools.repeat (wie Marcin vorgeschlagen):

     from itertools import repeat from functools import reduce # necessary for python3 def repeated(func, n): def apply(x, f): return f(x) def ret(x): return reduce(apply, repeat(func, n), x) return ret 

    Sie können es wie folgt verwenden:

     >>> repeated(os.path.dirname, 3)('/a/b/c/d/e/f') '/a/b/c' >>> repeated(square, 5)(3) 1853020188851841 

    (Nach dem Importieren os oder definieren square )

    Python ist die beste Programmiersprache der Welt.