taichino.com » python

DjangoでJinja2を使いたいという話

taichino — Wed, 12 Oct 2011 16:31:48 +0000

先ほどの記事にも書いたようにAppStatsは、Kay frameworkで途中まで書いたコードをDjangoに移植したんですが、その際にテンプレートエンジンの差異に少し戸惑いました。

Kayで採用されているjinja2はDjangoの標準テンプレートに良く似せて作られていて、Djangoを触った事があれば違和感無く使い始められます。ところがDjangoでイマイチな部分が解消されていて、一度jinja2を使ってしまうとDjangoに戻ってきた時にイライラしてしまうという問題が生じます。jinja2の何が良いかというと、例えばdjangoのドット記法はヤダとか、テンプレート中で関数呼び出しを見慣れている形で記述できるとか、デフォで{% macro %}が使える等などです。

正直macroなんかは一回使ったらもう同等機能がないテンプレートシステムなんて使えないです。という訳でDjangoでもjinja2を使いたいということで、調べた方法を記録しておきます。

ありがたい事にDjangoにはテンプレートのローダーをプラガブルに設定する仕組みが備わっています。なので下記のようなシンプルな手順でjinja2を使えるようになりました。

jinja2用のテンプレートローダを記述
– jinja2にKayのurl_forにあたるURL逆引き関数を設定
– jinja2にi18nの設定を行う
settings.pyに1のローダを指定

1. jinja2用のローダを記述
ローダはgistに張られていたコチラのコードをほぼ丸パクリさせてもらいました。修正したポイントは上記の2点です。まず今回Kayからの移植という事もあり、URLの逆引き関数が必要だったので、django.core.urlresolvers.reverseをテンプレート中で使えるようにしています。関数名はKayに合わせてurl_forました。もう一点はi18nの設定です。jinja2には国際化を行う為のクラスを指定する仕組みが備わっているので、そこにDjangoの翻訳モジュールを指定します。こうするとDjangoで作成できる.poファイルをjinja2からそのまま利用できます。

あと補足ですが、このローダは拡張子が.htmlのものをロードしません。なのでDjango標準のテンプレートとjinja2のテンプレートを共存させられます。

from django.core.urlresolvers import get_callable
from django.template import TemplateDoesNotExist
from django.template.loader import BaseLoader
from django.template.context import BaseContext
from django.conf import settings
from django.utils import translation
from django.core import urlresolvers
 
import jinja2
 
def monkey_patch_django():
    """
    Patching some django objects to make them "safe" for jinja's escape() function.
    Good for us it uses __html__() method.
    """
    # Django's SafeString and SafeUnicode should not be escaped:
    from django.utils.safestring import SafeData
    SafeData.__html__ = lambda self: self
 
    from jinja2 import escape
    from django.forms import BaseForm, Media
    from django.forms.forms import BoundField
    from django.forms.formsets import BaseFormSet
    from django.forms.util import ErrorDict, ErrorList
 
    for cls in (BaseForm, Media, BoundField, BaseFormSet, ErrorDict, ErrorList):
        cls.__html__ = lambda self: escape(unicode(self))
 
 
class Template(object):
    """
    A container for jinja2 Template class
    """
    def __init__(self, template, origin=None, name=''):
        self.template = template
        self.origin = origin
        self.name = name
 
    def render(self, context):
        if isinstance(context, BaseContext):
            d = {}
            for u in context.dicts:
                d.update(u)
        else:
            d = context
        return self.template.render(d)
 
