残高照会メモ

python自習テキスト

2010-06-21T22:45:00.002+09:00

wikiで書き始めた。

http://giraffe.topaz.ne.jp/wiki/doku.php/py:python_curriculum

pythonでハフマン符号化

2010-03-18T20:54:00.003+09:00

データの出力頻度をもとに、一つずつのデータを可変長にエンコードする。
適当なファイルを filename 変数に入れて実行すると、いろいろ出力が変わる。
ハフマン符号の正規化とかいう処理はしていないので、ツリーの散らばり具合はいいかげん。

出力例は、"The Brothers Karamazov" の全テキストを突っ込んでみたときのもの。
この手法を素直に使うだけでは、そんなに高い効率の圧縮にはならないということかな。


# -*- coding:cp932 -*-

filename = r'any_file.txt'

# 出現頻度取得
freq = dict()
for line in open(filename, 'rb'):
  for c in line:
    freq.setdefault(c, 0)
    freq[c] += 1

# 頻度が少ないものから順に枝をまとめてツリー形成
wtree = [i for i in freq.iteritems()]
while len(wtree) > 1:
  # 出現頻度ワースト2の枝を見つけてまとめる
  wtree.sort(lambda a,b: cmp(b[1], a[1]))
  b2, b1 = (wtree.pop(), wtree.pop())
  wtree.append(((b1[0], b2[0]), b1[1] + b2[1]))

tree = wtree[0][0]
print "frequency tree:"
print tree
orig_bits = wtree[0][1] * 8

# ツリーをもとに変換表生成
def collapse_tree(t, leaf, prefix):
  if type(leaf) == tuple:
    c = 0
    for i in leaf:
      collapse_tree(t, i, prefix + (c,))
      c += 1
  else:
    t.append((leaf, prefix))

e_table = []
collapse_tree(e_table, tree, ())

# 変換表印字
compressed_bits = 0
print "encoding table:"
for i in e_table:
  print "".join([str(j) for j in i[1]]), (i[0], freq[i[0]])
  compressed_bits += freq[i[0]] * len(i[1])

print "data can be compressed from %d bits into %d bits (%f%%)" % \
  (orig_bits, compressed_bits, float(compressed_bits) / orig_bits)

出力例：


frequency tree:
(((' ', (('s', (('.', ('I', (((('z', 'L'), 'G'), '!'), (('P', 'q'), ((('E', ('V'
, ('U', (('4', '0'), ('3', '5'))))), 'C'), ';'))))), ('p', 'b'))), ('r', ('m', '
y')))), (('t', ((('v', ("'", (('-', 'x'), 'A'))), 'w'), 'd')), ((('\n', '\r'), (
'c', ',')), ('l', ('f', 'g'))))), ((('o', 'a'), ('n', (((((('S', 'M'), (('K', ('
R', ':')), 'W')), ('T', (('D', ((('Z', 'J'), ')'), ('(', (('*', (('8', '7'), 'Q'
)), (('2', (('X', '9'), '6')), '1'))))), 'B'))), 'k'), ('"', (((('O', 'N'), 'F')
, 'H'), ('?', ('j', 'Y'))))), 'u'))), (('h', 'i'), 'e')))
encoding table:
000 (' ', 349903)
00100 ('s', 87812)
0010100 ('.', 22205)
00101010 ('I', 10989)
001010110000 ('z', 730)
001010110001 ('L', 675)
00101011001 ('G', 1352)
0010101101 ('!', 2687)
00101011100 ('P', 1293)
00101011101 ('q', 1279)
0010101111000 ('E', 339)
00101011110010 ('V', 165)
001010111100110 ('U', 69)
00101011110011100 ('4', 17)
00101011110011101 ('0', 16)
00101011110011110 ('3', 16)
00101011110011111 ('5', 15)
001010111101 ('C', 592)
00101011111 (';', 1171)
0010110 ('p', 20938)
0010111 ('b', 19549)
00110 ('r', 78044)
001110 ('m', 38521)
001111 ('y', 37053)
0100 ('t', 133524)
0101000 ('v', 18431)
01010010 ("'", 9357)
0101001100 ('-', 2399)
0101001101 ('x', 2172)
010100111 ('A', 4190)
010101 ('w', 32169)
01011 ('d', 64044)
011000 ('\n', 32018)
011001 ('\r', 32018)
011010 ('c', 31099)
011011 (',', 30341)
01110 ('l', 60812)
011110 ('f', 30287)
011111 ('g', 27884)
1000 ('o', 117883)
1001 ('a', 117275)
1010 ('n', 99433)
1011000000 ('S', 2028)
1011000001 ('M', 2019)
10110000100 ('K', 1027)
101100001010 ('R', 517)
101100001011 (':', 474)
1011000011 ('W', 1918)
101100010 ('T', 3586)
10110001100 ('D', 972)
10110001101000 ('Z', 132)
10110001101001 ('J', 119)
1011000110101 (')', 219)
1011000110110 ('(', 219)
101100011011100 ('*', 62)
10110001101110100 ('8', 13)
10110001101110101 ('7', 12)
1011000110111011 ('Q', 23)
1011000110111100 ('2', 21)
101100011011110100 ('X', 6)
101100011011110101 ('9', 5)
10110001101111011 ('6', 10)
101100011011111 ('1', 36)
1011000111 ('B', 1725)
1011001 ('k', 12741)
1011010 ('"', 12521)
10110110000 ('O', 861)
10110110001 ('N', 785)
1011011001 ('F', 1605)
101101101 ('H', 3190)
101101110 ('?', 3114)
1011011110 ('j', 1449)
1011011111 ('Y', 1415)
10111 ('u', 45643)
1100 ('h', 94800)
1101 ('i', 92948)
111 ('e', 177161)
data can be compressed from 15873136 bits into 9016123 bits (0.568011%)

pythonで加重ランダム

2009-07-30T15:05:00.006+09:00

何かをランダムに出現させたいが、値によって出現率が異なるようにしたい。

bisectモジュールをうまくつかうといいみたい。見つけた元ネタ：
http://code.activestate.com/recipes/576370/

bisectは、ソート済みのリストについて頭出しができるモジュール。


(いろいろテスト)
>>> import bisect
>>> scale = [10, 20, 30, 40, 50]   # ソート済みのリストを使うこと
>>> bisect.bisect(scale, 15)    # 15はどこに位置する?
1
(これはスライス範囲を指定するときの場所。つまり10と20の間ってこと)
>>> bisect.bisect(scale, 46)    # 46は?
4
(この場合は、40と50の間ってこと)

>>> scale = ['a', 'j', 'z']  # 数字以外でも使えるのかな
>>> bisect.bisect(scale, 'q')
2
(できそうですね)

元ネタのコードには何も付け加える余地がないからここでは動作原理のみ書くと、間の空き具合がまちまちな数のリストを準備しておいて、それに乱数を使ってbisect探索するということ。random関数が0.0から1.0の乱数を出すから、値の範囲も0.0から1.0で作ると相性がよい。

下のようなスケールがあるとして、


0.0   0.1           0.3                            1.0
 |-----+-------------+------------------------------|
  範囲A     範囲B                  範囲C

で、ランダム値にこのスケールをあてはめれば、範囲Cが選ばれる確率は70%くらいで、範囲Aは大体10%くらいしか出現しないことになる。

実証したコード：


>>> import bisect
>>> import random
>>> scale, items = [0.1, 0.3, 1.0], ['A', 'B', 'C']
>>> [items[bisect.bisect(scale, random.random())] for i in xrange(100)]
['C', 'C', 'C', 'A', 'B', 'C', 'A', 'A', 'C', 'C', 'C', 'C', 'C', 'B', 'C', 'B',
 'B', 'C', 'C', 'C', 'A', 'C', 'C', 'C', 'C', 'C', 'C', 'B', 'C', 'B', 'C', 'B',
 'B', 'C', 'C', 'C', 'B', 'B', 'B', 'C', 'C', 'C', 'C', 'C', 'C', 'C', 'C', 'C',
 'B', 'C', 'B', 'C', 'A', 'C', 'C', 'C', 'C', 'C', 'C', 'C', 'C', 'C', 'A', 'B',
 'B', 'C', 'C', 'B', 'C', 'A', 'C', 'A', 'C', 'B', 'C', 'C', 'C', 'C', 'C', 'B',
 'C', 'C', 'C', 'A', 'C', 'C', 'C', 'B', 'C', 'B', 'C', 'A', 'B', 'A', 'B', 'C',
 'B', 'C', 'C', 'C']

Cの出現率が多くて、Aがレア。なるほどねー

pythonでタートルグラフィック

2009-06-16T13:27:00.004+09:00

Tkinterモジュールのオマケ?にタートルグラフィックのライブラリがあって、多分一番手っ取り早くCGっぽいことを始められる。

下のスクリプトを適当なファイル名で保存してから実行すると、ペンでグリグリ落書きしているかのようなデモが走る。


from turtle import *
import random

speed('fast')

while True:
  for i in xrange(1000):
     down()
     forward(3)
     up()
     forward(2)
     right(random.randint(-3,10))
  reset()

また、コンソールから、

>>> import turtle
>>> turtle.demo()

とか

>>> import turtle
>>> turtle.demo2()

とかすると、出来あいのデモが見られたりする。

MS-Accessでリンクテーブルを張替え(VBA)

2009-06-01T14:14:00.005+09:00

pythonで書きたくても、VBAなんかを書かなくちゃいけないときもある。一応成果メモ。

MS-Accessで、データ自体はどこかの共有フォルダ内のmdbファイルに置いておいて、それを各クライアントがリンクテーブルとして使う、という運用はよくあるパターン。

で、クライアントを新しく配置するごとに、リンクテーブルをちまちま張りなおすのは面倒だなあ、ということで、モジュール化した。refresh_link_tables というサブルーチンを呼ぶと、ネットワークフォルダにドライブ名を振って、リンクテーブルの定義を消して、あたらしくリンクを作り直している。


Function exists_table(ByVal name As String)
    On Error Resume Next
    exists_table = CurrentDb.TableDefs(name).name = name
End Function

Sub connect_net_drive()
    Dim oShell As Object
    Set oShell = CreateObject("WScript.Shell")
    '環境にあわせて適宜変える。最後のTrueは同期実行のしるし
    oShell.Run "NET USE Q: \\some_server\shared_folder passwd1 /USER:user1", , True
    Set oShell = Nothing
End Sub

Public Sub refresh_link_tables()
    Call connect_net_drive
    tt = Array("master", "master2", "journal1", ...... )  'リンクするテーブルをいくつでも
    For Each table_name In tt
        If exists_table(table_name) Then
            CurrentDb.TableDefs.Delete (table_name)
        End If
        Set tdef = CurrentDb.CreateTableDef(table_name)
        tdef.Connect = ";database=Q:\sample\shared_db.mdb"  '環境にあわせて書き換え
        tdef.SourceTableName = table_name
        CurrentDb.TableDefs.Append (tdef)
    Next
End Sub

補足：WScript.Shell オブジェクトを作ってNTコマンドを外部で実行するというのがなんだか格好悪いと思うなら、WScript.Network オブジェクトの MapNetworkDrive メソッドを使っても似たことができる。まあ、やりたいことが実現するのならなんでもいいや。

pythonでキャッシュサーバーを叩く

2009-05-20T15:52:00.000+09:00

WebサーバーにExcelシートなんかを置いて、ダウンロードさせる場合があるとする。ダウンロード経路にsquidとかのキャッシュサーバーがある場合、こいつが旧バージョンのドキュメントをしばらく確保して、なかなか新バージョンが配布できない。HTMLファイルなどだったら[F5]キーで明示的にキャッシュを再取得すればいいんだけど、Excelじゃできない。

キャッシュを回避するためにファイル名を明示的に変えて置いておくという方法があるにはあるが、なんだかムキになってキャッシュ破棄にこだわりたくなった。つまり Pragma:no-cache とかそんなヘッダを投げつければいいんでしょ。結果、下のようなスクリプトを書いた。Tkinter版。print文でデバッグ情報を出力するので、標準出力をどっかに表示できること。

スクリプト中の cache_server 変数には、あらかじめ自分の環境のプロキシサーバーとポート番号を設定する。


# -*- coding: cp932 -*-

import Tkinter as tk
import httplib, urllib

cache_server = "192.168.1.100:3128"  #configure yourself

def clear_cache(url):
    print url
    headers = {"Pragma": "no-cache", }
    conn = httplib.HTTPConnection(cache_server)
    conn.request("GET", url, "", headers)
    response = conn.getresponse()
    print response.status, response.reason
    print response.getheaders()
    conn.close()
    return "%s %s" % (response.status, response.reason)

class CacheRefresherFrame(tk.Frame):

    def __init__(self, parent, **kwag):
        tk.Frame.__init__(self, parent, **kwag)
        self.s1 = tk.StringVar()
        self.s2 = tk.StringVar()
        self.t1 = tk.Entry(self, width=100, textvariable=self.s2)
        self.b1 = tk.Button(self, text='refresh cash', command=self.do_hello)
        self.l1 = tk.Label(self, textvariable=self.s1)
        self.t1.pack()
        self.b1.pack()
        self.l1.pack()
        self.s1.set('ready')
        self.t1.focus()

    def do_hello(self):
        self.t1.configure(state=tk.DISABLED)
        self.b1.configure(state=tk.DISABLED)
        url = self.s2.get()
        self.s1.set('processing %s ...' % url)
        self.update()
        try:
            self.s1.set(clear_cache(url))
        finally:
            self.t1.configure(state=tk.NORMAL)
            self.b1.configure(state=tk.NORMAL)


root = tk.Tk()
root.title(u'キャッシュサーバーにキャッシュ破棄を指示するスクリプト')
CacheRefresherFrame(root).pack()
root.mainloop()

ここまで書いてから、ファイル名を変えずに明示的にキャッシュを回避する方法を思いついてしまった。ダウンロードページのHTMLで、ハテナ記号つきのリンクを張ればよかったんだよね。たとえば、app.xls というシートを配布するときに、リンクのURLに app.xls?ver_2 とか書くってこと。

あと、メソッド名が do_hello とかになっている理由は、公開用に名称を整理するのが面倒だったから。

pythonでsplit

2009-05-11T13:25:00.003+09:00

文字列を一定のルールでちょん切って配列にするという仕事はよく生じる。
こんなときは、文字列にsplitメソッドを適用すればよい。


>>> "out of google, out of existence".split(" ")
['out', 'of', 'google,', 'out', 'of', 'existence']

でもsplitメソッドは、不定数の空白文字で区切られたものをうまく扱えない。


>>> "out    of google, out of   existence".split(" ")
['out', '', '', '', 'of', 'google,', 'out', 'of', '', '', 'existence']

perlだと正規表現を使ってsplitもできたのになあ、と不便に思って調べると、ちゃんとpythonでもそれができた。ただ、明示的に正規表現オブジェクトのメソッドとしてこれを使う。


>>> import re
>>> r1 = re.compile("\s+")
>>> r1.split("out    of google, out of   existence")
['out', 'of', 'google,', 'out', 'of', 'existence']

あらよかったね。

あと、例文には何の意味もありません。

pythonで再帰関数

2009-04-08T13:41:00.007+09:00

メールの同報エイリアスのリスト中に、さらに別の同報エイリアスが入れ子になっているときがある。再帰的な展開ルーチンを書くことで、一発で最後まで展開することができる。


aliases = {
  'haken':    ['Michael', ],
  'kaikei':   ['Tanaka', 'Yamada', 'Ogawa', 'haken', ],
  'syomu':    ['Kobayashi', 'Shima', ],
  'syomu_ex': ['syomu', 'Futamura', ],
  'all':      ['kaikei', 'syomu_ex', 'BigBoss', ],
}

# recursive!
def expand_alias(k):
  for i in aliases[k]:
    if aliases.has_key(i):
      for i2 in expand_alias(i):
        yield i2
    else:
      yield i

for i in aliases.keys():
  print "%s: %s" % (i, ", ".join([j for j in expand_alias(i)]))

実行結果（各行の表示順は異なるかもしれない）


kaikei: Tanaka, Yamada, Ogawa, Michael
syomu: Kobayashi, Shima
all: Tanaka, Yamada, Ogawa, Michael, Kobayashi, Shima, Futamura, BigBoss
haken: Michael
syomu_ex: Kobayashi, Shima, Futamura

再帰的な処理がyieldで値を返すようにして、これを利用するほうはfor文なんかで簡単に扱えるようにしてしまうのが快適（この例ではforじゃなくてリスト内包で利用しているが）。yieldは便利だなあ。

Whoosh

2009-03-17T22:34:00.005+09:00

pure pythonな全文検索ライブラリ。luceneを意識しているようだ。
http://trac.whoosh.ca/

かなり新しいプロジェクトみたいなので、うまくいってほしい。
アナライザとかn-gramとかいう単語もページ中にちらほら見かけるので、きっとCJK系も
扱える。サイト内にも、完全unicode対応とあった。

とりあえずトップページから「Whooshの特徴」とでもいった部分を抜き出して訳しておく。


Some of Whoosh's features include:
Whooshはこんな特徴とかがあるよ：

 * Pythonic API.
   python風なAPI
 * Pure-Python. No compilation or binary packages needed, no mysterious crashes.
   ピュアpython。別途コンパイルが必要なものはない。だから謎のクラッシュも起こらない
 * Fielded indexing and search.
   フィールドに分けた索引検索ができる
 * Fast indexing and retrieval -- much faster than any other pure-Python solution.
   高速な索引生成と検索。ピュアpythonなものの中ではダントツ早い
   (C/C++製のものにはさすがに負けるけど)
 * Pluggable scoring algorithm (including BM25F), text analysis, storage,
   posting format, etc.
   適合度のアルゴリズム、アナライズ、格納、ポストするフォーマット等がプラグインで
   入れ替え可能
 * Powerful query language parsed by pyparsing.
   検索式が強力。pyparsingを使える
 * Pure Python spell-checker (as far as I know, the only one). 
   ピュアpythonなスペルチェッカー。たぶんWhooshが唯一

pyLuceneとかが結局java必要だったりして悶々としていたので、これは注目しておこう。っていうか、近くちゃんといじってみよう

WebOb

2009-03-09T10:01:00.003+09:00

