白菜

博客搬新家

2010-04-10T15:30:00.003+08:00

鉴于blogger常年在墙外，严重影响了发贴的心情。终于搭建了自己的博客。 http://www.yi-programmer.com/blog/ 博客的成功运转跟下面这些光辉的名字是分不开，向创造这些东西的大牛们表示致敬，谢谢git，谢谢make，谢谢python，谢谢docutils，谢谢mako，谢谢pygments，谢谢latex。

2009-04-23T13:32:00.001+08:00

hello

学习Haskell

2009-04-20T18:23:00.001+08:00

学习Haskell

发现自己学习一门新语言的时候总是去尝试找到一个能完全表达这门语言的最小子集，然后其他的都是语法糖。比如c语言这个子集基本就是汇编语言所提供的那些东西：分支跳转指针等，python的这个子集大概是些对象、类型、属性、duck typing之类的东西。这样可以帮助记忆。haskell的这个子集里都会有些什么呢？lambda、type、typeclass，这样考虑起来 haskell 语言的核心概念还是挺少的，就是有些理论还需要学习，函数式的风格需要转换过来。

monad与状态

2009-04-20T14:19:00.002+08:00

monad与状态

最近重新捡起haskell来看了看，似乎对monad和程序状态的关系有点小小的明白了。强烈希望明白人指点一下。

话说用命令式语言写程序的时候，有明白人就强烈要求不要用全局变量不要用全局变量，其实要取消所有的全局变量也容易，不过就是增加几个参数而已，比如这样的程序：

int 全局变量=0;

void inc(){全局变量+=1;}

void dec(){全局变量-=1;}

void main(){inc(); dec();}

改成这样就成了：

void inc(int *变量){*变量+=1;}

void dec(int *变量){*变量-=1;}

void main(){int 全局变量=0; inc(&全局变量); dec(&全局变量);}

其实说起来，搞个全局变量也就是为了让函数少写几个参数而已。参数实在太多了，大不了就搞个 struct stat 把公用的参数给包装成一个。

函数式编程号称不准修改状态，那大不了就每次改都创建一份新的，然后返回了，这样程序就变成这样了：

void inc(状态,...){...; return 结果和新状态;}

void dec(状态,...){...; return 结果和新状态}

void main(){

初始状态;

新状态, 返回值 = inc(初始状态,...);

新状态2, 返回值 = dec(新状态,...);

}

这样所有函数都要多加一个状态参数，要多返回一个新状态。麻是麻烦点，不过据说都要玩并行计算了嘛，忍了。

那么可以把状态这个东西本身抽象了一下，我们用python来模拟一下吧，假设原来的程序是这样的：

global_stat = []
def inc1(stat, input):
    return stat+['inc1'], input+1

def inc2(stat, input):
    ...
    return stat+['inc2'], input+2

a = 1
new_stat, a1 = inc1(global_stat, a)
new_stat, a2 = inc2(new_stat, a1)

为了简化这个问题，我们引入一个 bind 函数来进行抽象：

def bind(func1, func2):
    def lazy_bind(stat, value):
        new_stat, return_value = func1(stat, value)
        func2(new_stat, return_value)
    return lazy_bind

# 然后就可以这样来调用 inc1,inc2...

bind(inc1,
bind(inc2,
bind(xxx,
...
))...) (init_stat, defaut_value)

就我们这个例子来说，后面这种方式除了让程序更加诡异以外看不出来有什么特别的好处。
但是对于 Haskell 来说，很多基本的东西（IO）都是构建与这种类型的抽象之上，并且提供一些语法糖让代码变得更好看，这样一种抽象方式也就成为理解haskell程序很重要的一个东西了。
而haskell之所以说能够通过这种抽象方式来隔离纯代码和有副作用的代码（比如说具体的IO操作）就我个人理解就是因为可以把有副作用的代码放到bind里面执行，从而保证 inc1、inc2 这种函数的纯粹性。

所谓日久生情

2009-01-20T15:20:00.000+08:00

不要怀疑，这个日就是你心里想的那个日，而且是被。意思是说，再郁闷的东西，被郁闷久了，也总能从中发掘出一些稍微好玩一点的东西出来。 http://huangyilib.googlecode.com/svn/trunk/doc/js_best_practice.html 当然，玩python的兄弟就不要点了，主要是用来忽悠没玩过动态语言的朋友的。

无题

2008-12-26T17:46:00.001+08:00

想起来也很久没有用python，尤其没有用来做web了，没想到还记得很清楚，不容易不容易。

linux下的半透明窗口

2008-11-12T00:31:00.002+08:00

为了做一个显示歌词的小玩意，学习了一把x window，我希望歌词窗口能背景透明但文字清晰显示。理论基础就是 composite window manager（比如compiz）支持窗口使用 alpha channel。那么应用程序只要整好rgba的图像交给x服务器即可。发现使用 gtk＋cairo＋pango 大大简化了工作。代码：http://code.google.com/p/huangyilib/source/browse/trunk/py_transparent_window.py

关于设计模式

2008-11-11T23:39:00.002+08:00

又看到关于设计模式的文章，突然联想到vim的作者说过一句大概是这样的话：学习vim的方法就是使用它，然后在使用过程中注意发现那些经常重复的行为，然后简化之。写程序的模式又何尝不是如此呢？只不过程序的事情更复杂罢了，那些重复的模式往往需要灵感来发现，简化的方法也总是不那么明显，甚至需要思维方式的彻底改变。

inkscape还是很好用的

2008-11-08T17:20:00.003+08:00

北京好远啊

2008-10-28T20:54:00.000+08:00

唉

工作后

2007-12-18T21:53:00.000+08:00

转眼来到腾讯有5个月了，博客也就长个5个月的草了。 china-pub 又给我送了几本书来，自然也就又有一百多块离开了我的身边。拿到书的时候心情自然是不用说，不过想起床上躺着上个月的科幻世界没看完时，却也着实让人发愁。有时间的时候没钱，有钱的时候没时间，人生啊！！！还有可爱的python也是许久没有贡献新东西了，真是惭愧，唉~~~

爆强的翻译

2007-09-26T20:46:00.000+08:00

第一次见到翻译得这么好的编程之道了：http://livecn.huasing.org/tao_of_programming.htm Prince Wang's programmer was coding software. His fingers danced upon the keyboard. The program compiled without an error message, and the program ran like a gentle wind. Excellent!" the Prince exclaimed, "Your technique is faultless!" "Technique?" said the programmer, turning from his terminal, "What I follow is the Tao -- beyond all technique. When I first began to program I would see before me the whole program in one mass. After three years I no longer saw this mass. Instead, I used subroutines. But now I see nothing. My whole being exists in a formless void. My senses are idle. My spirit, free to work without a plan, follows its own instinct. In short, my program writes itself. True, sometimes there are difficult problems. I see them coming, I slow down, I watch silently. Then I change a single line of code and the difficulties vanish like puffs of idle smoke. I then compile the program. I sit still and let the joy of the work fill my being. I close my eyes for a moment and then log off." Price Wang said, "Would that all of my programmers were as wise!" 程序员为公子王写软件，指飞键舞，不差丝毫，行之如风。公子王曰：『嘻，善哉！技盖至此乎？』程序员释键对曰：『臣之所好者道也，进乎技矣。始臣之编程之时，所见无非程序者；三年之后，未尝见程序也，见其子程序也；方今之时，臣以神遇而不以目视，官知止而神欲行，因其固然，程序自写之。诚然，尝至于难者，吾见其难为，怵然为戒，视为止，行为迟，改其一字，謋然已解，如烟随风。使之编译，释键而坐，为之踌躇满志，闭目而log off之。』公子王曰：『吾之程序员皆如此，则其善焉！』

实现一个 django 的 url dispatcher

2007-06-26T01:02:00.000+08:00

心血来潮，实现了一个 django 的 url dispatcher，比想象中简单多了。 http://djangodispatcher.googlecode.com/svn/trunk/mapper.py http://djangodispatcher.googlecode.com/svn/trunk/test.py 实际实现功能的代码才2、30行，功能基本完整，包括分层次的url配置，和发生异常时帮助调试用的一些信息。 PS：发现最近爱上了 Test Driven.

如何在醉酒的情况下编写正确的程序

2007-06-22T17:07:00.000+08:00

答案很简单：Test Driven。哈哈，这个（http://code.google.com/p/pylifegame/）就是好例子！醉了，不多说了，自己看去，我要睡觉去了，嗯 ...

Faint! 和我同名的编辑器

2007-06-20T12:17:00.000+08:00

Yi is a text editor written and extensible in Haskell. The goal of Yi is to provide a flexible, powerful and correct editor core dynamically scriptable in Haskell.

原来 pickle 这么有意思

2007-06-20T11:28:00.000+08:00

Pickle: An interesting stack language 原来 pickle 本身就是就是一个微型的基于栈的语言，呵呵，有点意思。研究一下 pickle.py 和 pickletools.py ，可以看到更细节的东西。

翻译了这篇文章

2007-06-20T11:26:00.000+08:00

Python 3000 进度报告也可以从 guido 的中文 blog 看到：http://blog.csdn.net/gvanrossum/archive/2007/06/20/1658829.aspx

Python 3000 Status Update (Long!)

2007-06-19T16:39:00.000+08:00

Python 3000 Status Update (Long!) by Guido van Rossum """ Summary Here's a long-awaited update on where the Python 3000 project stands. We're looking at a modest two months of schedule slip, and many exciting new features. I'll be presenting this in person several times over the next two months. """

老子毕业了

2007-06-08T23:47:00.000+08:00

http://picasaweb.google.com/yi.codeplayer/070608

SQLAlchemy Examples

2007-06-03T02:22:00.000+08:00

看 SQLAlchemy 自带的 zblog 的例子，可以看到 SQLAlchemy 一些非常有用的特性。

文章相关评论数统计

比如显示文章列表的同时我们希望获得相关文章的评论数，如果是用 django 那就只能放弃 ORM 的好处自己去执行 sql 语句了，否则就只会导致 n+1 条 SQL 语句的执行。在 SQLAlchemy 中你可以把任意的 select 语句映射到一个 class ，这样就可以用一条 SQL 语句搞定，还能获得 ORM 的好处，下面是原封不动拷过来的代码（只调整了下格式）：

   # Post mapper, these are posts within a blog.
  # since we want the count of comments for each post,
  # create a select that will get the posts
  # and count the comments in one query.
  posts_with_ccount = select(
      [c for c in tables.posts.c if c.key != 'body'] + [
          func.count(tables.comments.c.comment_id).label('comment_count')
      ],
      from_obj = [
          outerjoin(tables.posts, tables.comments)
      ],
      group_by=[
          c for c in tables.posts.c if c.key != 'body'
      ]
      ) .alias('postswcount')

  # then create a Post mapper on that query.
  # we have the body as "deferred" so that it loads only when needed,
  # the user as a Lazy load, since the lazy load will run only once per user and
  # its usually only one user's posts is needed per page,
  # the owning blog is a lazy load since its also probably loaded into the identity map
  # already, and topics is an eager load since that query has to be done per post in any
  # case.
  mapper(Post, posts_with_ccount, properties={
      'id':posts_with_ccount.c.post_id,
      'body':deferred(tables.posts.c.body),
      'user':relation(user.User, lazy=True,
               backref=backref('posts', cascade="all, delete-orphan")),
      'blog':relation(Blog, lazy=True,
               backref=backref('posts', cascade="all, delete-orphan")),
      'topics':relation(TopicAssociation, lazy=False, private=True,
               association=Topic, backref='post')
  }, order_by=[desc(posts_with_ccount.c.datetime)])

树形评论 映射如下：

   # comment mapper.  This mapper is handling a hierarchical relationship on itself,
  # and contains
  # a lazy reference both to its parent comment and its list of child comments.
  mapper(Comment, tables.comments, properties={
      'id':tables.comments.c.comment_id,
      'post':relation(Post, lazy=True,
               backref=backref('comments', cascade="all, delete-orphan")),
      'user':relation(user.User, lazy=False,
               backref=backref('comments', cascade="all, delete-orphan")),
      'parent':relation(Comment,
               primaryjoin=tables.comments.c.parent_comment_id==tables.comments.c.comment_id,
               foreignkey=tables.comments.c.comment_id, lazy=True, uselist=False),
      'replies':relation(Comment,
               primaryjoin=tables.comments.c.parent_comment_id==tables.comments.c.comment_id,
               lazy=True, uselist=True, cascade="all"),
  })

很多时候我们需要一次性获取对应一个文章的所有评论，可以用一条 select 先把数据取出，然后手动建立树形结构：

# we define one special find-by for the comments of a post, which is going to make its own
# "noload" mapper and organize the comments into their correct hierarchy in one pass. hierarchical
# data normally needs to be loaded by separate queries for each set of children, unless you
# use a proprietary extension like CONNECT BY.
def find_by_post(post):
  """returns a hierarchical collection of comments based on a given criterion.
  uses a mapper that does not lazy load replies or parents, and instead
  organizes comments into a hierarchical tree when the result is produced.
  """
  q = session().query(Comment).options(noload('replies'), noload('parent'))
  comments = q.select_by(post_id=post.id)
  result = []
  d = {}
  for c in comments:
      d[c.id] = c
      if c.parent_comment_id is None:
          result.append(c)
          c.parent=None
      else:
          parent = d[c.parent_comment_id]
          parent.replies.append(c)
          c.parent = parent
  return result

Comment.find_by_post = staticmethod(find_by_post)

multitask and Hive

2007-05-30T12:29:00.000+08:00

multitask multitask allows Python programs to use generators (aka coroutines) to perform cooperative multitasking and asynchronous I/O. Applications written using multitask consist of a set of cooperating tasks that yield to a shared task manager whenever they perform a (potentially) blocking operation, such as I/O on a socket or getting data from a queue. The task manager temporarily suspends the task (allowing other tasks to run in the meantime) and then restarts it when the blocking operation is complete. Such an approach is suitable for applications that would otherwise have to use select() and/or multiple threads to achieve concurrency. Producer/Consumer with multitask library Hive This is a basic concurrency module that uses only dependencies available in the Python 2.5 standard library. It allows the creation of a jobfile for uses to queue work that any number of worker processes with access to the jobfile can pull from the queue and run. 看到这两个库很快就联想到曾经写过的那段代码，python2.5 增强的 yield 表达式所蕴涵的 continuation 的能力似乎终于有人拿它来发挥点实际作用了。

Polymorphic Associations in Rails

2007-05-30T12:16:00.000+08:00

Polymorphic Associations with SQLAlchemy SQLAlchemy 老大展示怎么用 sqlalchemy 实现 rails 的 Polymorphic Associations 顺便看了下 Rails 所谓Polymorphic Associations 的介绍，才发现其实就是我很早就介绍过的 django 的 content-type app 所干的事情，app 就是插件的意思。

Python and vim: Two great tastes that go great together

2007-05-26T16:23:00.000+08:00

Python and vim: Two great tastes that go great together 用 python 扩展 vim ，想法倒是不新，不过第一次看到 tutotial 。记得 tocer 说过要用 python 写个 vim 库的，不知道有没有进展哈，呵呵。

Evolution of a Python programmer

2007-05-26T15:47:00.000+08:00

http://dis.4chan.org/read/prog/1180084983/ 哈哈，有点意思，再加一个： Python 2.5 programmer:

def fact(x):
    return x * fact(x - 1) if x > 1 else 1
print fact(6)

Elixir Examples

2007-05-22T02:47:00.000+08:00

有的时候在 blog 里写 wiki，有的时候在 wiki 里写 blog，有的时候在 blog 里发在 wiki 里写的 blog ;-)

多重继承真是好哇

