lisp - 静かなる名辞

python使いのためのhy基本文法まとめ

Thu, 01 Mar 2018 10:32:07 +0900

はじめに

　hyの使い方の記事は一定の需要があると思い、まとめて公開する。

　hyはpythonの抽象構文木に変換されるlisp。lispなのでマクロなどの素敵な機能が使えるらしいが、私もよくわからないのでその辺には触れない。とりあえずpythonのコードをhyに書き写せる水準を目標にする。

　なお、公式ドキュメントはここ。
Welcome to Hy’s documentation! — hy 0.15.0 documentation

最初に覚えておくべきこと

　hyはlispなのでS式を扱う必要がある。S式は(e1 e2 e3 ...)という形式で、これはlispにおけるリストである。

　S式をそのまま書くと（一部特別な例外があるが）、e1を関数名、e2以下を引数として呼び出す。だから、

=> (+ 1 2)
3

　という結果が得られる。

　hyはlispであり、lispは関数型言語なので、考えられるほとんどのオブジェクト操作はこの関数呼び出しという形で実現することになる。こう書くとpythonのオブジェクト指向が使えなくて不便そうな気がするが、普通に使える。

=> (setv hoge "h o g e")
=> (hoge.split)
['h', 'o', 'g', 'e']

　setvはset variable・・・要するにpythonの代入文。そして二行目でpythonでいうhoge.split()をしている。なんてことはない。イメージとしては、インスタンスに属する関数オブジェクトへの参照をなんとかして作り、それをS式の形で関数として呼び出す感じである。

　このことがわかれば、ほぼpythonと同じように書けると思う。

hyのインストール

　pip install hyで入る。

import

　最も簡単なimportは次のように書ける。

(import os)

　これはpythonのimport osと等価である。

　もう少し複雑なimportをしたい場合、カッコが増える。しかもカクカッコである。たとえばfromに相当するものを書くときは、

(import [collections [defaultdict]])

　こんな感じである。これはfrom collections import defaultdictと等価である。もし複数階層あるモジュールからimportしたいときは、単にドットで繋げば良い。

　もちろんasも使える。

(import [numpy :as np])

　これでimport numpy as npと等価である。

　外側のカクカッコには一つのモジュールしか書けないが、内側の子モジュールのカッコには複数書けるようである。

=> (import [os [listdir name]])

　また、一つのimport関数で複数のモジュールからimportすることも可能。

(import [numpy :as np]
        [scipy :as sp])

代入

　最初に出したが、setvがpythonの代入と等価である。

=> (setv hoge 10)
=> hoge
10

　setv自身は値を返さない（強いて言えばNoneを返す）。pythonの代入文にそのままコンバートされる都合上そうなっている。なんだかlisp的には妥協した仕様に見える。

組み込みコレクション型

　pythonの組み込みコレクション型は使える（はずである）。表記もほぼpythonと同様だが、カンマがないのが違い。ただしreplはカンマ付きのpython表記を返してくる。ご愛嬌である。

=> [1 2 3 4]
[1, 2, 3, 4]
=> {1 2 3 4} # 恐ろしいことにsetのつもりで書くとdictになる
{1: 2, 3: 4}
=> (set [1 2 3 4]) # setにしたい場合
{1, 2, 3, 4}
=> (tuple [1 2 3 4]) # tupleも同様に対応するとこうなる
(1, 2, 3, 4)
=> (, 1 2 3 4) # 不思議なtupleの記法がある
(1, 2, 3, 4)

　記法がlispとpythonで混ざる欠点がある。一応問題にならないよう努力はしていると思うが、わかりやすい構文かと言われると微妙。hyの割と大きな弱点だと思う。

条件分岐

　条件分岐はifとcondがある。ifの書式は次の通り（公式チュートリアルから引用）。

(if (try-some-thing)
  (print "this is if true")
  (print "this is if false"))

　lispのifを知っている人には違和感がないと思う。知らない人はpythonの三項演算子だと思えば良い。というか、恐らく三項演算子そのものにコンバートされる。

　三項演算子なのでif関数自体に返り値がある。ということはpythonのif文より使いみちは多い。

　condもlispでは典型的なもの。これもチュートリアルから例を借用する。

