老子毕业了

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

SQLAlchemy Examples

看 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

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

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

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

Evolution of a Python programmer

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

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

多重继承真是好哇

写 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 太好用了

建一个项目 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

又用 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了

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

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

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

python3000与接口

""" 要编写复杂软件又不至于一败涂地的唯一方法就是用定义清晰的接口把若干简单模块组合起来。 """ 抽象的说，其实接口、契约、协议、界面等等概念说的差不多都是一个意思。 作为如此流行的被大规模使用的语言，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 ！

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

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

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

trying out PyPy

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

[有趣]Invasion Of The Dynamic Language Weenies

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

django and non programmers

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

字典与动态语言

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

pypy 介绍

前面写过篇介绍 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

刚才看到这个页面：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 了！

真是方便那！