class Loader(BaseLoader):
    is_usable = True
 
    def __init__(self, *args, **kwargs):
        """
        Creating jinja2 environment
        """
        assert hasattr(settings, 'TEMPLATE_DIRS'), 'Jinja2 template loader needs TEMPLATE_DIRS setting'
        monkey_patch_django()
 
        extras = self._get_env_extras()
        options = getattr(settings, 'JINJA2_ENVIRONMENT_OPTIONS', {})
        options['extensions'] = extras['extensions']
        options['loader'] = jinja2.FileSystemLoader(settings.TEMPLATE_DIRS)
 
        ### Some special tuning of jinja2 environment goes here
        # Number of compiled jinja2 templates in process memory
        options['cache_size'] = -1
        # Check whether template file is changed only in development
        options['auto_reload'] = settings.DEBUG
        # Use jinja's bytecode cache
        options['bytecode_cache'] = jinja2.FileSystemBytecodeCache(settings.BASE_DIR + '/tmp/jinja_cache')
 
        self.env = jinja2.Environment(**options)
        self.env.filters.update(extras['filters'])
        self.env.globals.update(extras['globals'])
        self.env.tests.update(extras['tests'])
 
        # 1. urlresolvers.reverseをurl_forとして登録
        self.env.globals['url_for'] = urlresolvers.reverse
 
        # 2. djangoの翻訳モジュールをjinjaに登録
        if 'jinja2.ext.i18n' in options['extensions']:
            self.env.install_gettext_translations(translation)
 
    def _get_env_extras(self):
        """
        Creates a dict of extensions, filters, globals and tests from settings
        """
        extensions, filters, objects, tests = [], {}, {}, {}
 
        # add the globally defined extension list
        extensions.extend(list(getattr(settings, 'JINJA2_EXTENSIONS', [])))
 
        # parse filters, globals and tests settings
        def from_setting(setting):
            retval = {}
            setting = getattr(settings, setting, {})
            if isinstance(setting, dict):
                for key, value in setting.iteritems():
                    retval[key] = callable(value) and value or get_callable(value)
            else:
                for value in setting:
                    value = callable(value) and value or get_callable(value)
                    retval[value.__name__] = value
            return retval
 
        filters.update(from_setting('JINJA2_FILTERS'))
        objects.update(from_setting('JINJA2_GLOBALS'))
        tests.update(from_setting('JINJA2_TESTS'))
 
        return dict(
            extensions=extensions,
            filters=filters,
            globals=objects,
            tests=tests,
        )
 
    def load_template(self, template_name, template_dirs=None):
        # Leave .html extension for django template (admin, contrib, etc)
        if template_name.endswith('.html'):
            raise TemplateDoesNotExist(template_name)
        try:
            template = self.env.get_template(template_name)
            return Template(template, None, template_name), None
        except jinja2.TemplateNotFound:
            raise TemplateDoesNotExist(template_name)
 
    def load_template_source(self, template_name, template_dirs=None):
        # Leave .html extension for django template (admin, contrib, etc)
        if template_name.endswith('.html'):
            raise TemplateDoesNotExist(template_name)
        try:
            source, filename, uptodate = self.env.loader.get_source(self.env, template_name)
            return source, filename
        except jinja2.TemplateNotFound:
            raise TemplateDoesNotExist(template_name)
</unknown>

2. settings.pyに1のローダを指定
次に1で作ったローダをsettings.pyに記述しましょう。同時にJINJA2_EXTENSIONSも記述します。
また自分のフィルタを追加する場合はJINJA2_FILTERSに追記すればOKです。

TEMPLATE_LOADERS = (
  'jinjalink_loader.Loader',
  'django.template.loaders.filesystem.Loader',
  'django.template.loaders.app_directories.Loader',
)
 
JINJA2_EXTENSIONS = (
  'jinja2.ext.with_',
  'jinja2.ext.i18n',
)
JINJA2_FILTERS = {
  ...
}
JINJA2_ENVIRONMENT_OPTIONS = {
  ...
}

以上でjinja2をDjangoから使えるようになりました。jinja2は本当に便利で、Django使うのがさらに楽しくなるのでオススメです。あとどうでも良いんですが、jinja2のテンプレートの拡張子って皆さん何使ってるんでしょうか。僕はもっぱら.j2なんですけど。

Hello Tcl/Tk World

taichino — Sun, 19 Dec 2010 23:44:21 +0000