(setv somevar 33)
(cond
 [(> somevar 50)
  (print "That variable is too big!")]
 [(< somevar 10)
  (print "That variable is too small!")]
 [True
  (print "That variable is jussssst right!")])

　ま、lisp知ってる人には説明するまでもないし、知らない人はこんなページだけで勉強するなんて無謀なことはしてないはずなので、これといって説明はしない。あと、condも当然値を返す。

ループ構文

　pythonのforとwhileがそのまま使える。まずfor。

=> (for [c "hoge"] (print c))
h
o
g
e

　カクカッコに囲まれている部分がpythonで言うところのfor c in "hoge"のc in "hoge"に相当する。その次がbodyで、bodyは複数の関数を書けば逐次実行される。

=> (for [c "hoge"] (print c) (print (+ c "!")))
h
h!
o
o!
g
g!
e
e!

　zipなどもpythonと同様に使える。構文がちょっとだけ変わるけど。

=> (for [[c1 c2] (zip "hoge" "fuga")] (print c1 c2))
h f
o u
g g
e a

　組み込み関数などはだいたい使える。hyはlispの皮をかぶったpythonに過ぎない。

　whileも直感的なものである。(while condition *body)というフォーマットで書けば良い。

=> (setv i 0)
=> (while (< i 10) (print i) (+= i 1))
0
1
2
3
4
5
6
7
8
9

　新しくインクリメント演算子が登場した。このインクリメント演算子はNoneを返す。どうやらhyはpythonの文を片っ端からNoneを返す関数に変換して作ったlispらしい（for, whileともに返り値はNone）。やはりlispの皮をかぶったpythonに過ぎないという気がする。

関数定義

　defnを使う。書式は(defn function-name [*args] *body)。

=> (defn str_hoge [string] (setv s (+ string "hoge")) (print s))
=> (str_hoge "fuga")
fugahoge

　ちなみにlisp的にはアンダーバーではなくハイフンを使うのが正しいらしい。また、hyはアンダーバー区切りとハイフン区切りを勝手に相互変換するので、str-hogeでも同じ関数が呼べる。python使い的には気持ち悪いので、とりあえずアンダーバー区切りで説明している。

　また、関数オブジェクトはfnで作れる。これを利用してsetvで関数定義することも可能（pythonのlambda文を変数に代入することに相当。ただしhyでは複数行書いても良い）。

=> (setv str_hoge2 (fn [string] (setv s (+ string "hoge")) (print s)))
=> (str_hoge2 "fuga")
fugahoge

　キーワード引数なども指定できる。lispでいうラムダリスト。

=> (defn piyo [str1 &optional [str2 "piyo"]] (print (+ str1 str2)))
=> (piyo "hoge")
hogepiyo
=> (piyo "hoge" :str2 "fuga")
hogefuga

　他に可変長引数、可変キーワード引数に対応した&restや&kwargsもあるが、使う機会は少ないので説明は省く。

オブジェクト指向

　pythonはオブジェクト指向言語である。よってlispの皮を被ったpythonであるhyもオブジェクト指向言語である。

　hyのオブジェクト指向はあまり深く考えずとも、直感的に使える。たとえばクラス定義してクラスメソッドを呼ぶというよくある処理。

=> (defclass X []
... (defn __init__ [self x] (setv self.x x))
... (defn print [self] (print self.x)))
=> (setv x (X "xxx"))
=> (x.print)
xxx

　簡単そうである。クラスのインスタンス化がちょっと気持ち悪いと思うかもしれないが、クラス名は実質的にコンストラクタへの参照だと思えばそんなにキモくない。

　ただし、python風の（普通のオブジェクト指向言語風の）ドット記法が使えるのは変数に束縛されたオブジェクトに対してだけである。

=> ("hoge hoge".split)
  File "<input>", line 1, column 13

  ("hoge hoge".split)
              ^-----^
HyTypeError: cannot access attribute on anything other than a name (in order to get attributes of expressions, use `(. <expression> split)` or `(.split <expression>)`)

　親切なことにエラーメッセージがなすべきことを教えてくれる。

=> ((. "hoge hoge" split))
['hoge', 'hoge']
=> (.split "hoge hoge")
['hoge', 'hoge']