[TODO]:WebObで検索すると妙に検索順位が高いらしい。せっかくなのでもう少し詳しく書き直す

WSGIアプリを書くときに色々楽できるようになるライブラリ。他のフレームワークにすでに組み込まれていることもあるが、WebObだけ単独で使ってもよい。python付属のcgiライブラリやcookieライブラリを使いやすくしてくれるラッパーに過ぎないが、つまらないミスを防いでシンプルに書けるようになるのがいい。これは標準配布になってもいいと思うなあ。

Requestオブジェクトを使うと、パラメータやcookieの入力がまとめてここから扱える。
準備は、WSGIアプリが受け取る辞書オブジェクト(仮引数はenvironが多い)を突っ込んでRequestを生成するのみ。


req = webob.Requset(environ)

あとは、req.paramsにGETやPOST経由で届いたパラメータが辞書になって入っていたり、req.cookiesにCOOKIEの値が同じく辞書になって入っていたりするので、単に参照すればよい。

Responseオブジェクトは、WSGIアプリとして生成される。使い方は、


def some_app(environ, start_response):
    ...
    res = webob.Response()
    res.body = '<html><body>hello</body></html>'
    return res(environ, start_response)

といった感じ。MIMEメッセージ設定（初期値はtext/html)やCOOKIEの設定も、resインスタンスのメソッドとしてひととおり準備されている。

HTTPでのリダイレクトは、


res = webob.exc.HTTPSeeOther(location="dokosoko.html")
return res(environ, start_response)

みたいに行う。

本メモ・本を読む本

2009-03-08T21:35:00.002+09:00

『本を読む本』アドラー&ドーレン著、講談社学術文庫。ブックオフに安値で転がっていた。

本の読み方についての方法論。ヒマつぶしみたいな本ばかり持ってきて字面だけを追っかけて、それを読書だと思い込んでると損するよ、という話。読書の深さにはそれぞれレベルがあるから、適当な品質の本は浅いレベルの読み方で読み飛ばしちゃって、本当に価値がある本を見つけたらそいつは一生かかっても徹底的に読みつくしなさい、それこそ読書だよ、とのこと。いやあハンパな本読みですんません。この本はちゃんと本棚に納めて、背表紙だけはいつも見えるようにしておこう。

読書メモ（カラシニコフ・ベルカ、吠えないのか？）

2009-03-07T21:31:00.003+09:00

『カラシニコフ(1)(2)』松本仁一著、朝日文庫　を読んだ。自動小銃の傑作であるカラシニコフが作られた時の話（本人へのインタビュー含む）から、それがあまりに性能がよく扱いやすいために、貧困国の住民がそれを使うことが可能になってしまったという話までを取材した本。そこにはアジアやアフリカの天然資源の利権がイヤな感じに絡んでいたり、植民地支配や冷戦のために煽られた対立がこじれてしまった姿が浮かんだり、しまいには子供ゲリラが弾除け代わりに戦場に駆り出されていく話になっていったりして、読んでひたすら暗くなる。書きぶりは淡々としていて、どんな文にもよけいな修飾はない。もちろん、書くべき事実が凄まじすぎるのでヘタに飾る必要が最初からない。

この本で、『ベルカ、吠えないのか？』古川日出男、文春文庫　をちょっと思い出した。カラシニコフが「世界に銃が拡散していく話」なら、こっちは「世界に犬が拡散していく話」。多分ちゃんと歴史を踏まえているんだし、世界一周的な場面の移り変わりも面白かったけど、文体がなんかハードボイルドのなりそびれって感じがしてそこは好きじゃない。

OpenID自習

2009-03-06T01:08:00.002+09:00

OpenIDの勉強をちょっとしてみようかなと思った。
http://openid.net/specs/openid-authentication-1_1.html を見ながら、例え話みたいなもので理解してみようと考えた。例えが的確かはわからない。

---

アマヤ君が、目の前にあるなんちゃらランドに入場したいと思っている。このなんちゃらランドの入場管理役は、入場したい人が本当にその人本人であることが証明できたら入場を許可してもよいと思っている。

ここでいう「本人であることの証明」とは、本人の所属する組織がその人を確かに本人だと認めることである。

なので入場管理役は、まずアマヤ君という名前の人物がどこに所属しているかを調べる。これをアマヤ君本人に聞いては信用ならないので、事務室に帰って専用の検索サービスで調べる。ここで、アマヤ君はタチバナ市に所属する人物であることがわかった。

入場管理役「アマヤ君とやら、あなたがあなたであることを証明できるのはタチバナ市の認証担当者ということだ。たいへんお手数だが、今からタチバナ市に赴いて、その担当者からこの書類にハンコをもらってきてくれたまえ。押してもらうハンコは、必ず40227番のハンコと指定しなさい。タチバナ市にはたくさんのハンコがあるはずだが、これ以外のハンコが押されている場合は無効であるから心せよ。」

今、入場管理役がハンコの番号をはっきり指定したのは、現在、その管理役自身も手元にその40227番のハンコと全く同じものを持っているからである。実はさっき、アマヤ君が訪れてから、大急ぎでタチバナ市に渡りをつけてこのハンコを共有したのだ。（次回からは、他のタチバナ市の人間が来ても、しばらくこのハンコを使いまわす予定。タチバナ市でなくハイジマ町だったりしたらまた別のハンコを準備する）

数時間後、アマヤ君が息を喘がせて再びなんちゃらランドの門前に帰ってきた。タチバナ市の担当者にハンコをもらってきたという。

よろしい、精査するので待ちたまえ、と、入場管理役はその書類を持って事務室に戻る。そこで、同じ文面の書類を作って、自分が持っている40227番のハンコを使って全く同じようにその書類の上に捺印してみた。完全に同じハンコを使うから、文字のインクとにじんで朱肉が交じりあう様子も全く同じだ。これはもう疑いなく、アマヤ君がタチバナ市の担当者に認められて戻ってきたということに違いない。

大変おまたせした、アマヤ君、我々は君を確かにアマヤ君であると認め、このなんちゃらランドへの入園を心から歓迎するものである。

※なんちゃらランドとタチバナ市が行った印章の共有は、OpenID1.1では平文方式とDH鍵交換方式があってどちらかを選べる。平文が実装は楽だろうが、セキュリティに劣る。

※このケースでは、なんちゃらランドが印章をあらかじめ共有しているという「スマートモード」の場合を想定した。印章をあらかじめ共有しない「ダムモード」というやりかたもある。

※アマヤ君がタチバナ市に行かされたのは、checkid_immediateモードでか、checkid_setupモードでかは明確にしていない。仕様では、どっちも似たようなものと読めた。

※アマヤ君がどうやってタチバナ市に自分のことを証明したかは、なんちゃらランドでは関知していない。合言葉でも使ったんじゃないの？または顔パスなのかな。どっちでもいいよ。ハンコさえ押してもらったんなら。

pythonでCDをイジェクト

2009-03-04T21:43:00.004+09:00

どうも手持ちのPCのCDがイジェクトしにくい。何十回も試してはじめてトレイが出てくるという具合。

下のようなコードを実行して、何回もイジェクトを試行するのを自動化した。要pygame。


>>> import pygame
>>> pygame.cdrom.init()
>>> cd_obj = pygame.cdrom.CD(0)
>>> cd_obj.init()
>>> cd_obj.eject()  #一回だけイジェクト試して…

>>> while 1: cd_obj.eject()  #うまくいくまでずっとやってて
...

ctypeモジュールを使って直接win32APIを叩くなんていうのもあるんだろうけど、考えるのめんどい。

python challenge 面白い

2009-03-03T23:27:00.002+09:00

http://www.pythonchallenge.com/ がかなり面白く、悩みながらちょっとづつ進めている。現在10番。

仕掛けとしては、問題のページにあるヒントを手がかりに、次のページのURLを当てるというもの。それをブラウザのアドレス欄に直接入力してみて、当たっていれば次の問題が表示される。
python challengeというだけあって、pythonを使うと問題が解きやすいように作ってある。事実、python抜きではかなり分かりにくい場合もある。

これは自習教材を作るときに使える方法だなと思う。ある練習問題を正しく解くと次の問題に進めるから、達成感がある。
pythonの初歩の学習にはpython challengeをマネした教材を用意して、上級になったらpython challengeそのものをやればいいか。

URLメモ・アーカイブ公開システム

2009-03-03T16:47:00.004+09:00

個人アーカイブのようなものを作る仕組みを実装してみた。
http://giraffe.topaz.ne.jp/wiki/doku.php/tinyrep

WSGIアプリとして書いたが、CGIとして動作する。python製（なんか、perlとかphpが書けなくなってきた）。

使用法などのドキュメントはそのうち整備がいるが、難しいものではない。wikiに添付ファイルをくっつけたようなもの。
ただ、タイトルとタグのデータを登録と同時にdelicious（ソーシャルブックマークのひとつ）にも送信する仕組みを内部的に組み込んだので、階層管理や簡単な検索までならそちらに任せてしまうことができる。と思う。
ソーシャルブックマークなんだから、誰かが気に入った記事はブックマーク数が増えてタグが充実していくかもしれない。

pythonでCAS

2009-01-07T09:50:00.002+09:00

CASサーバとクライアントアプリのサンプルを書く。

サーバーのコード(casserver.py)


# -*- encoding: cp932 -*-

"""
極めて簡易なCASサーバー実装。2.0プロトコルのつもり。

使用法：スクリプトをダブルクリックでサーバープロセスが開始する。

・https:// でなく http:// で動く（多分仕様違反だが）
・すべてのログインIDを、入力したパスワードを評価せずに認証する
・service値のチェックを省略している
・シングルサインオンには未対応(Cookieを交換しないので)
・その他、最初のログインに関わる機能以外をたくさん省略
"""
import cgi, random

def get_cgi_params(environ):
    pars = cgi.parse(environ['wsgi.input'], environ=environ, keep_blank_values=True)
    for k in pars: pars[k] = "".join(pars[k])
    return pars

ticketstore = dict()
ticketseed = '012456789ABCDEFGHIJKLMNOPQRSTUVWXYZ'

def app_cas_login(environ,start_response):
    pars = get_cgi_params(environ)
    service = pars.get("service", "")
    userid = pars.get("userid", "")
    if userid:
        ticket = 'ST-' + ''.join([random.choice(ticketseed) for i in xrange(32)])
        ticketstore[ticket] = (userid, service)
        print 'ticket:', ticket, userid, service
        location = "%s?ticket=%s" % (service, ticket,)
        print "redirect:", location
        start_response("302 Moved Temporarily", [('Location', location)])
        return []
    start_response("200 OK", [('Content-Type','text/html')])
    return ["""<html><head>
<meta http-equiv="Content-Type" content="text/html; charset=Shift_JIS">
<title>LOGIN</title></head><body>
<form action="login" method="post">
<input type="hidden" name="service" value="%s">
ID:<input name="userid"><br>PASS:<input name="pass"><br><input type="submit">
</form></body></html>""" % (service,), '']

def app_cas_validate(environ,start_response):
    pars = get_cgi_params(environ)
    service = pars.get("service", "")
    ticket = pars.get("ticket", "")
    try:
      userid = ticketstore[ticket][0]
      ticketstore.pop(ticket)
      start_response("200 OK", [('Content-Type','text/xml')])
      return ["""<cas:serviceResponse xmlns:cas='http://www.yale.edu/tp/cas'>
  <cas:authenticationSuccess>
    <cas:user>%s</cas:user>
    <cas:ticket>%s</cas:ticket>
    </cas:Attributes>
  </cas:authenticationSuccess>
</cas:serviceResponse>""" % (userid, ticket, ), '']
    except KeyError:
      start_response("200 OK", [('Content-Type','text/xml')])
      return ["""<cas:serviceResponse xmlns:cas='http://www.yale.edu/tp/cas'>
  <cas:authenticationFailure code='INVALID_TICKET'>
    ticket '%s' is expired or not recognized
  </cas:authenticationFailure>
</cas:serviceResponse>""" % (ticket,), '']

dispatch_table = {
    'login':          app_cas_login,
    'serviceValidate':app_cas_validate,
}

def app_dispatcher(environ, start_response):
    """ URL情報から実行するWSGIを決めるミニミドルウェア """
    if environ.has_key('PATH_INFO'):
        a = environ['PATH_INFO'].split("/")[-1]
    else:
        a = environ['SCRIPT_NAME'].split("/")[-1]
    a = a.split(".")[0]
    app = dispatch_table.get(a)
    return app(environ, start_response)

if __name__ == '__main__':
    from wsgiref.simple_server import make_server
    srv = make_server('localhost', 8081, app_dispatcher)
    srv.serve_forever()

クライアントアプリのコード(client.py)


# -*- encoding: cp932 -*-
import urllib

# 自分自身のログインURL(service引数)
url_mylogin = "http://localhost:8082/mylogin"
# CASサーバーの認証画面
url_caslogin = "http://localhost:8081/login"
# CASサーバーのticket問い合わせ用ベースURL
url_casvalidate = "http://localhost:8081/serviceValidate"

def get_cgi_params(environ):
    import cgi
    pars = cgi.parse(environ['wsgi.input'], environ=environ, keep_blank_values=True)
    for k in pars: pars[k] = "".join(pars[k])
    return pars

def my_login_test(environ,start_response):
    """クライアントアプリ側の動作テスト"""
    pars = get_cgi_params(environ)
    ticket = pars.get("ticket", "")
    # ticket引数がなければ、CASサーバーの認証画面にリダイレクトする
    if not ticket:
        url = "%s?service=%s" % (url_caslogin, urllib.quote(url_mylogin))
        print "redirect:", url
        start_response("302 Moved Temporarily", [('Location', url)])
        return []
    # 受け取ったticket引数を使って、CASのヴァリデーションをする。
    import re
    url = "%s?ticket=%s&service=%s" % (url_casvalidate, ticket, urllib.quote(url_mylogin))
    print "validate:", url
    # レスポンスを文字列に格納して、中身を調べる
    r = urllib.urlopen(url).read()
    # ここでは簡易に行うためにXMLのパースでなく正規表現による抽出で済ます
    r1 = re.compile("<cas:user>(.+?)</cas:user>")
    r2 = r1.findall(r)
    if len(r2) > 0:
      userid = r2[0]
      start_response("200 OK", [('Content-Type','text/plain')])
      return ['hello,', userid, '']
    else:
      start_response("200 OK", [('Content-Type','text/plain')])
      return ['something wrong', '']

dispatch_table = {
    'mylogin':   my_login_test,
}

def app_dispatcher(environ, start_response):
    """ URL情報から実行するWSGIを決めるミニミドルウェア """
    if environ.has_key('PATH_INFO'):
        a = environ['PATH_INFO'].split("/")[-1]
    else:
        a = environ['SCRIPT_NAME'].split("/")[-1]
    a = a.split(".")[0]
    app = dispatch_table.get(a)
    return app(environ, start_response)

if __name__ == '__main__':
    from wsgiref.simple_server import make_server
    srv = make_server('localhost', 8082, app_dispatcher)
    srv.serve_forever()

ふたつのスクリプトをそれぞれダブルクリックなんかで実行しっぱなして、
http://localhost:8082/mylogin
をブラウザから表示するとCAS側のログイン画面にリダイレクトされる。
ここで認証に成功するともとのアプリに戻ってログインIDが表示される。

CASサーバーがないのにCASのクライアントアプリを書くような羽目になったらこれで仮に開発を進めておくとか。

WSGI・謎の用法

2008-10-15T21:42:00.004+09:00

WSGIは標準入力（相当のもの）と標準出力（相当のもの）を与えられて動く仕組みなのだから、UNIXのフィルタ処理みたいなものにも使えるのだろうか。と、ふと思いついたので作ってみた。以下に。

下のスクリプトを適当な名前で保存して実行すると、WSGIアプリ用の簡易Webサーバーが立ち上がる。myapp関数がやってることは、標準入力から一行ずつテキストを受け取って、それを大文字化してからレスポンスとして返すというだけ。


def myapp(environ, start_response):
    start_response('200 OK' , [('Content-Type', 'application/octet-stream')])
    def myfilter(stream):
        while True:
            a = stream.readline()
            if len(a) == 0: break
            yield a.upper()
    return myfilter(environ['wsgi.input'])

if __name__ == '__main__':
    from wsgiref.simple_server import make_server
    make_server('127.0.0.1', 8800, myapp).serve_forever()

で、このサーバーにデータを投げつけてレスポンスを受け取るというスクリプトを別に用意する。ここでは filter1.py とでもする。


import sys
import socket
server, port = '127.0.0.1', 8800
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.connect((server, port))
s.send('GET / HTTP/1.0\n\n')
for i in sys.stdin:
    s.sendall(i)
    a = s.recv(1024)
    sys.stdout.write(a)

で、動作テストは、例えばWindows系のコマンドプロンプトからなら


type some_text.txt | python filter1.py

とでも入力してみる。適当なファイルがなければ、このスクリプト自身を処理してみてもいい。


type filter1.py | python filter1.py

で、得られるテキスト。


HTTP/1.0 200 OK
Date: Wed, 15 Oct 2008 12:42:23 GMT
Server: WSGIServer/0.1 Python/2.5.2
Content-Type: application/octet-stream

IMPORT SYS
IMPORT SOCKET
SERVER, PORT = '127.0.0.1', 8800
S = SOCKET.SOCKET(SOCKET.AF_INET, SOCKET.SOCK_STREAM)
S.CONNECT((SERVER, PORT))
S.SEND('GET / HTTP/1.0\N\N')
FOR I IN SYS.STDIN:
    S.SENDALL(I)
    A = S.RECV(1024)
    SYS.STDOUT.WRITE(A)

ワーイ、なんかフィルタコマンドっぽいものができた。WSGIで。

普通のCGIスクリプトとかと違って、リクエストボディが全部終わらなくても受け取ったそばからレスポンスにして返してくれるから、どんなに巨大なデータを投げつけても、（ある意味）大丈夫。まさにフィルタコマンド。

（なんかバッファリングの都合か、何回に一回かテキスト処理が途中で中断します。とりあえずまあいいや）

(追記:2009.3.3 windowsのときは、標準出力を明示的にバイナリモードに設定しておかないとだめか。)

pythonでtar