GUIっぽい実験するのにTcl/Tkが良いんじゃないかっていう事で、ちょっとかじってみる事にしました。とりあえずtclでfizzbuzzやってみたのが以下になります。インタプリタのコマンドはtclshです。情報源としては公式ドキュメントのチュートリアルを最速文法マスター見ながらなめれば何となくならコード書けるかなぁと思います。

#!/usr/bin/tclsh
 
for {set i 1} {$i < 100} {incr i} {
    if {[expr $i % 15] == 0} {
	puts "$i: FizzBuzz"
    } elseif {[expr $i % 3] == 0} {
	puts "$i: Fizz"
    } elseif {[expr $i % 5] == 0} {
	puts "$i: Buzz"
    }
}

ついでにnabeatzzもやってみました。練習材料としてはfizzbuzzより遥かに優れているので、これから新しい言語触る時はとりあえずやっとけば良いんじゃないかと思います。

#!/usr/bin/tclsh
 
set numdic [dict create]
dict set numdic 0 [dict create 0 "ぜろ" ]
dict set numdic 1 [dict create 0 "いち" ]
dict set numdic 2 [dict create 0 "に"   ]
dict set numdic 3 [dict create 0 "さん" ]
dict set numdic 4 [dict create 0 "よん" ]
dict set numdic 5 [dict create 0 "ご"   ]
dict set numdic 6 [dict create 0 "ろく" 3 "ろっ"]
dict set numdic 7 [dict create 0 "なな" ]
dict set numdic 8 [dict create 0 "はち" 3 "はっ" 4 "はっ" ]
dict set numdic 9 [dict create 0 "きゅう"]
 
set digdic [dict create]
dict set digdic 1 [dict create 0 "" ]
dict set digdic 2 [dict create 0 "じゅう" ]
dict set digdic 3 [dict create 0 "ひゃく" 3 "びゃく" 6 "ぴゃく" 8 "ぴゃく"]
dict set digdic 4 [dict create 0 "せん" 3 "ぜん" ]
 
proc num2ja { num } {
    global numdic
    global digdic
 
    if { $num < 0 || $num > 9999 } {
	return "$num: あほなのでわかりませーん"
    }
    set len [string length $num]
    set n 0
    set ret ""
    while {$n < $len} {
	set place [expr $len - $n]
	set base [expr (10 ** [expr $place - 1])]
	set number [expr $num / $base]
	set numIndex 0
	set digIndex 0
	if { [dict exists [dict get $digdic $place] $number] } {
	    set digIndex $number
	}
	if { [dict exists [dict get $numdic $number] $place] } {
	    set numIndex $place
	}
	set strDigit  [dict get [dict get $digdic $place]  $digIndex]
	set strNumber [dict get [dict get $numdic $number] $numIndex]
	if { !($number == 0 || ($number == 1 && $place != 1)) } {
	    append ret $strNumber
	}
	append ret $strDigit
 
	set num [expr $num - ($base * $number)]
	set n [expr $n + 1]
    }
 
    return $ret
}
 
set cnt 40
if {$argc > 0} { set cnt $argv }
for {set i 1} {$i < $cnt} {incr i} {
    if {([expr $i % 3] == 0) || [string match *3* $i]} {
	puts "$i [num2ja $i]"
    } else {
	puts "$i"
    }
}

知ってる他の言語と、そこまで違いは無いんですが、変数の参照時のみ$が必要というのが面倒なのと、辞書にシンタックスシュガーがあったらなぁという印象です。あと[ ]で囲った部分が先に評価されて結果で置換されるのも特徴的で、関数呼び出し周辺はObjetive-Cみたいな見た目になります。

さてヨチヨチ歩きでtclが書けるようになったところでtkを試してみます。tkもtclと同様公式ドキュメントのチュートリアルがやけに気合いが入っていて、例題ごとにtcl, perl, ruby, pythonの各言語用のバインディングにあわせて解説がされています。pythonのバインディングのサンプルが手元で動かなかったのが残念ですが。。。