　上の書き方だとsplitの関数オブジェクトが得られるので、呼び出すにはもう一回カッコでくくってやる必要がある。下の書き方は直接呼べる。

スライス・辞書などのキー参照

　getという関数があり、(get a 0)はpythonのa[0]と等価である。次のように使うことができる。

=> (setv l [1 2 3])
=> (get l 0)
1
=> (setv d {1 10 2 20})
=> d
{1: 10, 2: 20}
=> (get d 1)
10
=> (setv (get d 3) 30)
=> d
{1: 10, 2: 20, 3: 30}

リスト内包表記

　pythonのリスト内包表記がちゃんとhyにもある。安心して欲しい。次のように書く（チュートリアルの例）。

(setv odds-squared
  (list-comp
    (pow num 2)
    (num (range 100))
    (= (% num 2) 1)))
; And, an example stolen shamelessly from a Clojure page:
; Let's list all the blocks of a Chessboard:

(list-comp
  (, x y)
  (x (range 8)
   y "ABCDEFGH"))

; [(0, 'A'), (0, 'B'), (0, 'C'), (0, 'D'), (0, 'E'), (0, 'F'), (0, 'G'), (0, 'H'),
;  (1, 'A'), (1, 'B'), (1, 'C'), (1, 'D'), (1, 'E'), (1, 'F'), (1, 'G'), (1, 'H'),
;  (2, 'A'), (2, 'B'), (2, 'C'), (2, 'D'), (2, 'E'), (2, 'F'), (2, 'G'), (2, 'H'),
;  (3, 'A'), (3, 'B'), (3, 'C'), (3, 'D'), (3, 'E'), (3, 'F'), (3, 'G'), (3, 'H'),
;  (4, 'A'), (4, 'B'), (4, 'C'), (4, 'D'), (4, 'E'), (4, 'F'), (4, 'G'), (4, 'H'),
;  (5, 'A'), (5, 'B'), (5, 'C'), (5, 'D'), (5, 'E'), (5, 'F'), (5, 'G'), (5, 'H'),
;  (6, 'A'), (6, 'B'), (6, 'C'), (6, 'D'), (6, 'E'), (6, 'F'), (6, 'G'), (6, 'H'),
;  (7, 'A'), (7, 'B'), (7, 'C'), (7, 'D'), (7, 'E'), (7, 'F'), (7, 'G'), (7, 'H')]

　私はチュートリアルを読んでもよくわからなかったので、次の内包表記を自分でhyに変換してみることにした。

>>> [[x*y for y in range(1,10)] for x in range(1,10)]

　何の事はない掛け算九九である。

　まず外側を作る。

=> (list-comp x (x (range 1 10)))
[1, 2, 3, 4, 5, 6, 7, 8, 9]

　次に内側を書く。

=> (list-comp (list-comp (* x y) (y (range 1 10))) (x (range 1 10)))
[[1, 2, 3, 4, 5, 6, 7, 8, 9], [2, 4, 6, 8, 10, 12, 14, 16, 18], [3, 6, 9, 12, 15, 18, 21, 24, 27], [4, 8, 12, 16, 20, 24, 28, 32, 36], [5, 10, 15, 20, 25, 30, 35, 40, 45], [6, 12, 18, 24, 30, 36, 42, 48, 54], [7, 14, 21, 28, 35, 42, 49, 56, 63], [8, 16, 24, 32, 40, 48, 56, 64, 72], [9, 18, 27, 36, 45, 54, 63, 72, 81]]

　仕組みはわかった。わかりやすいかと言われると微妙だが、pythonのリスト内包表記も最初は読みづらく感じたし、慣れればなんとかなるだろう。

まとめ

　内容は必要を認めれば追加する。

　hyはけっこう楽しい（小並感）。

【python】hyを触ってみる

Wed, 28 Feb 2018 11:24:23 +0900

　なんか、たまにlisp使ってみたくなるんだよね。

　去年のこれくらいの時期にもcommon lispをやってみた記憶があるが、たぶん言語として悪くはないんだろうけど、ちゃんと書けるようになる前に飽きてしまった*1。

　という訳で、今回はpython方言（lisp方言と言うべきか？）のhyを使う。これが何なのかというと、pythonにコンパイルされるlisp。・・・その発想がなかった訳じゃないけど、本当にやるとは思わなかった。

