Ich habe einen Artikel wie den oben genannten gefunden, also dachte ich, ich würde ihn auch gerne mit Python machen, also habe ich ihn ein wenig ausprobiert.
Zunächst aus der Implementierung der Funktion zur Funktionssynthese (g ≤ f) (x) = g (f (x))
def compose(f_t_u, f_u_r):
'''
:type f_t_u: t -> u
:type f_u_r: u -> r
:rtype: t -> r
>>> comp(lambda a: a + 'oppai', lambda b: b + 'hoge')('')
'oppaihoge'
>>> comp(comp(lambda a: a+'oppai', lambda b: b+ 'hoge'), lambda x: '[' + x + ']')('')
'[oppaihoge]'
'''
return lambda t: f_u_r(f_t_u(t))
Ich habe versucht, so etwas wie einen Typkommentar einzufügen, aber es ist nicht bekannt, ob es leichter zu lesen ist.
Die Funktionszusammensetzung erfolgt übrigens oben, aber die Klammern sind voll. Scala Ich bin mir nicht sicher, aber der ursprüngliche Artikel scheint Operatoren und implizite Typkonvertierungen zu verwenden, um Klammern zu entfernen. Scala hatte Angst
Python kann den Oleore-Operator jedoch überhaupt nicht definieren. Hier werden wir also an der Neutralisierung der Funktion arbeiten. Jeder liebt "ror", "or" Überladung und schreibt die Komposition neu.
class infix(object):
def __init__(self, function):
self.function = function
def __ror__(self, other):
self.left = other
return self
def __or__(self, other):
return self.function(self.left, other)
def __call__(self, value1, value2):
return self.function(value1, value2)
@infix
def c(f_t_u, f_u_r): return lambda t: f_u_r(f_t_u(t))
Nun, damit
(str.upper |c| sorted |c| set)('abcdeabc')
# > set(['A', 'C', 'B', 'E', 'D'])
Sie können jetzt so schreiben.
Zum Schluss implementieren wir einen Container namens Ap, der in Teil 2 des Originalartikels erscheint. Verwenden Sie den richtigen Bitverschiebungsoperator, um die Funktion zu übernehmen und entsprechend zu verwenden.
class Ap(object):
def __init__(self, val):
self.val=val
def __rshift__(self, func):
return func(self.val)
Mit diesem Kerl
Ap('abcdeabc') >> (str.upper |c| sorted |c| set)
# > set(['A', 'C', 'B', 'E', 'D'])
Ich kann jetzt schreiben. Ich habe es getan.
Es sind noch Klammern übrig, aber es ist in Ordnung zu beenden. Ich mag das, weil es interessant ist, aber ich denke nicht, dass es praktisch ist, weil ich nicht denke, dass es Python-ähnlich ist.
# Nachtrag
Implementierung der Ap-Klasse
class _Ap(object):
def __rlshift__(self, other):
self.value = other
return self
def __rshift__(self, other):
return other(self.value)
Ap = _Ap()
a = Ap
Wenn Sie tun
'abcdacb' <<a>> (str.upper |c| sorted)
#> ['A', 'A', 'B', 'B', 'C', 'C', 'D']
Es ist so. Dies ist eine visuelle Annäherung an den Originalartikel und vermittelt ein besseres Gefühl (?)
Nachtrag:
Obwohl es weniger vielseitig ist, habe ich auch etwas geschrieben, das eine Haskell-ähnliche Atmosphäre hat, die eine Funktionskomposition mit . ermöglicht.
[Haskells Kompositionsoperator. In Python ~ Implementierung der Sammlungsverarbeitung durch Funktionskomposition](https://hachibeechan.hateblo.jp/entry/implements-the-haskells-compose-function-in-python-and-list- wird bearbeitet)
Recommended Posts