何はともあれ円が壁に当たったら跳ね返るサンプルが以下になります。あまり理解していませんがGUIなtclコード書く時はtclshではなくてwishを使うのが通例のようです。

#!/usr/bin/wish
 
package require Tk
 
proc random {{range 100}} {
    return [expr {int(rand()*$range)}]
}
 
wm geometry . 300x200
 
grid [tk::canvas .canvas]
grid configure ".canvas"
 
set radius [random 30]
set x 20
set y 10
set circle [.canvas create oval $x $y [expr $x + $radius * 2] [expr $y + $radius * 2]]
 
set v_x [expr [random 10] + 1]
set v_y [expr [random 10] + 1]
 
proc update {} {
    global circle v_x v_y
 
    set coords [.canvas coords $circle]
    set x1 [lindex $coords 0]
    set y1 [lindex $coords 1]
    set x2 [lindex $coords 2]
    set y2 [lindex $coords 3]
 
    set x1 [expr $x1 + $v_x]
    set y1 [expr $y1 + $v_y]
    set x2 [expr $x2 + $v_x]
    set y2 [expr $y2 + $v_y]    
 
    .canvas coords $circle $x1 $y1 $x2 $y2
 
    if { [expr $x1 + $v_x] < 0 || [expr $x2 + $v_x] > 300 } {
    	set v_x -$v_x
    }
    if { [expr $y1 + $v_y] < 0 || [expr $y2 + $v_y] > 200 } {
    	set v_y -$v_y
    }
    after 100 update
}
 
update

とりあえずtcl/tkを触ってみたものの、やっぱりtclよりpythonの方が使いやすいです。せっかくpythonバンディングが準備されているので上記のサンプルを書き換えてみました。タプルのおかげでシンプルに短く記述できますね。

#!/usr/bin/python
# -*- coding: utf-8 -*-
 
import Tkinter
import random
 
i = 0
root = Tkinter.Tk()
root.geometry("300x200")
 
canvas = Tkinter.Canvas(root)
canvas.pack()
 
(x, y, r) = (10, 20, random.randint(1, 30))
(v_x, v_y) = (random.randint(1, 10), random.randint(1, 10))
circle = canvas.create_oval(x, y, x+r, y+r)
 
def loop():
  global circle, v_x, v_y
  (x1, y1, x2, y2) = canvas.coords(circle)
  (x1, y1, x2, y2) = (x1 + v_x, y1 + v_y, x2 + v_x, y2 + v_y)
  canvas.coords(circle, x1, y1, x2, y2)
 
  if x1 + v_x < 0 or x2 + v_x > 300:
    v_x = -v_x
  if y1 + v_y < 0 or y2 + v_y > 200:
    v_y = -v_y
  root.after(100, loop)
loop()
 
 
root.mainloop()

結局tclじゃなくてpythonからtkを叩くことになりそうですが、tkはちょっとしたGUIアプリとか描画の実験なんかには重宝しそうです。もうちょっと色々と触ってみようと思います。

PythonでMovableTypeのXML-RPCインターフェースを叩く

taichino — Thu, 25 Nov 2010 16:53:31 +0000

MovableTypeにはXML-RPCインターフェースが準備されているので、外部から新しい記事を投稿したり過去の記事を取得したりできます。MT自体のリファレンスを探せなかったので、コチラのページを参考にさせて頂きました。

さてPythonでXML-RPCインターフェースを叩くのにはxmlrpclibを使います。まず以下でサポートしているAPIの一覧を取得してみましょう。これでXML-RPCのURLを確認できます。

import xmlrpclib
 
rpc_url = 'http://url/to/mt-xmlrpc.cgi'
api = xmlrpclib.ServerProxy(rpc_url)
print api.mt.supportedMethods()

次に記事の投稿をしたいのですが、その為にはユーザ名とウェブサービスパスワードが必要です。ログインパスワードでは無いので注意してください。僕はかなりハマりました。ウェブサービスパスワードはログイン後の画面の右上にある「こんにちは○○さん」をクリックすると遷移できる「ユーザ情報の編集」画面で確認できます。