2008-10-14T19:11:00.002+09:00

WSGIの話がちょっと滞ったけど、再開するついでにtarの扱いについて。

tarは、標準配布のtarfileモジュールを使って非常に簡単に扱える。無圧縮のtar、gzip圧縮したtar、bz2圧縮したtarが扱えるようだ。(Python2.5)

tarfile.openで新しいtarファイルを作り、ファイルのフルパスないし相対パス名をどんどんaddしていけばよい。


import os
import tarfile

th = tarfile.open('test.tar', 'w')
#th = tarfile.open('test.tar.bz2', 'w:bz2') <--- こっちを有効にするとbz2圧縮
for root, dirs, files in os.walk(r'c:\windows\media'):
    for f in files:
        fullpath = os.path.join(root, f)
        print fullpath
        th.add(fullpath)
th.close()

ファイルを取り出すには、rオプションで開いて、extractでひとつづつ展開する。一度に展開するextactallもあるけど。


import tarfile

th = tarfile.open('test.tar', 'r')
#th = tarfile.open('test.tar.bz2', 'r:bz2')
for item in th:
    print item
    th.extract(item)
th.close()

WSGI探求(2)

2008-09-27T23:16:00.002+09:00

前回のスクリプトのメインルーチン


if __name__ == '__main__':
    from wsgiref.simple_server import make_server
    make_server('127.0.0.1', 8780, myapp).serve_forever()

は、myappというWSGIアプリケーションを使って、ローカルホストの8780番ポートでHTTPサーバーを実行してください、という意味。python2.5以降には、wsgirefというWSGIサーバーのサンプルが同梱されているので、これを使う。他にも、もっとちゃんと書かれたWSGIサーバーもあるので、それらが手元にあるのならそれを使っても同じこと。pasteなんかにもサーバー実装が含まれていた。とにかく、myappという名前のWSGIアプリを動かすんだという点が最も重要。

で、そのmyappとかいう名前のアプリケーションがどう定義されているかというと、こんなふう。


def myapp(environ, start_response):
    if environ['PATH_INFO'] == '/hello':
        return myapp2(environ, start_response)
    start_response('200 OK' , [('Content-Type', 'text/html')])
    message = 'you requested %s. HAZURE.' % environ['PATH_INFO']
    return ['<html><body><p>', message, '</p><body></html>']

関数は、environとstart_responseという引数を取る。仮引数の名前はなんでもいいけど。

前者は、python辞書が必ず入ると決まっている。で、CGIスクリプトなんかで使う環境変数にあたるものはみんなこの辞書に入っている。だからPATH_INFOなんていうキーの値もこんな風に取り出せばよい。QUERY_STRINGとか、REMOTE_HOSTとか、おなじみの情報はみんなここから。
CGIスクリプトが使う標準入力や標準出力も、この辞書に特定のキーの値として入ってくる。標準入力ならenviron['wsgi.input']、標準出力なら['wsgi.output']とか。他にもwsgi独自の値がいくつか入ってくるけど、今は重要でない。どこかでリファレンスを見れば全部載っている。
なんせ、Webアプリとして参照したいであろう情報は、environ辞書にみんな入っている。

