Dieser Artikel ist Lisp-ähnlich, aber vorerst ist Python Part 2 Adventskalender 2015 der Artikel des dritten Tages.
In Fortsetzung von Letztes Mal werden wir die Möglichkeit von Hy untersuchen.
Die stabile Version von Hy zum Zeitpunkt dieses Schreibens ist 0.11.0.
Verwenden Sie in 0.11.0 beim Definieren einer Klasse "def class" und schreiben Sie wie folgt.
(defclass FooBar [object]
[[--init--
(fn [self x]
(setv self.x x)
None)]
[get-x
(fn [self]
"Return our copy of x"
self.x)]])
In der neuesten Entwicklungsversion von Hy wie dokumentiert Es ist ein bisschen seltsam.
(defclass FooBar [object]
(defn --init-- [self x]
(setv self.x x))
(defn get-x [self]
"Return our copy of x"
self.x))
Im Vergleich zu 0.11.0 oder früher ist der Schreibstil sauberer.
Ich weiß nicht, wann die Version, die geschrieben werden kann, stabil sein wird, aber wenn sie sich trotzdem ändert, werde ich mich an das neue Schreiben gewöhnen, daher gehe ich davon aus, dass ich von nun an die von Github installierte Entwicklungsversion von Hy verwenden werde. schreiben.
pip install git+https://github.com/hylang/hy.git
if __name__ == '__ main __' in HyEs hat nichts mit der Klassendefinition zu tun, aber wenn ich ein Skript schreibe, um die Operation zu überprüfen,
if __name__ == '__main__':
#Mach hier etwas
func()
Ich möchte eine Redewendung schreiben, die Hy entspricht.
Anscheinend wird Pythons __X__ in Hy zu --X -, sodass Sie es wie folgt schreiben können.
; hello.hy
(defn hello []
(print "Hello, World"))
(if (= --name-- "__main__")
(hello))
Führen Sie mit dem Hy-Interpreter aus.
$ hy ~/tmp/hello.hy
Hello, World
Als ich über das Beispiel der objektorientierten Programmierung mit Klassenvererbung nachdachte, fiel mir kein nützliches Beispiel ein, also das zeitlose Meisterwerk "Rudolph und Ippai Attena" Ich habe ein triviales Beispiel basierend auf dp / 4061335057 /) gemacht.
Definieren Sie die "Cat" -Klasse, die eine Hauskatze darstellt, und die "StrayCat", die eine streunende Katze darstellt, die von der abstrakten Klasse "AbstractCat" erbt.
; cat.hy
(defclass AbstractCat [object]
(defn --init-- [self name]
(setv self.name name))
(defn greet [self]
(raise NotImplementedError)))
(defclass StrayCat [AbstractCat]
(defn greet [self]
(.format "Mein Name ist{}" self.name)))
(defclass Cat [AbstractCat]
(defn --init-- [self name home]
(.--init-- (super Cat self) name)
(setv self.home home))
(defn greet [self]
(.format "mein Name ist{}。{}Ich wohne in." self.name self.home)))
(defn main []
(let [cat1 (Cat "Rudolph" "Rie-chans Haus")
cat2 (StrayCat "Ippai Attena")]
(print (.greet cat1))
(print (.greet cat2))))
(if (= --name-- "__main__")
(main))
Nur weil "X" zu "--X -" wird, entsteht der Eindruck, dass Sie die Python-Syntax fast in die Lisp-Syntax verschoben haben.
Der Konstruktor "__init __" wird zu "--init -" und verwendet "(setv self.key value)", um Eigenschaften festzulegen.
(defclass AbstractCat [object]
(defn --init-- [self name]
(setv self.name name))
Das Python-Idiom "super (X, self) .method ()", das die Methode der übergeordneten Klasse aufruft, ist fast dasselbe und wurde nur durch die Lisp-Syntax ersetzt. Im obigen Beispiel wird es verwendet, wenn der Konstruktor der übergeordneten Klasse aufgerufen wird.
(defclass Cat [AbstractCat]
(defn --init-- [self name home]
(.--init-- (super Cat self) name)
(setv self.home home))
Das Muster, das eine "NotImplementedError" -Ausnahme auslöst, um eine abstrakte Methode darzustellen, kann fast genau als "(erhöhen NotImplementedError)" portiert werden.
(defclass AbstractCat [object]
;;Abkürzung
(defn greet [self]
(raise NotImplementedError)))
Hy wird mit einem Hy → Python-Konvertierungstool namens "hy2py" geliefert. Verwenden Sie dieses Tool, um das obige Beispiel in Python-Code zu konvertieren.
hy2py cat.hy
Das Ergebnis ist wie folgt.
from hy.core.language import name
class AbstractCat(object):
def __init__(self, name):
self.name = name
self.name
return None
def greet(self):
raise NotImplementedError
class StrayCat(AbstractCat):
def greet(self):
return u'\u4ffa\u306e\u540d\u524d\u306f{}'.format(self.name)
class Cat(AbstractCat):
def __init__(self, name, home):
super(Cat, self).__init__(name)
self.home = home
self.home
return None
def greet(self):
return u'\u50d5\u306e\u540d\u524d\u306f{}\u3002{}\u306b\u4f4f\u3093\u3067\u3044\u307e\u3059\u3002'.format(self.name, self.home)
def main():
def _hy_anon_fn_6():
cat1 = Cat(u'\u30eb\u30c9\u30eb\u30d5', u'\u308a\u3048\u3061\u3083\u3093\u306e\u5bb6')
cat2 = StrayCat(u'\u30a4\u30c3\u30d1\u30a4\u30a2\u30c3\u30c6\u30ca')
(cat1, cat2)
print(cat1.greet())
return print(cat2.greet())
return _hy_anon_fn_6()
(main() if (__name__ == u'__main__') else None)
Es wurde fast wie beabsichtigt in Python-Code konvertiert, außer dass es eine bedeutungslose "return None" enthielt.
Mit der neuesten Entwicklungsversion von Hy können Sie Klassen mit "def class" sehr intuitiv definieren, sodass es sich nicht allzu schwierig anfühlt.
Vielleicht, weil Pythons Grammatik einfach ist, sehen Python-Code und Hy-Code sehr ähnlich aus, und Sie erkennen, dass "alle Programmiersprachen zu Lisp führen".
Das nächste Mal möchte ich ein größeres Programm schreiben, um die Möglichkeiten von Hy zu erkunden.
Recommended Posts