2007-05-22T01:57:00.000+08:00

写 model 的时候发现有些东西在重复，第一反应就是写个基类，把这些重复的东西拿出来，然而 Model 类之间继承却不是那么方便的，应该会影响到 ORM 的行为。怎么办呢？幸好 python 有多重继承。下面就是项目中做这些重复事情的类：

class ModelMixin(object):
    def save(self):
        if not self.id: # creation time
            if hasattr(self, 'pubdate'):
                self.pubdate = datetime.now()
            if hasattr(self, 'pubtime'):
                self.pubtime = datetime.now()

        if hasattr(self, 'updatedate'):
            self.updatedate = datetime.now()
        if hasattr(self, 'updatetime'):
            self.updatetime = datetime.now()
        if hasattr(self, 'number'): # 今天第几次发布
            self.number = self.__class__.objects.filter(pubdate=datetime.now()).count()+1

        if hasattr(self, 'before_save'):
            self.before_save()
        super(ModelMixin, self).save()
        if hasattr(self, 'after_save'):
            self.after_save()

注意：django 将废弃 auto_add 和 auto_now 这些东西，认为太 magic ，建议在 save 中处理，所以上面这个类就更有用了。怎么用呢？

class Product(ModelMixin, models.Model):
    pubdate = models.DateField(u'...', editable=False)
    number = models.IntegerField(u'...', editable=False)
    ...

这样 pubdate 和 number 自然就有了相应的含义了。另外 ModelMixin 还定义了 before_save 和 after_save 的钩子，具体 model 可以在这两个方法里放点代码，比如：

    def before_save(self):
        self.totalprice = self.count * self.product.unitprice

...

    def after_save(self):
        if self._create:
            p = OutProduct(postuser=self.postuser,count=1,
                    pubdate=self.pubdate,mainproduct=self)
            p.save()

这些都是项目中直接拷出来的代码，具体意思你就慢慢猜吧，呵呵。多重继承的实现其实是个还算复杂的过程，复杂的多重继承也会产生一些奇特的行为，不过基本上只要遵守一些良好的习惯（比如常用 super ，虽然写起来有些繁琐），了解一些多重继承的基本原理，基本上不会遇到什么奇怪的问题了。关于 python 多重继承的实现，请看：The Python 2.3 Mehod Resolution Order

newforms 太好用了

2007-05-22T01:08:00.000+08:00

建一个项目 newformstutorials ，建一个 app blog ，在 blog 的 models 中定义个：

class Article(models.Model):
    title = models.CharField(u'标题', maxlength=255)
    author = models.CharField(u'作者', maxlength=20)
    hits = models.IntegerField(u'点击数', default=0, editable=False)
    content = models.TextField(u'内容')

配置好数据库，把 newformstutorials.blog 加到 INSTALLED_APPS，manage.py syncdb，然后 manage.py shell ，然后：

In [1]: import django.newforms as forms

In [2]: from newformstutorials.blog.models import Article

In [3]: ArticleForm = forms.form_for_model(Article)

In [4]: form = ArticleForm()

In [5]: print unicode(form)
<tr><th><label for="id_title">标题:</label></th><td><input id="id_title" type="t
ext" name="title" maxlength="255" /></td></tr>
<tr><th><label for="id_author">作者:</label></th><td><input id="id_author" type=
"text" name="author" maxlength="20" /></td></tr>
<tr><th><label for="id_content">内容:</label></th><td><textarea id="id_content"
rows="10" cols="40" name="content"></textarea></td></tr>

In [6]: print form.as_ul()
<li><label for="id_title">标题:</label> <input id="id_title" type="text" name="t
itle" maxlength="255" /></li>
<li><label for="id_author">作者:</label> <input id="id_author" type="text" name=
"author" maxlength="20" /></li>
<li><label for="id_content">内容:</label> <textarea id="id_content" rows="10" co
ls="40" name="content"></textarea></li>

一个空白的 form 就这样出来了，这就是个添加文章的表单，让我们用这个表单来加点数据吧：

In [7]: form = ArticleForm({'title':'some title','author':'huangyi'})

In [8]: form.is_valid()
Out[8]: False

In [9]: form.errors
Out[9]: {'content': [u'This field is required.']}

In [10]: form = ArticleForm({'title':'some title','author':'huangyi', 'content':
'some contents...'})

In [11]: form.is_valid()
Out[11]: True

In [12]: article = form.save(commit=True)

OK，数据就这样保存了，我们再来试试数据更新的页面吧：

In [13]: ChangeForm = forms.form_for_instance(article)

In [14]: form = ChangeForm()

In [15]: print unicode(form)
<tr><th><label for="id_title">标题:</label></th><td><input id="id_title" type="t
ext" name="title" value="some title" maxlength="255" /></td></tr>
<tr><th><label for="id_author">作者:</label></th><td><input id="id_author" type=
"text" name="author" value="huangyi" maxlength="20" /></td></tr>
<tr><th><label for="id_content">内容:</label></th><td><textarea id="id_content"
rows="10" cols="40" name="content">some contents...</textarea></td></tr>

In [16]: form = ChangeForm({'title':'another title', 'author':'huangyi', 'conten
t':'other contents...'})
In [17]: form.is_valid()
Out[17]: True

In [18]: form.save()
Out[18]: <Article: Article object>

In [19]: article = Article.objects.get(id=article.id)

In [20]: article.title
Out[20]: 'another title'

django newforms admin

2007-05-21T23:41:00.000+08:00

又用 django 做了个项目，因为主要都是后台的东西，所以决定启用 django 的 newforms admin 分支！(不过这里我不是推荐大家现在就开始用 newforms admin 分支，如果没有把握，最好是抱着玩玩的态度先，我在开发过程中就改掉它好几个bug) newforms admin 分支是用 newforms 来重构 admin 模块，也顺便改变了一些设计决策，大大增强了 admin 的可定制性。首先 newforms 的应用，成功分离了 db field、form field、widget 三个部分，db field 属于 ORM ，主要负责 model 相关的事务，form field 主要处理用户输入数据的验证，widget 负责渲染ui，似乎这里面还透着 MVC 的影子呢 ;-) newforms admin中可以方便地对 widget 进行替换，怎一个爽字了得。另外，新的 admin 把 admin 部分的定义从 model 中分离出来了，似乎写起来要麻烦点，不过好处也是显而易见的，首先是 model 定义更整洁了，其次新的 admin 设计成了一种重用性更好的形式，用得好的话还能省下不少代码呢，而且能够完成一些以前的 admin 很难完成的任务。新 admin 的核心在于 AdminSite 和 AdminModel，AdminSite 负责一些全局性的事务，比如首页，用户登录登出改密码权限控制，和model的注册，AdminModel 负责单个 model 的相关管理页面。这样做的好处是你可以继承这两个类，覆盖掉一些合适的方法，你基本上可以为所欲为。比如，我在这个项目中就写了这么几个自定义的 admin 类：

class CustomAdmin(admin.ModelAdmin):
    def before_save(self, request, instance, form, change=False):
        pass

    def save_add(self, request, model, form, post_url_continue):
        def custom_save(form, commit=False):
            instance = model()
            new_object = forms.save_instance(form, instance,
                    fail_message='created', commit=False)
            self.before_save(request, new_object, form)
            if commit:
                new_object.save()
                for f in model._meta.many_to_many:
                    if f.name in form.cleaned_data:
                        setattr(new_object, f.attname, form.cleaned_data[f.name])
            return new_object
        form.__class__.save = custom_save
        return super(CustomAdmin, self).save_add(request, model, form,
                    post_url_continue)

    def save_change(self, request, model, form):
        def custom_save(form, commit=False):
            from copy import copy
            new_object = forms.save_instance(form,
                    copy(form.original_object),
                    fail_message='changed', commit=False)
            self.before_save(request, new_object, form, change=True)
            if commit:
                new_object.save()
                for f in model._meta.many_to_many:
                    if f.name in form.cleaned_data:
                        setattr(new_object, f.attname, form.cleaned_data[f.name])
            return new_object
        form.__class__.save = custom_save
        return super(CustomAdmin, self).save_change(request, model, form)

大家应该可以看得出来，这个 admin 提供了 before_save 的钩子（当然你也可以提供 after_save 不过我这里暂时只需要 before_save），你可以继承它然后在这个方法里写些代码，就得在 model 保存之前得到执行。你可能要问，为什么不直接定义 Model 的 save 方法呢？答案很简单 Model 不知道 request 和 form 的存在！在 before_save 中你就可以做些很有意思的事情了，比如自动把 model 中某个字段设置成当前登录用户！这个定制需求其实很早就提出来了，以前的解决方案是写个 middleware 把 request 放到 threadlocal 中去，然后在 model 中通过 threadlocal 获取当前请求的 request ，能用，但是很麻烦也很丑。现在用这个 before_save 可以轻松实现：

class AutoUserAdmin(CustomAdmin):
    user_field_name = 'postuser'
    def before_save(self, request, instance, form, change=False):
        setattr(instance, self.user_field_name, request.user)
        super(AutoUserAdmin, self).before_save(request, instance, form, change)

当然你也可以继承这个 AutoUserAdmin ，写上你自己的 user_field_name ，太简单了。还有一个常见的定制需求就是限制登录用户只能看到自己发布的信息，看不到更不能修改别人发布的信息。在上面这个 AutoUserAdmin 的基础上做：

class RestrictUserAdmin(AutoUserAdmin):
    def queryset(self, request):
        queries = {self.user_field_name:request.user}
        return super(RestrictUserAdmin, self).queryset(request).\
                filter(**queries)

是不是超简单？呵呵。另外别忘了 python 还支持传说中的多重继承，意味着你可以同时继承多个 admin 类，并拥有多个 admin 类的组合功能。比如我这里定制了一个支持文件上传的 admin（newforms 和 newforms admin 暂时都还没有把文件上传相关的东西加进去，只能自己写），我把它叫做 FileUploadAdmin ，现在我希望我的 admin 能同时拥有 RestrictUserAdmin 和 FileUploadAdmin 的功能，没问题：

class CommonAdmin(FileUploadAdmin, RestrictUserAdmin):
    date_hierarchy = 'pubdate'
    list_per_page = 15
    ordering = ('-id',)

当然我还在里面定义了一些通用的（当然是对于我自己的项目来说） admin 配置。然后怎么把这些 admin 应用到 model 上去呢？

class ProductAdmin(CommonAdmin):
    list_display = ('__str__', 'type', 'unitname', 'unitprice',
        'qsinfo', 'postuser', 'pubdate', 'image_view')
    list_filter = ('type', 'pubdate')
)
admin.site.register(Product, ProductAdmin)

上面的代码虽然不错，不过我还是嫌麻烦，实际上我是这么写的：

admin.site.register(Product,
    CommonAdmin,
    list_display = ('__str__', 'type', 'unitname', 'unitprice',
        'qsinfo', 'postuser', 'pubdate', 'image_view'),
    list_filter = ('type', 'pubdate'),
    section_name = '通用',
)

不过要让上面的代码正常运行，还需要对 django newforms admin 分支的代码做一点小改动才行，在文件 django/contrib/admin/sites.py 中大约 73 行的位置：

          # TODO: Handle options

的下面加上：

          # it works
        if options:
            admin_class = type(admin_class.__name__, (admin_class,),
                    options)

实际上，使用 django 乃至 python 最大的快乐就是别人写的代码你都可以轻松看懂，这难道不是作为程序员最大的快乐吗？ ;-) 如果你现在开始用 django newforms admin 分支的话，估计遇到的大部分问题都是和 unicode 有关（因为我遇到的就是这样的），这是因为目前 django 的开发和 python 本身的开发一样，都处在整体向 unicode 迁移的过程之中，当前最大的矛盾就是 ORM 使用的是普通字符串(也就是 python3000中所谓字节数组)，而 newforms 却开始整体使用 unicode 了，这常常带来麻烦。如果你在基于 django 最新的 svn 版本开发，那一定要看一下 Unicode 分支了，里面说到了如何使让你的程序顺利过渡到 unicode ，祝大家过渡快乐 ;-)

好久没写blog了

2007-05-15T21:37:00.000+08:00

好久没写 blog 了，现在毕业论文终于敲定，可以长舒一口气 ;-)

写论文的时候，rst 可真是帮我不少忙，不过学校规定得交 doc 的版本，包括论文的格式什么的都是针对 msword 来说的，只好用 rst 生成 html ，然后拷贝到 msword。看到同学直接在 msword 里写论文，最后再痛苦地调整格式，窃喜 ;-)

继续我们可爱的python的写作，不过写到现在感觉自己还是不习惯写入门的东西，总是不自觉地想用最简洁的语言把所有东西都说出来（不过这倒符合python的哲学 = =" ），只好努力压下许多 python 的好东东了。

python3000与接口

2007-05-01T14:07:00.001+08:00

""" 要编写复杂软件又不至于一败涂地的唯一方法就是用定义清晰的接口把若干简单模块组合起来。 """ 抽象的说，其实接口、契约、协议、界面等等概念说的差不多都是一个意思。作为如此流行的被大规模使用的语言，python 一直没有这么个东西的标准实现，实在是一种遗憾，当然第三方的实现 zope.interface 其实早就在 zope 和 twisted 中大量应用了。 python 3000 中正在讨论的： pep 3119 Introducing Abstract Base Classes； pep 3124 Overloading, Generic Functions, Interfaces, and Adaptation；（还有 pep 3133 Introducing Roles ，不过暂时没看出它和 Abstracet Base Class 有啥大区别）希望向 python 中引入一些类型约束的能力，配合上已经被接受的 PEP 3107 Function Annotations 提议的语法，真是对 python 非常好的补充。甚至对其他动态语言也是非常好的一个启示！另外，啄木鸟上有 python3000 页面，欢迎大家在上面添加自己的想法 ;-)

新的 pep ！

2007-04-02T15:27:00.000+08:00

虽然我发晚了一点，但还是很值得一看的 PEP ;-)

突破 gwf 的封锁访问 blogger 的通用方法

2007-04-01T01:26:00.000+08:00

根据这篇文章给出的好办法，据说 ie 下也可以用。简单得说就是先下载这个代理文件，比如说你保存在 c:/proxy.pac，然后在 firefox 中选项 -> 高级 -> 连接配置 -> 自动配置代理url ，填入 file:///c:/proxy.pac 。如果有任何疑问看上面的连接以获得详细的配置办法！

trying out PyPy

2007-03-30T15:56:00.000+08:00

对 pypy 的简单试验，惊叹其优化的智能！

[有趣]Invasion Of The Dynamic Language Weenies

2007-03-27T09:52:00.000+08:00

Invasion Of The Dynamic Language Weenies 这文章很是耐人寻味，嘿嘿 ;-)

django and non programmers

2007-03-18T15:45:00.000+08:00

看了Are You Generic?，Django for non-programmers 两篇文章。 django 真是设计人员的福音啊！

字典与动态语言

2007-03-17T14:43:00.000+08:00

