Ich habe Funktionssynthese und Curry mit Python versucht

Python hat teilweise

Es gibt jedoch kein Curry. Ich bin traurig. Also habe ich eine Curry-Funktion geschrieben, die selbst Positionsargumente zählt.

Funktionssynthese

Zuerst habe ich eine Funktionskomposition geschrieben. Es ist einfach und schäbig.

def compose(*funcs: Callable) -> Callable:
    '''
    >>> compose(multest, multest)(4)
    16
    '''
    def composed(*args: Any) -> Any:
        return reduce(lambda x, y: y(x), (funcs[0](*args),)+funcs[1:])
    return composed

Currying-Funktionen

Der Mechanismus ist so einfach wie das Überprüfen der Anzahl der Positionsargumente und das teilweise Partialisieren. Also manchmal funktioniert es nicht.

def _curry_one(func: Callable) -> Callable:
    def wrap(*args: Any, **kwargs: Any) -> Any:
        return partial(func, *args, **kwargs)
    return wrap


def curry(num_of_args: Optional[int] = None) -> Callable:
    '''
    >>> fnc = curry(2)(multest2)
    >>> fnc(2)(3)
    6
    >>> fnc = curry()(multest3)
    >>> fnc(2)(3)(4)
    24
    '''
    def curry_wrap(func: Callable) -> Callable:
        length_of = compose(filter, list, len)
        if num_of_args:
            num = num_of_args
        else:
            def is_empty(x): return x.default is inspect._empty
            num = length_of(is_empty,
                            inspect.signature(func).parameters.values())
        for n in range(num - 1):
            func = _curry_one(func)
        return func
    return curry_wrap

Wenn Sie dies curryen, zählen Sie die Anzahl der Argumente und curry so viele wie die Anzahl der Positionsargumente. Sie können auch die Anzahl der Currys angeben. In der Praxis ist es jedoch auf 2 festgelegt und es fühlt sich gut an.

Warum ist es Curry? Ist es teilweise nutzlos?

Es kann teilweise sein, aber dieses Curry kann als Dekorateur verwendet werden.

@curry()
def test(x, y, z):
    return x * y + z

Es ist auch manchmal praktisch, wenn es als Funktion höherer Ordnung verwendet wird. Hauptsächlich, wenn es notwendig ist, Fälle zu trennen Wenn ich eine Sternenkarte herausbringen muss. Zum Beispiel kann ich den letzten Teil unten nicht lesen. (Schreiben)

def plus(x, y):
    return x * y

result = list(map(partial(plus, 3), range(4)))

Auch wenn dieser Typ teilweise getrennt ist.

def plus(x, y):
    return x * y

plus3 = partial(plus)
result = list(map(plus3, range(4)))

Der Namensraum ist ein bisschen ... Ich fühle mich unwohl mit mehr plus hoge. Ich kann diesen Kerl so schreiben

@curry()
def plus(x, y):
    return x * y

result = compose(map, list)(plus(3), range(4))

Ist es okay das zu tun?

Es wird entschieden, nutzlos zu sein, es ist gut, dass Python das gleiche ist, egal wer es schreibt. Daher sollte das oben genannte nicht verwendet werden.

Auflösung

Wenn es nicht funktioniert, warum hast du das getan?

Verwenden Sie numpy in Ihrem persönlichen Projekt. Ich bin selbstständig, aber ich war enttäuscht, weil ich den Code nicht lesen konnte, weil ich einen solchen Code geschrieben habe.

np.save(fname, baseline(np.square(fft(data.mean(axis=1)))))

Dies ist ein wissenschaftliches Berechnungspaket, daher gibt es in der Situation Raum für Überlegungen (gibt es das?) Es gab so viele mathematische Variablen, dass der Namespace verrückt war ... Wenn es hier Currying und Funktionszusammensetzung gäbe, wäre dies der Fall, oder?

mean = curry(np.mean)
save = curry(np.save)
compose(mean(axis=1), fft, np.square, np.std, save(fname))(data)

... nicht wahr? Persönliche Projekt-Unschuldstheorie.