　たぶん前回common lispに飽きてしまったのは「lispしなきゃ」って気張りすぎたのが原因なので、今回はpythonだと思って気楽に書くことにする。その上でpythonで書くのと比較してメリットが見えれば今後何かに使うのもありだし、なければさっさとゴミ箱に放り込むつもりである。

　公式サイト
Welcome to Hy’s documentation! — hy 0.15.0 documentation

試す

　hyのチュートリアルを一通り読んで「雰囲気はわかったけど、実際のプログラムがこんなので書けるの？」と思った。そこで簡単なプログラムをまずpythonで書いた。

# coding: UTF-8

import numpy as np
from sklearn.datasets import load_iris
from sklearn.svm import SVC
from sklearn.model_selection import StratifiedKFold
from sklearn.metrics import precision_recall_fscore_support as prf

def main():
    iris = load_iris()
    svm = SVC(C=5, gamma=0.01)

    trues = []
    preds = []
    for train_index, test_index in StratifiedKFold().split(
            iris.data, iris.target):
        svm.fit(iris.data[train_index], iris.target[train_index])
        trues.append(iris.target[test_index])
        preds.append(svm.predict(iris.data[test_index]))

    scores = prf(np.hstack(trues), np.hstack(preds), average="macro")
    print("p:{0:.6f} r:{1:.6f} f1:{2:.6f}".format(
        scores[0], scores[1], scores[2]))

if __name__ == "__main__":
    main()

　sklearnのsvmでirisを分類する。たった26行の、機械学習初心者が書いたみたいなコードだ。ちなみに0.96くらいのF1値になった（irisってつくづくちょろい奴だな）。

　これを一行ずつhyに翻訳していく。まあこの程度の内容が書ければなんとか実用にはなるだろう、というつもりである。

　ちなみに、公式ドキュメント以外で以下のページを参考にさせて頂きました。

ゼロから始めるHy(hylang)
ChainerのMNISTの例をHyに翻訳してみる
 Pythonで書かれたイカしたLisp: Hy - Qiita
PythonistaのためのLisp入門（Hyチュートリアル和訳） - Qiita

encoding指定

　マジックコメントはしょせんコメントなのでコメントとして書けば良いらしい（こう書いてるところがあった）。

;; -*- coding:utf-8; mode:hy -*-

　でもこれ、emacsに認識させるだけなのでは？　sjisとかにしたらちゃんとhy側で認識するのかしら。わざわざ試す必要は感じないけど。

　あとhy-modeは入れた。

import

　こうなりました。

(import [numpy :as np]
        [sklearn.datasets [load_iris]]
        [sklearn.svm [SVC]]
        [sklearn.model_selection [StratifiedKFold :as SKF]]
        [sklearn.metrics [precision_recall_fscore_support :as prf]])

　階層構造をカッコで表現する、理にかなってるような、カッコいいような、キモいような、微妙な感じ。

main関数

　なんかそれ用のマクロ（defmain）もあるっぽいが、便利マクロに頼り切るのもどうかと思ってifで素直に書いてみる。とりあえずhogeるmain関数を作成。

(defn main []
  (print "hoge"))

(if (= __name__ "__main__")
  (main))

　そういや=の比較演算子なんだけど、eq、eq?、equal?、==の順に試してぜんぶダメで、最後に試した=が正解だった。勘弁してくれ。

　で、hy2pyでpythonコードに変換してみた結果は、

def main():
    return print('hoge')


main() if __name__ == '__main__' else None

　なにこれ。めっちゃウケる。「main() if __name__ == '__main__' else None」とか、まさか条件演算子にされるとは思わなかった（確かにその方がlispのifの機能を考えると自然だが）。この書き方にはけっこう「萌えた」ので、友達に渡したりするpythonコードで今後使っていきたい。

残り

　あとは淡々とググりながら（グダりながら）書いただけだった。

　ハマったポイント（最初わからなかったこと）としては、

クラスからオブジェクトのインスタンスを作るときは「オブジェクトのインスタンスを返す関数呼び出し」だと思ってやればできる
リストのスライスはgetで書く
シンボルに束縛していないインスタンスのメソッドは「(. instance method-name)」で呼ぶ（これで関数オブジェクトが返るので、もう一回外にカッコを付けると呼び出せる）