字典（或者叫哈希表、关联数组..）与动态语言的渊源可谓极深。动态语言之所以动态，归根结底是因为把对变量的求值放在了运行时完成而非静态语言的编译时确定。动态语言程序中众多的不同层次的名字空间（或者说作用范围）其实就是一个个的字典，变量名为 key，对象为 value。而对变量求值的过程就是对所在名字空间查找的过程，根据变量名，找出相应的对象，有时候在局部名字空间中没找到，还可能会自动跑到外部名字空间或是全局名字空间去找。对于支持 OO 的动态语言，对对象的实现其实也都是字典，属性名为 key，属性值为 value ，属性的获取也就变成了对字典的查找。有时子类中找不到还会到父类中去找，这也就是动态语言对继承的实现。 javascript 的 prototype 可能是动态语言实现继承最直接最简洁的方式了。python 为 OO 加了几个新语法，新概念，还有对多重继承的支持，不过本质上其实还差不多。字典的核心地位在 lua、javascript 中表现得最为明显，在 javascript 中字典和 object 其实就是同义词；在 python 中其实也不难找到字典的身影：locals()、globals()、还有(几乎)所有对象都有的 __dict__ 属性；ruby 这样的语言中这一点会藏得深一些。【以下为个人感受】字典是动态语言的灵魂，要使用好动态语言首先肯定是要认清这一点的，不过在实际软件开发中像 lua 一样直面字典编程未免太简陋了一些，javascript 稍微好点，python 完美，而 ruby 过了。

pypy 介绍

2007-03-12T17:06:00.000+08:00

前面写过篇介绍 pypy 的文章了，不过感觉有些东西还说得不够清楚也不够准确。 pypy 分为两部分：一个 python 的实现和一个编译器。 pypy 这名字说的就是这第一部分：用python实现的python。但其实这么说并不准确，准确得说应该是用 rpython 实现的 python ，rpython 是 python 的一个子集，不过不要搞混了，虽然 rpython 不是完整的 python ，但用 rpython 写的这个 python 实现却是可以解释完整的 python 语言。那为什么要用 rpython 来写这个 python 实现呢，这其实就涉及到了 pypy 的第二部分：编译器。这是一个编译 rpython 的编译器，或者说这个编译器有一个 rpython 的前端，目前也只有这么一个前端，不过它的后端却是不少，也就是说这个编译器支持许多的目标语言，比较重要的有：c, cli, javascript ... 而当我们把这两部分合起来看的时候，就能够发现 pypy 最重大的意义所在，当我们用这个编译器来编译这个用 rpython 写的 python 实现，我们能够得到什么呢？一个 c 写的 python 实现，一个用 .net 写的 python 实现（不过目前的 cli 后端还不能用来编译这个 python 实现） ... 我想这个介绍应该是比较简要了，pypy 的这两个大部分中都包含有许多有趣的内容，等玩得多些了再来介绍吧。 [update] 刚看到 pypy 0.99 发布的声明，其中说到编译后的解释器性能 twice the speed of the 0.9 release, overall 2-3 slower than CPython 。并且： It is now possible to translate the PyPy interpreter to run on the .NET platform . the JavaScript backend has evolved to a point where it can be used to write AJAX web applications with it. WOW!

pythonic cherrypy

2007-03-09T21:03:00.000+08:00

刚才看到这个页面：http://tools.cherrypy.org/wiki/InteractiveInterpreter，发现 cherrypy 还可以这样做，真是有点意思，正如作者所说： We think it showcases the pythonic nature of CherryPy. 不过那个视频使用的是cherrypy以前的版本，cherrypy3稍有不同，以下是我使用 cherrypy3 在 ipython 上实验的结果：

Python 2.4.4 Stackless 3.1b3 060516 (#71, Jan 27 2007, 21:48:58) [MSC v.1310 32
bit (Intel)]
Type "copyright", "credits" or "license" for more information.

IPython 0.7.3 -- An enhanced Interactive Python.
?       -> Introduction to IPython's features.
%magic  -> Information about IPython's 'magic' % functions.
help    -> Python's own help system.
object? -> Details about 'object'. ?object also works, ?? prints more.

In [1]: import cherrypy

In [2]: cherrypy.config.update({
  ...: 'autoreload.on':False,
  ...: 'server.log_to_screen':False
  ...: })

In [3]: class Hello(object):
  ...:     @cherrypy.expose
  ...:     def index(self):
  ...:         return 'hello world!'
  ...:     @cherrypy.expose
  ...:     def test(self):
  ...:         yield 'test1'
  ...:         yield 'test2'
  ...:

In [4]: hello = Hello()

In [5]: cherrypy.tree.mount(hello, '/')
Out[5]: <cherrypy._cptree.Application object at 0x00E2C0F0>

In [6]: cherrypy.engine.start(blocking=False)
CherryPy Checker:
The Application mounted at '' has an empty config.


In [7]: cherrypy.server.quickstart()
[09/Mar/2007:21:01:40] HTTP Serving HTTP on http://0.0.0.0:8080/

# 注释：此时可以访问 http://localhost:8080/ 和 http://localhost:8080/test 了。

In [8]: def test2(self):
  ...:     return 'test2'
  ...:

In [9]: Hello.test2 = cherrypy.expose(test2)
# 注释：此时可以访问 http://localhost:8080/test2 了！

真是方便那！

强大的 sqlalchemy

2007-02-07T04:29:00.000+08:00

sqlalchemy 的文档可谓典范，谁叫作者还开发着模板语言（myghty、mako）呢，呵呵。其实 sqlalchemy 的文档就是用 myghty 写的。

不过系统复杂了，功能多了，再好的文档也会让人迷路。最近用了用 sqlalchemy ，对这一点感受颇深，故把临时想到的几个比较常用的功能摘录如下，提纲挈领，既为自己整理一下思路，也让新手一窥 sqlalchemy 的精华。

Eager Loading Join，本是关系数据库中多么常见的操作，怎奈 django 的 orm 就是不支持，SQLObject 的做法也很不如人意。
Association Object many-to-many 关系都是通过增加一个中间表来实现，映射到对象后，这个中间表就不需要我们再操心了，会隐式地进行处理。不过对于多个实体两两之间多对多关系，往往另外再增加一个关联对象会更方便。这样的例子其实也不少，比如：user-bookmark-tags、产品-元件-元件供应商(这是一次期末考试题目里面的 ;-)
Deferred Column Loading 比如文章表里面的 body 字段通常比较大，在获取文章列表时这个字段就不必取出来了。甚至如果你有某个字段存的是文件的话，这个功能就更加重要了。这本是个不起眼的小功能，不过上次看到 javaeye 中有一贴说到大名鼎鼎的 Hibernate 都对这个功能实现得这么痛苦后，我蓦然发现 sa 真的很 nb。呵呵，托了动态语言的福了吧。
Mapping a Class with Table Inheritance 如何把对象间继承关系映射到关系数据库，sqlalchemy 提供三种方式： single table inheritance 所有子类型都放在一个表中； concrete table inheritance 每一种子类型存在独立的表中； multiple table inheritance 父子类型都存在独立的表中，查询的时候进行连接；显然最后一种是冗余最少的，不过查询的时候要做一次连接操作，如何选择还是看具体情况了。
Mapping a Class against Arbitary Selects 将对象映射到任意的 select，其实也就是任意的 sql 子查询。这功能太强大了，有了这个后，我们就可以骄傲地宣称，(几乎)没有什么是 sqlalchemy 做不了的了！
Identity Map session 在 sqlalchemy 中是一个非常重要的概念，session 跟踪对象的修改情况，跟踪对象之间的关联，智能判断数据库操作执行的顺序等等。 Identity Map 是 session 中一个容易让人掉入陷阱的概念，你可以把它想象成一个以数据表主键为key的cache。每次从数据库查询后，如果 sqlalchemy 发现 Identity Map 中已经有了相同主键的实例，那就不会重新生成实例了。因为如果存在多个实例会带来许多问题，比如多个实例分别修改并保存时就会产生混乱。偶尔 Identity Map 也会产生一些意想不到的行为，比如 ticket 458 ，不过理解了 Identity Map 的机理后，也就没什么问题了。值得一提的是，Mapper Options 有一个 always_refresh 参数，如果把它设为True，则对该 mapper 的任何查询操作都会自动使用从数据库中查询到的数据覆盖 Identity Map 中已有的实例，这样要是对旧实例做过什么还没保存的修改的话，就都没了。所以要慎用！
Cascade rules 最后这个也是很有用的功能，举个例子来说吧，user 和 article 有一对多的关系，现在删除一个 user，是否应该把相关的 article 也删了呢，要 article 还有其他的依赖关系呢？这些决定当然是要根据实际的需求来，而控制这些行为的方法就是通过 relation 的 cascade 参数，具体取值及其含义看文档去吧。

总滴来说，本文只是个提纲的作用，具体还得去看文档，看示例，看unittest。

最后还想说两句的就是，大家之所以选择 ORM ，主要原因是逃离 SQL，然而我感觉不能掌握 SQL 是不能(很好)掌握sqlalchemy的。至少要对关系数据库的这些概念了解，理解 SQL 就是理解关系数据库。只有这样才能利用sqlalchemy将关系数据库发挥到极致！

使用 sqlalchemy 的好处就是不用写 sql 了，屏蔽不同dbms之间SQL语法的区别，同时又让你在需要的时候能够利用到不同 DBMS 提供的一些独特特性，让你以对象的方式管理数据库访问代码，提高代码重用性！

Introducing Duck Typing

2007-02-07T02:50:00.000+08:00

用 google docs 写的：http://docs.google.com/View?docid=dczg8vtk_18gxgvgq&revision=_published

[豆瓣九点] 博客确认帖

2007-02-06T23:30:00.000+08:00

doubanclaim8bca4134ae01e52b 白菜的页面在这里：http://9.douban.com/subject/9031109/ 说实话，还不太会玩这个豆瓣九点，研究研究先。

Deploying Django

2007-02-05T22:48:00.000+08:00

Django Book Chapter 21: Deploying Django 肯定有许多人对这章的内容感兴趣 ;-) 这一章首先介绍了 django “Shared nothing”的设计哲学，这是django可扩展性的源泉。随后介绍了他们比较偏爱的典型配置：

操作系统用 Linux——特别是Ubuntu。
web 服务器用 Apache 和 mod_python。
数据库服务器用 PostgreSQL。

随后介绍如何配置 apache、mod_python 和你的django应用。教你如何在一个apache上部署多个django应用，如何把 mod_python 用做开发服务器，如何处理静态文件，如何处理错误等等。

随后还介绍了使用 fastcgi 方式部署 django 应用，不过这部分我不太感兴趣，就直接跳过去了。

然后，便是万众期待的 Scaling 了！一图胜千言：

最后还有很重要的一部分，调优，不过说来说去也还是那么几条了：

多买内存
关闭 Keep-Alive ，不过这一点只是大部分情况而已，具体还得看你网站提供的功能。
使用 memcached
积极参加各个开源产品的社区

ps: 有些日子没写blog了，刚考完，心一下就野了，什么计划都忘了，写一篇来凑凑数目 ;-)

使用 python 模拟 ruby 的 open class

2007-01-27T18:35:00.000+08:00

老早就写了这些代码，但一直懒得为它写篇博客，我觉得我永远也无法理解为什么会有人发明这种奇怪的东西。不过终于还是决定写一篇吧，多一点有意思的代码也许能吸引更多人对 python 的兴趣呢，呵呵。虽然我对 ruby 的这个东西有许多贬义词想说，不过想想既然有人用，也就应该有其理由吧。且看代码：

def update( klass, bases, attrs ):
    for k,v in attrs.items():
        if not k.startswith('__') or not k.endswith('__'):
            setattr(klass, k, v)
    if bases:
        klass.__bases__ = bases
    return klass

class Meta(type):
    def __new__(cls, klass, bases, attrs):
        try:
            return update( globals()[klass], bases, attrs )
        except KeyError:
            return type.__new__(cls, klass, bases, attrs)

# test
__metaclass__ = Meta

# test simple
class A:
    def say(self):
        print 'hi'

a = A()
a.say() # hi

class A:
    def say(self):
        print 'ho'
    def new_func(self):
        print 'new'

a.say() # ho
a.new_func() # new

# test inherit
#del A
#class A:
    #def say(self):
        #print 'hi'

#a = A()
#a.say() # hi

#class B:
    #def say(self):
        #print 'ho'

#class A(B):
    #def say(self):
        #super(A, self).say()

#a.say() # ho

update: 很遗憾，测试发现 new style class 貌似还有个 bug 。所以把后面部分注释了先，不知道 python2.5 怎么样。

用 jquery 加了点 js 效果

2007-01-26T12:36:00.000+08:00

代码超简单：

$(function(){
  $(".box h2").css('cursor', 'pointer');
  $(".box h2").click(
    function(e){
      $(this).next().toggle();
    }
  ).click();
  $(".post-title").css('cursor', 'pointer');
  $(".post-title").click(
    function(e){
      $(this).next().next().toggle();
    }
  ).click();
  $('#readerpublishermodule0 h3').css('cursor', 'pointer');
  $('#readerpublishermodule0 h3').click(
    function(e){
      $(this).next().toggle();
    }
  ).click();
})

ie sucks

2007-01-24T23:22:00.000+08:00

偶然的机会，在 ie 下看了一下今天的成果，才发现右边的 widgets 周围没有圆角，郁闷。只能是建议大家用 firefox 看了 ;-) 另外由于在 ie 下过长的单词会把 div 撑开，又不想用固定宽度，所以没办法，只好动用了 word-break: break-all; 也就是在需要换行的地方会把一个单词拆开，看的时候确实很不爽，不过没办法，在 firefox 下看就好了。要是你知道有什么好的 ie 下的解决方法，不妨告之，先谢了 ;-)

added google reader clip

2007-01-24T18:20:00.000+08:00

用 google reader 这么久，才发现它有这功能，看右边的 Starred Google Reader，那是我所有加过星的条目。另外看 google reader clip 的 css 效果不错，赶紧抄过来，现在右边全是这风格了，爽 ;-) 是不是好像和其他部分有点不太协调，不过要是全部搞成绿色的风格又觉得不太好，不管怎么说比以前还是好多了。

intergrate genshi with django

2007-01-22T13:17:00.000+08:00

写了个程序，用来在 django 中使用 genshi 模版： http://huangyilib.googlecode.com/svn/trunk/mashi_django/genshi_django.py

配置文件中通过元组 GENSHI_TEMPLATE_DIRS 指定模版存放路径；
会自动到已安装的 app 下的 genshi_templates 目录找模版文件；
DEBUG 为 True 时，启动模版的 auto_reload，否则关闭；

genshi 是个好模版，希望大家会喜欢。加上 genshi_django 后，就是名副其实的 mashi_django 了。发现什么问题，记得告诉我 ;-)

intergrate mako with django

2007-01-22T11:18:00.001+08:00

写了个程序，用来在 django 中使用 mako 模版： http://huangyilib.googlecode.com/svn/trunk/mashi_django/mako_django.py

配置文件中通过元组 MAKO_TEMPLATE_DIRS 指定模版存放路径；
另外自动到所有安装过的 app 下的 mako_templates 目录下找模版；
模版编译后的 python 代码默认和相应模版文件放在一个目录下面，然后在模版文件的文件名后面加 ‘.py’，你可以通过配置 MAKO_MODULENAME_CALLABLE callable 对象来定义你自己的 module 文件名生成方式，这个功能来源于 mako ticket 14 ，好像这是我第一个 ticket ;-)
如果在配置文件中指定 MAKO_MODULE_DIR 的话，所有编译后的 python 代码都会存到这一个目录里来。

mako 是个好模版，希望大家会喜欢。

[news] django moving towards 1.0

2007-01-22T11:06:00.000+08:00

都是些好消息 ;-)

There’s a lot of different things that “1.0” can mean. In many cases the label refers to some arbitrary measure of code maturity, but that’s usually very indistinct. There’s quite a bit of “1.0” software that’s far less robust than Django was at day 1; we could have called it “1.0” then and gotten away with it, I think.

