Funkcja dzwoni z 3 lub więcej Argument pól wejściowych - function()()()

Question

uczę właściwości funkcji w Pythonie i natknąłem się na ćwiczenia, które zmierza do:

Napisz funkcję, która zwraca de moc liczby. Warunki: Funkcja może przyjąć tylko 1 argument i musi użyć innej funkcji, aby zwrócić wartość mocy danej liczby.

Kod, który rozwiązuje tego ćwiczenia jest:

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

Na przykład, jeśli chcemy poznać wartość mocy: 2^3, chcielibyśmy wywołać funkcję tak: moc (tam

jakikolwiek sposób napisać funkcję, która, kiedy nazywa, ma podobną strukturę:: 3) (2)

Oto, co chciałbym wiedzieć, function()()(). Innymi słowy, czy możliwe jest napisanie funkcji wymagającej trzech lub więcej nawiasów()()() po wywołaniu? Jeśli to możliwe, czy mógłbyś podać przykładowy kod tej funkcji i krótko ją wyjaśnić?

również:

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

    def power_another(z): 
     return z 

    return power_extra and power_another 

możliwe?

Answer 1

Pewnie można:

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 

Po wywołaniu tej funkcji z argumentem 2 (power_times(2)), zwraca funkcję lambda, która działa jak lambda x: lambda y: 2 * y ** x (czyli, jak swojej pierwotnej funkcji, tylko z dodatkowym " razy 2 ").

można układać jak wiele lambda s na szczycie siebie, jak chcesz:

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 

Rzeczywiście, może to być nawet wyraźniejsze, jeśli pominąć używając def w ogóle i po prostu napisał:

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

Lub alternatywnie, można pominąć przy użyciu lambda kiedykolwiek i po prostu użyć ich jako zagnieżdżone funkcje:

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

@ Odpowiedź Davida mogłaby trafnie odpowiedzieć na pytanie dotyczące naprawionych zagnieżdżonych wywołań funkcji. W przypadku niezdefiniowanego zagnieżdżania możesz chcieć zdefiniować klasę i przeciążyć metodę __call__ wraz z __repr__ i __int__, aby służyć Twojemu Celowi.

>>> 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