　あたり。後はなんか適当にドキュメント通りに書くとか、適当にpythonの記法で書いても（ドットとか）受け付けるので、そんなに苦労はしなかった。

完成したもの

　もしかしたら変なところがあるかもしれないが、とりあえず動きはした。

;; -*- coding:utf-8; mode:hy -*-

(import [numpy :as np]
        [sklearn.datasets [load_iris]]
        [sklearn.svm [SVC]]
        [sklearn.model_selection [StratifiedKFold :as SKF train_test_split]]
        [sklearn.metrics [precision_recall_fscore_support :as prf]])

(defn main []
  (setv iris (load_iris))
  (setv svm (SVC :C 5 :gamma 0.01))
  
  (setv trues [])
  (setv preds [])

  (for [[train_index test_index] ((. (SKF) split) iris.data iris.target)]
    (svm.fit (get iris.data train_index) (get iris.target train_index))
    (trues.append (get iris.target test_index))
    (preds.append (svm.predict (get iris.data test_index))))
  (setv scores (prf (np.hstack trues) (np.hstack preds) :average "macro"))
  (print ((. "p:{0:.6f} r:{1:.6f} f1:{2:.6f}" format)
                                              (get scores 0)
                                              (get scores 1)
                                              (get scores 2))))

(if (= __name__ "__main__")
  (main))

　何回か実行したところ、心なしかpython版よりF1値が高めになった気がする（冗談です）。

感想

　スライスをS式で書けないせいで、どうやっても冗長になるね、というのが率直な感想。まあ、こればっかりはしょうがないだろう。

　良かったところは・・・意外となんとかなったところかな。lisp特有の機能は特に使わなかったので、事実上pythonから構文をトランスレートしただけだが、とりあえず書けない構文はなかった。正直どこかで素直には書き写せない場所が出てきてもおかしくないと思ってたけど（numpy配列のファンシーインデックスとか）、とりあえず詰みはしなかった。でもnumpy配列の列抽出とか、できるのだろうか・・・。

　あと、「これはlispだから、インスタンスメソッドだろうがなんだろうが、どんな処理だってしょせんは関数オブジェクトの呼び出しなんだ」と思って書いたので、初心者でもそんなに戸惑わなかった。文法が単純なのは素晴らしい。二週間もやればだいたい書けるようになると思う。

　悪かったところは、残念ながらいろいろ思いつく。

冗長（python比で）

　これはしょうがない。許す。

支援ツール（flymakeやjedi相当のもの）がなさそう

　これもしょうがないんだけど・・・マイナー言語って不利だよね。

hyインタプリタの吐くエラーメッセージが黄色かった）

　いつも使ってる開発環境（emacsのシェル）では凄いどぎつい色で表示された。これはしょうがなくない。なんで黄色にしたんだよ。全然読めねえんだけど。

　使えなくはないんだけど、日常的にnumpyとかsklearn走らせるのに使うかと言われると・・・って感じだな。でもpython環境上にいる強みはそのへんが使えることだと思うので、けっきょく存在意義がよくわからなくなってくる。

　まあ、「lispで書いた方が楽」な処理*2をpythonで書きたくなったらその部分だけhyで書くとか、あるいはpython使いが趣味のlispの勉強に使うとか、ネタとして愛でるとか、そういう用途で使うものだな、これは。

　やるメリットがあるのかどうかは微妙な感じだけど、関数型というか宣言型言語は面白そうと思ってるので、なんか強みを活かせるような感じでちょくちょくいじっていきたい。prologとかもやってみたいし*3。

*1:それからこのブログにも飽きて一年近く放置していたのを、最近になって性懲りもなく再開した訳だが・・・

*2:真っ先に思い浮かんだのはS式のパースだった。あと構文解析器とか言語処理系、探索とか自動証明みたいな辺りは歴史的に使われてきたので、書きやすいのだろうか？

*3:いずれ気が向いたらhyでprologインタプリタでも書いてみようかしら

【common lisp】common lispでn-gram

Sun, 12 Mar 2017 06:53:29 +0900

　趣味でCommon Lispを始めました。とりあえず練習にn-gramを書いてみました。