In the context of Django, though, 1.0 has always meant something more concrete: forwards compatibility. Once we tag something as 1.0, we’re committing to maintaining API stability as described in the contributing HOWTO (http://www.djangoproject.com/documentation/contributing/#official-releases).

——摘自邮件列表

这个页面列出的是很可能会在 1.0 中出现的特性，还在讨论中。最近 django 还定了一套新的 ticket 管理流程，并且组织了一个 4 人的 ticket 管理队伍：

The last, most important, piece of the puzzle, is that we now have official ticket managers, a group of volunteers who work together to manage ticket metadata and otherwise streamline the process. Although anyone can -- and is encouraged to -- help out keeping tickets organized, these folks have volunteered to take ownership of the ticket tracker in the long term. Please welcome Chris Beaven (SmileyChris), Simon Greenhill, Michael Radziej and Gary Wilson!

另外现在还有了一名专门的 release 管理员，并且最近发布了 django 0.95.1。

do it runtime

2007-01-19T22:05:00.000+08:00

第一次从静态语言到动态语言的人肯定在思维上需要一个比较大的跳跃，主要是许多静态语言中编译器干的事情到动态语言中后，或是不存在了，或是需要在运行时进行。典型的例子包括：类型检查，重载，访问控制，常量。（暂时就想到这几个，还有一些代码生成的技术像define、template我们就不提了） 1、类型检查。

对于类型检查我想大部分人倾向于可选地进行，毕竟动态语言不是静态语言，duck typing还是给动态语言带来了巨大的灵活性的。 python对类型检查的实现只搜到这么一个：http://oakwinter.com/code/typecheck/ ，粗略看了一下文档，似乎已经相当完善了。

而我自己出于学习的目的也写了个超级简单的：http://huangyilib.googlecode.com/svn/trunk/typecheck.py，这个代码做为学习的材料也还是不错的。而且写完这个我自己也感觉对python的函数参数的处理机制有了更完善的认识。

给大家看下测试输出先，从中大家可以一窥其功能：

call temp(1, 'hello')
call temp(1, 'hello', c=4)
call temp(1, c=4, b='hello')
call temp(a=1, c=4, b='hello')

call temp(1, 2)
TypecheckError : the value 2 of argument 'b' is not type <type 'str'>

call temp(1, 'hello', c='hello')
TypecheckError : the value 'hello' of argument 'c' is not type <type 'int'>

call temp(1, c=1)
TypeError : temp() takes at least 2 non-keyword arguments (1 given)

temp() has not this keyword argument 'd'

the default value 1 of argument 'c' is not type <type 'str'>

temp() has not so meny arguments 4

test success

另外还值得一提的就是，python3000 中的 pep-3107 提议一种给函数增加元数据的方式：

def foo(a: 'x', b: 5 + 6, c: list) -> max(2, 9):

不过这个东西并非为类型检查而生的，类型检查只是它潜在的一个应用而已，它本身只负责存储元数据，具体元数据是啥和元数据怎么用由第三方库决定，其他潜在应用包括：文档生成、rpc、与静态语言之间的交互等等。 2、重载。关于重载首先要说的一点是 python 中灵活的参数传递机制可以减少大量使用重载的场景，不过剩下那些基于实参类型的重载python仍然无能为力。而幸运的是我们有PEAK，其中有个RuleDispatch便是干这事的，而Guido这篇博客：Python 3000 - Adaptation or Generic Functions?说到要把这东西加到python3k中去，也掀起一阵热烈的讨论，只不过在这里我们不叫它重载，叫它Generic Function，但实质是一样的，就是根据传入的不同类型的实参调用合适的函数，比如：

>>> class PrettyPrinter:
...     @generic
...     def pformat(self, object):
...         """Return the pretty string representation of object"""
...         return repr(object)
...
>>> @PrettyPrinter.pformat.when(object=list)
... def pformat_list(self, object):
...     s = '['
...     for item in object:
...         s += (' '*self.indent) + self.pformat(item) + ',\n'
...     return s + (' '*self.indent) + ']'
...

然后当调用

PrettyPrinter().pformat([1,2,3])

时，实际调用到的函数其实是下面那个pformat_list 。 3、访问控制。 python是不对属性做强制性的访问控制的，而是依赖于约定，一方面是坚持相信程序员的信条，另一方面我觉的是确实不好实现，程序中对属性的访问是如此的常见，如果在运行时进行检查，效率上损失太大，得不偿失。 ruby 是进行强制性访问控制的，对象所有属性都只能通过方法暴露，然后对方法进行访问控制，也就是说，每一次你访问一个对象暴露出来的属性，实际上你都是通过调用一个方法，而调用方法之前访问控制机制还要先判断该调用地点是否可以调用该方法！所以说ruby慢不光是因为它的实现慢，它的语言设计本身就慢！(如对 ruby 有误解，欢迎指出) 另外还有一个原因是ruby中函数不是第一型对象，可以调用函数但不能获取函数对象本身。python中函数是第一型对象，函数对象本身可以当参数传递，而且class中的方法其实只是普通的函数而已，完全可以把一个外部定义的函数对象交给class给它当方法用，这带来巨大的灵活性，但也使得这种情况下对方法实现访问控制是根本不可能！你想啊：在class外部定义的函数自然是不能访问 class 的私有属性的，但是当它作为class的方法后就突然变得可以了吗？ 4、常量。常量换句话说就是只读的变量，在静态语言中它也是通过编译器在编译期间对代码进行约束。那么在动态语言中又该如何来实现呢？这个问题最近在两个邮件里都提出来：请教：在python中要实现类似define的功能怎么办？，怎么不用property来实现只读属性？。最常见的方法莫过于使用property实现只读的属性：

>>> class Person(object):
...     def __init__(self, name):
...         self.__name = name
...     @property  # 只读属性
...     def name(self):
...         return self.__name
...
>>> p = Person('huangyi')
>>> p.name
'huangyi'
>>> p.name = 'another'
Traceback (most recent call last):
  File "<stdin>", line 1, in ?
AttributeError: can't set attribute

我记得我当时在邮件的讨论中就很详细得总结了一下各种做法，但是刚才去搜的时候，竟然发现它不见了！难道出现了幻觉？估计是gmail当时出了点问题。不过幸好我在另一个地方存了一份;-) 顺便把它改成了doctest的形式。下面直接粘贴一份语法加亮过的版本，你也可以在这里找到代码和语法加亮的html：

# -*- coding: utf-8 -*-
'''
感觉楼主的这篇和上次用 python 实现 define 的那篇帖子，想说的都是
一个东西，就是静态语言中的 const，第一次初始化后不能修改的东西。

说起来，python 对象中其实是有这样的东西，就是 imutable object 。
不过常量针对的是名字而非对象，所以在 python 中常量的准确定义应该
是：在第一次绑定后不能重新绑定其他对象的名字。

遗憾的是 python 中没有这样的东西。

其实和类型检查、访问控制等东西一样，静态语言中常量是通过编译器在
编译时进行检查，而 python 就算实现那也只能是在运行时进行计算，势
必损耗性能，我想这也是 python 中没有这样的东西的原因。

但是正如 python 中的访问控制是通过对名字的约定来做的一样，其实常
量也比较适合这样做。

如果实在要用动态语言模拟 const，那么关键在于对名字的绑定进行控制。

下面总结一下各种做法：
'''

def a_const_value():
   '''
    方法1是通过使用函数替代对名字的直接访问，好像是比较傻的方法。
    不过 ruby 中函数调用可以省略括号就有点像了

    >>> a_const_value()
    'const'
    '''
   return 'const'

class Temp(object):
   '''
    class 中通过 property 可以做得更漂亮：

    >>> t = Temp()
    >>> t.a_const_value
    'const'
    >>> t.a_const_value = 'another value'
    Traceback (most recent call last):
        ...
    AttributeError: can't set attribute
    '''
   @property
   def a_const_value(self):
       return 'const'

class ConstError(Exception):
   pass

class Consts(object):
   '''
    方法2是将常量名字放入一个 class 中统一进行管理：

    >>> consts = Consts()
    >>> consts.a = 2
    >>> consts.a
    2
    >>> consts.a = 3
    Traceback (most recent call last):
        ...
    ConstError: can't rebind const name

    不过需要注意的是，仍然可以通过 __dict__ 直接访问常量：
    >>> consts.__dict__['a'] = 3
    >>> consts.a
    3
    '''
   def __setattr__(self, name, value):
       if name in self.__dict__:
           raise ConstError, 'can\'t rebind const name'
       else:
           self.__dict__[name] = value

class ConstBase(object):
   '''
    或者让 class 自己指定那些是常量：

    >>> class Temp(ConstBase):
    ...     __consts__ = {'a':None, 'b':2}
    ...     def __init__(self, a):
    ...         self.a = a
    ...
    >>> t = Temp(2)
    >>> t.a
    2
    >>> t.b
    2
    >>> t.a = 3
    Traceback (most recent call last):
        ...
    ConstError: can't rebind const name
    >>> t.b = 3
    Traceback (most recent call last):
        ...
    ConstError: can't rebind const name
    >>> t.c = 5
    >>> t.c
    5

    使用这种方式，也可以直接通过 __dict__ 对常量进行修改：
    >>> t.__dict__['a']= 3
    >>> t.a
    3
    '''
   __consts__ = {}
   def __setattr__(self, name, value):
       if name in self.__consts__:
           if self.__consts__[name] == None:
               self.__consts__[name] = value
           else:
               raise ConstError, 'can\'t rebind const name'
       else:
           super(ConstBase, self).__setattr__(name, value)
   def __getattr__(self, name):
       if name in self.__consts__:
           return self.__consts__[name]
       else:
           return super(ConstBase, self).__getattr__(name, value)

if __name__ == '__main__':
   import doctest
   doctest.testmod()

new blog template

2007-01-17T22:04:00.000+08:00

哈哈，新年新模版！从 oswd 随便找了个没图片的模版改了改，open source 的东西就是好哇！越发感觉到 google 的 blog 做得专业，还专门给模版整了个模版语言，nb！

Build extensible application with egg

2007-01-16T11:00:00.000+08:00

在 python 社区中 egg 已经是一种广为人知的格式了。众所周知对于 python 来说 egg 是一种用来生小蛇的东西，小蛇自然就是 python 软件包了(纯属瞎扯 ;-)。简单地说，egg 之于 python 正如 jar 之于 java。是一种软件包打包的格式——要注意的是这个格式并非文件格式，实际上 egg 可以使用多种文件格式，当然最常用的还是 zip ——这里的格式主要是指组织其中包含的文件的格式。只是把软件包打包成 zip 格式的话，那就不足为奇了。egg 显然不光是用来干这个的，egg 最重要的作用是给软件包增加元数据！而元数据具体包含些什么内容和它的格式几乎没有什么强制的定义，这给基于 egg 的应用提供了大量发挥的空间。比如做PyPi软件包注册查找的机制、处理软件包之间的依赖关系等等，比如 setuptools 就是定义了一些元数据的格式，然后软件包的开发者只需按照这种格式把相关信息写进 setup.py ，setuptools 读取到这些信息后就可以帮你干这些事情了。除此以外，我觉的 egg 最有意思的应用莫过于做为插件系统了。相信把 egg 做为插件系统来用的几个框架大家应该都了解，像 turbogears 的模版插件系统，paste 的可扩展的项目模版，还有 trac 的插件系统等。一个插件系统莫过于这么几个步骤：框架首先定义一个/些插件的接口；第三方插件替你实现这个/些接口；插件注册；框架发现并使用插件。而 setuptools 和 egg 便可以帮你完成后面两个最麻烦的步骤：注册和发现。先来看个效果，以下代码能帮你找到你安装过的所有 paste 项目模版(下面用到的 pkg_resources 模块安装 setuptools 后就有)：


In [3]: import pkg_resources

In [4]: pts = list( pkg_resources.iter_entry_points('paste.paster_create_templat
e') )

In [5]: pts
Out[5]:
[EntryPoint.parse('pylons_minimal = pylons.util:MinimalPylonsTemplate'),
EntryPoint.parse('pylons = pylons.util:PylonsTemplate'),
EntryPoint.parse('myghty_modulecomponents = myghty.paste.templates:MCTemplate')
,
EntryPoint.parse('myghty_simple = myghty.paste.templates:SimpleTemplate'),
EntryPoint.parse('myghty_routes = myghty.paste.templates:RoutesTemplate'),
EntryPoint.parse('basic_package = paste.script.templates:BasicPackage'),
EntryPoint.parse('paste_deploy = paste.deploy.paster_templates:PasteDeploy'),
EntryPoint.parse('toscawidgets = toscawidgets.util:ToscaWidgetsTemplate')]

In [6]: pts[0].name
Out[6]: 'pylons_minimal'

In [7]: pts[0].module_name
Out[7]: 'pylons.util'

In [8]: pts[0].attrs
Out[8]: ('MinimalPylonsTemplate',)

In [9]: pts[0].load()
Out[9]: <class 'pylons.util.MinimalPylonsTemplate'>

可以看到最后一步我们就在运行时加载了那个实现了 paste 所定义接口的类。注册的过程就更简单了，把 entry_points 元数据往 setup.py 里一填，setup.py install 一装就 ok 了。这个过程中使用到的元数据叫做 entry_points ，entry_points 的格式很简单，其实就是 ini 的格式，一个 group 对应多个 name，


[group_name]
...
...

pkg_resource 中将 name 的格式定义为：

name = some.module:some.attr [extra1,extra2]

而 group_name 则由框架定义，其实就是对应一个接口，插件只需要将自己实现了这个接口的类列在下面，然后 setup.py install 一装，就 ok 了。现在 setuptools 和 egg 已经帮你干完了这些麻烦事，你还需要做的事情就只剩下：设计你的系统，定义你的插件接口。

Recently...

2007-01-13T19:59:00.000+08:00

没啥要紧事写的时候就起这个标题：Recently... ;-) 现在开始为下一个学期做点计划了，下学期看来就是我待在学校的最后一个学期了(也是最闲的一个学期;-) 一毕业就得去公司报到了，连暑假都没得过 ;-) 不如就把下个学期当作是我过的最后一个“暑假”吧。虽然是“暑假”但也不能闲着啊，想干的事情还有一大堆呢：

昨天邮件列表又见 ZoomQuiet 提起 Leo ，再次对文学编程思考了一番，越发觉得有其合理之处。Leo 的核心就在于 outline ，它可以用来表达任何事物之间逻辑上的关联，这使得 Leo 拥有了难以置信的灵活性，你可以用它来组织管理许许多多的东西。而同时它能将这种逻辑上的关联与物理上的文件(代码、文档等)联系起来，并能做到两者之间的同步，这使得它可以当个 IDE 来用！今天看 Leo 的网站的时候，惊喜地发现文档多了不少(上次就是文档不够在短暂地接触leo后就离开了)，这个在线教程做得非常棒，并且有了一大堆的 plugin 了。打算找时间好好研究下这东西。
使用 vim 的时间也不算短了，可还是时常感觉不能够运用自如，想来主要原因在于还没系统地看过 vim 的文档，而最缺的一块就是vim插件的编写了，等把这个搞定应该就能够达到运用自如的境界了吧。
在 python 社区里面混，竟然都不会玩 linux，整体用着个盗版 xp，自己想起来都觉的惭愧 = =" 。下学期要试着在 linux 下面工作入下门了。
毕业就要去公司了，c/c++ 还是得先搞一搞，python 当然还是要宣传的，不过毕竟是公司，肯定不能完全顺着自己的喜好来。
Pylifes 项目一放就是半年没动了，下学期的毕业设计尽量给它找个合适点的题目，继续搞。

写了个方便下载 tudou 网视频的小程序

2007-01-09T19:33:00.001+08:00