で、次のstart_responseは、関数そのものが渡される。スクリプト中でstart_response(... なんてやっているように、これを呼び出して、レスポンスヘッダを作っている。
CGIスクリプトならヘッダの書き出しも標準出力に対して行うところだけど、WSGIだとレスポンスの内容とヘッダをこんなふうに別々のルートで返させている。
ちなみにレスポンスの内容のほうは、myappの返り値として素直に渡す。単なる文字列で返すんじゃなくて、わざわざリストの形にして返している点に注意。たぶん受け取り側で、for i in [返り値]: do [なんちゃら…] なんてしているのだろう。つまり、イテレータ（ジェネレータ）を返せってこと。これなら巨大なレスポンスを返すときに省メモリで済ますという工夫も可能になる。

myappの中にmyapp2への呼び出しがある点については、後述。ミドルウェアとかの用語とからめて記す予定。

WSGI探求(1)

2008-09-26T18:57:00.001+09:00

WSGIってのは、CGIみたいにWeb上で動くスクリプト等の一般的な仕様を決めるもの。CGIよりもちょっと便利な使い方ができるように改良されている。現在はpython専用の仕様だけど、とてもシンプルなものなので、色々な言語に移植できるんじゃないかなという気もする。

※たまに誤解されますが、CGIってのはperlで書かれたスクリプトじゃなくて、Webサーバーと手作りアプリケーションを連携させるための「仕様」のことです。標準入出力をこう使いなさいね、とか、あれこれの環境変数を渡しますよ、とか、そんなの。

下のスクリプトでは、myappとmyapp2がそれぞれWSGIの仕様に則って書かれた完全なアプリケーション。
これを適当なファイル名で保存して実行すれば、簡易Webサーバーが立ち上がり、今書いたWSGIアプリの動作をすぐに試せる。python2.5以降で。

サーバーを終了するには、Ctrl+Cなりコンソールウィンドウを閉じてしまうなりすればよい。


def myapp2(environ, start_response):
    start_response('200 OK' , [('Content-Type', 'text/html')])
    message = 'you requested %s. HELLO! :)' % environ['PATH_INFO']
    return ['<html><body><p>', message, '</p></body></html>']

def myapp(environ, start_response):
    if environ['PATH_INFO'] == '/hello':
        return myapp2(environ, start_response)
    start_response('200 OK' , [('Content-Type', 'text/html')])
    message = 'you requested %s. HAZURE.' % environ['PATH_INFO']
    return ['<html><body><p>', message, '</p></body></html>']

if __name__ == '__main__':
    from wsgiref.simple_server import make_server
    make_server('127.0.0.1', 8780, myapp).serve_forever()

http://127.0.0.1:8780/
とか
http://127.0.0.1:8780/some/path
とかにアクセスすると、myappが返答を返してくれて、'HAZURE' とか言われる。

http://127.0.0.1:8780/hello
にアクセスしたときは、myappはリクエストををmyapp2に転送してくれて、もうちょっと丁寧な挨拶が返ってくる。

このスクリプトはどういう意味なんだい、とか、なんで従来のCGIじゃダメなんだい、とか、とかそんな話は追って書く、予定

pythonで四川省

2008-09-25T20:05:00.004+09:00

「四川省」という名前で知られているゲームをpythonで書いてみた。麻雀牌を順に取り去っていくやつ。
勝手に問題を作って勝手に解いていくというデモなので、見てるだけ。
グラフィカルな表示は、まだなし。

同じ牌どうしを、２回まで曲がれるルートでくっつけて取り去るところがゲームのキモ。
まず同じ牌を適当に見つけてから、これを取ることができるかを考える(find_wayメソッド)。２回まで曲がれるということは、直線ルートを3回分つなげてよいということ。色々なパターンがあるが、実は最初の一回分の直線だけ決まればあとのルートは必然的に決まるので、最初の一回を全パターン分作り出し(enum_first_steps)て、残り(complete_way)が障害なく目的の牌に通じているかを評価する。

ここらへんをみんなクラスの内部に押し込めてしまって、メインルーチンは単純になった。すなわち、find_removable_pair で取れるペアを探してみて、見つかったらremove_pair で実際に取り去って、dumpで表示、あとはループ。見つからなくなったら終了。


import random

VERTICAL = (0, 1)
HORIZONTAL = (1, 0)

def signed_range(start, end):
    if start > end:
        for i in xrange(start - end): yield -1
    else:
        for i in xrange(end - start): yield 1

class Step(object):
    def __init__(self, orient, distance):
        self.vx = orient[0]
        self.vy = orient[1]
        self.distance = distance

class Sisensho(object):
    def __init__(self):
        self.board = [[0 for i in xrange(10)] for i in xrange(20)]
        tiles = []
        self.searchpath = []
        for i in xrange(36): tiles.extend((i+1,)*4)
        random.shuffle(tiles)
        for x in xrange(18):
            for y in xrange(8):
                self.board[x+1][y+1] = tiles.pop()
                self.searchpath.append((x+1, y+1),)
        random.shuffle(self.searchpath)
        self.last_remove_track = []

    def dump(self):
        TILE_IMAGE = ' 0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ'
        for y in xrange(10):
            tmp = []
            for x in xrange(20):
                if self.last_remove_track.count((x, y)):
                    tmp.append('*')
                else:
                    tmp.append(TILE_IMAGE[self.board[x][y]])
            print ''.join(tmp)
                
    def enum_first_steps(self, ox, oy):
        def _goer(direction, sign):
            d = 0
            while True:
                d += 1
                x, y = (ox+direction[0]*d*sign,
                          oy+direction[1]*d*sign)
                if x < 0 or x >= 20: break
                if y < 0 or y >= 10: break
                if self.board[x][y] != 0: break
                yield Step(direction, d*sign)
        yield Step(VERTICAL, 0)
        yield Step(HORIZONTAL, 0)
        e = [_goer(VERTICAL, -1), _goer(HORIZONTAL, 1),
              _goer(VERTICAL, 1), _goer(HORIZONTAL, -1)]
        while e:
          ee = []
          for i in e:
            try:
              yield i.next()
              ee.append(i)
            except StopIteration:
              pass
          e = ee

    def complete_way(self, ox, oy, tx, ty, initial_step):
        xd = (tx - (ox+initial_step.vx*initial_step.distance))
        yd = (ty - (oy+initial_step.vy*initial_step.distance))
        if initial_step.vx == 0: #VERTICAL
            tmp = (initial_step, Step(HORIZONTAL, xd), Step(VERTICAL, yd))
        else:
            tmp = (initial_step, Step(VERTICAL, yd),Step (HORIZONTAL, xd))
        return filter(lambda x: (x.distance!=0), tmp)

    def trace_way(self, x, y, way):
        tx, ty = (x, y)
        tmp = [(x, y), ]
        for w in way:
            for i in signed_range(0, w.distance):
                tx += w.vx * i
                ty += w.vy * i
                tmp.append((tx, ty),)
        return tmp

    def find_way(self, ox, oy, tx, ty):
        for i in self.enum_first_steps(ox, oy):
            way = self.complete_way(ox, oy, tx, ty, i)
            a = self.trace_way(ox, oy, way)
            for aa in a[1:-1]:
                if s.board[aa[0]][aa[1]] != 0: break
            else:
                return a
        return None

    def find_pair(self):
        for (i, v) in enumerate(self.searchpath):
            c = self.board[v[0]][v[1]]
            if c != 0:
                for j in xrange(i+1, len(self.searchpath)):
                    vv = self.searchpath[j]
                    if self.board[vv[0]][vv[1]] == c:
                        return (v, vv)
        return None

    def find_removable_pair(self):
        for (i, v) in enumerate(self.searchpath):
            c = self.board[v[0]][v[1]]
            if c != 0:
                for j in xrange(i+1, len(self.searchpath)):
                    vv = self.searchpath[j]
                    if self.board[vv[0]][vv[1]] == c:
                        way = self.find_way(v[0],v[1],vv[0],vv[1]) 
                        if way: return (v, vv, way)
        return None

    def remove_pair(self, pairinfo):
        p1, p2, way = pairinfo
        self.board[p1[0]][p1[1]] = 0
        self.board[p2[0]][p2[1]] = 0
        self.searchpath.remove(p1)
        self.searchpath.remove(p2)
        self.last_remove_track = way

if __name__ == '__main__':
    s = Sisensho()
    s.dump()
    while True:
        p = s.find_removable_pair()
        if not p: break
        s.remove_pair(p)
        s.dump()

実行中の表示例。使う牌は36種類x4枚づつなので、0-9とA-Zでちょうど代用できた。


 STAR5KENZ5HP3JGMNT 
 DLP8EGIT    0WR8O  
 BSG1HXAOU9 *804GVD 
 IU3RJ2C96O *X578YN 
 VY7I1 TZ   *    C7 
 O4UMX U    * 2I W  
 6Y LDK B           
 N7 X5D        Y  R 
                    
                    
 STAR5KENZ5HP3JGMNT 
 DLP8EGIT    0WR8O  
 BSG1HXAOU9  804GVD 
 IU3RJ2C96O  *578YN 
 VY7I1 TZ    *   C7 
 O4UMX U     *2I W  
 6Y LDK B    *      
 N7 *5D      * Y  R 
    **********      
                    
 STAR5KENZ5HP3JGMNT 
 DLP8EGIT    0WR8O  
 BSG1HXAOU9  *04GVD 
 IU3RJ2C96O  *57*YN 
 VY7I1 TZ    ****C7 
 O4UMX U      2I W  
 6Y LDK B           
 N7  5D        Y  R

平均して、2回に1回くらいクリアに成功するみたい。

pythonでさめがめ(2)

2008-09-23T19:34:00.003+09:00

前のエントリで作ったSameGameBoardクラスを実際に使って、さめがめを最低限プレイできる程度の実装をしてみた。要pygame。

ライブラリの読み込みパス（大抵は本スクリプトと同じディレクトリ上）に、samegame.pyが置いてあること。

スコアも何にも出ないのであまり面白くはないが、とつぜんさめがめがやりたくなったときに、この程度で足りることもある。


from samegame import SameGameBoard

import pygame
import pygame.locals as C

class SameGame(object):

    clr = [ 0x000000, 0xff00ff, 0xff8000, 0xff0000, 0x00ff00, 0x0000ff, 0xffff00, 0x00ffff, 0xffffff]

    def __init__(self, width, height, variety):
        self.b = SameGameBoard(width, height, variety)
        pygame.display.set_mode((640, 480))
        self.c = pygame.display.get_surface()

    def run(self):
        self.draw()
        while True:
            e = pygame.event.poll()
            if e.type == C.QUIT:
                break
            if e.type == C.MOUSEMOTION:
                (x, y) = e.pos
                (x, y) = (x // 14, y // 14)
                if (x >= 0) and (x < self.b.width) and (y >= 0) and (y < self.b.height):
                    self.b.setHighLight(x, y)
            if e.type == C.MOUSEBUTTONDOWN:
                self.b.shootHighLight()
            self.draw()

    def draw(self):
        self.c.fill(0x000000)
        for i in xrange(self.b.width):
            for j in xrange(self.b.height):
                p = i+j*self.b.width
                if self.b.highlightregion[p] != 0:
                    pygame.draw.rect(self.c, self.clr[-1],
                     (i*14, j*14, 13, 13), 0)
                else:
                    pygame.draw.rect(self.c, self.clr[self.b.content[p]],
                     (i*14, j*14, 13, 13), 0)
        pygame.display.flip()

if __name__ == '__main__':
    pygame.init()
    try:
        SameGame(40, 32, 4).run()
    finally:
        pygame.quit()

pythonでさめがめ(1)

2008-09-23T19:27:00.002+09:00

「さめがめ」をなんとなくpythonで実装してみる。
下のリストはグラフィカルな描画ルーチンを含まない、データ構造と振る舞いを定義するだけのクラス。あとでimportするから、samegame.pyとでもして保存しておく。

setHighLightメソッドとshootHighLightメソッドが重要で、前者はある点を基点として同じ色のマスを順次探していって、一度に消せる隣接マスを決める。後者はあらかじめ探索しておいた隣接マスを実際に消して、まずはタテ方向に、次にヨコ方向に「詰める」。

SameGameBoardクラスのコンストラクタは三つの引数を取る。横サイズ、縦サイズ、コマの種類。


import random

class SameGameBoard(object):
    def __init__(self, width, height, variation):
        self.width, self.height = width, height
        self.content = [random.randint(1, variation) for i in xrange(width*height)]
        self.highlightregion = [0 for i in xrange(width*height)]

    def _getNeighbours(self, offset):
        x = offset % self.width
        y = offset // self.width
        tmp = []
        if x > 0:               tmp.append(offset-1)
        if x < (self.width-1):  tmp.append(offset+1)
        if y > 0:               tmp.append(offset-self.width)
        if y < (self.height-1): tmp.append(offset+self.width)
        return tmp

    def resetHighLight(self):
        self.highlightregion = [0 for i in xrange(self.width*self.height)]

    def setHighLight(self, x, y):
        self.resetHighLight()
        h = self.highlightregion #shortcut
        c = self.content         #shortcut
        seed = c[x+y*self.width]
        if seed == 0: return
        h[x+y*self.width] = 1
        size = 1
        while True:
            cnt = 0
            for i in xrange(self.width*self.height):
                if h[i] == 1:
                    for k in self._getNeighbours(i):
                        if c[k] == seed and h[k] == 0:
                            h[k] = 1
                            cnt += 1
                            size += 1
                h[i] == 2
            if cnt == 0: break
        if size == 1:
            self.resetHighLight()

    def shootHighLight(self):
        c = self.content #shortcut
        # vanish phase
        for i in xrange(self.width*self.height):
            if self.highlightregion[i] != 0: c[i] = 0
        self.resetHighLight()
        # drop phase
        for i in xrange(self.width):
            while True:
                cnt = 0
                for j in xrange(self.height-1):
                    offset = i+(self.height-1-j)*self.width
                    if c[offset] == 0 and c[offset-self.width] != 0:
                        c[offset] = c[offset-self.width]
                        c[offset-self.width] = 0
                        cnt += 1
                if cnt == 0: break
        # cram phase
        while True:
            cnt = 0
            for i in xrange(self.width-1):
                for j in xrange(self.height):
                    if c[i+j*self.width] != 0: break
                else:
                    for jj in xrange(self.height):
                        offset = jj*self.width
                        for ii in xrange(i, self.width-1):
                            if c[offset+ii+1] != 0: cnt += 1
                            c[offset+ii] = c[offset+ii+1]
                        c[offset+self.width-1] = 0
            if cnt == 0: break

    def dump(self):
        for i in xrange(self.height):
            offset = i * self.width
            for j in xrange(self.width):
                if self.highlightregion[offset+j] != 0:
                    print "!",
                else:
                    print self.content[offset+j],
            print
        print "---"

if __name__ == '__main__':
    b = SameGameBoard(32, 24, 3)
    b.dump()
    while True:
        b.setHighLight(0, 23)
        b.dump()
        b.shootHighLight()
        b.dump()

pythonでパスワードをハッシュ化

2008-09-02T11:06:00.004+09:00

スクリプト中にパスワードを直接書かずに、特定のパスワードと比較してログイン処理などを書きたいことがある。md5モジュールを使ってできる。


>>> import md5
>>> md5.md5('secretpassphrase').digest()
')mMD\xa2\x9b{+\xf2\x19\xc2-+\x8b\xa5\x19'

こんな風にハッシュ値（ダイジェスト値ともいう）を出しておいて、スクリプトにはこれを使って比較ルーチンを書けばよい。


import md5
pass_hash = ')mMD\xa2\x9b{+\xf2\x19\xc2-+\x8b\xa5\x19'
r = raw_input('input password:')
if md5.md5(r).digest() == pass_hash:
    print "login OK"
else:
    print "login NG"

ダイジェスト値から元のパスワードを導き出すのは、事実上不可能といわれている。なので万一スクリプトが漏れたとしてもパスワードはばれない。まあ、あまり単純なパスワードだったら、総当りでハッシュ計算し続ければいつかばれてしまうけど。

pythonでwebサイトの構成チェック

2008-09-02T10:37:00.002+09:00

ローカルファイルにコピーしたWebサイトのファイル群について、互いのリンク関係を抜き出して調べたい。

まずファイルの列挙には、os.walk() を使う。引数は始点ディレクトリ。これは下にあるディレクトリを再帰的に調べて、（現在のディレクトリパス、その下のディレクトリ名一覧、その下のファイル名一覧）というタプルを列挙するイテレータを返してくるので、forループで処理する。

.htm または .html で終わるファイル名のものについては、中身の調査をする。具体的には、該当ファイルの中身を全部読み込んでから、href=.... というパターンをすべて探し出して、リンク先を抜き出す(正規表現r1)。

リンクの表現は、スキーム名のついた完全URLだったり、相対URLだったりする。特に相対URLだったときは、os.pathモジュールを使って、これらを正規化して表示させる。os.path.normpathが面白くて、これは 'a/b/c/../../d' といったパスを 'a/d' に整理したりという働きをする。windowsでなら、スラッシュは逆スラッシュになる。


import os
import re

r1 = re.compile(r'href="?(.+?)"?[ >]', re.I)
r2 = re.compile(r'^(http|file|javascript|mailto):', re.I)

def search_link(filename):
    print "[%s]" % filename
    t = open(filename).read()
    for i in r1.findall(t):
        if r2.match(i):
            print i
        else:
            print os.path.normpath(os.path.join(os.path.dirname(filename), i))

for dname, dirs, files in os.walk("."):
    for i in files:
        if i.endswith(".htm") or i.endswith(".html"):
            search_link(os.path.join(dname, i))

pythonで8queens

2008-08-13T01:38:00.002+09:00

ちょっと前に書いた8queensを解くスクリプトを置いておく。
8queensってのは、チェス版(8x8)の上に8体のクイーンの駒を置いて、互いに取りっこできないように配置するというパズル。クイーンは前後左右斜めに何マスでも動けるとても強力なコマ。


#BSIZE = 10
BSIZE = 8

class chessboard:

  def __init__(self):
    self.p = [0] * BSIZE
    self.pt = 0

  def __str__(self):
    return self.p.__str__()

  def put(self, row, pos):
    self.p[row-1] = pos
    self.pt = row

  def check_corride(self):
    for i in range(1, self.pt):
      d = 1
      for j in range(i+1, self.pt+1):
        if self.p[i-1] == self.p[j-1]:
          return True
        if self.p[i-1]+d == self.p[j-1]:
          return True
        if self.p[i-1]-d == self.p[j-1]:
          return True
        d = d + 1

    return False

def testloop(b, row):

   for i in range(BSIZE):
     b.put(row, i+1)
     if b.check_corride():
       continue
     else:
       if row < BSIZE:
         testloop(b, row+1)
       else:
         print "queen", b

testloop(chessboard(), 1)


(実行結果)
queen [1, 5, 8, 6, 3, 7, 2, 4]
queen [1, 6, 8, 3, 7, 4, 2, 5]
queen [1, 7, 4, 6, 8, 2, 5, 3]
queen [1, 7, 5, 8, 2, 4, 6, 3]
....

一行の表示が一とおり分の解。順に、一番上の列で左から1番目に配置、二番目の列で左から5番目に配置…というように読む。
BSIZEの値を8より大きくしても、ちゃんと解はあるみたい。解くの遅いけど。

また滞った

2008-08-04T21:40:00.000+09:00

次はMicroApacheのことを書いてみよう、と備忘的に書いておくテスト

pythonのメモと、その他の読書

2008-07-22T00:08:00.004+09:00

pythonを相変わらずチマチマいじっている。今日はpython付属のCGIHTTPRequestHandlerを使ってCGIスクリプトのテストをしていて、Locationヘッダをまともに扱ってくれない点を調べていた。ApacheかなんかからCGIを叩かれたときは、そこで


print "Location: http://どこそこ…

なんていうヘッダを標準出力に書いたらレスポンスコードを302番なんかに切り替えてくれるのに、今のヤツでは普通のOK、つまり200番を返すだけなので、ブラウザはリダイレクトだと気づいてくれない。そういう仕様かな、と考えてソース読んだら、もろにその旨のコメントが書いてあった。


Note that status code 200 is sent prior to execution of a CGI script, so
scripts cannot send other status codes such as 302 (redirect).

これの改造はちょっと大変そうなので、無理せずにApacheか何か持ち出して続きを開発するか。

あとはこれと関係ない読書メモ。

『小倉百人一首を学ぶ人のために』糸井通浩編、世界思想社。別に百人一首が好きなわけでもないし古典が好きなわけでもないけど、ちょっと考えるところがあって百人一首を暗記してみようと思ったので。今は25個くらいまで歌の解説を読みながら覚えたり忘れたり。そうか百人一首の中の歌ってこんな意味だったりするのか、とか気づいたりもして、案外勉強になっている。

『虚数の情緒』吉田武著、東海大学出版会。分厚い本。自然数の説明からはじまってその性質をいろいろいじくって見せるうちに、そこから整数という考えが必要になってきた理由、またそこから有理数、無理数、実数、果ては虚数までが必要になってきた理由を、断絶のない自然なストーリーで、また物理、音楽、生物学なんかも縦横に援用しながら語りぬく。こういった事柄の本質をを心底理解していないとこんな本書けないんだろうなあ、と思う。副題は「中学生からの全方位独学法」。中学生に理解させることを目指して、しかも内容は変なたとえ話でゴマかさない、本物の数学。これぞ学者の書く本だ。すごいぞ。
と言っておきながら、流し読み程度しかできていない。いつか中学生くらいの年代と数学を学ぶ機会でもあるのなら、この本のことを思い出さなくてはいけない。

pythonで壁紙変更

2008-07-18T21:46:00.002+09:00

Windows専用のサンプルスクリプト。とりあえずWinXPとpython2.5で動作確認した。
下のスクリプトを適当な名前で保存して、ダブルクリックで実行するだけ。
システムディレクトリ下にあるビットマップファイルを適当に選んで、壁紙変更のWin32APIを実行する、と思う。


import ctypes
import glob
import random
u32 = ctypes.windll.LoadLibrary('user32.dll')
bb = glob.glob(r'c:\windows\*.bmp')
fname = random.choice(bb)
u32.SystemParametersInfoA(20, 0, fname, 2 | 1)

ctypesライブラリは、python2.5から標準配布だけど、それ以外はどうやって導入するかは知らない。
あと、SystemParametersInfoAの中でいくつか数字を決めうちするのは、定数名をちゃんと示しておらず手抜き。APIの名前でググったら色々出てきます。

pythonの付属HTTPサーバーを読む

2008-07-17T15:41:00.005+09:00

pythonの標準ライブラリにあるWebサーバーは、サーバーとハンドラという要素に分けて設計されている。

サーバー部は、クライアントからの接続を待ち受けるという役割を受け持っている。接続が確立すると、残りの仕事はハンドラ部に振ってしまって、自分は次の接続を待ち受けるといった分業体制が成り立っている。
振ってしまって自分は次の…とは書いたが、実際は今の実装ではハンドラ部が仕事を終えるまで、サーバー部は何もできず（次の接続待ちにも移れず）にボンヤリ待っているだけ。もっと本気で実装するなら、ここらへんをマルチスレッドだか何だかにすることになるだろう。（ThreadingMixInとかの仕組みもモジュールから見つけたのだけど、ちゃんといじってない）

サーバー部の基底になっているモジュールはBaseServer、ハンドラ部の基底になっているモジュールはBaseRequestHandler。

BaseServerは、クライアントからのリクエストを受けてハンドラに仕事を振るという基本的な動きを定義している。ハンドラに振るとは、ここでは、ハンドラクラスのインスタンスを生成するということ。でも、生成したインスタンスのその後については、サーバー側としてはもう関心がない。ハンドラの__init__メソッド、つまりコンストラクタが実行されることが重要みたいだ。ハンドラにとって大事な仕事は全部コンストラクタ、またはコンストラクタが呼び出すメソッド上に書いてあると想定している。
リクエスト受けて、ハンドラに振って、またリクエスト受けて…といった、長時間動くサーバーとしての動作を、serve_foreverという名前のメソッドで定義している。

BaseServerを継承して書かれているのがTCPServerで、クライアントからのリクエストを受ける部分が具体的にソケット通信の手続きとして書いてある。UDPServerも書かれているけど今回は触れない。

TCPServerを継承して、HTTPServerが書かれている。でもあまりTCPServerから進んだことはしていなくて、自分のホスト名とかポート名とかを使いやすくしておこうとかそんな程度に見える。

サーバー部はここまで。

ハンドラ部の基底クラスであるBaseRequestHandlerは、一般的なリクエストの処理順序を決めているだけ。すなわち、__init__（コンストラクタ）のタイミングで、サーバー部からリクエストの文脈を受け取って、setupして、handleして、finishすること、と。リクエストの文脈とは具体的に何なのか、setupやらhandleやらとは具体的にどういう仕事なのかは全然決めていない。

BaseRequestHandlerを継承して書かれたStreamRequestHandlerは、このクラスが入力ストリームと出力ストリームを持つこと、finishではこれをcloseすべしということを決めている。でも相変わらずこれを使って何をするとは決めていない。

StreamRequestHandlerを継承して書かれたBaseHTTPRequestHandlerになると、かなりウェブサーバーっぽい挙動ができるようになる。これのhandleメソッドでは、HTTPのリクエストメソッド(GET、POST、HEAD…)を調べてこれに対応するクラスメソッドを実行することを記述している。GETならdo_GET、POSTならdo_POST、といった具合に。でもこれらをこのクラス自身では準備していないから、該当の処理ルーチン不明ということで、すべてのHTTPリクエストは501のレスポンスコードをクライアント（出力ストリーム）に返す。

BaseHTTPRequestHandlerを継承して書かれたSimpleHTTPRequestHandlerが、やっとクライアント側にとって意味のある動作をするようになる。このハンドラはdo_GETとdo_HEADを実装していて、あらかじめ決めた基準ディレクトリ下のファイルを、HTTPのリクエストパスに従って選び、これの内容を出力ストリームに流すという動作を実現している。リクエストパスがディレクトリそのものに対応するときは、該当ディレクトリのファイルリストを提供する。つまり、これで静的なWebサイトを（ある程度）提供できる程度のものになった。

CGIRequestHandlerは、SimpleHTTPServerを継承して、さらにdo_POSTを実装した。環境変数をそろえ、外部CGIスクリプトを実行し、標準入力にリクエストからの入力ストリームをつなげ、標準出力を受け取ってクライアント側に流す。つまりCGIのインターフェースに決められた動作をサポートする。これでCGIスクリプトを叩くことができるようになった。POSTメソッドでしか起動できない、決まったパス下のものしか叩けない、など制限は多いけど、ある程度のテストになら十分使える。

pythonの標準配布ライブラリがここまでそろっているから、あとはこんなふうに：


from BaseHTTPServer import HTTPServer
from SimpleHTTPServer import SimpleHTTPRequestHandler
HTTPServer(('', 8000), SimpleHTTPRequestHandler).serve_forever()

コードを書いて実行するだけで、http://127.0.0.1:8000/ から見られるWebサーバーが立ち上がるようになったわけ。

pythonサンプル・ROT13

2008-07-17T00:43:00.004+09:00

ROT13ってのはごく単純な暗号アルゴリズムで、AをN、BをOとかそんな入れ替えだけを行って文章をわかりにくくする方法。シーザー暗号とかともいう。

pythonの対話プロンプト上で、import thisと叩くと、the Zen of Pythonっていうタイトルの変な詩が表示される。オマケ機能。
thisモジュールを読んでみたら、詩そのものはこのROT13で簡易暗号化されて格納されていた。同モジュールにはその復号ルーチンも含まれていて、短いサンプルが得られた。これを参考に関数としてちょっとだけ書き直すと、


d = {}
for c in (65, 97):
    for i in range(26):
        d[chr(i+c)] = chr((i+13) % 26 + c)
def rot13(s):
    return "".join([d.get(c,c) for c in s])

って感じ。dが翻字用辞書で、ここでは手を抜いてグローバル変数としている。


これを使ってみるテスト
>>> rot13("I don't know why you say good-bye. I say hello.")
"V qba'g xabj jul lbh fnl tbbq-olr. V fnl uryyb."
>>> rot13("V qba'g xabj jul lbh fnl tbbq-olr. V fnl uryyb.")
"I don't know why you say good-bye. I say hello."

暗号化と復号が全く同じルーチンでできますね。

まあ、最初からencodeを使ってもよかったんだけど。こんなコーデックがあるのねえ。


>>> "I don't know why you say good-bye. I say hello.".encode('rot_13')
"V qba'g xabj jul lbh fnl tbbq-olr. V fnl uryyb."
>>> "V qba'g xabj jul lbh fnl tbbq-olr. V fnl uryyb.".decode('rot_13')
u"I don't know why you say good-bye. I say hello."

pythonサンプル・ファイル削除

2008-07-14T21:39:00.002+09:00

ファイル削除は、osモジュールにある。


import os
os.remove(r'c:\doko\zo\no\file.txt')
# os.unlink(r'c:\doko\zo\no\file.txt')

removeとunlinkは全く同じ。UN*X的にはunlinkが分かりやすいのだけど、そうでないユーザーにも安心して使えるように、より直感的なremoveという別名も用意してくれたのだろう。か?

pythonでアップロード

2008-07-10T22:28:00.002+09:00

アップローダじゃなくて、今度はアップローダに「アップロード」するというサンプル。つまりHTTPクライアント側。

ファイルをアップロードするときの動作をリクエストヘッダからPOSTデータ本体からみんな手作りして、あとはサーバーへのコネクションに流し込む。
下のサンプルではあまり大きすぎるファイルはStringIO用のメモリを圧迫して失敗しそうな気がするけど、まあある程度までなら大丈夫、だった。
ここではupfileというファイル欄とownerというテキスト欄を持ったフォームの内容を、http://doko.zo/no/uploader.cgiというアップローダのURLに送っている。

aとかいうメソッド名がいいかげんだなあ。


#!python
# -*- encoding: utf-8 -*-

import urllib2
import random
import os.path
import StringIO

boundary = '-----------48923489478932'

def a(filename):
    s = StringIO.StringIO()
    s.write('--%s\r\n' % boundary)
    s.write('Content-Disposition: form-data; name="upfile"; filename="%s"\r\n' % (os.path.split(filename)[1]))
    s.write('Content-Type: application/octet-stream\r\n')
    s.write('\r\n')
    f = open(filename, 'rb').read()
    s.write(f)
    s.write('\r\n')
    s.write('--%s\r\n' % boundary)
    s.write('Content-Disposition: form-data; name="owner"\r\n')
    s.write('\r\n')
    s.write('dare\r\n')
    s.write('--%s--\r\n' % boundary)
    return s.getvalue()

d = a(r'c:\nantyara.jpg')
req = urllib2.Request('http://doko.zo/no/uploader.cgi', d)
req.add_header('Content-Type', 'multipart/form-data;  boundary=%s' % boundary)
print urllib2.urlopen(req).read()

pythonでアップローダ・Webサーバ付

2008-07-08T22:47:00.003+09:00

サーバースクリプトを下のように書いて実行する。


import CGIHTTPServer
CGIHTTPServer.test()

次に、同じディレクトリに uploader.html というファイルを作って下のような内容を書く。


<html>
<body>
アップロード<br>
<form method="POST" action="/cgi-bin/up.py" ENCTYPE="multipart/form-data">
<input type="file" name="upfile">
<input type="submit">
</form>
</body>
</html>

最後に、同じディレクトリにcgi-binという名前のディレクトリを作って、その下にup.pyというCGIスクリプトを下のように書く。


#!python
# -*- encoding: utf-8 -*-

from random import random
import md5
from datetime import time
import cgi
import cgitb; cgitb.enable()

store_root = r'c:\work\store\'   #ここは環境にあわせて

fields = cgi.FieldStorage()
print 'Content-Type: text/plain\n'
#cgi.print_environ()
bitstream_id = str(int(md5.new(str(random())+str(time())).hexdigest(),16))

try:
    t = open(store_root+bitstream_id, 'wb')
    while True:
        chunk = fields["upfile"].file.read(100000)
        if not chunk: break
        t.write(chunk)
    t.close()
    #t.write(fields["upfile"].value)
    t = open(store_root+bitstream_id, 'rb')
    digest = md5.new(t.read()).hexdigest()
    t.close()
    t = open(store_root+bitstream_id+'.metadata', 'wb')
    t.write(fields["upfile"].filename)
    t.write('\n')
    t.write(digest)
    t.close()
    print "OK\n%s\n%s" % (bitstream_id, digest)
except:
    print "NG"

これで、http://127.0.0.1/uploader.html からアップローダの動作を試すことができる。

アップロードしたファイルはランダムな英数字の羅列のファイル名に変換されて格納されるが、同じ名前に .metadata とついたファイルが同時に生成されて、そこにはもとのファイル名とチェックサム(md5ハッシュ値)が記録される。

到底堅牢なものとは言えないけど、それなりに動作する。

pygameでテトリス（と紛らわしいもの）

2008-07-07T22:55:00.002+09:00

テトリスを作ってみたくなっていろいろいじくりはじめたが、脱線して変なデモになった。
中央からランダムなテトリミノが回転しつつ噴水のようにほとばしるという、ワケわからないもの。


from random import randint
import pygame
import pygame.locals as C

t = [ 'efghbfjnefghbfjn', 'abefabefabefabef', 'efgbbfjgefgjbfje',
      'abfgbfeiabfgbfei', 'bfeiabfgbfeiabfg', 'efgkbfjiaefgbfjc',
      'aefgbfjcefgkbfji']
clr = [ 0xff00ff, 0xff8000, 0xff0000, 0x00ff00, 0x0000ff, 0xffff00, 0x00ffff]
tet = []
for i1 in t:
    t2 = []
    for i2 in xrange(4):
        t3 = []
        for k in i1[i2*4:i2*4+4]:
            t = ord(k) - ord('a')
            t3.append((t%4, t/4,))
        t2.append(t3)
    tet.append(t2)

class Tetrimino(object):
    
    def __init__(self, ruler, kind, place, speed):
        self.kind = kind
        self.x, self.y = place
        self.xx, self.yy = speed
        self.iter = iter(self)
        self.r = 0

    def __iter__(self):
        rr = 0
        while True:
            rr = (rr+1) % 4
            if rr == 0: self.r = (self.r+1) % 4
            self.x += self.xx
            self.y -= self.yy
            if self.y > 560: break
            self.yy -= 1
            yield

    def draw(self, surface):
        for xd, yd in tet[self.kind][self.r]:
            pygame.draw.rect(surface, clr[self.kind],
                             (self.x+xd*16, self.y+yd*16-80, 15, 15), 0)

class Gunner(object):
    
    def __init__(self, ruler, place, prob):
        self.ruler = ruler
        self.place = place
        self.prob = prob
        self.iter = iter(self)

    def __iter__(self):
        while True:
            if randint(0, 99) < self.prob:
                speed = (randint(-15, 15), randint(5, 25))
                self.ruler.t.append(Tetrimino(
                    self.ruler, randint(0, 6), self.place, speed,))
            yield

class BackGround(object):

    def __init__(self, ruler):
        self.ruler = ruler
        self.iter = iter(self)

    def __iter__(self):
        while True: yield

    def draw(self, surface):
        surface.fill(0x003000)

class GameRuler(object):
    
    def __init__(self):
        self.t = []
        self.t.append(BackGround(self))
        self.t.append(Gunner(self, (320, 480), 26))
        pygame.display.set_mode((640, 480))
        self.surface = pygame.display.get_surface()
        self.clock = pygame.time.Clock()

    def __iter__(self):
        while True:
            tt = []
            for j in self.t:
                try:
                    j.iter.next()
                    tt.append(j)
                except StopIteration:
                    continue
                if hasattr(j, 'draw'): j.draw(self.surface)
            self.t = tt
            yield
            # adjust timing ...
            pygame.display.flip()
            if pygame.event.poll().type == C.QUIT:
                break
            self.clock.tick(30)

pygame.init()
r = GameRuler()
for i in r: pass
pygame.quit()

pygameでお絵かきツール

2008-07-06T21:40:00.003+09:00

pygameをもうちょっといじってみようと、今度は簡単なお絵かきツールを。
といったって、マウスドラックで線が書けるというだけのシロモノだけど。
しかも、前回のエントリを変な感じに再利用している。（再利用を目指しているともいえるけど、まだ不器用な感じ）

pygameはマウスイベントを受け取るのも簡単だなあという例。


import pygame
import pygame.locals as C

class MouseSenser(object):

    def __init__(self, ruler):
        self.ruler = ruler
        self.iter = self.__iter__()
        self.prevpos = (0, 0)
        self.drawing = False

    def __iter__(self):
        while True:
            e = self.ruler.event
            if e.type != C.MOUSEMOTION:
                yield
                continue
            self.pos = e.pos
            self.pressed = e.buttons[0]
            if self.pressed:
                if self.drawing:
                    self.line = (self.prevpos, self.pos, )
                    self.prevpos = self.pos
                else:
                    self.prevpos = self.pos
                    self.drawing = True
                    self.line = (self.pos, self.pos, )
            else:
                self.drawing = False
            yield

    def draw(self, surface):
        if self.drawing:
            pygame.draw.line(surface, 0xffffff, self.line[0], self.line[1], 2)

class GameRuler(object):
    
    def __init__(self):
        self.t = []
        self.t.append(MouseSenser(self))
        pygame.display.set_mode((640, 480))
        self.surface = pygame.display.get_surface()

    def __iter__(self):
        clock = pygame.time.Clock()
        while True:
            while True:
                e = pygame.event.poll()
                if e.type == C.QUIT: raise StopIteration
                if e.type == C.NOEVENT: break
                self.event = e
            tt = []
            for j in self.t:
                try:
                    j.iter.next()
                except StopIteration:
                    continue
                tt.append(j)
                if hasattr(j, 'draw'): j.draw(self.surface)
            self.t = tt
            pygame.display.flip()
            yield
            clock.tick(30)

pygame.init()
r = GameRuler()
for i in r: pass
pygame.quit()

こんな感じに描けるよ。マウス代わりにタブレットを使ったけど。

pythonサンプル・pygameデモ

2008-07-05T12:43:00.004+09:00

pygameを使ったちょっとしたデモ。
左下と右下に配置された見えない高射砲？がランダムに弾丸を発射し、空中で破裂する。

yieldを多用してみたのが今回の特徴。yieldはイテレータ/ジェネレータを実現するための命令で、ここではイテレータから値をひとつ読み出すと「副作用で」ゲームが一コマ進行する、という変なものになっている。

なんでこんなやりかたで作ったかというと、単にやってみたかったから。yieldを覚えてからpythonの楽しさは倍増です。


from random import randint
import pygame
import pygame.locals as C

class Bullet(object):
    
    def __init__(self, ruler, p_from, p_target):
        self.ruler = ruler
        self.p_from = p_from
        self.p_current = p_from
        self.p_target = p_target
        self.iter = self.__iter__()

    def __iter__(self):
        self.status = 'flying'
        for s in xrange(60):
            x, y = self.p_from
            tx, ty = self.p_target
            self.p_prev = self.p_current
            self.p_current = x+(tx-x)*s/60, y+(ty-y)*s/60
            yield
        self.status = 'exploding'
        self.p_current = self.p_target
        for s in xrange(63):
            self.blast = s+1
            yield

    def draw(self, surface):
        if self.status == 'flying':
            pygame.draw.line(surface, 0, self.p_prev, self.p_current)
        if self.status == 'exploding':
            c = (self.blast*4,self.blast*4, 255)
            pygame.draw.circle(surface, c, self.p_current, self.blast, 1)

class Gunner(object):
    
    def __init__(self, ruler, place, prob):
        self.ruler = ruler
        self.place = place
        self.prob = prob
        self.iter = self.__iter__()

    def __iter__(self):
        while True:
            if randint(0, 99) < self.prob:
                target = randint(0, 639), randint(0, 400)
                self.ruler.t.append(Bullet(self.ruler, self.place, target))
            yield

class GameRuler(object):
    
    def __init__(self):
        self.t = []
        self.t.append(Gunner(self, (0, 480), 16))
        self.t.append(Gunner(self, (640, 480), 10))
        pygame.display.set_mode((640, 480))
        self.surface = pygame.display.get_surface()
        self.clock = pygame.time.Clock()

    def __iter__(self):
        while True:
            self.surface.fill(0xffffff)
            tt = []
            for j in self.t:
                try:
                    j.iter.next()
                    tt.append(j)
                except StopIteration:
                    pass
                if hasattr(j, 'draw'): j.draw(self.surface)
            self.t = tt
            yield
            # adjust timing ...
            pygame.display.flip()
            if pygame.event.poll().type == C.QUIT:
                break
            self.clock.tick(30)

pygame.init()
r = GameRuler()
for i in r: pass

pythonで日付を扱う

2008-07-03T21:24:00.003+09:00

日付を扱う方法について度忘れすることもあるので、pythonの対話プロンプトからいろいろ試した結果を貼り付けて今後のメモにする。


# 日付を扱うときに必要なモジュールをインポート
>>> import datetime
# 今日
>>> datetime.date.today()
datetime.date(2008, 7, 3)
# 今日＋現在時刻
>>> datetime.datetime.now()
datetime.datetime(2008, 7, 3, 21, 11, 44, 15000)
# dateオブジェクトの文字列表現
>>> a = datetime.date.today()
>>> a.__str__()
'2008-07-03'
# __str__は、printするときにどう表示されるかを定義する。だから下のように。
>>> print a
2008-07-03
# dateオブジェクトをその他の形式にフォーマットする
>>> a.strftime('%B %d, %Y')
'July 03, 2008'
# dateオブジェクトのn日後（負数ならn日前）の日付を出す
>>> a + datetime.timedelta(1)
datetime.date(2008, 7, 4)
# 100日後なんかでも問題ない
>>> a + datetime.timedelta(100)
datetime.date(2008, 10, 11)
# 年、月、日をそれぞれ数値から受け取ってdateオブジェクトを構築
>>> datetime.date(2008, 10, 2).__str__()
'2008-10-02'
# フォーマットされた日付文字列を解析してdateオブジェクトを作る
>>> datetime.datetime.strptime('2008.10.12', '%Y.%m.%d')
datetime.datetime(2008, 10, 12, 0, 0)
#
# 次はcalendarモジュール。python2.5から標準配布みたい
>>> import calendar
# カレンダー機能は、いったんCalendarオブジェクトを作ってから使う
>>> c = calendar.Calendar()
# 年月を指定して、日を全部表示する
>>> c.itermonthdates(2008, 9)
<generator object at 0x011BEF80>
# 上のままだと、ジェネレータ（イテレータ）だけ帰ってくる。なので
# リスト内包なんかで展開して表示してみる
>>> [i for i in c.itermonthdates(2008, 9)]
[datetime.date(2008, 9, 1), datetime.date(2008, 9, 2), datetie
.date(2008, 9, 3), datetime.date(2008, 9, 4), datetime.date(20
08, 9, 5), datetime.date(2008, 9, 6), datetime.date(2008, 9, 7)
, datetime.date(2008, 9, 8), datetime.date(2008, 9, 9), dateti
me.date(2008, 9, 10), datetime.date(2008, 9, 11), datetime.dat
e(2008, 9, 12), datetime.date(2008, 9, 13), datetime.date(2008
, 9, 14), datetime.date(2008, 9, 15), datetime.date(2008, 9, 1
6), datetime.date(2008, 9, 17), datetime.date(2008, 9, 18), da
tetime.date(2008, 9, 19), datetime.date(2008, 9, 20), datetime
.date(2008, 9, 21), datetime.date(2008, 9, 22), datetime.date(
2008, 9, 23), datetime.date(2008, 9, 24), datetime.date(2008, 
9, 25), datetime.date(2008, 9, 26), datetime.date(2008, 9, 27)
, datetime.date(2008, 9, 28), datetime.date(2008, 9, 29), date
time.date(2008, 9, 30), datetime.date(2008, 10, 1), datetime.d
ate(2008, 10, 2), datetime.date(2008, 10, 3), datetime.date(20
08, 10, 4), datetime.date(2008, 10, 5)]
# 上の表示結果は、9月の日付だけでなくて、8月と10月がちょっとくっ
# ついているのに気づく。これはカレンダーを表示しやすいように、
# 一週間単位にそろえてデータを作ってくれるため。これが余計なら、
# もらったあとで省いて使えばよい。
#
# 今度は年間カレンダーを…
>>> c.yeardatescalendar(2009)
（この結果を引用するのは省略します。やってみたらわかる。どっさり）

pythonサンプル・宿泊予約管理

2008-07-02T22:13:00.003+09:00

全く役に立つバージョンではないけど、さしあたってはやりかたの取っ掛かりだけを。

python2.5からはsqlite3モジュールが標準配布になっているので、これを使ってデータベース管理をしてみることを考える。ここでは手始めに宿泊予約管理みたいなものがどうやって実現できるかを示す。

sqlite3は、ファイルベースの簡易RDBライブラリ。データベース管理のためのサービスプロセスを立ち上げなくてもいいところが手軽でよい。

まず、初期データを作る。下のようなスクリプトを書いて実行すると


import sqlite3

c = sqlite3.connect('testdb')
c.execute('create table heya (date text, vacant int, reserved int)')
for i in xrange(1, 32):
    c.execute("insert into heya values (?, ? ,?)", ("2008-07-%02d" % i, 10, 0))
c.commit()

スクリプトを置いたディレクトリの下に、testdbというファイルができあがる。これがデータベース。
最初から2008年7月の予約台帳(heyaテーブル)ができている。vacant(空き室)は10、reserved(予約数)は0という初期値で。

※データファイルを簡単に眺めるために、
http://sqlitebrowser.sourceforge.net/index.html
みたいなツールを使うとお手軽です。

そしたら次は、下のような予約入力システム(?)のスクリプトを同ディレクトリに作成する。


import sqlite3

db = sqlite3.connect('testdb')

class Yoyaku(object):
    def __init__(self, dates, num=1):
        self.dates = dates
        self.num = num
        self.status = 'unverified'

    def can_reserve(self):
        for i in self.dates:
            r = [j for j in db.execute('select vacant from heya where date=?', [i])]
            print r
            if len(r) == 0: return False
            if r[0][0] < self.num: return False
        self.status = 'verified'
        return True

    def do_reserve(self):
        if self.status == 'finished':
            print "finished"
            return
        if self.status != 'verified':
            print "not verified"
            return
        for i in self.dates:
            db.execute(
                'update heya set vacant=vacant-?, reserved=reserved+? where date=?', (self.num, self.num, i)
                )
        db.commit()
        self.status = 'finished'

このスクリプトはダブルクリックなんかで実行するとすぐ終わってしまって役に立たないので、IDLEみたいな環境から実行して、実行後もpythonのプロンプトが残るようにしながら実行すること。

そしたら順に下のように命令を叩いて、動作を確認してゆく。


>>> y1 = Yoyaku(['2008-07-01'], 3)  -----7月1日に3部屋予約
>>> y1.can_reserve()  -----できますか?
[(10,)]
True  ----- オッケー
>>> y1.do_reserve()  -----じゃあ予約確定
OK.  ----- オッケー
>>> y1.do_reserve()  -----もういちど予約確定?
NG. finished  ----- もう済んでるよ

>>> y2 = Yoyaku(['2008-07-01'], 8)  -----7月1日に8部屋予約
>>> y2.can_reserve()  -----できますか?
[(7,)]
False  ----- できないッス（空き部屋はあと7つだから）
>>> y2.do_reserve()  -----ええい、予約確定だ
NG. not verified  ----- だからできないって
>>>

>>> y3 = Yoyaku(['2008-07-01', '2008-07-02', '2008-07-03'], 2)
     ----- 7月1日、2日、3日と連続で2部屋予約
>>> y3.do_reserve()  -----予約確定!
NG. not verified  -----まだ確認できてないよ
>>> y3.can_reserve()  -----そうか、じゃあ確認
[(7,)]
[(10,)]
[(10,)]
True  -----部屋取れるよ
>>> y3.do_reserve()  -----改めて予約確定!
OK.  -----オッケー
>>>

最後にツールを使ってテーブルの中身を眺めて、確かに台帳が更新されていることを確認する。

あとは予約者の記録とか、部屋の種類を増やすとか、こんなコマンド叩かないで済むようにGUIをつけるとかWebインターフェースをつけるとか、そんな拡張をしながら本物のシステムっぽく育っていく、んじゃないかな。

pythonサンプル・数独

2008-07-01T22:05:00.003+09:00

数独を解くスクリプト。（数独はニコリの登録商標です）
途中でboard配列を作っている文字列を変えれば、他の問題も解ける。81文字で、9x9マスの左上から右下の状態を順に書いていくだけ。0は未定マスという意味。

setオブジェクトを途中で使っている。これはpython2.4以降実装されたもののようなので注意。setは使いどころによっては便利なもので、順番を持たない、重複しない値の集合。辞書のキー部分だけみたいなものといえる。片っ端から値をsetに放り込んでいくと、ユニーク値の集合が得られる。あと、setどうしで差集合をとることも簡単にできる。数独を解くのにちょうど便利だった。

パズルを解くアルゴリズムとして、check_my_number_can_fixedメソッドとexclude_fixed_number_from_neighborsメソッドを書いてみた。前者は、あるマスの数字が一種類に確定できそうか調べるもの。後者は、数字が確定できている時に、周り8マスと縦8マス横8マスの影響範囲にはもうその数字が入りっこないことを表現するもの。これらを交互に実行して、少しずつパズルを解いていこうという意図。

この程度のスクリプトだと、難問は結構途中でギブアップしてしまうようだ。でも途中までは解くので、あとは勘で適当なマスの数字を決め打って正常に解けるか試す、という方法を繰り返せば、まあ解決支援ツールとしてくらいの使い道はある。

Wikipediaの「数独」の記事に出ていたサンプルくらいだと、楽に解けた。


import copy

def list_neighbor(pos):
    s = [[],[],[]]
    for i in xrange(9): s[0].append((pos%9)+i*9) #tate
    for i in xrange(9): s[1].append(int(pos/9)*9+i) #yoko
    t = int(pos/27)*27 + int((pos%9)/3)*3 #block
    for i in (0,1,2,9,10,11,18,19,20): s[2].append(t+i)
    s[0].remove(pos) #remove myself
    s[1].remove(pos)
    s[2].remove(pos)
    return s

def dump():
    for i in xrange(9):
        for j in cand_table[i*9:i*9+9]:
            print "%s," % " or ".join(map(str, j)),
        print
    print "-" * 72

def check_my_number_can_fixed():
    for i in xrange(len(cand_table)):
        for j in neighbor_table[i]:
            if len(cand_table[i]) > 1:
                s = set(cand_table[i])
                for jj in j:
                    s.difference_update(cand_table[jj])
                s = list(s)
                if len(s) == 1:
                    cand_table[i] = s
                    break

def exclude_fixed_number_from_neighbors():
    for i in xrange(len(cand_table)):
        if len(cand_table[i]) == 1:
            for j in neighbor_table[i]:
                for jj in j:
                    try:
                        cand_table[jj].remove(cand_table[i][0])
                    except:
                        pass

board = [int(i) for i in
         '530070000600195000098000060800060003400803001700020006060000280000419005000080079']

cand_table = []
for i in board:
    if i == 0:
        cand_table.append(range(1, 10))
    else:
        cand_table.append([i])
neighbor_table = [list_neighbor(i) for i in xrange(len(board))]
while 1:
    r = copy.deepcopy(cand_table)
    dump()
    check_my_number_can_fixed()
    dump()
    exclude_fixed_number_from_neighbors()
    if r == cand_table:
        print "no more change... maybe SOLVED or GIVEUP"
        break

pythonサンプル・オセロ

2008-06-30T20:38:00.003+09:00

オセロゲームをコンピュータ同士が延々とやりつづけるというデモ用スクリプト。

think_choiceが、どこにコマを置くかを考えるという部分。8x8で全部で64コマを調べて、どこに置くと一番コマが取れるかを考えている。いつも同じ結果ではアレなので、ちょっとランダムさも混ぜている。

双方とも置く場所がなくなったら一番終了、コマの数を清算してから次のゲームに移る。

あまりに早くて追いきれない場合は、#sys.stdin.readline() のコメントをはずせば、一手ごとにEnterキーをを押して進むようになる。

ひとつ手が進むたびにdisplay_board(board)を呼んで盤の状態を表示させているが、ここをコメント化（2箇所）すると、途中経過をすっ飛ばしてすごい勢いで勝敗だけを表示し始める。ほうっておくと100番でも1000番でもコンピュータ同士で勝手にオセロし続ける。


import sys
from random import randint

def display_board(board):
    for i in xrange(8):
        for j in board[i*8:i*8+8]: print ('.', 'O', 'X')[j],
        print
    print

def think_choice(board, me, opp):
    choice, result = None, []
    for pos in xrange(64):
        if board[pos] != 0: continue
        x = pos % 8; y = pos / 8
        cand = []
        # scan all directions
        for xx, yy in ((0,-1),(1,-1),(1,0),(1,1),(0,1),(-1,1),(-1,0),(-1,-1)):
            cand_tmp = []
            distance = 1
            while True:
                xt = x+xx*distance ; yt = y+yy*distance
                if xt > 7 or xt < 0 or yt > 7 or yt < 0: break
                p = yt*8 + xt
                if board[p] == opp: #add candidate
                    cand_tmp.append(p)
                    distance += 1
                    continue
                if board[p] == me and cand_tmp: #fix candidate
                    cand.extend(cand_tmp)
                    break
                break
            if not cand: continue
            # nearly random strategy :)
            if pos in (0, 7, 56, 63): return pos, cand # sumikko!
            if len(cand)+randint(0, 1) > len(result):
                choice, result = pos, cand
    return choice, result

def play_othello():
    board = [
    0, 0, 0, 0, 0, 0, 0, 0,
    0, 0, 0, 0, 0, 0, 0, 0,
    0, 0, 0, 0, 0, 0, 0, 0,
    0, 0, 0, 1, 2, 0, 0, 0,
    0, 0, 0, 2, 1, 0, 0, 0,
    0, 0, 0, 0, 0, 0, 0, 0,
    0, 0, 0, 0, 0, 0, 0, 0,
    0, 0, 0, 0, 0, 0, 0, 0,
    ]
    display_board(board)
    player1, player2 = 1, 2
    r = []
    while 1:
        choice, result = think_choice(board, me=player1, opp=player2)
        if result:
            board[choice] = player1
            for i in result: board[i] = player1
        if not (r or result): break
        r = result
        display_board(board)
        player1, player2 = player2, player1
        #sys.stdin.readline()
    print "%s %s" % ("O" * board.count(1), "X" * board.count(2))

while 1: play_othello()

pythonでお絵かきロジック(未完)

2008-06-29T13:21:00.004+09:00

気ままにコーディングをしているうちに、お絵かきロジックを解くプログラム、のフレームワークみたいなものになってきた。

IllustLogicクラス自身はパズルを解くわけではなく、肝心の部分は外部の関数に任せてしまう。ここではコンストラクタが受け取るfunc引数がそれ。
お絵かきロジックは、よく観察するとたくさんの小さなパズルに分かれるように見える。縦でも横でも、一度にやるべきパズルは一行分の細長いところだけだ。なので、funcにはそれを任せることにした。

コンストラクタは、パズルの問題そのものも受け取る。rowhintとcolhintがそれ。各行、各列のヒントの数字を「配列の配列」として渡しているだけ。

あとは、サンプルで書いたmy_logicをちゃんと書けば、パズル全体が解けるはず…まだやってないけど。今のmy_logicは、デタラメ。hintに一行分のヒント、artに一行分の配列が入ってくるので、それらを手がかりに新しく配列を作って返せばよい。0は未定、1は黒に決定、2は空白に決定、ということにした。マジックナンバーでかっこ悪いけど。

あと、try_solveメソッドはパズルが完全に解けるか詰まるかするまで黙り込んでしまうので、あまりよくない。


class IllustLogic(object):

    def __init__(self, func, rowhint, colhint):
        self.line_processor = func
        self.rowhint = rowhint
        self.colhint = colhint
        self.height = len(self.rowhint)
        self.width = len(self.colhint)
        self.board = [0 for i in xrange(self.width * self.height)]
        self.todo = set()
        for i in xrange(self.height): self.todo.add(('row', i))
        for i in xrange(self.width): self.todo.add(('col', i))

    def work_a_line(self, d, num):
        if d == 'col':
            poss = [num + self.width * i for i in xrange(self.height)]
            hint = self.colhint[num]
        else: #'row'
            poss = [self.width * num + i for i in xrange(self.width)]
            hint = self.rowhint[num]
        workcopy = [self.board[i] for i in poss]
        if not 0 in workcopy:
            return False
        memory = workcopy[:]
        result = self.line_processor(hint, workcopy)
        if memory == result:
            return False
        i = 0
        for p, r, m in zip(poss, result, memory):
            if r != m:
                self.board[p] = r
                if d == 'col':
                    self.todo.add(('row', i))
                    #print "ADD row", i
                else: #'row'
                    self.todo.add(('col', i))
                    #print "ADD col", i
            i += 1
        return True

    def try_solve(self):
        while self.todo:
            #print self.todo
            p = self.todo.pop()
            self.work_a_line(*p)

    def dump(self):
        for i in xrange(self.height):
            t = self.board[i*self.width : (i+1)*self.width]
            print t

def my_logic(hint, ary):
    #DETARAME!
    if hint:
        for i in xrange(hint[0]):
            ary[i] = 1
    return ary

rowhint = [
    [6],[2,1,2],[1,1,1,1],[1,1],[1,1],
    [8],[2,2],[1,1],[1,1],[1,3,1],
    [2,1,1,3],[2,3,3],[1,1,1],[1,1],[10],
]
colhint = [
    [9],[6,2,1],[2,1,1],[1,1,1,4,1],[1,1,1,1,1],
    [2,1,3,1],[1,1,1,1],[2,1,2,1,],[6,2,1],[9],
]

b = IllustLogic(my_logic, rowhint, colhint)
b.try_solve()
b.dump()

pythonサンプル・スクリプト中にビットマップ

2008-06-26T23:22:00.004+09:00

pygameを使っている。
普通は画像を外付けのファイルにして、それを必要なときにロードする。
ここでは、スクリプトだけで画像ファイルの表示に相当することをやってみる。大して意味はないが、昔プログラムの投稿雑誌とかではグラフィックまで含めて一本のソースコードで表現していたことを思い出したりできる。カセットテープからCLOADするときにソースが複数だと面倒じゃん。（よく分からない人へ：冗談なので聞き流してよいです）


import sys
import StringIO
import base64
import pygame
import pygame.locals as C

pygame.display.set_mode((320, 240))
c = pygame.display.get_surface()

bit = pygame.image.load(StringIO.StringIO(base64.decodestring(
 'R0lGODdhCAAIAPoAMWQEBJwEBP///wAAAAAAAAAAAAAAAAAAACwAAAAACAAIAAADFyi6G+BhvRmneCJACiyujhIpnJAAAAAAADs=')))
bit.set_colorkey(bit.get_at((0,0)))

c.fill((255,255,255,255))
c.blit(bit, (160, 120))
pygame.display.flip()

while True: 
  if pygame.event.poll().type == C.QUIT: sys.exit(0)

途中の変な文字列がミソで、あらかじめ画像ファイルの中身ををbase64エンコードしたものをこうやって扱えばよい。ファイルのように扱える文字列として、StringIOオブジェクトをこしらえてからimage.loadに渡している。

ところでこのbase64化した文字列をどうやって作るかというと、pythonの対話プロンプトから


>>> import base64
>>> print base64.encodestring(file('sample.gif', 'rb').read())

とでもして出したらよい。

pythonサンプル・pygameでライフゲーム

2008-06-23T21:51:00.001+09:00

先日書いたライフゲームをpygame版に書き直してみる。ゲーム製作用ライブラリなので、Tkinterよりスピーディで気持ちよい。
pygameにまだ慣れないので、どうやってクラスにまとめるべきかはよく分からない。

pygame: http://www.pygame.org/news.html


import sys
import pygame
import pygame.locals as C
from random import randint

class LifeGame(object):

    def __init__(self, xs=40, ys=40, fps=30):
        self.xs = xs
        self.ys = ys
        self.fps = fps
        self.b = [randint(0,1) for i in xrange(self.xs * self.ys)]
        pygame.display.set_mode((self.xs*8, self.ys*8))
        self.c = pygame.display.get_surface()

    def run(self):
        clock = pygame.time.Clock()
        while True: 
            if pygame.event.poll().type == C.QUIT:
                sys.exit(0)
            self.progress()
            clock.tick(self.fps)

    def chst(self, p):
        d = self.xs
        n = 0
        for i in (p-d-1, p-d, p-d+1, p-1, p+1, p+d-1, p+d, p+d+1):
            try:
                n += self.b[i]
            except:
                pass
        if n < 2 or n > 3: return 0  #die
        if n == 3: return 1          #born
        return self.b[p]  #survive

    def progress(self):
        self.b = [self.chst(p) for p in xrange(len(self.b))]
        self.c.fill(0x808080)
        for i in xrange(self.xs):
            for j in xrange(self.ys):
                if self.b[self.xs*j+i]:
                    f = 0
                else:
                    f = 0xffffff
                pygame.draw.rect(self.c, f,
                                 (i*8, j*8, 7, 7))
        pygame.display.flip()

if __name__ == '__main__':
    pygame.init()
    LifeGame(60, 40, 20).run()

pythonで音声合成

2008-06-21T12:01:00.002+09:00

AquesTalkという音声合成ライブラリを使って、簡単に音声合成を試してみることができる。
http://www.a-quest.com/aquestalk/からWin版(Free)の配布パッケージをダウンロードしてきて展開、その中のbinフォルダに必要なDLLがあるから、そこに AquesTalk.dll と AquesTalkDa.dll があることを確認して、同じディレクトリに下のようなスクリプトを作って実行してみるだけ。これで最低限の動作をする。(ctypesモジュールはpython2.5から標準配布されている)


# -*- coding:cp932 -*-

from ctypes import windll
talk_dll = windll.LoadLibrary("AquesTalkDa.dll")
v = talk_dll.AquesTalkDa_PlaySync
v("うらにわに'わ/に'わ/にわに'わ/に'わ/にわとりが/いる。", 120)
v("すもももももも/もものうち", 120)
v("とうきょう/とっ'きょ/きょか'きょく/きょかきょく'ちょう", 120)

下の記事を参考にさせていただきました。
http://boxheadroom.com/2008/04/18/aquestalk
http://d.hatena.ne.jp/tomoemon/20071116#p1

pythonでライフゲーム

2008-06-20T16:26:00.001+09:00

pythonの標準配布に含まれるTkinter（tkのラッパー）を使って何か表示してみるテスト。ここではライフゲームっぽいものを作ってみた。
下のスクリプトを適当な名前(life.pyとか)で保存して実行すると、大きさの異なるふたつのライフゲームが異なる速度で進んでいく。ゲームといっても、眺めるだけ。

スクリプトの途中に try: except: 構文で処理を書いているところだけを簡単に説明する。ライフゲームは自分のまわりの８個のコマに従って変化していくが、盤の端っこのコマにとっては部分的に存在しないマスを参照することになる。存在しないコマへのアクセスはpython的にはスクリプト終了級の事態なのだけど、exceptを使ってそのエラーを無視させてしまうことで、単に処理を飛ばすだけにとどめることができる。あまり正確な言い方ではないが。

やる前に厳重にチェックしてエラーを防ぐより、やっちゃってみてからエラーが起きたら対処する、というやり方のほうが楽になることもある、という例。


import Tkinter
from random import randint

class LifeGame(object):

    def __init__(self, xs=40, ys=40, interval=500):
        self.xs = xs
        self.ys = ys
        self.interval = interval
        self.b = [randint(0,1) for i in xrange(self.xs * self.ys)]
        self.c = Tkinter.Canvas(width=self.xs*8, height=self.ys*8)
        self.c.pack()
        self.c.after(self.interval, self.progress)

    def chst(self, p):
        d = self.xs
        n = 0
        for i in (p-d-1, p-d, p-d+1, p-1, p+1, p+d-1, p+d, p+d+1):
            try:
                n += self.b[i]
            except:
                pass
        if n < 2 or n > 3: return 0  #die
        if n == 3: return 1          #born
        return self.b[p]  #survive

    def progress(self):
        self.b = [self.chst(p) for p in xrange(len(self.b))]
        for i in self.c.find_all(): self.c.delete(i)
        for i in xrange(self.xs):
            for j in xrange(self.ys):
                if self.b[self.xs*j+i]:
                    f = 'black'
                else:
                    f = 'white'
                self.c.create_rectangle(i*8+2, j*8+2,
                                        i*8+8, j*8+8, fill=f)
        self.c.after(self.interval, self.progress)

if __name__ == '__main__':
    lg1 = LifeGame(50, 40)
    lg2 = LifeGame(18, 18, 310)
    Tkinter.mainloop()

pythonで難解バカボン

2008-06-19T21:50:00.003+09:00

『難解バカボン』という、変な文章を作り出すソフトウェアがある。作者は難解計画氏。
http://www.vector.co.jp/soft/dos/amuse/se007728.html

オリジナルはC言語で書いてあるのを、pythonに移植してみた。下のソースを適当な名前(nankai.pyとか)で保存の上、オリジナルの難解バカボンに入っている辞書ファイル(*.nb1)を同ディレクトリにコピー等してから実行する。スクリプト中ではデフォルト値をnanba.nb1にしているが、これを変更することで、色々な辞書を使った変な文章が作れる。
完全に移植してはいない。適当に翻案したり組み方を変えてしまったところもある。また、文章生成パラメータの説明も省略する。本物を参照のこと。

スクリプトそのものについて説明できるところはない。前回のエントリで、面倒な辞書リテラル（ここでは入れ子リストのリテラル）を簡単に書く方法を書いたが、ここでこれの応用をしている。


# -*- coding: cp932 -*-

import random

inf_raw = u'しない:せず はない:はなく がない:がなく にない:になく'\
 u'ている:ており でいる:でおり する:し ずる:じ ある:あり える:え'\
 u'げる:げ ぜる:ぜ める:め れる:れ 言う:言い いう:いい 入る:入り'\
 u'見る:見て 出る:出て 得る:得て しい:しく あう:あい 合う:合い'\
 u'だ:で く:き つ:ち む:み ぐ:ぎ ぶ:び'

config_default = {'mn':1, 'mx':5, 'sn':6, 'rc':2, 'sc':60,
          'sh':70, 'jt':50, 'sz':50, 'bm':50, 'kt':u'、', 'tt':u'。' }

#WORDS_MAX = 2500
#kugiri = u' !?:;.,^~_/<>()[]{}｢｣｡､･\'"\t\n　！？：；．，。、・\…'\
#          u'‥＾￣＿／＜＞（）［］「」〔〕｛｝〈〉《》『』【】“”‘’'

class NankaiBakabon(object):

    def __init__(self, datafile='nanba.nb1'):
        import copy
        self.inf_dic = []
        for i in inf_raw.split(" "): self.inf_dic.append(i.split(":"))
        self.wlow = ([], [], [], [], [], [], [])
        self.config = copy.copy(config_default)
        self.read_data_config(datafile)

    def set_config(self, key, val):
        if key in ('mn', 'mx', 'sn', 'rc', 'sc', 'sh', 'jt', 'sz',
                   'jt', 'sz', 'bm'):
            self.config[key] = int(val)
        elif key in ('kt', 'tt'):
            self.config[key] = val.decode('cp932')

    def read_data_config(self, datafile):
        f = open(datafile, 'r')
        wtype = 0
        wcount = 0
        for line in f:
            line = line[:-1]
            a = line.find("'")
            if a != -1: line = line[:a]
            if not line: continue
            if line.startswith('-'):
                key = line[1:3].lower()
                val = line[3:].strip(' \t\"\'')
                self.set_config(key, val)
                continue
            if line.startswith('@'):
                wtype += 1
                continue
            self.wlow[wtype].append(line.decode('cp932'))
            wcount += 1
        f.close()
        print wcount, u"個の語句を読み込みました"

    def test_dice(self, attr):
        return random.randint(0, 100) < self.config[attr]

    def sel(self, wtype, buf):
        sz_limit = 15
        fm_limit = 15
        while 1:
            b = random.choice(self.wlow[wtype])
            if len(buf) == 0: break
            #形容詞のあとの書き出しを制限（副作用大きい）
            #if buf[-1].endswith(u'い'):
            #     形容詞のあとの単語を制限
            #    if b[:2] in (u'べき', u'べか', u'べく', u'べし', u'しか',
            #                 u'ため', u'には', u'まで'):
            #        print "[WARNING]" + buf[-1] + b
            #        continue

            #接続助詞の重複感を(できるだけ)避ける
            if sz_limit > 0:
                if buf[-1][-2:].rstrip(self.config['tt']) == \
                         b[-2:].rstrip(self.config['tt']):
                    #print "[WARNING]" + buf[-1] + b, sz_limit
                    sz_limit -= 1
                    continue

            #述語語尾の重複感を(できるだけ)避ける(TODO)

            #語句の重複感を(できるだけ)避ける
            f = 0
            if fm_limit > 0:
                for i in (u'であ', u'され', u'とい', u'と言',
                          u'でき', u'もの'):
                    if buf[-1].find(i) > -1 and b.find(i) > -1:
                        #print "[WARNING]" + buf[-1] + b, fm_limit
                        fm_limit -= 1
                        f = 1
            if f == 1: continue
            
            break
        buf.append(b)

    def inflect(self, buf):
        for i in self.inf_dic:
            if buf.endswith(i[0]):
                buf = buf[:-len(i[0])] + i[1] + self.config['tt']
                return buf
        return buf + u'し' + self.config['tt']

    def make_sentence(self):
        buf = []
        slen = random.randint(self.config['mn'], self.config['mx'])
        a = 0
        while True:
            st = 1
            #主語前の副詞
            if self.test_dice('sh'):
                self.sel(2, buf)
                st = 0
            #主語・助詞
            if st == 1 or self.test_dice('sc'):
                self.sel(0, buf)
                self.sel(1, buf)
            #主語後の副詞
            if self.test_dice('sh'):
                self.sel(2, buf)
            #述語
            if self.test_dice('jt'):
                #他動詞
                self.sel(0, buf)
                self.sel(4, buf)
            else:
                #自動詞
                self.sel(3, buf)
            a += 1
            if a >= slen: break
            if self.test_dice('sz'):
                #接続句から並列文へ
                self.sel(5, buf)
            else:
                #語形変化で接続して並列文へ
                buf[-1] = self.inflect(buf[-1])
        #文末
        if self.test_dice('bm'):
            self.sel(6, buf)
        buf.append(self.config['kt'])
        #return buf
        return "".join(buf)

    def run(self):
        while 1:
            for i in xrange(self.config['sn']):
                print self.make_sentence(),
            print; print

if __name__ == '__main__':
    NankaiBakabon('nanba.nb1').run()

以下、実行結果の例。

つくづく結構死体になるしかないかもしれませんがそれにしてもコカインはすっかり墓石を売り飛ばすとは恐怖でしょう。とりあえずつくづく油揚を破壊する今日この頃ですがまず墓石を利用するので感心するよーに。ティッシュも特に陰謀を穴に埋めるとはゆーもののテクノロジーはついに埋葬されると思いますです。主として閑古鳥だってほとんどマネキンをやめる。

ティッシュはまず芸者を手に入れるに決まってます。彼岸は結構コカインを見るとか言いつつもキムチがどーにもこーにも死体を繰り広げるみたいっすね。お姉さまは救いよーがないなんて知らんのでますますすかさずのたうつなんて知らんのですかさず暴れるざます。ひねもすオリジナリティの野郎が死体を破壊するんだから結構つまり蝋燭を練り練りするので感心するよーに。

油揚が閑古鳥を推進し、なるべくウィルスはいつでもとぐろを巻くみたいっすね。五寸釘だって石燈篭とは違うらしいですがしかもスキャンダルをやめると思いますです。ほとんどチェーンソーとゆーのは貝柱を利用し、もれなくナスビを開発するのでワケわからないす。アンドロメダ病原体のくせにやっぱしヒロポンを開発するでしょう。

臓物がまずわななくので怪しげですがもれなく一応蝋燭とは違うので焦ります。彼岸は貝柱を利用する場合一応アンドロメダ病原体の野郎がそれにしてもヘチマを売り飛ばすなんて知りません。つくづくキノコに関心を寄せるし、マネキンだけが狂うし、とりあえずつまり暴れるので危険です。ひねもす朝日新聞のくせにわななき、思わずバリウムもめでたいし、結局パンチパーマの野郎がコカインを貰うんでしょーか。

やっぱし卒塔婆がどーにもこーにもキノコにはならない今日この頃ですが一気に能面は実にモアイを用意するとゆー噂ですがわりと土管がどーにもこーにも死ぬとゆーことでしょう多分。芸者はまさしく土管とは違うと思いますです。土管だけが盛大にわななくのでワケわからないす。たまにモアイがすでにカフェインを穴に埋めるとゆーことでしょう多分。

そのうち盛大に幼女を開発するよーですがマンホールのくせにそのうちヘロインにはかなわないなんて信じられません。なるべく包丁が結局死体になるしかないし、霊園の野郎が包丁を切り刻むとゆーのは実に往生際は頭金を切り刻むのだーだーだー。謹んで馬はいつでも脳みそ腐るし、霊界ではもれなく彼岸にはかなわないなんて知りません。どーにもこーにも朝日新聞を貰うし、それにしても蝋燭はもれなく救いよーがなく、キムチが思わず埋めてしまいたいんでしょーか。

pythonサンプルコード(5)

2008-06-18T21:08:00.002+09:00

辞書（連想配列とかハッシュと呼ばれるときもある）はもちろんpythonにも実装されていて、非常に有用です。でもリテラル表現で辞書をセットするのは書き方がやや煩雑です。特に日本語が混じったりして、ユニコード表現(u)が混じってくると、下のような打ち込むのが大変なコードになります。


inf_dic = { u'しない':u'せず', u'はない':u'はなく', u'がない':u'がなく',
            u'にない':u'になく', u'ている':u'ており', u'でいる':u'でおり',
            u'する':u'し', u'ずる':u'じ', u'ある':u'あり', u'える':u'え',
            u'げる':u'げ', u'ぜる':u'ぜ', u'める':u'め', u'れる':u'れ',
            u'言う':u'言い', u'いう':u'いい', u'入る':u'入り',
            u'見る':u'見て', u'出る':u'出て', u'得る':u'得て', u'しい':u'しく',
            u'あう':u'あい', u'合う':u'合い', u'だ':u'で', u'く':u'き',
            u'つ':u'ち', u'む':u'み', u'ぐ':u'ぎ', u'ぶ':u'び'}

こんなのを書くよりは、最初にこれを作るための決まりをもった文字列を準備して、これを必要に応じて文字列操作で辞書に作り上げてしまったほうが、作成はかえって楽です。


inf_raw = u'しない:せず はない:はなく がない:がなく にない:になく'\
 u' ている:ており でいる:でおり する:し ずる:じ ある:あり える:え'\
 u' げる:げ ぜる:ぜ める:め れる:れ 言う:言い いう:いい 入る:入り'\
 u' 見る:見て 出る:出て 得る:得て しい:しく あう:あい 合う:合い'\
 u' だ:で く:き つ:ち む:み ぐ:ぎ ぶ:び'

inf_dic = {}
for i in inf_raw.split(" "):
    (k, v) = i.split(":")
    inf_dic[k] = v

どっちも同じinf_dic辞書ができ上がります。こんな感じで確かめました。


>>> print inf_dic[u'言う']
言い

pythonサンプルコード(4)

2008-06-17T20:43:00.004+09:00

いつかperlで書いたことのある、デタラメ書名を作り出すスクリプトをpythonに移植した。使い道は、謎。
ソースコードはutf-8で保存すること。一行目に encoding: utf-8 と書いたから。ここでシフトJIS(cp932)と書くときは、シフトJISで保存すればよいのだけど。


# -*- encoding: utf-8 -*-
#でたらめな書名を作る。
import random

a = u"着衣 人間 デンマーク 霧氷 砂漠 雨 鉄道 正義 心臓 血流 詩人 環境"\
    u" 権利 熱帯 ナマコ 人種 マーケティング 幕末 光合成 修道院 歴史"\
    u" 芸術 回想 芸能".split(" ")
b = u"早分かり・%s 小説・%s 判例で学ぶ%s 本当はおそろしい%s いちばん詳しい%s %sの研究"\
    u" %sを歩く %s事典 %s大百科 %sだいすき %s入門 %s超入門 %sってなんだろう %sの心理学"\
    u" %sハンドブック・改訂版 %sがわかる %s大好き！ %sを求めて %s年鑑 %sの謎を追う"\
    u" %sの歴史 %sの裏側 %s物語 次代に伝える%s ヒゲの先生、%sを語る".split(" ")
c = u"の の と 的な".split(" ")
c.append("")
d = u"%s学 %s論 %s派 %s主義 反%s %s %s %s %s".split(" ")

def getMeisi():
    return random.choice(d) % random.choice(a)

def getMeisiKu(p):
    r = p - random.random()
    if r > 0.0:
        return getMeisi()
    else:
        return getMeisi() + random.choice(c) + getMeisiKu(r)

def getDetarameBookTitle():
    title = getMeisiKu(0.7)
    if random.random() > 0.2:
        title = random.choice(b) % title
    return title

for i in xrange(0,10): print getDetarameBookTitle()

今回このスクリプトをことごと説明はしない。ただ、randomモジュールの使いかたにだけ触れておく。
random.random() ... 0.0以上1.0未満の乱数を発生する。
random.choice(a) ... 配列aから適当にいっこ取り出す。
random.randint(a, b) ... aからbまでの整数をランダムに発生する。今回は使ってないけど。

実行結果はこんなふう…

反環境事典
ナマコ
砂漠派の修道院
早分かり・心臓的な回想主義の人間学
ナマコ論と環境の血流学
霧氷論の血流
芸術
マーケティング派
熱帯的な砂漠派
回想と心臓

pythonサンプルコード(3)

2008-06-17T15:06:00.003+09:00

おもちゃだけど、下の二行を書いたスクリプトを実行してみると、


import SimpleHTTPServer
SimpleHTTPServer.test()


Serving HTTP on 0.0.0.0 port 8000 ...

なんていう表示がされて、一見動作が止まる。（Windowsだと、なんか警告みたいなのが出るときがある。一時的に云々…というボタンを押して、やり過ごしておく）

で、手持ちのWebブラウザで、アドレス欄に http://127.0.0.1:8000/ と入力してみると、なんと簡単なWebサーバーができてしまったことがわかる。

これだけだと大した役にはたたないけど、これを骨組みに改良していくことで、実用的なアプリケーションに育てていくこともできる。
また、SimpleHTTPServerのモジュールソースを読むのは楽しくて勉強になる。

サンプルの動作を止めるには、Ctrl+Cを押しても、コマンドプロンプトの窓を直接閉じてもよい。

pythonサンプルコード(2)

2008-06-17T09:53:00.003+09:00

書いたコードをHTMLに載せるのに、コードをそのまま切って貼ると都合が悪いときがある。

ひとつはタブ記号によるインデントが再現できないこと、もうひとつは松葉括弧がタグとみなされて表示が壊れてしまうことである。

ブログ用のソフトウェアによってはちゃんと対応してくれるが、bloggerに直接書こうとするとやっぱりこのための手間をかける必要があった。

ということで、手持ちのスクリプトを貼り付け用HTMLに直す処理自体をスクリプトに書いた。


import sys

w = 72

for line in sys.stdin:
    line = line[:-1]
    if not line:
        print
        continue
    line = line.expandtabs(4)
    while line:
        (a, line) = line[:w], line[w:]
        print a.replace('&', '&amp;').replace('<', '&lt;')\
               .replace('>', '&gt;')

import sysしてからforループでsys.stdin（標準入力）を処理するという書き方はお決まりのもので、もう考えなくても手が動く。ついでに、次のline[:-1]という書き方は、行末の改行記号を取り除くという、これもお決まりの書き方。

expandtabsメソッドは、文字列に含まれるタブ記号を空白文字の集まりに置き換えるもの。(4)だからタブひとつあたり空白4文字になる。
次の while line ループは、lineが空っぽになるまで続けるよという書き方。ループの中でlineはだんだん短くなっていく。具体的には、左72文字分を切りながらaに渡し続けることによって。
aを出力するときは、HTMLでよくある &、 >、 < を対応するHTML上の書き方に変換してから表示している。replaceメソッドの戻り値もまた文字列だから、サンプルに書いたようなつなげ方で書ける。
円記号（環境によっては逆スラッシュ記号）は、次の行に続くよという目印。一行が長すぎると思ったら適宜改行することにする。

このスクリプトがpy2html.pyという名前だとしたら、これの使い方は


cat py2html.py | python py2html.py

って感じ。この例では自分自身を整形してみせる。

pythonサンプルコード(1)

2008-06-17T08:38:00.008+09:00

pythonのサンプルでも書いて暮らしてみようと思った。
とりあえず、W3CのトップページのHTMLを持ってくるようなサンプル。


import urllib2
url = 'http://www.w3c.org/'
print urllib2.urlopen(url).read()

こいつにsample.pyとでも何とでも名づけて保存し、コマンドプロンプトから実行。


python sample.py
（実行結果）
<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.
org/TR/xhtml1/DTD/xhtml1-strict.dtd">
<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en-US" lang="en-US"
>
<head profile="http://www.w3.org/2000/08/w3c-synd/#"><meta http-equiv="C
ontent-Type" content="text/html; charset=utf-8" />
<meta name="generator" content="HTML Tidy for Mac OS X (vers 1st March 2
004), see www.w3.org" />
<meta name="keywords" content="W3C, World Wide Web, Web, WWW, Consortium
, computer, access, accessibility, semantic, worldwide, W3, HTML, XML, s
tandard, language, technology, link, CSS, RDF, XSL, Berners-Lee, Berners
, Lee, style sheet, cascading, schema, XHTML, mobile, SVG, PNG, PICS, DO
M, SMIL, MathML, markup, Amaya, Jigsaw, free, open source, software" />
<meta name="description" content="The World Wide Web Consortium (W3C) is
...ごちゃごちゃ

標準出力に出てくるだけでは嫌なら、ファイルを書き込み用に開いてそこにwriteすればいい。'wb'のうちwが「書き込み用OPEN」っていう意味で、bが「バイナリモード」って意味。bは今のところこれ以上の説明を割愛。


import urllib2
url = 'http://www.w3c.org/'
f = open('index.html', 'wb')
f.write(urllib2.urlopen(url).read())
f.close()

ところで、read() をたまに read とだけ書いてしまうことがありますが、これだと動かないです。括弧をつけないと、メソッドそのものを返すという動作になり、意図と違うことになります。python練習中にはよくやるミスです。


>>> 'hello'.upper  # 大文字で表示するメソッド呼んでるつもり…
<built-in method upper of str object at 0x00CD51A0>  # なんか出た！
  #これはメソッドの内部形式みたいなもの。こんなのが欲しいんじゃない
>>> 'hello'.upper()  # 括弧をつけて、メソッドを呼んでいることを明記
'HELLO'  # これでいい

時間を寸断される

2008-04-23T01:01:00.002+09:00

スクリプトなんかを書いているときに他用でちょっとでも中断が入ると、再開してもいきなり能率が落ちたりする。
僕のような凡人では、簡単なスクリプトなんかを書くだけでも多くの集中力を必要とするのだなと分かる。ちょっとしたミスで大事なデータを壊してしまったら大変だから。
僕の個人的なイメージだが、スクリプトの挙動を頭の中で想像しながら書くには、意識の中にそれなりの空間を作って、そこで思考実験みたいなことを繰り返す必要がある。ほかごとに気が散ってしまうとこの「空間」が壊れてしまうので、またこれをがんばって作り直してから作成の続きをするはめになる。この作り直しの時間がロスになるわけ。

だから何時間も邪魔しないでくれ、と言ってみたくもなるが、仕事でやる以上それも無理だったりするから、書こうとしていることをさらに細かい要素に分けて、ひとつづつの目標地点を単純なものにしていく。で、ひとつあたりの必要な連続時間を短くする。

ひとつのスクリプトを複数の細かい要素に分けることそれ自体もそれなりの技能を必要とすることではあるけど、楽するためのスキルだと思えばがんばって上達させようと思える。

紛失リスク、漏洩リスク

2008-04-16T19:07:00.005+09:00

データを管理することについてぼんやり考えているうちに、悩みのすべては根本的にはデータ紛失のリスクとデータ漏洩のリスクのどちらかだなと思いついた。当然すぎることではあるけど、今さら。

データ紛失のリスクとは、文字通りデータがなくなるリスク。旧バージョンのものを上書きしてしまったりすることも含む。また、どの情報が最新なのかが分からなくなってしまうようなときも、結果として紛失みたいなものだと思う。
漏洩のほうは、意図しない相手にデータを与えてしまうリスク。P2Pとかで巷で大流行のやつ。パスワード管理なんてのは、データ漏洩リスクを管理することそのものだ。

データを管理しとけ、って言われたら、とりあえず紛失も漏洩もするなよ、ということと捉えれば大きく間違ってはいないだろう。

さて、ある部署で、データの管理のためと称して、ネットワークストレージ(NAS)を導入したとする。このことだけを取ったときに、これは上の二つのどっちのリスクを軽減するか。
紛失のリスクは？別に減ってはいない。たとえNASがディスクの冗長化などで壊れにくくなっているとしても、人間がやるデータの上書きや消去なんかは簡単だ。それにファイルが長年無秩序にたまり続けてロクに検索ができなくなってしまったら、そんなの紛失してるのと同じだ。それに何より、皆が根拠のない安心感を持って蓄積し続けたデータが、ある日NASの故障で一網打尽に失われる、という恐ろしいことも、運用次第ではありうる。
漏洩のリスクは？増えるとも減るともいえないが、増える可能性のほうが大きいんじゃないだろうか。多分部署の構成員だけに読めるようにパスワードでもかけて管理しておくだろうが、構成員が異動したときに、ついパスワードの組み換えをサボってしまう、とかそんなこともあるかも知れない。

今後も、このソリューションはデータの紛失と漏洩のどっちを減らすつもりなのか、と考えてみるようにしたい。

ブラックボックス化

2008-04-10T22:28:00.003+09:00

仕事がブラックボックス化すると、とてもよくない。

特に、コンピュータ上で何かの仕組みを作りこんだときによく起こる。
典型的には、「このボタンを押すとこういう表示が出るから、ここでこのボタンを押してね。理由は僕も分からないけど、こうしないと次の処理がおかしくなるから」といった場面で仕事のブラックボックス化が起こり、これが固定される。

結局何を実現するための手続きなのか、内部的には何が起こるのか、といったことをあわせて伝えておかないと、または自分自身でも理解しておかないと、工夫の余地が失われてしまって、伝えられた手続きからちょっとでも外れたことが恐ろしくてできなくなってしまう。

ここでシステムの「疎外」がおこり、人間の支配を離れたシステムが逆に人間を支配し始める…とか大げさなことを言うつもりはないが、なんせ人に仕事を渡す／人から仕事を渡されるときはもっとスムーズにやれる方法はあるだろうにと痛感するんだよな。

Google App Engine

2008-04-09T21:45:00.004+09:00

手元のwinXPで試してみることにする。

まずpythonを2.5.2にアップグレードして、次に、GoogleAppEngineのインストーラを実行。インストール先のパスが、path環境変数に追加された。でもpythonへのパスは通ってないので、c:\python25もさらに追加。

で、適当なところにディレクトリを掘って、そこにちょっとしたpythoコードとアプリケーションを定義するYAMLを書く。ここらへんは Getting Started とかいう記事を見ながらほぼそのままに。

で、コマンドを一発叩いて簡易Webサーバーが上がって、ブラウザでアクセスするとすぐに動作を確認できる。

ベースはDjangoかー。で、Googleがこれを拡張して、ユーザー認証とかデータベースとかをむちゃくちゃ簡単に扱えるようにしている。Djangoだから、この前ちょっと勉強したテンプレートの知識もそのまま使えると。自分もDjangoに目をつけてたのが、ちょっと嬉しい。

予備知識のおかげで、サンプルコードはすぐに理解できる。とても楽しいオモチャだ。なんか書いて、Googleにホスティングしてみたいな。ということで登録待ちの予約を入れてしまった。

root権限を畏れよ

2008-04-08T23:35:00.002+09:00

こんなことを言わなくても、誰でもrootを畏れるようになるけどね。ただし失敗したあとで。願うらくはその失敗が社会をマヒさせるような種類のものでありませんように。

UNIX系のスーパーユーザーになってするべき作業は多い。コマンドのインストールとか、ユーザー作成とか。スーパーユーザーはどんなファイルでも削除や改変ができて、どんなプロセスも殺せます。

ノッて作業していると、思わぬところで変な間違いをしてしまう。大事な設定ファイルをバックアップ取らずに編集しちゃったとか、消しちゃったとか。あとは作業ディレクトリを消そうとして本環境を丸っと消しちゃうとか。

筆者だけかも知れませんが、catとrmをうっかり打ち間違うことがあるのです。なぜかは分からない。ファイルを眺めるだけのつもりが、サッパリ消してしまう。これはショック大きいです。

UNIX系ってサーバーとして動いているときが多いので、最悪、皆の仕事を止めてしまうような失敗もありうる。怖いです。

基本的に、必要なとき以外はスーパーユーザーにならないのがよいです。で、必要な仕事が終わったらとっととスーパーユーザーを抜ける。

スーパーユーザーの状態でファイルを消したり、ディレクトリを消したりするのは最大限の注意を払うこと。削除のかわりにファイル名やディレクトリ名を変える程度にしておいて、後日全く問題ないことを確認してから本当に削除するとか、そういう工夫もアリ。自分がちょっとでも興奮状態などで判断が鈍っているという自覚がある場合は、スーパーユーザーにならないこと。可能なら、二人以上で確認しあいながら作業すること。

ブランクがあいている

2008-04-08T00:08:00.001+09:00

忘れているわけでもないが、ここの更新が滞った。
備忘的な意味を込めて、とりあえずエントリだけ作る。

次は「スーパーユーザー権限を畏れよ」の巻。の予定

階層型メモ

2008-01-21T23:10:00.000+09:00

メモの管理が劇的に変わったのは、階層型メモを使うようになってから。

それまでは、
・notepadとかで単に書き残す
・付箋ソフトみたいなやつに書き残す
・メールとして自分に送り、マークとかフォルダ分けとかしてみる
などと色々試したが、なんだかうまくいかなかった。

一番やりたかったことは、自分の目前にある仕事を整理するとともに、やっていること・やってきたことのカテゴリー化を体系的に行うことだった。これはうまくツリー型のメモとしておさまり、それまでは「なんだか何でもかんでもやらされてる気がして、忙しさが終わる気がしなくて腹が立つ」という状態だったのが、気分的にたいへん楽になった。

仕事上のメモはとりあえず新しい項目として突っ込んでおき、あとでそれを適当なツリー上に置きなおして、付近にある仕事との関係をそのつど確認しておく。そうすると、類似の仕事をまとめて単純な形に直してしまうことを思いつくかも知れないし、または、片手間のつもりの仕事と思っていたものについて、それが積もってきて、新しいカテゴリーを作ってちゃんと労力を集中したほうがよいと気づくかも知れない。

ドキュメントは大きなツリーをもつものを主にひとつだけ管理することにして、マスターメモと名づけた。これが失われるととても困るので、バックアップを神経質に取るようになった。

FitzNOTEを結構長く使ったあと、Nami2000に乗り換えた。後者のほうがデータファイルの構成が単純で、単にテキストファイルとして開いてもほとんど問題なく読めるから。

README.txt

2008-01-18T00:29:00.001+09:00

メモを書いたのにそれをなくすというのがよくある。
だから、思いつくままにメモを書くのはもちろん大事なのだけど、しまう場所も大体きめておく。

そのひとつは、README.txt。作業フォルダひとつづつにできる限りREADME.txt
を作って、どんな意図でこの作業をしているのかを書き残す、または随時更新することにする。
作業時間が寸断されていたりすると、このディレクトリは何のために掘ったっけ、ということさえ忘れていったりする。誰の依頼で何をどうしようとしているのか、とかそんなあたりから。
ちょっと慣れた人なら、必ずREADME.txtには目を通すはずだから、引継ぎ事項のうちいくつかはこういうところにも残す。人から引き継いだものとかにそれがなければ、自分自身でディレクトリ内にREADME.txtを足したりするときもある。

テンプレートを使いたい

2008-01-05T23:44:00.000+09:00

話の流れが前後することになるが、現在pythonをうまく仕事で実用的に使ってやろうと試行錯誤している。

今は、python製のWebアプリ構築用ライブラリであるDjangoを勉強している、というか眺めたりいじったりしている。
DjangoのO/RマッパーやURLディスパッチャについても面白いと思っているが、今のところWebアプリを実際に作るような用事はないから、Djangoのテンプレートサブシステムだけを仕事で使い始めてみようかというところ。

とりあえず、ごく原始的なサンプルをメモまでに：


from django.conf import settings
#settings.configure(TEMPLATE_DEBUG=True, TEMPLATE_DIRS=('.'))
settings.configure()
from django.template import Context, Template

t = Template("Hello, {{ yourname }}.")
x = {"yourname": "harry"}
print t.render(Context(x))

django.templateをインポートする前に、settings.configure()をあらかじめ呼んでおくのがミソ。テンプレートをファイルに格納していない限りは、何の引数も与えなくてもこれだけで一応動作する。

テンプレートだけのためにDjangoを導入するのはオーバースペックではある。でも、Djangoは結構息の長いプロジェクトになるだろうという予感があるので、詳しくなっておいて損はないんじゃないかなあと思って。

perlでHTML::Templateを使ってた経験が結構長いんだけど、どうにもスクリプトが汚くなってしまいがちなのに悩んでいたところでもある。リファレンスとかデリファレンスとか、無名ハッシュとか、なんかなあ。今の仕事に後任者がいるとして、あとで悩ませることが少ないソリューションをできるだけ残していきたい。

メモを作る

2007-12-31T23:42:00.001+09:00

記憶力が、以前と比べるとやや落ちているのではないかと考えてしまうときがある。テストなどではそういったことはないが、やるつもりだった仕事が抜け落ちることがあるせいだ。自分では、これはまだ「衰え」ではないと思っている。要求される仕事量が込み入ったものになることが増え、より複雑な記憶が必要になってしまったせいだろう。

とても当たり前のことではあるが、メモを作るということが極めて重要なことがそのあたりからわかってきた。メモを作るということは、自分にとっては、それを忘れてもよい状態になるということだ。うまくメモをまとめて管理することがうまくなるほど、自分の脳みそは楽になる。

もっと楽したい。この動機から、メモをどういうルールで書いてどうやって管理するのかということに強い興味をもつことになった。

担当者用か自分用か

2007-12-28T20:27:00.001+09:00

仕事用のスクリプトを書くとき、これを使うのが自分（システム管理者）であるか、それ以外の業務担当者であるかを意識する。
自分のためのものなら、とりあえずでも動くものなら用事はこなせるが、他人、とくにコンピュータに詳しくない他人が使うことが想定される場合は、なるべくきっちりと対話式に動かせるように書く。
ドキュメントの書き方も少し違ってくる。自分用のものなら、技術上の側面を主に書いて、他人用のものなら、起こることを順番に記述する方針で書く。イレギュラーなことが起こったときだけはシステム管理者に連絡できるようにしておけばよい。
実際には、他人用ドキュメントにも、最後の章あたりを割り当てて技術メモを書いておくよう心がけている。これのコピーを携えてシス管に泣きついてくるのが通常のパターンなので、そのときすぐ見られる場所に情報を書いておくっていうこと。

部品の完成度を上げておく

2007-12-27T23:11:00.001+09:00

やや大がかりな目的のためにプログラムを組むときは、それらの部品になるものから手をつけていき、その部品の完成度を上げることになるべくたくさんの努力を費やす。
それで、その部品を扱うことに安心感を持てると思う程度になったら、それらを次に組み立てて実際の仕事をする。
これがうまくいくと、安定した足場の上にいる気分で仕事ができます。これをうまくやれないと、組んだプログラムがまともに動かないことが増えて嫌になってきます。
安定した部品は自分用ライブラリとしてとっておき、必要に応じて引っ張り出して再利用すれば楽ができます。

僕自身はまだ自分のコードを再利用するのがあまりうまくないと感じていますが、もっとうまくやれるようになって、一度書いたことのある仕事はもう改めて書くまでもないくらいになりたいものです。

スクリプト言語で十分

2007-12-25T11:19:00.001+09:00

プログラムを書くというとC言語とかJavaとかそんなのを連想しがちだけど、もっとお手軽なスクリプト系でほとんどの場合十分です。もちろん仕事の種類によるんでしょうけど、たとえばシステム管理みたいな仕事では特にそうだと思います。
ここでスクリプト系ってのは、明示的なコンパイルの必要がない言語、って程度の意味で言っています。perl、python、VBscript、シェルスクリプト、そんな感じの。
スクリプト系言語は、書いて即実行してみて、手直ししてまた実行、というサイクルが短いので、楽に開発ができます。楽するために生まれた言語なんだから当たり前ですけど。
スクリプト系言語の弱点があるとすれば、「遅さ」がその最たるものじゃないかと思います。でも最近のコンピュータは動作がすごく速くなってますから、ちっとも問題になりません。仕事が遅くなるから思い切ってC言語で書き直しちゃおうか、と考えたことは一度もありません。それに、例えばネットワークがからむような仕事なら、一番遅い部分はコンピュータの処理速度よりそっちですから、何で書こうが同じですし。

「速さ」が問題にならないからには、やっぱり「楽さ」を基準に普段使いの言語を決めます。

大体C言語はとっても面倒です。Cマスター達には笑われるでしょうが、そんなレベルにはないんだから仕方ないです。

プログラマの美徳

2007-12-25T09:50:00.001+09:00

知っている人には有名なものですが、プログラマの第一の美徳は怠惰(laziness)だと言われています。perlの作者の言葉ですが。
プログラムを組む理由は、少なくとも仕事においては、何らかの楽をするためです。大量の決まりきった仕事、手順の込み入った仕事、正確さに気をつかう仕事、そんなものを自動的にやらせるためにプログラムを組みます。
人力で無理にやったって、できるにはできることばかりなんですよ。もっと極端に言えば、コンピュータにできる仕事で、人間にできないことはないです。効率の問題です。
プログラムを書くのは、自分の小さな分身を作ることに似ている気がします。分身でなくても、小人さん、使い魔、バイト君、なんと呼んでもいいですけど、それはあらかじめ与えられた指示を忠実に実行するシモベで、そいつがお決まりの仕事を片付けてくれるから主人がその分楽できます。
より複雑なプログラムが組めるようになれば、より臨機応変で優秀な分身君を使えるようになるわけです。だからプログラマは腕を磨きます。楽するために苦労するんです。

プログラムを書けない人もプログラムを書けるようになってみたくなりませんか？なりたいでしょう。あなたがプログラムを書いてくれれば、その分僕が楽できます。どうぞよろしく。どうすればプログラムが書けるようになるのか、それはいつか考えて述べてみたいです。

ところで「怠惰」の別の側面として、何度も同じ質問に答えなくてよいように、良いドキュメントを残そうとするということがあります。こっちは忘れる人が多いんだよな…がんばります。

そこにある言語を使う

2007-12-24T21:49:00.000+09:00

作業する環境は、自分の選択の余地がないときがある。
rubyをちょっと触ってみたら面白かったので、これから仕事用のスクリプトをrubyで書いてみようとしたとする。でも今の環境にはrubyがない、または満足なバージョンのものがない。それならサッサとあきらめて、そこで使えるperlかなんかを使う。
perlならperlで、何か特別な追加モジュールがあると便利なことがわかっていても、導入する前には本当に必要かを考え抜く。単に外部コマンドの出力を取り込んだりして済むのなら、そっちを優先する。稼動中のシステムに余分な要素が混入するのを極力避けたいから。ここらへんもKISSの原則だと思う。

これでもたいていの場合ちゃんと仕事になる。

そんな理由で、どんな環境でも「つぶし」の利くスクリプト言語として、今までperlに習熟してきた。サーバー上でもPC上でも、これひとつでどうにかなる。
でもそろそろ、pythonなんかを使っても大丈夫な気がしてきた。機種更新のときには、配布クライアントにperlだけでなくpythonをインストールするようにしておいてもよいかと思う。実際のところ、python好きなんだ。

KISSの原則

2007-12-24T00:06:00.000+09:00

システム管理をやっていて究極の願いは、「安定しますように」ということだと思う。
開発側だって同じに決まってるだろうけど。

変な不具合が出ませんように。スピードが極端に落ちませんように。
夜間バッチが朝までかかって業務が開始できなくなりませんように。

システムが安定するのに一番大事なことのひとつは、それがシンプルなことだろう。
KISSの原則とは、Keep It Simple, Stupid（単純なままにしとけ、バカ）を縮めたもので、これがシステムを設計する、または実装する際の重要な指針になる。迷ったら単純な解法を選んでおけば、たぶんそっちが正しい。複雑な工夫をシステム中に持ち込むと、その場では気の利いた感じがしたとしても、システムはきっと不安定になる。
発注する側は要求した仕様どおり作ってもらって満足だろうけど、それはバグが多いよ。
あとで結局改修の手間がかかって余計な損するよ。
または、ちょっとした手直しができなくなって、結果としてシステムが業務の実情を反映できなくなるよ。
または、担当者が変わったときなんかに、訳のわからないブラックボックスとしてしか扱えなくなるよ。ブラックボックスになると、マニュアルとほんの少し違う操作をする工夫もできなくなって、すごくストレスを抱えながらシステムを使う羽目になるよ。

KISSの原則を守れなくなるのは専ら「作らせる」ほうだけど、その原因はコンピュータが魔法の道具だと思ってるからだと思う。SEさん達は魔法使いで、望みをなんでもかなえてくれる。（で、不具合を出したらそれを無限に修正してくれる。）
そんなわけないのに。

ところで筆者は、'KISS'の解釈は、Keep It Simple and Stupid（単純でバカな状態にしろ）とするほうが好きです。バカというか、愚直なシステム。そのほうが、使う側で色々と工夫ができてよいです。「馬鹿とハサミは使いよう」なんて言葉もあるし。

社内SE

2007-12-22T21:53:00.000+09:00

開発会社でシステムを作っているときは、社内SEという立場の仕事に興味を持っていた。
あまり根拠があっての考えではないが、なんか社内SEって楽なのかな？って感じで。
だって、さすがに本職のSEほど過酷じゃないだろう…

で、現在の自分は、奇しくもその社内SEといってよい。なんだ大変じゃないか、この仕事も。
たくさんあってなお増えるコンピュータを相手に走り回る。品質の悪いシステムのお守りで頭を抱える。よく変わる環境にあわせて、前任者の書いた変な管理スクリプトを書きなおさせられる。一から書き直すほうが楽だったものも多数ある。（もちろん前任を責めるものではない。僕の書くスクリプトだって、別の人が見たら変なものに決まっている）
プリンタだの無線LANだのと、内輪からの無理難題をさばいて、やっとできた余り時間はよくわからないミーティングと書類作成に消える。
忙しい上に、求められる知識はオールアラウンド。
こういう状況はなんとかしなくてはなあと、いつも強く思う。どういう種類の「なんとか」なのかは、また追々。

昔受注者、今発注者

2007-12-22T20:05:00.000+09:00

以前システム開発の仕事をしていたことがある。
中小企業と呼べる程度の規模の会社だった。そこで色々な仕事をさせられて勉強したのが貴重な経験だった。時にはクライアントや上司からずいぶん無茶な要求を突きつけられたりして怒りを感じることもあった。発注者というのはなんと勝手なものだろうと思ったりした。
あれから数回の転職を経て、偶然ながら、今はシステム開発を発注する立場にいる。こちらの側に立ってみると、今度は発注した相手からロクでもないシステムを納入されて怒りを感じることになった。
どちら側に立っても損をした気分で腹を立てているのはどういうことだろう。片方の側にしかいたことがないのなら、相手側がなにかしら不誠実なせいだと思うところだが、自分の経験では、システムを開発するほうにしても発注するほうにしてもそれなりに誠実にやっていたと思う。なのに、win-winどころか、lose-loseな感じにさえなりかねないのはなんでだろう。
考えているところは色々あるが、そのうち述べていくかも知れない。

発注側の悩みとして、田邊氏の記事にある内容に全面的に共感している。発注側が、システムを開発するということについて知識が足りないときは、相当の確かさで悲劇的なことが起こる。

田邊稔. 打破！変わらない組織と動かないシステム～パイレーツ・オブ・ライブラリアンを目指して～. カレントアウェアネス. (294), 2007, p.7-10.

残高照会メモ

2007-12-21T18:34:00.000+09:00

メモでも残しておこうと思った。

ブログのタイトルには特に意味はないです。