　書き方は色々あると思いますが、ループ構文がまだいまいちわからないので再帰で書きます。

(defun rec-ngram (list n &optional (ret-list '()))
  (if (eq (length list) (- n 1))
      ret-list
      (rec-ngram (cdr list) n 
		 (nconc ret-list 
			(list (subseq list 0 n))))))

　いけてる書き方なのかどうかは良くわかりませんが、そう複雑なものではありません。末尾再帰で書いていますが、末尾再帰でなくて良いならもっと簡単に書けます。

　使い方はこんな感じ。

* (rec-ngram '("吾輩" "は" "猫" "で" "ある" "。") 2)
(("吾輩" "は") ("は" "猫") ("猫" "で") ("で" "ある") ("ある" "。"))

　けど、毎回listの長さを計算するのは馬鹿馬鹿しいと思ったので、最初に全体の長さを計算し、後は1ずつ引いていくことにしました。

(defun rec-ngram (list n &optional (list-length nil) (ret-list '()))
  (if (eq list-length nil)
      (setq list-length (length list)))
  (if (eq (length list) (- n 1))
      ret-list
      (rec-ngram (cdr list) n (- list-length 1)
		 (nconc ret-list 
			(list (subseq list 0 n))))))

　こんな感じでn-gramが作れますが、以前書いたpython版と比べると機能的に見劣りします。

文字列を引数に取れない
n-gramの要素がリストで返ってきても嬉しくない（区切り文字列で区切られた文字列の方が嬉しい）

　とりあえずpython版と同じ機能になるように、適当に関数を増やしてラップしてみます。

(defun ngram (str &key (n 2) (splitter "-*-"))
  ;文字列が来たら一文字ずつの文字列のリストに変換
  (if (typep str 'string)
      (setq str (mapcar #'string (concatenate 'list str))))
  ;任意の区切り文字でn-gramの結果を連結
  (let ((ngram-result (rec-ngram str n)))
    (mapcar (lambda (list) 
	      (format nil (format nil "~~{~~A~~^~A~~}" splitter) list)) 
	    ngram-result)))

　nと区切り文字列はキーワード引数にしてみました。list-lengthをこっちの関数で計算する前提にすればrec-ngramのif文を外せますが、面倒くさいのでやっていません。formatを二段重ねにしてる辺りがとても気持ち悪いですが、formatの書式指定がよくわからないので勘弁してください。こんな感じで使えます。

* (ngram "吾輩は猫である。")
("吾-*-輩" "輩-*-は" "は-*-猫" "猫-*-で" "で-*-あ" "あ-*-る" "る-*-。")
* (ngram '("吾輩" "は" "猫" "で" "ある" "。"))
("吾輩-*-は" "は-*-猫" "猫-*-で" "で-*-ある" "ある-*-。")
* (ngram "吾輩は猫である。" :n 3)
("吾-*-輩-*-は" "輩-*-は-*-猫" "は-*-猫-*-で" "猫-*-で-*-あ" "で-*-あ-*-る" "あ-*-る-*-。")
* (ngram "吾輩は猫である。" :n 3 :splitter "!??!")
("吾!??!輩!??!は" "輩!??!は!??!猫" "は!??!猫!??!で" "猫!??!で!??!あ" "で!??!あ!??!る" "あ!??!る!??!。")

　lispは書く分には楽しいですが、pythonと比べるとコード量が多いというか、低水準な印象です。使いこなせてない便利な機能も色々あると思うので、慣れてくればもう少し気楽に書けるようになるとは思います。とりあえず、しばらくは趣味で触っていくことにします。

追記 2017/03/16

　ループでも書きました。

(defun loop-ngram (list n)
  (let ((result-list '())) 
    (dotimes (count (- (length list) n -1) result-list)
      (setq result-list (cons (subseq list count (+ count n)) result-list)))))

　シンプルですが、逆向きになって出てきます。

* (loop-ngram '("吾輩" "は" "猫" "で" "ある" "。") 2))
(("ある" "。") ("で" "ある") ("猫" "で") ("は" "猫") ("吾輩" "は"))

　逆向きがいやならreverseするか、最初からnconcでリストを作るだけなので難しいことはありません。