ウェブサービスパスワードを確認したら記事を投稿してみます。ここで注意するべきなのはblog_idが文字列である事と、mt_text_moreで「キー名=値」とするとカスタムフィールドデータを渡せる事です。

import xmlrpclib
from pit import Pit
 
api_url = 'http://url/to/mt-xmlrpc.cgi'
 
blog_id = '1'
config = Pit.get('taichino@mt')
user    = configu['user']
passwd  = config['pass']
post    = {'title'        : 'title from xmlrpc',
           'description'  : 'this is a body and custom',
           'dateCreated'  : '2010-01-01',
           'mt_keywords'  : 'test, sample',
           'mt_text_more' : 'item1=abc'}
publish = False
api = xmlrpclib.ServerProxy(api_url)
api.metaWeblog.newPost(blog_id, user, passwd, post, publish)

以上で一応は記事の投稿ができましたが、投稿された記事を確認してみるとまだ問題があります。それはpublishをFalseにしているにも関わらず、投稿された記事が公開状態になっている事です。調べてみると、現バージョンのMTではpublishしないというのは再構築しないという意味で、公開せずに下書き状態にするという意味ではないようです。何とかならないかと調べてみると、mt-config.cgiに以下の設定を加える事で、publishがFalseの場合は下書き状態にできる事がわかりました。

# mt-config.cgiに以下を追加
 
NoPublishMeansDraft 1

これで無事にXML-RPC経由で投稿した記事が下書きで保存されます。他にも基本的なAPIはほぼ実装されていて、画像をアップロードしたり、記事を再構築したりというのができて便利なのですが、APIの仕様が汎用的な事もあり細かいところには手が届きません。(例えばアップロードした画像のasset idなどは取得できません) なので現時点で本気で外部からMTを制御する場合はXML-RPCインターフェースに加えてmechanizeなどのやや強引な手段も必要になるような気がします。

Hello Cython World

taichino — Sun, 24 Oct 2010 05:05:42 +0000

lxmlのソースを読もうとしたらcythonというPythonの拡張を書くためのPythonとCの間の子みたいな言語で書かれているという事で、全く知らないままだとlxmlのソースに挑む気が起こらなかったので少し調べてみました。まぁ調べてみたといってもcythonのドキュメントの最初に書かれているGetting Startedを舐めただけなんですけども。

まずcythonをインストールします。

$ easy_install cython

そして恒例のhello worldは以下になります。拡張子は.pyxを使うようです。

# hello.pyx
def say_hello_to(name):
  print 'Hello %s' % name

どう見てもPythonのコードなので楽勝なのですが、これを使えるようにsetup.pyを書かねばなりません。少しだけ面倒ですね。以下のように基本は通常のsetup.pyですが、cmdclassにbuild_extを指定する必要があります。

from distutils.core import setup
from distutils.extension import Extension
from Cython.Distutils import build_ext
 
ext_modules = [Extension('hello', ['hello.pyx'])]   # hello.pyxファイルからhelloモジュールを登録する
setup(
  name        = 'Hello world app',
  cmdclass    = {'build_ext':build_ext},
  ext_modules = ext_modules
)

続いてsetup.pyを使ってビルドしてみます。そうするとhello.cとbuildディレクトリが作成されます。ちらっとだけhello.cを見てみましたが、1263行もあったのでそっとファイルを閉じました。

$ python setup.py build_ext
$ ls
build           hello.c         hello.pyx       setup.py

ビルドが成功したら早速インストールします。

$ python setup.py install_lib

これで通常のpythonモジュールと同様にimportして実装した機能を使う事ができます。簡単ですね。

>>> from hello import say_hello_to
>>> say_hello_to('taichino')
Hello taichino

さて上記のようにpure pythonと同様のコードで拡張機能を書いても良いのですが(コンパイルされる分高速)、どうせCythonを使って拡張機能を実装するのであれば、高速化のためにCython独自の構文を使った方が良いようです。

