funzione di chiamata con 3 o più Argument Campi di input - la funzione()()()

Question

sto studiando le proprietà delle funzioni in Python e mi sono imbattuto in un esercizio che chiede di:

Scrivete una funzione che restituisce de potere di un numero. Condizioni: la funzione può richiedere solo 1 argomento e deve utilizzare un'altra funzione per restituire il valore della potenza di un determinato numero.

Il codice che risolve questo esercizio è:

def power(x): 
    return lambda y: y**x 

Ad esempio, se vogliamo conoscere il valore della potenza: 2^3, diremmo la funzione come questa: Potenza (ci

è un modo per scrivere una funzione che, quando viene chiamato, ha una struttura simile:: 3) (2)

Ecco quello che vorrei sapere la funzione()()(). In altre parole, è possibile scrivere una funzione, che richiede tre o più parentesi()()() quando viene chiamata? Se è possibile, potresti darmi un esempio di codice di tale funzione e spiegarlo brevemente?

anche:

def power(x): 
    def power_extra(y): 
     return y 

    def power_another(z): 
     return z 

    return power_extra and power_another 

possibile?

Answer 1

Certo che puoi:

def power_times(k): 
    """use as power_times(k)(x)(y) => k * y^x""" 
    return lambda x: lambda y: k * y**x 

print power_times(2)(3)(4) # returns 2 * 4^3 = 128 

Quando si chiama questa funzione con argomento 2 (power_times(2)), restituisce una funzione lambda che funziona come lambda x: lambda y: 2 * y ** x (vale a dire, come la vostra funzione originale, solo con un extra " volte 2 ").

È possibile impilare il maggior numero di lambda s l'uno sopra l'altro come vi piace:

def many_lambdas(x): 
    """many_lambdas(x)(y)(z)(q) => x + y * z^q""" 
    return lambda y: lambda z: lambda q: x + y * z ** q 

print many_lambdas(1)(2)(3)(4) # prints 163 

Anzi, potrebbe essere ancora più chiaro se si saltato utilizzando def a tutti, e appena scritto:

many_lambdas = lambda x: lambda y: lambda z: lambda q: x + y * z ** q 

O, in alternativa, si potrebbe saltare usando lambda sempre e solo usarli come funzioni nidificate:

def many_funcs(x): 
    def many_funcs_y(y): 
     def many_funcs_z(z): 
      def many_funcs_q(q): 
       return x + y * z ** q 
      return many_funcs_q 
     return many_funcs_z 
    return many_funcs_y 

print many_funcs(1)(2)(3)(4) # prints 163 

Answer 2

@ La risposta di David risponderebbe correttamente alla domanda per chiamate di funzioni nidificate fisse. Per l'annidamento non definito, potresti voler definire una classe e sovraccaricare il metodo __call__ insieme a __repr__ e __int__ per servire il tuo Scopo.

>>> class Power(object): 
    def __init__(self, value): 
     self.value = value 
    def __call__(self, value): 
     self.value **= value 
     return self 
    def __int__(self): 
     return self.value 
    def __repr__(self): 
     return str(self.value) 


>>> print Power(2)(2)(2)(2)(2) 
65536 
>>> int(Power(2)(2)(2)(2)(2))/2 
32768