http://huangyilib.googlecode.com/svn/trunk/tudou_dl.py 只要给它视频播放页面的地址，比如： http://www.tudou.com/programs/view/AmYV7YnHqBU/ 它能帮你找出实际的 flv 视频下载地址： http://hot.tudou.com/flv/003/900/922/3900922.flv#81100#1 这可是我辛辛苦苦反编译了它的 flash 播放器的代码才找到的方法啊，希望 tudou 不要太快升级才好 ;-)

Recently...

2007-01-03T19:58:00.001+08:00

最近——正在翻译 Text Process in Python 附录A：选择性的令人印象深刻的 python 简短回顾这算是本老书了，可惜以往总是瞟一眼那短小的目录就感觉似乎都懂，没啥好看的，所以一直都没正眼瞧过它，最近偶然仔细看了几眼却惊喜地发现这竟是本不可多得的好书。就说这篇附录吧，我发现它正是我一直在寻求的对 python 的超精简的但绝不失深度的介绍。更别说书中还有大量的高质量的(pythonic的) python 程序。我想这篇附录最适合让已经有丰富的其他语言编程经验，甚至是有丰富的动态语言编程经验的兄弟来快速掌握 python 语言的精髓的了！最近——惊现新的模版引擎 mako (http://www.makotemplates.org/) ，myghty 杀手啊！估计最吸引眼球是它那个 benchmark 了： Mako: 0.90 ms Myghty: 5.25 ms Cheetah: 0.70 ms Genshi: 12.53 ms Django: 5.43 ms Kid: 19.12 ms Cheetah above gets a speed boost from native C extensions, whereas Mako is pure Python. 恐怖啊！ genshi 刚成取代 kid 之势，看来 myghty 就快要被 mako 取代了，呵呵。 genshi/kid 的特点在于方便灵活的 xml 生成；mako/myghty 是用来生成任意形式的模版的，特点在于将 python 语言优雅地植入到模版中，并且将模版编译成 python 代码，获得极高的性能。而这两组中的前者都超越了后者一大步！难道 genshi 和 mako 要平分(django以外的)模版世界了？拭目以待。另外由于 mako 将模版查找的逻辑抽象到灵活的 TemplateLookup 里面 (窃以为是学习了 django 模版的思想)，我想在要在 django 的基于 app 的架构中应用 mako 模版应该不是难事，有机会要尝试一下。再另外 mako 模版还吸收了 django 模版中的 filter 的概念。最近—— cherrypy3.0 发布了 ( http://cherrypy.org/wiki/WhatsNewIn30)，大量的重构！我感兴趣的变化首先是："CherryPy 3 is much faster than CherryPy 2 (as much as three times faster in benchmarks)." 其次就是 web 服务器和逻辑服务器的完全分离了，说 cherrypy 的 web 服务器是目前最优秀的 wsgi服务器应该没有人会反对 ;-) 另外："cherrypy.Application objects are now WSGI applications"，也就是说 cherrypy 的 url dispatcher 直接处理的就是 wsgi 应用程序了，好处不言自明，呵呵。另外，刚又发现了这篇文章 cherrypy 3 has fastest WSGI server yet. 和 aspen：一个基于 cherrypy wsgi server 的 web server，目的是方便各种风格的 web 应用程序以统一的方便的 pythonic 的方式进行部署。直到最近——才发现原来 routes 已经支持了 REST 形式的 dispatch 了，跟 rails 还跟得挺紧，呵呵。还发现不少新特性： # Sub-domain support built-in # Conditional matching based on domain, cookies, HTTP method (RESTful), and more # Easily extensible utilizing custom condition functions and route generation functions

理解 python 的 method 和 function 兼谈 descriptor

2006-12-31T15:41:00.000+08:00

总是看到有人对 python 中的 method 和 function 之间关系的困惑，其实初学 python 时我也困惑过，不过现在自认为对这个问题还是基本清楚了 ;-)。

我在前面写过的 selfless python 里面说过 method 本质上就是 function，这个从它们的形式上也看得出来，呵呵，而让人困惑的问题主要就是那个隐式传入的 self 参数。这其实是利用了descriptor 机制，请看代码：

>>> class Temp(object):
...   def test(self, a):
...     print self, a
...
>>> func = Temp.__dict__['test']
>>> func
<function test at 0x00B48170>
>>> func(1, 2)
1 2

由此可见 test 就是个不折不扣的函数！

>>> Temp.test
<unbound method Temp.test>
>>> t = Temp()
>>> t.test
<bound method Temp.test of <__main__.Temp object at 0x00B46CD0>>

但是这又是怎么回事了？哪里冒出个 bound/unbound method 来了？

>>> dir(func)
['__call__', '__class__', '__delattr__', '__dict__', '__doc__', '__get__', '__ge
tattribute__', '__hash__', '__init__', '__module__', '__name__', '__new__', '__r
educe__', '__reduce_ex__', '__repr__', '__setattr__', '__str__', 'func_closure',
'func_code', 'func_defaults', 'func_dict', 'func_doc', 'func_globals', 'func_na
me']

请注意其中的 __get__ 方法，这就是 descriptor 的标志(任何定义了 __get__, __set__, __delete__ 三个方法中的一个或几个的对象都是 descriptor ，这几个方法的意思大家应该能猜到了) 根据对象 attribute 的查找策略，当 t.test 时，首先根据 attribute查找策略找到这个函数对象，然后会发现它有 __get__ 属性，则调用之，并把它的返回值当作该 attribute 的值。

Temp.test 等价于 Temp.__dict__['test'].__get__(None, Temp)
t.test    等价于 Temp.__dict__['test'].__get__(t, Temp)

其实你可以把 func.__get__ 的实现想象成下面这个等价物：

>>> class Function(object):
...     def __get__(self, obj, objtype=None):
...         import types
...         return types.MethodType(self, obj, objtype)

到这里事情已经比较清楚了，不过还有一点可能仍然会让你感到困惑：

>>> Temp.test = test

>>> t.test(1)
<__main__.Temp object at 0x00B46E90> 1
>>> t.test = test
>>> t.test(1)
Traceback (most recent call last):
File "<stdin>", line 1, in ?
TypeError: test() takes exactly 2 arguments (1 given)
>>> t.test
<function test at 0x00B42A30>

咦？不是说 function 是 descriptor 的吗？怎么这里没有去调用它的 __get__ 方法呢？

另外：

>>> class Meta(type):pass
...
>>> class Temp(object):
...   __metaclass__ = Meta
...
>>> class Desc(object):
...   def __get__(self, instance, type):
...     print instance, type
...
>>> desc = Desc()
>>> Meta.d = desc
>>> Meta.d
None <class '__main__.Meta'>

>>> Temp.d
<class '__main__.Temp'> <class '__main__.Meta'>
>>> Temp.d = desc
>>> Temp.d
None <class '__main__.Temp'>
>>> t = Temp()
>>> t.d
<__main__.Temp object at 0x00B46DD0> <class '__main__.Temp'>

>>> t.d = desc
>>> t.d
<__main__.Desc object at 0x00B46D30>

注意到，到最后一步 t.d 的时候也没有对 descriptor 求值。这个道理和上面那个是一样的，仔细看一下 attribute 查找策略 就可以找到答案了， descriptor 只有绑定在 type object 上才有效。

这里我们涉及到了 python对象一种分类： type object 和 非 type object ，这两种对象在 attribute 查找过程中的待遇是不一样的。

简单地说 type object 包括 type, type 的子类( 也就是 metaclass 了 )、 type 的实例( 也就是 class 了 )

一般来说 type object 和 非 type object 不光在 attribute 受到不平等待遇，而且非 type object 还不能成为其它对象的基类型，想成为 metaclass 更是痴心妄想了。

不过就像我以前说过的那样，python 中的对象本质上都是平等的，区分它们的唯一方法是它们的接口，所以我相信所谓 type object 与 非 type object 的区别也只在于接口而已。也就是说只要实现 type object 所需的接口，任何对象都可以成为 type object 。

参考：

How-To Guide for Descriptors

Python Attributes and Methods

突然想到之 ajax 和 REST

2006-12-28T20:01:00.000+08:00

在最近做的 django+jquery 的开发过程中，突然想到：

感觉有一些框架中自带的一些用来生成 javascript 的 helper 库的作用实在相当有限(至少对于我现在做的，它们完全帮不上忙)。他们应该也就在一些超级简单的 ajax 场景中能发挥一点作用，而对于这些简单场景，使用 jquery 写出来的 javascript 代码还不一定会比 python/ruby 的多。
其次是关于所谓的 REST 。当然首先申明，我对 REST 了解并不是很深入，我只是就我所知的发发牢骚而已，所以，欢迎大家拍砖 ;-) REST 本身其实是 web 成功以后从中总结出来的一些东西，也就是说 web 其实一直以来就是 RESTful 的。不过这里说的是老的 web，或者说是“web1.0”，在那个时代说 resource+uri+CRUD 就是一切似乎还是挺恰当的。不过现在 web 升级了，原来的瘦客户端现在也越来越“富”了，简单的 resource + CRUD 的概念还足以描述现在（以及将来）的 web 世界吗？当然，也许 REST 并不如我所想的这么简单 ;-)

python virtual machines

2006-12-24T16:09:00.000+08:00

Jython，IronPython，PyPy。这几个项目相信玩过 python 的兄弟都不会陌生。Jython 好像是没有继续下去了，就不多说了。IronPython 和 PyPy 两个项目现在都正是如日中天的时候，都有许多让人兴奋的进展！先来看看 IronPython 吧。在讨论之前，我们不妨先下这么一个定义，对于 python 来说，通常说让它支持某个平台，不光是要让 python 程序能够在该平台上运行，更重要的是 python 程序要能与这个平台进行互操作！我们说 python 是跨平台的，是因为 CPython 不光能让 python 程序运行在不同的操作系统上，更可以通过一定的接口与 c 语言进行互操作，其实也就是和操作系统平台进行互操作了。但是如果把 .net、java 两个也看作是平台的话，就更有意思了。.net 和 java 是两个特殊的平台，它们构建于操作系统平台之上，而且它们本身已经拥有了一些比较高级的抽象，比如OO、自动内存管理等。固然，在它们上面实现 python 的时候，某些问题可以(比如内存管理)不用再考虑了，但是解决 python 与这个两个平台之间互操作的问题仍然艰巨。问题的关键还是在于静态与动态的区别，或者说编译期与运行期之间的区别。就拿对 OO 的实现来说吧，静态语言和动态语言就大不一样，比如说静态语言中对象的属性在运行时其实只是编译器算出来的相对对象基地址的一个偏移，取属性值的过程只是个对地址做加法的过程；而 python 的属性却是实打实的 key:value ，名字和值都存在内存中，取属性值的过程实际上是个查哈希表的过程。如何才能让这两种 OO 系统之间的对象之间可以互相使用，甚至进行组合、继承？另外这两个平台本身也拥有一些自己独特的特性，比如元数据、.net的 attribute、delegate 等，如何让 python 对象拥有这些特征？这些问题就成为 Jython 和 IronPython 要解决的关键问题所在了。适配！也许你已经联想到这个设计模式了，不过这两个字的答案还是太抽象，等于没说，如何适配才是问题的关键所在。IronPython 在这方面似乎已经做得很不错了，许多 .NET 平台上组件、框架(比如 asp.net)已经可以为 IronPython 所用了。木野狐同学已经写了好几篇分析 IronPython 实现的文章，看完后受益匪浅，也期待他更多的分析。从他的文章中可以看出，通过让 .net 对象实现一些由 IronPython 定义的接口便可以让 .net 的对象拥有一些 python 对象的动态特性。其实现在很想知道在 IronPython 中，一个 python 对象究竟被翻译成了一个什么样的 .NET 对象，有时间再研究研究。再说说 PyPy 吧。今天逛到 pypy 首页的时候发现首页不知何时变了，变成了对项目的一个描述。可以感觉到，PyPy 已经比以前成熟很多了，至少现在对于“什么是PyPy”这个问题有了个明确的答案：“Researching a higly flexible and modular language platform and implementing it by leveraging the Open Source Python Language and Community” 。这是个实验性很强，也是野心很大的项目。我的理解是一套通用的“面向方面”的动态语言转换机制(其实现在只是 python 向其它语言的转换，不过许多东西对于其它语言也是通用的)。它是从对 python 语言的一个“抽象”的实现开始的，其实这也就是它的名字的由来：用 python 编写的 python 实现。虽然看起来没有多大意义，其实这只是一个开始。为什么说它是个“抽象”的实现呢，因为在这个实现中把 python 实现中的许多“方面”都抽象出来了，比如对象模型、自动内存管理、并发模型等，单就这个实现本身它只是个空壳(从pypy的源代码也看得出来，非常少)，而把这些“方面”一加上，它就是个有用的 python 实现了！而这些“方面”或者是可选的，或者是可替换的，这让这个 python 实现拥有了巨大的灵活性！然后它通过实现一整套语言转换的流程成了一个python到其它语言的转换工具！其中有一个 demo 演示了一个神经网络的程序在转换成 c 后执行速度提高了十几倍！目前可用的转换后端已经有：c、LLVM、.net、Smalltalk、ECMAScript、Common Lisp ！对于研究人员来说 PyPy 自然是一个不可多得的实验平台。而随着 pypy 的成熟，它对于 python 程序员的价值也会越来越大，我觉得最重要的一点就是对 python 程序进行优化，比如向 c 语言的转换，为 python 虚拟机提供 JIT ，还有在转换中进行的优化等；其次就是 stackless ；另外向 javascript 的转换也是很有用(也是很好用)的。最后还有重要的一点不得不提的就是，所有这些全部都是用纯 python 编写而成！更多的细节也不多说了 (再说下去就要露馅了 ;-) PyPy 涉及的范围广，要研究透彻还得花一番功夫，只能是期待它结出累累硕果的那一天早日来到吧，呵呵。

selfless python

2006-12-17T11:49:00.000+08:00

Eliminating self with Metaclasses 此文利用 metaclass 和字节码，使得在 class 中定义方法时不再需要显式指定 self 参数，当真妙极！关于这个 self 参数是否多余，本身也是仁者见仁、智者见智的事情。我认为 python 这么做是有它充分的理由的，那就是 class 中定义的方法本质上还是函数，是函数就应该遵循函数的规矩，没必要对方法进行特殊照顾，隐藏掉 self 参数只是增加了一份 magic。也许你会问了：那这个 self 是怎么传进去的呢？这里不又是一个 magic 吗？其实，这是利用了 descriptor 对函数进行了包装，而 descriptor 本身是个应用面很广的概念，并不只是为了实现这个而生的。不管怎么说，相信总是有一些人(可能还是不少人)不喜欢这个 self 参数，那让我们回到主题，看看去掉 self 参数之后的 class 定义是什么样的：

class Test(object):

   __metaclass__ = Selfless

   def __init__(x=None):
       self.x = x

   def getX():
       print self.x

   def setX(x):
       self.x = x

test = Test()
test.getX()

test.setX(7)
test.getX()

python types and objects

2006-12-16T19:27:00.000+08:00

在探寻 metaclass 的过程中，对以前熟知的 OO 又有了全新的认识。我开始感觉到，只有在动态语言的世界，才有可能对这些概念有如此通透的理解。在静态语言中，type 和 instance 之间永远隔着编译期和运行期之间的鸿沟。而在动态语言中，简单的 object 的概念统一世界，type 和 instance 突然变得如此的一致(都是object)，其间并没有本质的区别。我们只有按照逻辑对其进行区分。虽然由于现实世界问题概念本身的局限性，和 python 提供的各种方便的“语法糖”，使得普通的 python 程序和静态语言程序似乎区别不大。但其实当你深入 python 的基础，你会发现表象的下面其实隐藏着动态语言与生俱来的优雅和强大的根基！这一切，都始于 python2.2 那一场翻天覆地的变革！ Everything is an object 而所有 objects 之间存在着两种关系：is-a-kind-of 即类型-子类型，is-an-instance-of 即类型-实例。对应这两种关系，也就存在着两种产生新对象的方式：继承和实例化，前者可通过 class 语句：