以下のコードが次のサンプルになります。型とcdefやらcpdefといった呼び出し規約の明示を行っています。ついでにmathライブラリの機能も使っていますね。

cdef extern from "math.h":
  double sin(double)
 
cpdef double func1(double x):
  return sin(x*x)
 
cpdef double func2(double x):
  return x**2-x

外部ライブラリを利用する場合はsetup.pyにリンク情報を明示する必要があるようです。ビルドとインストールは先ほどと同じ手順になります。

from distutils.core import setup
from distutils.extension import Extension
from Cython.Distutils import build_ext
 
ext_modules=[
  Extension("sample",
            ["cython_func.pyx"],
            libraries=["m"])]
 
setup(
  name = "sample",
  cmdclass = {"build_ext": build_ext},
  ext_modules = ext_modules
)

折角なのでベンチマークを取ってみました。

#!/usr/bin/python
# -*- coding: utf-8 -*-
 
import math
from benchmarker import Benchmarker
import sample
 
def func1(x):
  return math.sin(x*x)
 
def func2(x):
  return x**2-x
 
def main():
  num = 50000
 
  # func1
  bm  = Benchmarker()
  # pure python code
  with bm('pure python'):
    for i in range(num):
      func1(i)
  # cython code
  with bm('cython'):
    for i in range(num):
      sample.func1(i)
  bm.print_compared_matrix()
 
  # func2
  bm = Benchmarker()
  with bm('pure python'):
    for i in range(num):
      func2(i)
  with bm('cython'):
    for i in range(num):
      sample.func2(i)
  bm.print_compared_matrix()
 
if __name__ == '__main__': main()

結果は以下のようになりました。まぁ速いには速いけどそこまで劇的でもない印象です。関数呼び出しのコストが高いみたいなので、Cライブラリを呼び出すなどして纏まった処理単位をラップすると効果が高そうですね。

                                  utime     stime     total      real
pure python                       0.050     0.000     0.050     0.028
cython                            0.017     0.000     0.017     0.014
-------------------------------------------------------------------------------
                        real      [01]     [02]
[01] pure python      0.028s        -    -50.6%
[02]      cython      0.014s    102.5%       - 
                                  utime     stime     total      real
pure python                       0.017     0.000     0.017     0.016
cython                            0.017     0.000     0.017     0.011
-------------------------------------------------------------------------------
                        real      [01]     [02]
[01] pure python      0.016s        -    -33.7%
[02]      cython      0.011s     50.8%       -

という事でイカツそうなCythonがほとんどPythonと同じで、怖くない事がわかったので、早速lxmlのコード解析に着手したいと思います。

Pythonで実行時間とメモリの測定をする

taichino — Sun, 03 Oct 2010 11:05:30 +0000

しばらくベンチマークコードを書いてなくてすっかり忘れていたので、メモ書きです。今回は例題として、yahooのこのページをBeautifulSoupとlxmlでのスクレイピング比較をしてみる事にしました。比較対象の関数は以下の通りです。どちらのコードも入力・出力ともに同じなので、どちらが実行時間やメモリ使用量が少ないのかを知りたくなりますね。

# BeautifulSoup
def scrape_with_bs(html):
  from BeautifulSoup import BeautifulSoup  
  soup = BeautifulSoup(html)
  rows = soup.find('table', attrs={'class':'channel9'}).findAll('tr')
  channels = rows[0].findAll('td', attrs={'class':'station'})
  programs = rows[1].findAll('td', attrs={'class':'turnup'})
  res = []
  for ch, prog in zip(channels, programs):
    res.append((ch.find('span').string, ch.find('a').string, prog.find('a').string))
  return res
 