class Temp(object):
  a = 1

产生；后者通过“调用”语句：

obj = Temp()

产生。通过这两条规则，python中的对象可以向这两条正交的方向延伸，它们的起点就是内置对象：type 和 object 。 type 是所有对象(包括它自己!)的类型，object 是除了它自己以外所有类型(包括type!)的基类。理论上说，从这两个起点出发我们可以朝着两个方向无限延伸，不过一般 python 代码中都只出现两层类型-实例关系，也就是： metaclass - class - instance 一般 metaclass 是 type 的子类，class 是 object 的子类，instance 不存在继承关系。参考： Python Types and Objects 要是你对这个主题有兴趣，那一定要看这篇了，基本上你可以把本文当作是这篇文章的一个摘要。

metaclass in python (part 2)

2006-12-11T17:34:00.000+08:00

接着上一篇的讲。现在我们知道了，metaclass 生 class，class 生 instance。但是 metaclass 还可以有它的 metametaclass，metametaclass 还可以有... 如此反复，永无止境。这样想起来，脑袋就有点晕了。其实在 python 中万物皆对象而已，所有对象皆有其类型，对象的类型也还是对象！而类型对象的类型就是它自己。而前面说过的所谓 instance、class、metaclass 等东西，都只是不同种类的对象而已。判断对象是什么对象的唯一方法就是通过其提供的“接口”，这就是所谓的 duck typing！只要一个对象实现了成为一个 class 所需的接口，它就是 class ！metaclass 亦然。那么我们不如先来讨论讨论 metaclass 的接口吧，看看究竟需要实现哪些接口能使一个对象成为一个 metaclass。先来看一些等价关系：

class Temp(object):
   __metaclass__ = Meta
   a = 1
   def __init__(self, a):
       self.a = a

上面代码其实等价于：

Temp = Meta('Temp', (object,),
  {'a':1, '__module__':'current module name', '__metaclass__':the object Meta, '__init__':function object __init__})

（class的语法原来只是个语法糖而已，汗！）由此可见 Meta 首先应该是个 callable，并且应该接受如上所示的三个参数。

t = Temp(2) # 构建 Temp 的 instance

从这一句我们可以看出 Temp 也应该是个 callable 对象。而我们知道 Temp 对象其实是调用 Meta 所返回的，也就是说 Meta 这个 callable 对象返回的还应该是一个 callable 对象。典型地，如果 Meta 是一个 class，意味着它应该实现一个 __call__ 方法。这样的话，那么上面那句就可以等价为：

t = Temp.__call__(2)

上面说的这几点基本上可以作为判断一个对象能否成为 metaclass 的标准了：一个接受三个参数并返回另一个 callable 对象的 callable 对象！不急，在继续分析之前我们不妨利用刚才发现的这一点搞点小怪先，呵呵。

def Meta(name, bases, attrs):
   def _class(a):
       return a
   return _class

class Temp(object):
   '''
   >>> Temp(1)
   1
   >>> Temp('hello')
   'hello'
   '''
   __metaclass__ = Meta

继续分析，虽然可以像上面那样恶搞，不过要想写个有点实际用处的 metaclass ，还是通过 class 来实现比较方便。最典型的方法便是直接继承 type 了，毕竟那是所有 new-style class 的 metaclass，在 python3000 里就要成为所有 class 默认的 metaclass 了。可以说大部分 metaclass 的实现都是这么做的，不过下面要分析的这一例却是个例外，虽然不像上面我们写的那个 metaclass 那么奇怪，不过分析起来也不是那么容易的。不过我们还需要继续澄清一些事实，先看这个例子：

class Temp(object):
   @staticmethod  # 这一句可以忽略，不管有没有这句，__new__ 都是静态方法
   def __new__(cls, a):
       return object.__new__(cls, a)
   def __init__(self, a):
       self.a = a
   def __getattribute__(self, name):
       return super(Temp, self).__getattribute__(name)
   def __getattr__(self, name):
       return super(Temp, self).__getattr__(name)

t = Temp(2)
print t.a

在默认的 metaclass type 的实现中，上面这句，也就是 type 的 __call__ 方法，其实是分以下两步完成的：

t = Temp.__new__(Temp, 2) # 调用 staticmethod __new__，创建 instance
t.__init__(2) # 调用该 instance 的构造函数，初始化 instance

另外，既然 Temp 实现了 __getattribute__， t.a 实际上等价于：

try:
   t.__getattribute__(self, 'a')
except AttributeError:
   t.__getattr__(self, 'a')

到这里基本上一些概念问题已经搞清楚了，下一篇终于可以正式开始研究这里的代码了。参考： Unifying types and classes in Python 2.2 这是老大对 python2.2 以后的“python对象模型”的深刻的描述 The Python 2.3 Mehod Resolution Order 这也是今天碰巧看到的好文，虽然与本文没有什么联系，不过，此文深入讲解了 python2.3 以后对多继承的实现，我也是看完这篇才知道实现个多继承是如此的复杂，不过幸好他们找到了合适的算法。另外对于平时不经常接触算法的人（比如我）来说，偶尔用数学的思维思考思考还有很有好处的。 New-style Classes 这里是 new-style class 相关的文献的集合。另外想找这方面中文资料的兄弟可以去啄木鸟：python中的新型类及其实例详解 Metaclasses(元类)

metaclass in python (part 1)

2006-12-11T14:49:00.000+08:00

python 的东西虽然概念上容易理解，但是实际用起来却也不都是那么容易的。这个 metaclass 就是典型一例。虽然早知道了它是什么，不过要说出它具体能干点啥，一时半会还真想不起来。先看看官方文档中的定义吧：

__metaclass__: This variable can be any callable accepting arguments for name, bases, and dict. Upon class creation, the callable is used instead of the built-in type(). New in version 2.2.

The appropriate metaclass is determined by the following precedence rules:

If dict['__metaclass__'] exists, it is used.
Otherwise, if there is at least one base class, its metaclass is used (this looks for a __class__ attribute first and if not found, uses its type).
Otherwise, if a global variable named __metaclass__ exists, it is used.
Otherwise, the old-style, classic metaclass (types.ClassType) is used.

The potential uses for metaclasses are boundless. Some ideas that have been explored including logging, interface checking, automatic delegation, automatic property creation, proxies, frameworks, and automatic resource locking/synchronization.

看完这个似乎又能理清了一点东西：所谓 new-style class 和 old-style class 最根本的区别其实正在于它们的 metaclass 一个是 type，一个是 types.ClassType，所以只要一个 class 继承自 object 而又没有指定自己的 __metaclass__ 的话，其 metaclass 就会自动使用基类 object 的 __metaclass__，但是 object 却没有 __metaclass__，那就使用 type(object)，也就是 type 了！

然后再 google 一下（这次是要 google code 一下了），看看实际生活中的代码都用它来干了点啥。不搜不知道，这一搜还真发现不少有意思的结果：

第一条[地址]，是twisted里的代码
```
__metaclass__ = type
```
真有创意！根据上面定义中 __metaclass__ 查找顺序，在使用 old-style class 的 metaclass (也就是types.ClassType)之前会找一下全局变量 __metaclass__ ，而上面代码中通过定义模块全局变量 __metaclass__ ，使得模块中原来的 old-style class 立刻变成了 new-style class。使用这种方法来将 old-style class 升级为 new-style class，确实省了不少代码，毕竟将来的 python 中将会只存在 new-style class ，那时候便可放心地将这一句去掉了。聪明！(不过这样会导致查找 metaclass 的过程要多了几个步骤，效率上可能就 ... )
第二条[地址]，从这个例子的路径看它是在 python25/tools/ 下面，不过翻了一下自己python25 安装目录下却没有发现这些代码，郁闷！在这个例子中，__metaclass__ 被当成了一种快捷定义 class 方法的方式了。我们知道在 class 中定义的方法其实默认都是 instance 方法，要使它们成为 class 方法需要使用 classmethod 进行装饰，对于有大量 class 方法的类来说，这的确是有点小麻烦。既然 class 中定义的方法是 class 的 instance 方法，那么在 type 中定义的方法岂不就是 type 的 instance 方法，也就正好是 class 方法了？这个例子便是利用这一点，通过继承 type，添加 type 的 instance 方法，也就是添加了 class 方法了。好聪明啊，呵呵 ;-)
第三条的用法与第一条类似，第四条[地址]来自传说中的 psyco ！一看到这个名字差点没有勇气继续看下去了，不过还好，这个 metaclass 其实并不复杂，它的作用就是在 class 创建之后自动将它或 __psyco_bind__ 中指定的属性 bind 到 psyco，具体 bind 干了什么事情就只有对 psyco 有研究的兄弟来解答了，不过估计这样就可以进行某种特别的优化了。也许你要说了：这个工作也可以在 class 的 __init__ 或是 __new__ 方法里做啊。但是放在 __init__ 里面做的话你就需要其他的 class 都来继承你这个基类了，而使用 __new__ 的问题是它可以被子类 override 掉。使用 metaclass 的另一个好处是，你可以神不知鬼不觉地修改 class 的创建过程，比如这个例子里面，在模块中定义好 __metaclass__ 全局变量，那当其他的代码 from module import * 的时候，该 __metaclass__ 的定义就会自动作用于其后所定义的所有 class 了。
第五条和第八条的用法也和第一条类似，第六条貌似只是在使用 __metaclass__ 的情况下对 pickle 进行测试，没有什么特别的。至于第七条。。。。

而至于第七（来自zope）和第九（来自sqlobject）两条，还是听下回分解吧。不好意思，真的不是我卖关子，实在是被第七条整晕了 = ="，真不知道写这些代码的人是怎么想的，呵呵。希望大家能从这些代码中看到 metaclass 的强大，动态语言的灵活。什么？还没看到？去看看这个去！

a python tutorial

2006-12-04T13:05:00.000+08:00

A Very Brief Introduction To Python And It's Data-Types 一篇短小精悍的 python tutorial 。对一些容易被忽视的问题讲得很清楚！很专业的 tutorial！摘录片段如下：

The Python 'philosophy' emphasises readability, clarity and simplicity, whilst maximising the power and expressiveness available to the programmer. 看到这句话我不自觉地就想起了c++：“The c++ 'philosophy' emphasises performance, performance and performance, whilst maximising the power and expressiveness available to the programmer” ;-) 它们在各自的领域都做得很不错。
The line of code x = 3 is a statement (more about that in a bit) which means it does a job. The job it does is to assign the value 3 to the variable 'x'. In Python terminology we say that it binds the name 'x' to the number three. This idea of variables being names bound to objects (or names which 'reference' objects) is important in Python.
'Under the hood' Python actually uses two types of integer, the integer and the 'long integer' for integers bigger than a certain amount.
If you need to a lot of complicated maths with floating point numbers, then you may be interested in extensions like numpy or General Multiprecision Python project. These extensions provide very fast ways of doing mathematical operations. For normal use the capabilities built in to Python will be sufficient.
The name 'string' probably comes from the fact that programming languages often treat text as a sequence of characters 'stringed' together.
The basic string type (which I have called 'normal strings' below) store the text as a sequence of bytes (numbers) with one byte per character. .... They can also be used for storing binary data in.
Unicode strings store text internally using the unicode standard. They are slightly more complicated, because you must know the 'encoding' the text is stored in whenever you read the text in or save it out. In the long run this can save a great deal of confusion.
Because the interpreter knows the length and types of the members of a tuple, working with them can be more efficient than using a list.
Dictionaries are an extremely useful and flexible datatype. In fact Python is built on them.
Programs are actually compiled to byte-code before being executed, but the byte-code is then interpreted. In some ways this is similar to Java or .NET which also compile to byte-code. Because these languages are statically typed with JIT compiler, they are generally considered as compiled languages whilst Python is generally considered as being interpreted.

django collection

2006-12-02T16:43:00.000+08:00

Inspired by CherryPy Collection which is inspired by wsgicollection . code 代码不知不觉又是好久没有写 blog ，最近被 javascript 和浏览器折磨得好惨！哎，怀念漂亮的 python。这不，忙里偷闲还是要写点有意思的小程序，希望对某些人有用 ;-)

This project include two applications: the djcollection and a demo app task. REST is mostly about url dispatching, and djcollection app provide a set of generic RESTful urls for all the models of the project, djcollection app also provide a GenericCollection which uses the django generic views. the task app is for demonstrate the usage of the djcollection.

simple rpc with allegra

2006-11-16T11:22:00.000+08:00

先安装 allegra 和程序然后执行测试服务器和测试客户端！

使用 google docs 发的第一篇 blog

2006-11-15T18:21:00.000+08:00

Google 的东西就是好，就是好哇就是好 ;-)

file upload monitor

2006-11-12T16:51:00.001+08:00

Paste 有不少有意思的 wsgi 组件，这个 progress.py 就是其中之一。使用它配合ajax编写了一个简单的文件上次进度检测程序，ajax部分是从其他人的代码复制过来稍作修改而得，另外如果你感觉文件上传速度奇慢无比，请不要吃惊，那是因为服务器端用了 sleep 故意获得这种慢的效果的，程序在此。要运行此程序你需要安装 paste 先！

MochiKit Animator : 太漂亮了

2006-11-08T22:29:00.001+08:00

demos 评论

django new forms and tgwidgets

2006-10-29T16:11:00.000+08:00

看到一个漂漂亮亮的forms库就这样在大家的讨论中逐渐成型，虽然自己并没有参与(怕说话他们看不懂)，但也已经觉得很开心了。

另外turbogears中的widgets库也被抽取出来了，变成了tgwidgets。

REST，让 web 变得更美好！

2006-10-23T19:43:00.000+08:00

What is Representational State Transfer (REST)? Building Web Services the REST Way Python Web Frameworks and REST Dispatching in a REST Protocol Application selector: a RESTful url dispatcher. robaccia: a RESTful web framework. (yes, the mini web framework!) wsgicollection: make robaccia even more RESTful. use JSON RESTfully Using REST with Ajax

什么是REST？

representation

state

Representation State

state

representation

设计 RESTful 的web服务的原则

标识所有需要暴露的资源，
为每一个资源设计URL，资源应该是名词而非动词，比如应该使用 http://www.parts-depot.com/parts/00345 而非 http://www.parts-depot.com/parts/getPart?id=00345
根据用户能否修改还是只能查看资源对资源进行分类，前者只能进行 GET 请求，后者可以使用 POST、PUT 和/或 DELETE
没用孤岛。所有资源的 representations 应该通过超链接联系起来

最后看点代码吧

Be Pythonic

2006-10-19T10:15:00.000+08:00

Be Pythonic What is Pythonic Python is not Java path 操纵文件系统的 pythonic 的做法

I'm back!

2006-10-17T09:56:00.001+08:00

回家了个把月，也离开了网络个把月。 gmail里几百封邮件和google reader里几百篇文章不知道要看到什么时候咯 = = 回学校的火车上认识了一个14岁的小家伙，一个人逃票坐火车，才念初一就说不想读书了，成天泡网吧，还是包间，5元/小时！除了玩游戏就是视频聊天。哎，想当初我念初一的时候还不知道电脑是个啥样子呢。网络也害人啊！

compatibility of IronPython

2006-09-19T11:28:00.000+08:00