# lxml
def scrape_with_lxml(html):
  import lxml.html
  root = lxml.html.fromstring(html.decode('utf-8'))
  rows = root.xpath('//table[@class="channel9"]/tr')
  channels = rows[0].xpath('td[@class="station"]')
  programs = rows[1].xpath('td[@class="turnup"]')
  res = []
  for ch, prog in zip(channels, programs):
    res.append((ch.xpath('span/text()')[0], \
          ch.xpath('descendant::a/text()')[0], \
          prog.xpath('descendant::a/text()')[0]) )
  return res

ちなみに上記の関数から得られる配列をprettyprintすると、以下の様な出力が得られます。各チャンネルごとに、今放送中の番組を取得しています。

[
    [
        "アナログ1ch", 
        "ＮＨＫ総合", 
        "ニュース"
    ], 
    [
        "アナログ3ch", 
        "ＮＨＫ教育", 
        "ハーバード白熱教室＠東京大学「イチローの年俸は..."
    ], 
    [
        "アナログ4ch", 
        "日本テレビ", 
        "真相報道　バンキシャ!"
    ], 
    [
        "アナログ6ch", 
        "ＴＢＳ", 
        "THE世界遺産「皇帝たちの地下宮殿」〜..."
    ], 
    [
        "アナログ8ch", 
        "フジテレビ", 
        "笑顔がごちそう　ウチゴハン"
    ], 
    [
        "アナログ10ch", 
        "テレビ朝日", 
        "ドライブ　A　GO!GO!「群馬格安温..."
    ], 
    [
        "アナログ12ch", 
        "テレビ東京", 
        "TOKYO　..."
    ], 
    [
        "アナログ14ch", 
        "TOKYO MX", 
        "芸術史と芸術理論( 10)第1回◇放送..."
    ]
]

さて、いきなり結論になりますが、書いたコードが以下になります。時間計測にtimeit、メモリ計測にguppyをそれぞれ使用しています。

#!/usr/bin/python
# -*- coding: utf-8 -*-
 
import sys
import timeit
from guppy import hpy
from prettyprint import pp
 
# BeautifulSoup
def scrape_with_bs(html):
  from BeautifulSoup import BeautifulSoup  
  soup = BeautifulSoup(html)
  rows = soup.find('table', attrs={'class':'channel9'}).findAll('tr')
  channels = rows[0].findAll('td', attrs={'class':'station'})
  programs = rows[1].findAll('td', attrs={'class':'turnup'})
  res = []
  for ch, prog in zip(channels, programs):
    res.append((ch.find('span').string, ch.find('a').string, prog.find('a').string))
  return res
 
# lxml
def scrape_with_lxml(html):
  import lxml.html
  root = lxml.html.fromstring(html.decode('utf-8'))
  rows = root.xpath('//table[@class="channel9"]/tr')
  channels = rows[0].xpath('td[@class="station"]')
  programs = rows[1].xpath('td[@class="turnup"]')
  res = []
  for ch, prog in zip(channels, programs):
    res.append((ch.xpath('span/text()')[0], \
          ch.xpath('descendant::a/text()')[0], \
          prog.xpath('descendant::a/text()')[0]) )
  return res
 
# load target html
def load():
  import urllib
  url = 'http://tv.yahoo.co.jp/listings/realtime/'
  html = urllib.urlopen(url).read()
  return html.decode('euc_jp', 'ignore').encode('utf-8')
 
def main():
  func_name = 'scrape_with_lxml' if 'lxml' in sys.argv else 'scrape_with_bs'
 
  # load data to scrape
  html = load()
 
  # measure time 
  setup = \
"""
from __main__ import load, %s
html=load()
""" % func_name
  timer = timeit.Timer('%s(html)' % func_name, setup)
 
  # print result
  print '%s result %f' % (func_name, timer.timeit(10))
  hp = hpy()
  print hp.heap()
 
if __name__ == '__main__': main()

また実行結果は以下の通りです。実行時間とメモリ使用量がとれていますね。本筋から外れますが、なんと実行速度に100倍近い差が出てます。メモリ使用量でもlxmlの方が少ないので、流石にlxmlの方が早いかな位で思ってたんですが、ここまで違うとは思いませんでした。lxml使える場合はlxml一択な雰囲気です。