IronPython 1.0 的发布，在邮件列表中引起了很多争论，有的人担心 IronPython 会污染了 CPython 标准的纯洁，也有人希望 IronPython 的兴起会给 Python 社区注入新的力量。而在我看来，这些争论归根到底，就是一个兼容性的问题。在 .net 程序员看来，它是 IronPython 和 .net 的兼容性，和其它 .net 程序的互操作性如何；而在 python 程序员看来，它就是 IronPython 和 CPython 的兼容性了，和其它 python 程序互操作性如何。在 IronPython 与 CPython 2.4.3 的兼容性问题上，有这么一份详细的比较文档官网下载啄木鸟下载。其中除了众多细小的区别外，在我看来比较重要的几点有：

Some CPython built-in extension modules do not exist in IronPython:

_bisect

_codecs_hk

audioop

_multibytecodec

parser

array

msvcrt

_codecs_kr

_heapq

_codecs_jp

imageop

mmap

_subprocess

_codecs_tw

regex

zipimport

xxsubtype

_codecs_cn

md5

_codecs_iso2022

rgbimg

_csv

signal

_hotshot

sha

cmath

_symtable

_winreg

strop

The doctest module does not run in IronPython. IronPython doesn’t support the select module. IronPython has no os.system function.

看来库的问题还是最大的，而且 CPython 中除了标准库还要那么多第三方的“事实上"的标准库！况且 .net 本身有那么一个庞大的库资源(包括官方的、第三方的等等)，也没有必要非得使用 CPython 的标准库了。不管兼容问题如何，我都不同意所谓 IronPython 污染 Python 之类的说法。是说 IronPython 会让本来的 python 程序员转向 IronPython 从而导致 Python 社区的分离吗？不管 IronPython 和 CPython 在语法上是如何的接近，让一个不了解 .net框架的 CPython 程序员转向 IronPython ，其难度怎么也算得上是学习半个语言了。因为这就是 .net ，.net框架对多语言支持好，但实际上众多语言写出的 .net 程序都是一个模子里出来的。所以 python 程序员的选择应该是很明确的：如果你需要在 .net框架下工作，那 IronPython 是你的不二选择，否则，就完全没有必要使用 IronPython 了，使用 CPython 还有个跨os平台的优势，何乐而不为呢。至于 IronPython 和 .net 之间的问题应该不大，不是很清楚，也不想做评论。

python is obvious !

2006-09-19T01:23:00.000+08:00

初识 python 的时候常常会被一些陌生的概念绊倒，而当熟悉了这些概念之后你会发现它们原来是如此的简单明了！由于它们是如此的简单，所以我试图在*一*篇文章中就想把它们全部都介绍一遍。

万物皆对象，甚至一个小小的整数也不例外；而变量只是一个名字，它可以绑定到任何一个对象；使用内置函数 id 可以查看绑定的对象的 id ，语言的实现会保证两个不同对象的 id 是绝对不一样的。
```
>>> a = 1
>>> id(a)
11541872
>>> a = 2
>>> id(a)
11541860
>>> b=1
>>> id(b)
11541872
```

callable 对象函数、方法、类、实现了 __call__ 方法的实例对象都是 callable 对象。callable 的意思就是在后面写个括号直接就可以进行调用了。调用内置函数 callable 可以检验一个对象是否 callable 对象。

>>> def check(obj):
...   if callable(obj):
...     obj(1,2)
...   else:
...     print 'not a callable'
...
>>> def func(a,b):print a,b
...
>>> class Temp(object):
...   def __init__(self,a,b):print a,b
...   def __call__(self,a,b):print a,b
...   def method(self,a,b):print a,b
...
>>> check(func)
1 2
>>> check(Temp)
1 2
>>> t = Temp(1,2)
1 2
>>> check(t)
1 2
>>> check(t.method)
1 2
>>>

参数传递机制

>>> def a_func(a,b,c=1,d=2):print a,b,c,d
...
>>> a_func(1,2,d=4,c=3)
1 2 3 4
>>> a_func(1,2,3,d=4)
1 2 3 4
>>> a_func(1,2)
1 2 1 2
>>> args = (1,2)
>>> kw = dict(c=3,d=4)
>>> a_func(*args, **kw)
1 2 3 4
>>> def a_func(*args, **kw):
...   print args
...   print kw
...
>>> a_func(1,2,d=4,c=3)
(1, 2)
{'c': 3, 'd': 4}

docorate 一个装饰就是一个接受一个函数作为参数的函数，它返回的还是一个函数。好像有点绕口，还是让代码说话吧：

>>> def simple_log(func):
...   def new_func(*arg, **kw):
...     print 'enter',func.func_name
...     func(*arg, **kw)
...     print 'exit',func.func_name
...   return new_func
...
>>> def log(some_args):
...   def simple_log(func):
...     def new_func(*arg, **kw):
...       print some_args,'enter',func.func_name
...       func(*arg, **kw)
...       print some_args,'exit',func.func_name
...     return new_func
...   return simple_log
...
>>> def a_func(a,b):print a,b
...
>>> simple_log(a_func)(1,2)
enter a_func
1 2
exit a_func
>>> @simple_log
... def a_func(a,b):print a,b
...
>>> a_func(1,2)
enter a_func
1 2
exit a_func
>>> log('haha')(a_func)(1,2)
haha enter a_func
1 2
haha exit a_func
>>> @log('haha')
... def a_func(a,b):print a,b
...
>>> a_func(1,2)
haha enter a_func
1 2
haha exit a_func

new style class 继承自 object 的都是 new style class，详细内容参考这里
__new__ 参考
staticmethod, classmethod 参考

metaclass 参考实例对象由 class 构造而成，而 class 便是由 metaclass 构造而成。简单地说一个 metaclass 就是一个接受三个参数（class的名字，基类tuple，class 的属性字典）的 callable 对象，它返回一个 class 。在构建 class 的时候便会调用这个 callable 对象，并使用它返回的 class 。所有内建类型的 metaclass 和 new style class 默认的 metaclass 都是 type

>>> def meta(name, bases, classdict):
...   print name
...   print bases
...   print classdict
...   return type(name, bases, classdict)
...
>>> class Temp(object):
...   __metaclass__ = meta
...   a = 1
...   def b():pass
...
Temp
(<type 'object'>,)
{'a': 1, '__module__': '__main__', 'b': <function b at 0x00BD5670>, '__metaclass
__': <function meta at 0x00BCEE30>}
>>> class ATemp(Temp):
...   __metaclass__ = meta
...
ATemp
(<class '__main__.Temp'>,)
{'__module__': '__main__', '__metaclass__': <function meta at 0x00BCEE30>}

暂时只想到这些，当然遗漏在所难免了，如有任何意见，欢迎评论 :) update [2006-9-21]: 结合 callable 和 docorate ，其实 docorate 那个 log 的例子还可以这么写，似乎更好读一些：

>>> class log(object):
...   def __init__(self, someargs):
...     self.args = someargs
...   def __call__(self,func):
...     def new_func(*args,**kw):
...       print self.args,'enter',func.func_name
...       func(*args,**kw)
...       print self.args,'exit',func.func_name
...     return new_func
...
>>> @log('haha')
... def a_func(a,b):print a,b
...
>>> a_func(1,2)
haha enter a_func
1 2
haha exit a_func

意外收获：get_caller

2006-09-16T22:01:00.001+08:00

阅读 PLY 的 lex.py 的时候，看到这么一段代码（line：449）：

try:
  raise RuntimeError
except RuntimeError:
  e,b,t = sys.exc_info()
  f = t.tb_frame
  f = f.f_back           # Walk out to our calling function
  ldict = f.f_globals    # Grab its globals dictionary

哈哈，这种用法还真是前所未见（也许是见识还不够吧）！自己抛出异常自己捕捉，然后就可以访问到 frame stack 了！那还不无法无天了啊，呵呵。你可以在这个 frame stack 中前后移动，这样你可以获得调用者的信息：比如 f_globals、f_locals、f_builtins、f_code 等，你还可以获得调用者的调用者的信息，你还可以获得 ... 。而且获得了调用者的字节码（ f_code ）之后，你还可以直接把它再执行一遍！

import sys

count = 0

def get_caller():
   global count
   try:
       raise RuntimeError
   except RuntimeError:
       e,b,t = sys.exc_info()
       f = t.tb_frame
       f = f.f_back
       count += 1
       print count
       eval(f.f_code, f.f_globals, f.f_locals)

def caller():
   get_caller()

if __name__=='__main__':
   caller()

大家还有什么变态的想法，尽管留言哈 ^_^ . 另外，查看 sys.exc_info 的文档时候，看到有一个警告，大意是说 sys.exc_info() 返回的那个 traceback 对象( 返回的 tuple 中第三个)，最好不要赋值给当前捕捉到异常的这个函数的局部变量，如果你不需要用到 traceback 对象的话可以这么干：

exctype, value = sys.exc_info()[:2]

如果你确实需要使用这个对象，那你最好用完后 delete 掉这个变量，或者在另外开一个函数来调用 sys.exc_info()。理由是将 traceback 对象赋值给当前函数的局部变量会产生引用循环，而这个东西是引用计数垃圾回收方式的软肋，python2.2 以前的版本它直接就会导致内存泄露了，虽然随后版本的gc能搞定引用循环问题，不过考虑到效率，最好还是不要创建引用循环了。

PLY: 一个以教学为目的的lex、yacc实现

2006-09-16T20:37:00.001+08:00

官方网站想学或正在学编译原理的同学可不要错过了，要是上个学期我就看到了它的话，我的编译原理课也不至于考得这么糟糕吧。 = =||| 现在突然又涌起研究下编译原理的冲动，谁知道能持续多久呢。不过现在实现一门语言的关键技术还在虚拟机上，编译器的技术已经太成熟了！不过原理呢还是懂点为好，不是吗 :)

laying out an application

2006-09-14T15:19:00.001+08:00

好文推荐：Django tips: laying out an application 我想这篇文章能帮助你对 django 有个全面的理解。它对 project 和 app 的区别，和 django 中对 project 和 app 代码布局的约定有很详细的讲解，这些知识对于编写可重用可扩展的 app ，或是整合定制扩展第三方的 app 都是必不可少的。其中还花费了一些笔墨介绍了 django 的一个很有意思的机制 signal 。它允许应用程序可以通过监听 signal ，在某些事件发生的时候获得通知并执行特点代码，并且 app 也可以编写自己的 signal。这个机制使得 app 的某些代码可以“侵入”核心框架和其他 app 的执行过程中，对于 app 的重用性是大有裨益啊! 文章剩下的部分还介绍了其他一些不成文的代码组织规范。希望这些东西对你有用 ^_^

django 的 contribs 之 comments

2006-09-14T14:52:00.001+08:00

comments ，顾名思义，它是用来处理用户评论的。托 contenttypes 的福，它可以处理对任意 model 的评论！是一个通用的 comment 框架！并且它自带有相关的urls配置、templates、templatetags、控制器，可以很方便地将它们整合到项目中来。 comments 框架围绕两个关键 model 分成相对独立的两部分：Comment 和 FreeComment ，前者是一个相当复杂的评论系统，包括reviews, ratings, attached images, reputation over time, flagging of potentially bad content, user bans and groups of moderators who can remove comments 等许多功能！后者是个简单的版本，只有一些基本的评论的功能。关于 FreeComment 部分已经有一些不错的文档了：Using Django's Free Comments ， Django tips: Hacking FreeComment 。 Comment 部分虽然功能多一些，不过结合对 FreeComment 使用方法的介绍和对代码的阅读，应该搞清楚也不是难事，也许有时间有机会会去仔细研究一下。

Rails/Django comparison synopsis

2006-09-12T13:25:00.000+08:00

Rails/Django comparison synopsis (a BIG summary)

这是 django 邮件列表中的一个帖子，收集了一些比较 rails/django 的观点。
当然几乎所有人都强调的一点就是，django 和 ror 是非常相似的。
不过也许是因为 django 社区中的缘故，似乎说 django 好话的多些。
总结一下他们的意见，django 表现得好的方面主要有：

灵活的app，
"If you're creating a single monolithic application, Rails is pretty sweet."
"With Django you can build an app, put it on the server somewhere, and for as many sites (projects) as you like you can pull in that app, skin it and use it."
部署，通过 mod_python 部署在 apache 上
文档，虽然 ror 有一本好书，不过站点上的文档比较糟糕
模版语言，这个主要看个人爱好，不过似乎多数人偏爱 django 的方式
admin 界面

django 做得不好的地方：

admin 界面还不够灵活
没有内置 ajax 支持

当然，我对 ror 的了解有限，各位有何意见大可留言回复，非常欢迎 ^_^

Pocoo: 半个框架

2006-09-12T01:48:00.000+08:00

xiaoping.tang 兄向我推荐这个论坛程序，说它写得不错。我于是下了代码来研究了一下，发现它确实有点意思。这是个demo。与其说它是个应用程序，不如说它是半个web框架，想必从中抽取出一个完整的框架也不是什么难事。模版：jinja（独立后的 django 模版），orm：sqlalchemy，基于WSGI。而我认为其中最有特色的部分还在 package 的配置管理这一块，它的整个系统都建立在这个机制之上。而这个论坛程序只是这个机制下面一个叫做 core 的 plugin 而已。这一块让我联想起稍微接触过一下的zope3。它的配置文件的语法就挺有意思，很像 python ：

components = list:
   db.CoreTableObserver
   captcha.CaptchaImage
   session.SessionWrapper
   pages.IndexPage

一个 package 只是一个普通的 python 包，不过下面可以放个配置文件描述包中的内容，分这么几类：components、tables、template_tags、 template_filters、middlewares。在初始化时按照配置文件指示加载并初始化这些东西，将所有包的内容分门别类放在一起进行统一管理。pocoo/pkg/core/package.conf 便是 core 的配置文件。 components 范围比较广，只要它是 Component 的子类的子类即可。Component 的直接子类可以看作是实际组件的抽象基类，并不能直接当作组件使用。组件必须继承自这些抽象基类。框架会将组件按照其基类进行分类管理。我看到在 core 中有这么几个 component 的类型：

RequestWrapper：将 request 对象交给 RequestHandler 之前交给它们处理一遍先，cache、session等就是以这种方式实现
RequestHandler：这就是我们熟悉的控制器了，处理请求并返回内容，每一个 RequestHandler 都有一个 handler_regexes 的属性，指定匹配 url 的正则表达式，类似 django ，
RemoteCallable：处理 web服务的请求，
AuthProvider：提供用户验证的组件，
PostProcessor ：对帖子进行处理，
DatabaseObserver：在创建数据表的前后进行一些处理，

等等。 tables 便是 package 使用到的 sqlalchemy 的 Table，Pocoo 对 sqlalchemy 进行了一层封装，还没仔细看。 template_tags、template_filters 是 jinja 模版的东西。 middlewares 便是 WSGI 中间件！ ps:这里列出了demo站安装的所有package ，这个功能本身也是通过一个package来实现的:) -- update [2006-9-12]

usable stackless

2006-09-10T21:57:00.000+08:00

所谓士别三日当刮目相看，有一段时间没有注意看 StacklessPython 的邮件列表了，没想到现在 sandbox 中已经有了这么多有意思的代码了 ^_^ 。最有意思的莫过于 examples/stacklesssocket.py 了，只要把标准库中的 socket 替换成stacklesssocket，然后使用 urllib 就自动成为异步的和StacklessPython兼容的。演示程序如下(摘自StacklessPython邮件列表)：

import sys
import stacklesssocket
import stackless

sys.modules["socket"] = stacklesssocket

import urllib
import time

def download(uri):
    t1 = time.time()
    f = urllib.urlopen(uri)
    s = f.read()
    t2 = time.time()
    print "Downloaded", uri, "in", "%.1f" % (t2-t1), "seconds"
    return t2-t1