$ python bm_test.py bs    # まずはBeautifulSoup
scrape_with_bs result 29.445319
Partition of a set of 96041 objects. Total size = 4762520 bytes.
 Index  Count   %     Size   % Cumulative  % Kind (class / dict of class)
     0  24263  25  1831800  38   1831800  38 str
     1  10210  11   785056  16   2616856  55 tuple
     2  50129  52   601548  13   3218404  68 int
     3    490   1   256760   5   3475164  73 dict (no owner)
     4    157   0   226268   5   3701432  78 dict of module
     5   2420   3   164560   3   3865992  81 types.CodeType
     6   2338   2   140280   3   4006272  84 function
     7    296   0   131680   3   4137952  87 dict of type
     8    296   0   128908   3   4266860  90 type
     9    209   0   104524   2   4371384  92 dict of class
&lt;112 more rows. Type e.g. '_.more' to view.>
 
$ python bm_test.py lxml  # 次にlxml
scrape_with_lxml result 0.399702
Partition of a set of 62306 objects. Total size = 4553468 bytes.
 Index  Count   %     Size   % Cumulative  % Kind (class / dict of class)
     0  26190  42  1991864  44   1991864  44 str
     1  10939  18   480916  11   2472780  54 tuple
     2    498   1   272472   6   2745252  60 dict (no owner)
     3    135   0   227796   5   2973048  65 dict of module
     4    459   1   199124   4   3172172  70 type
     5    459   1   184068   4   3356240  74 dict of type
     6   2599   4   176732   4   3532972  78 types.CodeType
     7   1836   3   149512   3   3682484  81 unicode
     8   2491   4   149460   3   3831944  84 function
     9    184   0   122528   3   3954472  87 dict of class
&lt;137 more rows. Type e.g. '_.more' to view.>

以上でとりあえずBenchmarkが取れます。ところが今までは不満に感じなかったのですが、流石にtimeitは不便すぎると思います。文字列で測定対象のコード渡すなんてインデント崩れてコードは汚くなるし、比較も簡単に出来ません。幾ら何でもこれはないです。Perlで言うところのtimetheseやcmptheseは無いの？と思って調べてみたら、Benchmarkerモジュールが見つかりました。これを使えばcmptheseのノリで実行時間の測定、比較ができます。

使い方は簡単で、withブロックの中に測定したいコードを書いて、print_compared_matrixを呼ぶだけです。

from benchmarker import Benchmarker
 
# 測定対象のコードなどは上記と同じです。
 
def cmp_with_benchmark():
  html = load()
 
  bm = Benchmarker()
  # BeautifulSoupの測定コード
  with bm('BeautifulSoup'):
    scrape_with_bs(html)
  # lxmlの測定コード
  with bm('lxml'):
    scrape_with_lxml(html)
 
  bm.print_compared_matrix()

すると以下の様な結果が得られます。これこそ欲しかった結果ですね。コードもすっきりしていますし、比較も簡単です。ついでにメモリの測定についてももう少し便利なモジュールが無いか探してみたのですが、見つかりませんでした。ご存知の方がおられましたら教えて下さい。

                                  utime     stime     total      real
BeautifulSoup                     5.200     0.183     5.383     3.242
lxml                              0.100     0.033     0.133     0.086
-------------------------------------------------------------------------------
                          real      [01]     [02]
[01] BeautifulSoup      3.242s        -    -97.4%
[02]          lxml      0.086s   3691.9%       -

長くなりましたが、以下がまとめになります。

実行時間測定にtimeitは使いづらいのでbenchmarker
メモリ使用量測定にguppy。でももっと良いモジュールないの？
lxml速すぎワロタ

なお100倍近い差が出ている上記測定結果はPython2.5.4上でのもので、Python2.6.1だとBeautifulSoupとlxmlの差は15倍程度でした。Python2.7.x、Python3.xではもっと速くなっているかもしれません。