print " === Serial === "
t1 = time.time()
download("http://www.stackless.com/wiki/Tasklets")
download("http://www.stackless.com/wiki/Channels")
t2 = time.time()
print " --->", t2-t1

print " === Parallel === "
t1 = time.time()
stackless.tasklet(download)("http://www.stackless.com/wiki/Tasklets")
stackless.tasklet(download)("http://www.stackless.com/wiki/Channels")
stackless.run()
t2 = time.time()
print " --->", t2-t1

效果：

% spython async_fetch.py
 === Serial ===
Downloaded http://www.stackless.com/wiki/Tasklets in 2.6 seconds
Downloaded http://www.stackless.com/wiki/Channels in 2.7 seconds
 ---> 5.34717988968
 === Parallel ===
Downloaded http://www.stackless.com/wiki/Channels in 4.0 seconds
Downloaded http://www.stackless.com/wiki/Tasklets in 5.4 seconds
 ---> 5.43875193596

% spython async_fetch.py
 === Serial ===
Downloaded http://www.stackless.com/wiki/Tasklets in 2.6 seconds
Downloaded http://www.stackless.com/wiki/Channels in 2.7 seconds
 ---> 5.32963705063
 === Parallel ===
Downloaded http://www.stackless.com/wiki/Channels in 2.2 seconds
Downloaded http://www.stackless.com/wiki/Tasklets in 2.7 seconds
 ---> 2.71087312698

还有 examples/threadchannels.py ，examples/threadscheduling.py 演示了 Stackless 如何与多线程一起使用！还有更新过的 uthread 模块：libraries/uthread-ccp/uthread.py，这可是大名鼎鼎的 EVE-online 用到的东西哦 ^_^ 有时间再好好研究研究这些东西吧!

django 的 contribs 之 contenttype

2006-09-10T12:37:00.000+08:00

上一篇blog介绍到了那个 repository ，其中 trunk/libs.common/src/common/mptt/models.py 里有一个很有意思的叫做 Node 的 model。实现了一个叫 Modified Preorder Tree Traversal 的算法，相关内容还可以参考这个页面。算法细节刚才链接到的文章都讲得很详细了，吸引我注意的是代码中两个陌生的词语：ContentType, GenericForeignKey。django 文档中 model-api 中对 GenericForeignKey 完全没有涉及，add_ons 中对 contenttype 的描述也只有简单的一句：

A light framework for hooking into "types" of content, where each installed Django model is a separate content type. This is not yet documented.

通过 google 也只搜到了这么一篇文章，也只是泛泛而谈而已。经过研究，越发地感觉有意思了，于是写下心得，这么有意思的东西被埋没了可真可惜。简单得说，ContentType 就是一个 model，也就是一张数据表，其中保存着当前 project 中所有 models 的元数据，具体就是 name、app_label 和 model 三个字段，其中 app_label 和 model 这两个字符串组合起来便可以唯一标识一个 model 。通过调用 django.db.models.get_model(app_label, model) 就可以获得该 model 类。这样一个奇怪的 model 会有什么用处呢？可以设想一下，如果你需要一个和任意 model 都建立有关系的 model 时，你会怎么做？比如：用户评论！假设你的 project 中有电影、有文章、有音乐等等内容，它们分别对应不同的 model ，而用户对它们每一种内容都可以进行评论，那么最简单的做法就是为每一种内容建立相应的评论表，比如：movie_comments, article_comments 等。不过这种做法的弊端是很明显的：首先是增加了 model 的数量也增加了代码的复杂度；而且没有扩展性，增加其他内容的话还需要增加相应的 comments 表；还有就是统计用户所有评论的时候比较麻烦，需要在多个表中进行查询。要是我们有了一个记录了项目中所有 model 的元数据的表，表中一条记录便对应着一个 model ，那么我们只要通过一个元数据表的 id 和一个具体数据表中的 id ，便可以找到任何 model 中的任何记录。ContentType 正是这个表（不过有个前提就是：相关 model 的主键类型必须是相同的，使用django默认的主键就ok了）。有了 ContentType ，我们的用户评论就只需要一个 model 就可以搞定！下面开始介绍具体做法吧，首先通过执行以下命令 >django-admin.py startproject ContentType 创建一个 project。然后修改 settings.py ，配置合适的数据库后端。然后通过 >cd ContentType >manage.py startapp contents 创建一个 app，修改 contents/models.py 如下：

from django.db import models
from django.contrib.contenttypes.models import ContentType

class Movie(models.Model):
   title = models.CharField(maxlength=100)

class Article(models.Model):
   title = models.CharField(maxlength=100)

class Music(models.Model):
   title = models.CharField(maxlength=100)

class Comment(models.Model):
   content_type = models.ForeignKey(ContentType)
   object_id = models.IntegerField()
   content_object = models.GenericForeignKey()
   title = models.CharField(maxlength=100)

然后在 settings.py 的 INSTALLED_APPS 中加入： "ContentType.contents", 执行命令: >manage.py syncdb 然后执行： >manage.py shell 现在就可以好好地享受享受劳动果实了。

>>> from ContentType.contents.models import *
>>> a = Article()
>>> a.title = 'article1'
>>> a.save()
>>> m = Movie()
>>> m.title = 'movie1'
>>> m.save()
>>> mu = Music()
>>> mu.title = 'music1'
>>> mu.save()
>>> c = Comment()
>>> c.content_object = a
>>> c.title = 'comment1'
>>> c.save()
>>> c = Comment()
>>> c.content_object = m
>>> c.title = 'comment2'
>>> c.save()
>>> c = Comment()
>>> c.content_object = mu
>>> c.title = 'comment3'
>>> c.save()
>>> for c in Comment.objects.all():
...   print c.content_type,c.object_id
...
article 1
movie 1
music 1
>>> c.content_object.title
'music1'

还有一个值得提一下的地方就是 Comment 的 content_object 字段。实际上根据上面的解释它只要有 content_type 和 object_id 两个字段就够了，不过你总是需要亲自指定两个字段的值。而 GenericForeignKey 出现的目的就是要把这个过程给自动化了，只要给 content_object 赋一个对象，就会自动得根据这个对象的元数据，给 content_type 和 object_id 赋值了。 GenericForeignKey 的构造函数接受两个可选参数： def __init__(self, ct_field="content_type", fk_field="object_id"): 你可以在构造 GenericForeignKey 时指定另外的字段名称。另外还有值得注意的一点就是：contenttype 的表是在 syncdb 时创建的，不过一开始其中并没有元数据，其中的数据是在需要的时候才添加上去的，正如你所想的，它使用的是get_or_create方法。

django apps repository！

2006-09-10T11:46:00.000+08:00

最近django的邮件列表热烈讨论一个叫做 apps repository 的东西。就是建立一个保存用户提交的 app 的统一的存储中心。

我想这么一个东西的存在一定程度上是直接得益于 django 的一些优秀的设计：

在 django 中一个 project 由多个 app 组成，一个 app 由相关的 urls、views、models、templates、templatetags(自定义的模版标签) 等组成，一个 app 就是一个文件夹，一个包，一个重用单位。而 pylons 等框架是将所有 controllers (对应django的views) 放一处、所有 models 放一处、所有 templates 放一处。相比之下，django 提供一个相对 project 更小粒度的 app 成为重用的最小单元，使得代码重用变得更为方便。

这样一个好机制其实是得益于 django 中许多细节上的设计的，比如 url dispatcher 的 include 机制，使 app 可以独立设计自己的 urls ；灵活的可扩展的 template 加载机制使 app 可以和自己的模版、自定义模版标签一起分发；...；最后还有最重要的一点原因就是：django "一块式" 的设计哲学。因为这些便利都是基于一个前提的，那就是：这些 app 使用着同一套url dispatcher，同一套模版引擎，同一套 orm 等。

目前 django 代码里面 contrib 目录下那些东西，就是些可重用的 app 。简单如 sites 的，只有一个 models(和相关的managers)；更复杂一些如 comments 的，便连 views、templates 也都有了；还有庞大如 admin 的，甚至连自己的 urls 都有了！

貌似目前还没有推出正式的 django apps repository 吧，倒是有个兄弟公开了自己一个私有的repository：
http://svn.sourceforge.net/svnroot/django-userlibs
虽然数量还不多，不过还是有了一些很有意思的代码了 :)

希望正式的 repository 快快建立起来，希望用 app 组装 project 的日子快快到来吧！

ps：据说 ror 有个 plugin 的东西，不知是什么样的一个机制，希望有了解的朋友也介绍介绍吧. ^_^

使用 python2.5 中增强的 yield 模拟 StacklessPython

2006-09-05T16:19:00.000+08:00

今天邮件列表里讨论 python2.5 中增强的 yield 特性，讨论得热火朝天。

顿觉心血来潮，就用这增强型的 yield 大致模拟了下 StacklessPython 的基本功能。

虽然不能一模一样，不过感觉也只能做到这一步了。

主要是因为相对 StacklessPython 来说 yield 有这么几个限制：

函数只能通过 yield 来挂起，这导致实现 channel 的时候只能通过 yield command(c.send, value)，value = yield command(c.receive) 这样的语法来使当前 tasklet 挂起 (一定条件下) ，不像 StacklessPython 直接 some_channel.send(...) 就有可能挂起当前 tasklet 。
yield 只能向上一层，而不能直接 yield 到调用栈的最上层（或者甚至是指定 yield 到哪一层!!），这导致我们的 tasklet 只能在函数调用的第一层进行 yield 才能将执行权切换给调度程序，像下面:

def a_task() :
    a_func()
def  a_func():
    # 在这个函数里是没用办法将执行权切换给调度程序的。

不像 StacklessPython ，随便哪里调用 stackless.schedule() 都可以把执行权交出去。

谁叫人家c写的呢。:(

本来想顺便把 evolution 也转过来的，发现 pygame 还没为 windows 编译 python2.5 的版本，自己编译太麻烦，还是等 python2.5 正式发布了再说吧。

具体代码请看 http://wiki.woodpecker.org.cn/moin/huangyi/2006-09-05

python web 框架可真多!

2006-09-04T09:36:00.000+08:00

python web 框架可真多！几乎所有比较python web框架和ruby web框架的时候都会提到这个现象。
最近几天我也基本上是钻在这一堆框架（和一堆评论比较的文章）里面度过的。
现在开学了，轻松了一天，似乎可以回过头来好好看看这个问题了。
首先我想产生众多框架的关键原因在于：开发一个新框架实在太简单了，而开发一个满足所有人需要和喜好的框架却是不可能的！
每个框架都有它的特色，都有它存在的理由。而当你稍微走近看的时候你会发现这些框架的结构是如此的相似，毕竟都逃不过mvc的框框。也有仁兄把这些个结构归纳为: url dispatcher,controller ( 就是django的view ) ,model,template.
不光结构相似，使用到的组件也都是那么几个 python 模块，基本上都是可以轻松替换的。所以为什么说这些个才开发了几个月的web框架就已经如此的成熟，因为这些模块早已久经考验。
框架的差别基本只存在于细节，只存在于底层实现，只存在于对快速开发与灵活性之间的权衡。

常用的组件都有哪些呢？不妨收集一下 :)

1、url dispatcher：
        django 的基于正则表达式的
        cherrypy 的基于 object publisher 的
        routes 学 ror 的
        还有 paste 的简单的 urlmap

2、templating：
模板系统比较多，详细列表请看http://wiki.python.org/moin/Templating
我所知的几个比较常用的是：
        django template system （简单易用，适合设计人员使用）
        myghty （功能强大，基于组件）
        kid （基于xml，对xml文档的生成相当自然）

3、orm：
        sqlalchemy
        sqlobject
        django orm

另外python中还有webpy这类的"微型"框架，不熟悉，也就不敢多加评论了。

而对于 ror vs python web frameworks 的争论，我感觉这种争论更多的是集中在ruby or python的争论上，框架本身区别并不大。而这两种语言区别其实也不大，争论更多集中在一些 features 的比较和美学观念上差异。而ruby 和 python 最大的观念的差别就是：

ruby：there is more than one way to do it.
python：there should be one obvious way to do it.

了。
不管怎么说百家争鸣是个好事，web框架如此，ruby和python的存在也是如此。具体选择取决于你自己了。

------------------------------------
web框架详细列表：

http://wiki.python.org/moin/WebFrameworks
http://wiki.woodpecker.org.cn/moin/PyWebFrameList

所有研究python web框架的朋友不得不看（至少我是这么认为）的一个东西：

http://wsgi.org/
http://www.python.org/dev/peps/pep-0333/
http://wiki.woodpecker.org.cn/moin/WSGI

最后还有两篇好文想与大家共欣赏：

        People Who Drive Silver or Blue Cars Should NOT Read This

        Pronouncement

有家的感觉，真好！

2006-09-03T19:55:00.000+08:00

好多天没写blog了，上次blogbus服务器出了点问题，弄丢了我两篇文章，给他们写邮件也没人理，郁闷一回后就没有再写了。这段时间有什么想法或是直接在人家blog里评论一下，或是邮件列表里讨论讨论，或是在啄木鸟的wiki上编辑个页面什么。流浪的日子颇为不好受，没有根的感觉，害怕被人遗忘。甚至想过干脆完全整个自己的，不过照了照镜子后终于没有动手。突然发现blogger貌似居然解封了，虽然似乎没有看到官方的什么消息，不过我还是强烈感觉到，漂泊的日子该结束了。顺便记下上个blog的地址吧，就像在上个blog中记下了上上个blog的地址一样。 http://codeplayer.blogbus.com/

白菜

博客搬新家

学习Haskell

学习Haskell

monad与状态

monad与状态

所谓日久生情

无题

linux下的半透明窗口

关于设计模式

inkscape还是很好用的

北京好远啊

工作后

爆强的翻译

实现一个 django 的 url dispatcher

如何在醉酒的情况下编写正确的程序

Faint! 和我同名的编辑器

原来 pickle 这么有意思

翻译了这篇文章

Python 3000 Status Update (Long!)

老子毕业了

SQLAlchemy Examples

multitask and Hive

Polymorphic Associations in Rails

Python and vim: Two great tastes that go great together

Evolution of a Python programmer

Elixir Examples

多重继承真是好哇

newforms 太好用了

django newforms admin

好久没写blog了

python3000与接口

新的 pep ！

突破 gwf 的封锁 访问 blogger 的通用方法

trying out PyPy

[有趣]Invasion Of The Dynamic Language Weenies

django and non programmers

字典与动态语言

pypy 介绍

pythonic cherrypy

强大的 sqlalchemy

Introducing Duck Typing

[豆瓣九点] 博客确认帖

Deploying Django

使用 python 模拟 ruby 的 open class

用 jquery 加了点 js 效果

ie sucks

added google reader clip

intergrate genshi with django

intergrate mako with django

[news] django moving towards 1.0

do it runtime

new blog template

Build extensible application with egg

Recently...

写了个方便下载 tudou 网视频的小程序

Recently...

理解 python 的 method 和 function 兼谈 descriptor

突然想到 之 ajax 和 REST

python virtual machines

selfless python

python types and objects

metaclass in python (part 2)

metaclass in python (part 1)

a python tutorial

django collection

simple rpc with allegra

使用 google docs 发的第一篇 blog

file upload monitor

MochiKit Animator : 太漂亮了

django new forms and tgwidgets

REST，让 web 变得更美好！

Be Pythonic

I'm back!

compatibility of IronPython

python is obvious !

意外收获：get_caller

PLY: 一个以教学为目的的lex、yacc实现

laying out an application

django 的 contribs 之 comments

突破 gwf 的封锁访问 blogger 的通用方法

突然想到之 ajax 和 REST

有家的感觉，真好！