看到很多SNS网站上，像校内，5G都有一个很棒的功能，就是登录之后在自己的首页，可以看到自己好友最新发生的动态。于是想到使用django其实可以非常简单的实现这个功能，并且效果比现在SNS网站所用的更好。

总体来说这个功能就是在用户发生某个动作的时候将其记录下来，我不知道别人是怎么实现的，也许是直接在发生那个动作的代码块里写死，也许是使用数据库的触发器之类，但是在django中，一个很简单的方法的就是使用signals。

什么是signals：

最初看到signals是在django的The database API文档，当保存一个object的时候，会发生下面的这些事情（原文）：

What happens when you save?

When you save an object, Django performs the following steps:

简单来说就是当django保存一个object的时候会发出一系列的signals，可以通过对这些signals注册listener，从而在相应的signals发出时执行一定的代码。关于signals的文档django还没有整理出来，不过找了些资料来看了看，不算很难懂，基本使用还是很简单的。

使用signals来监听用户的动作有很多好处，1、不管这个动作是发生在什么页面，甚至在很多页面都可以发生这个动作，都只需要写一次代码来监听保存object这个动作就可以了。2、可以完全不修改原来的代码就可以添加监听signals的功能。3、你几乎可以在signals监听代码里写任何代码，包括做一些判断是不是第一次发生此动作还是一个修改行为等等。

鉴于本人表达能力有限，如果看到这里感觉稀里糊涂，可以考虑先看一下本文底部所列出的一些资料获取更多信息。

现在需要面对的就是第二个问题，监听到用户动作之后如何完整有效地保存用户这一动作，保存一个字符串来描述这个动作？通过外键来指向某个表中的某条记录？

保存一个字符串来描述这个动作是一个很高效的方法，但是缺乏灵活性，比如用户发表了一篇日志，但是很快又删了，如何把这个多余的新鲜事记录找出来同时删除？想修改已经保存了的字符串描述该怎么办？

而通过外键来指向某个表中的某条记录虽然可以解决删除问题，但是需要为不同类型的动作各自添加一张表来对应，如果以后有新的功能实现需要添加新表，如何可以简单来进行扩展呢？

而这些django的 contenttypes framework就可以很好的解决。

什么是contenttypes framework（原文）：

Django includes a “contenttypes” application that can track all of the models installed in your Django-powered project, providing a high-level, generic interface for working with your models.

这句话听上去很难理解，不过对于新鲜事这个功能来说就是使用Generic relations来产生一个特殊的外键，它不像models.ForeignKey那样，必须指定一个Model来作为它指向的对象。Generic relations可以指向任何Model对象，有点像C语言中 void* 指针。

这样关于保存用户所产生的这个动作，比如用户写了一片日志，我们就可以使用Generic relations来指向某个Model实例比如Post，而那个Post实例才真正保存着关于用户动作的完整信息，即Post实例本身就是保存动作信息最好的地方。这样我们就可以通过存取Post实例里面的字段来描述用户的那个动作了，需要什么信息就往那里面去取。而且使用Generic relations的另外一个好处就是在删除了Post实例后，相应的新鲜事实例也会自动删除。

说了这么多，还是直接来看代码更实际些，看看到底怎么来实现吧。

假如有一个叫Post的Model，以及一个用来记录用户事件的Model定义如下：

# -*- coding: utf-8 -*-
from django.db import models
from django.contrib.auth.models import User
from django.contrib.contenttypes.models import ContentType
from django.contrib.contenttypes import generic

class Post(models.Model):
    author = models.ForeignKey(User)
    title = models.CharField(max_length=255)
    content = models.TextField()
    created = models.DateTimeField(u'发表时间', auto_now_add = True)
    updated = models.DateTimeField(u'最后修改时间', auto_now = True)


    def __unicode__(self):
        return self.title


class Event(models.Model):
    user = models.ForeignKey(User)
    content_type = models.ForeignKey(ContentType)
    object_id = models.PositiveIntegerField()
    
    event = generic.GenericForeignKey('content_type', 'object_id')
    
    created = models.DateTimeField(u'事件发生时间', auto_now_add = True)
    
    def __unicode__(self):
        return  self.user.username + u'的事件'

 Post这个Model很普通没什么好说的，Event这个Model有3个很特殊的字段，content_type是一个普通的外键指向一个叫ContentType的Model，而ContentType这个Model就很特殊了，文档描述是

Instances of ContentType represent and store information about the models installed in your project, and new instances of ContentType are automatically created whenever new models are installed.

就是说一个ContentType 实例 存储了 某个Model 的一些信息，通过这些信息就可以还原出那个Model。其实ContentType 的存储的信息也非常简单，其定义如下：

class ContentType(models.Model):
    name = models.CharField(max_length=100)
    app_label = models.CharField(max_length=100)
    model = models.CharField(_('python model class name'), max_length=100)
    objects = ContentTypeManager()

而通过app_label和model这2个字段，使用django.db.models.get_model这个方法就可以找出原来所对应的Model。而有了原来的Model的定义，再通过使用主键，就可以找到这个Model所对应的某条记录了，object_id这个字段正是用来存储这个主键的，

所以content_type和object_id这两个字段加起来就可以表达在一个project中所存在的所有Model的某个实例了。当然我们最终并不需要直接和这两个字段打交道，而是通过另外一个看起来很奇快的字段，generic.GenericForeignKey是一个特殊的外键，可以指向任何Model的实例，在这里就可以通过这个字段来指向类似Post这样保存着用户动作信息的Model实例。

定义完了Model之后就是来写一下signals部分的代码了，将原来的文件修改成如下这样：

# -*- coding: utf-8 -*-
from django.db import models
from django.contrib.auth.models import User
from django.contrib.contenttypes.models import ContentType
from django.contrib.contenttypes import generic
from django.db.models import signals
from django.dispatch import dispatcher

class Post(models.Model):
    author = models.ForeignKey(User)
    title = models.CharField(max_length=255)
    content = models.TextField()
    created = models.DateTimeField(u'发表时间', auto_now_add = True)
    updated = models.DateTimeField(u'最后修改时间', auto_now = True)
    
    events = generic.GenericRelation('Event')

    def __unicode__(self):
        return self.title
    
    def description(self):
        return u'%s 发表了日志《%s》' % (self.author, self.title)
    
    class Admin:
        pass
    



class Event(models.Model):
    user = models.ForeignKey(User)
    content_type = models.ForeignKey(ContentType)
    object_id = models.PositiveIntegerField()
    
    event = generic.GenericForeignKey('content_type', 'object_id')
    
    created = models.DateTimeField(u'事件发生时间', auto_now_add = True)
    
    def __unicode__(self):
        return  u"%s的事件: %s" % (self.user, self.description())
    
    def description(self):
        return self.event.description()
    
    class Admin:
        pass


def post_post_save(sender, instance, signal, *args, **kwargs):
    post = instance
    if post.created == post.updated:
        event = Event(user=post.author,event = post)
        event.save()

dispatcher.connect(post_post_save, signal=signals.post_save, sender=Post)

 前面说到django在保存一个object的时候会发出一系列signals，在这里我们所监听的是signals.post_save这个signal，这个signal是在django保存完一个对象后发出的，利用dispatcher.connect这个函数来注册监听器，第一个参数是要执行的函数，第二个参数是要监听的signal，第三个参数是指定发送信号的Class，这里指定为Post这个Model，对其他Model所发出的signal并不会执行注册的函数。而我们所定义的需要执行的函数可以将signal所发出的一些参数定义为需要执行的函数的参数，从而在函数里面进行使用，获取更多的信息，这里使用了instance这个参数，即刚刚保存完的Model对象实例。在函数里通过比较日志发布时间和修改时间是否相等来判断是第一次发表还是修改后的保存，并且只为第一次发表这个动作创建一个相应的事件。创建事件的时候看到可以将post这个instance直接赋给generic.GenericForeignKey类型的字段，从而event实例就可以通过它来获取事件的真正信息了，在这里，如果有其他类型的Model实例，当然也可以赋值给generic.GenericForeignKey类型的字段了。

现在事件已经保存起来了，如何来得到事件的一个简短描述呢？可以给自己做一个假定，event这个字段所指向的Model都有一个叫做description的方法，那么我们只管调用这个方法就可以得到描述了。至于Post里面的那个description方法，可以根据需要，自己存取post实例的字段来获取信息，包括直接在描述字符串里面包含日志的url等。

最后有一点需要的注意的是，Post的Model定义里现在多了一个字段：

events = generic.GenericRelation('Event')

通过这个字段可以得到与某篇post相关联的所有事件，最重要的一点是如果没有这个字段，那么当删除一篇post的时候，与该post关联的事件是不会自动删除的。反之有这个字段就会进行自动的级联删除。

 现在有了以上这些，如果你将这些Model定义和signals定义，添加到自己某个app，然后到admin页面添加一篇post试试，添加完后应该会自动多出了一条对应的event记录，修改一个post不会再添加event记录，而删除一篇post会自动删除相应的event记录。(现在django的newforms-admin分支已经合并了，可能关于本文的代码admin部分的定义已经无效，如何修改，可以参考此文：http://jinhao.javaeye.com/blog/218112)

这就是一个新鲜事功能简单的实现原理，而关于 signals 和 contenttypes 的更多资料可以参考以下这些：

官方的 contenttypes 文档：http://www.djangoproject.com/documentation/contenttypes/

contenttypes 例子：http://www.djangoproject.com/documentation/models/generic_relations/

Generic Relation在SharePlat的使用：http://blog.donews.com/limodou/archive/2006/12/31/1106217.aspx

django 的 contribs 之 contenttype：http://codeplayer.blogspot.com/2006/09/django-contribs-contenttype.html

django signals的wiki页：http://code.djangoproject.com/wiki/Signals

另一篇关于signals的文章：http://www.mercurytide.co.uk/whitepapers/django-signals/

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师

昨天看到一篇文章上写道Django的newforms-admin分支已经合并了。今天马上找了些文章想来看看学习下。

接下来说说现在看下来的一些基本感受吧。

1、首先Admin选项已经彻底和Model定义分离了，这是最基本也是最激动人心的变化。现在Model定义看上去一定干净整洁多了。

现在你新建一个project之后。urls.py文件已经变成了下面这个样子。

from django.conf.urls.defaults import *

# Uncomment this for admin:
# from django.contrib import admin

# Uncomment to load INSTALLED_APPS admin.py module for default AdminSite instance.
# admin.autodiscover()

urlpatterns = patterns('',
    # Example:
    # (r'^mysite/', include('mysite.foo.urls')),

    # Uncomment this for admin docs:
    # (r'^admin/doc/', include('django.contrib.admindocs.urls')),

    # Uncomment this for admin:
    # (r'^admin/(.*)', admin.site.root),
)

要开启admin，必须去除注释from django.contrib import admin 和 (r'^admin/(.*)', admin.site.root) 这2行，至于admin/doc/其实是以前admin中就有的view部分的文档，现在作为contrib下的一个新发布的package。连同url也换了，

还有 # admin.autodiscover() 这句的意思让admin开启在每个app的目录寻找一个叫admin.py的文件，如果注释掉这句，你会发现进入admin后原来的Users, Groups, Sites 这些Model都没了，去除注释之后就会出现了，因为auth这个app已经写了一个admin.py文件，所以admin.autodiscover() 可以搜索到。通过阅读这个admin.py的源代码从一定程度上也可以了解newforms-admin的一些用法。


最基本的newforms-admin的用法：

# a sample models.py file
from django.db import models

class Author(models.Model):
    first_name = models.CharField(max_length=30)
    last_name = models.CharField(max_length=30)

    def __unicode__(self):
        return u'%s %s' % (self.first_name, self.last_name)

class Book(models.Model):
    title = models.CharField(max_length=100)
    author = models.ForeignKey(Author)

# a sample admin.py file (in same app)
from django.contrib import admin
from myproject.myapp.models import Author, Book

class BookAdmin(admin.ModelAdmin):
    list_display = ('title', 'author')
    ordering = ('title',)

admin.site.register(Author)
admin.site.register(Book, BookAdmin)

简单来说就是把 class Admin 这个内部类的定义去除掉。利用admin.site.register来注册某个Model使其在admin中可用，而第二个参数可以用来设置一些选项，相当于以前class Admin这个内部类的定义。当然现在这些选项定义是通过继承ModelAdmin这个类来实现的，功能强大很多而且很多以前需要写在Filed中的选项（比如ForeignKey 的 edit_inline）也可以完全写在这里了。Model也就彻底变清净了。

这些admin相关代码可以与Model写在同一个文件里也可以写在一个admin.py文件里（推荐）让admin.autodiscover() 自动找到。

当然与newforms-admin相关的使用不是一言两语可以说得清的。毕竟这是从一个分支合并过来，改变是相当大的，而且现在官方文档也还没有正式的整理发布出来。

2、所以我找了一些newforms-admin的一些资料，希望对需要学习newforms-admin的朋友有些帮助吧：

Django 官方的 Tutorial 已经更新，很好的newforms-admin的入门材料：http://www.djangoproject.com/documentation/tutorial02/

newforms-admin的wiki页：http://code.djangoproject.com/wiki/NewformsAdminBranch

Lllama's handy how-do-I guide to newforms admin：http://code.djangoproject.com/wiki/NewformsHOWTO

Django 1.0a 代码库中的docs的admin，以后应该就是正式的文档了：http://www.djangoproject.com/documentation/admin/

一个视频教程：http://showmedo.com/videos/video?name=1750060&fromSeriesID=175

这个有点老了，还是分支时写的一个东西，是中文：http://codeplayer.javaeye.com/blog/81645

以后找到些什么新的资料也继续贴出来发布到这里吧，希望看到其他好的关于newforms-admin的资料的朋友也可以回复出来，大家一起学习。

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师

按：陈儒先生的《Python源码剖析--深度探索动态语言核心技术 》已经上架销售，欢迎大家评论、样章试读和购买，点击下图免费试读：

海猫MSN上问我：能否帮着写一篇《Python源码剖析》 的书评？他给我发这条信息时，我正在聚精会神地敲一段超无聊的代码，我看到这话吓了一跳，脑子一激灵，手一颤抖，一个伟大的死循环就此诞生。

我知道，这都是上次写书评被人骂了之后留下的后遗症。教训深刻呀，它让我再次清醒地认识到，胡说八道是没好下场的，作孽总会遭报应，只不过有现世现报的，有来世再报的，也有子子孙孙无穷报的，总之不是不报而是时候未到的。

所以这次我学乖了，在决定写下以下的文字之前，我找海猫要了近一半的书稿内容，打算好好啃上十天半个月之后再码个三五万字的、足以让鲁迅先生汗颜的书评出来，灭灭那帮鄙视我的IT人的威风，并以此向他们证明一点，即老韩我在技术上菜是菜了一点，写出来的文字也是俗了一点，骂人骂得是没品位了一点，但百无一是之中总有一样是可取的，那就是：起码我挑错别字还是眼光毒辣的。

但事实证明我错了，拿到书稿之后，翻完第四篇我就开始后悔，不仅后悔，甚至悔得连自杀的念头都有。因为......理由嘛，就像现代社会女人口中的"爱"字一样，很难说出口。待我梳弄完百结千愁的郭敬明式的忧伤，浅吟低唱着向你道来－－因为实在看不懂。　　

这是个历史问题，其渊源可以追溯到Long Long Ago的好几年前，那时年少，风华正好，年轻的我有着年轻的心以及两弯水汪汪的大眼睛，那时我在自学一门语言叫做C语言，用的教材是谭浩强老师的《C语言程序设计》，数月后，自以为学有所得，甚是高兴，高兴之余便开始夸下海口说我要搞编程，抱着这种想法，挤进了IT圈。然而挤进门去之后却没高兴太久，因为慢慢的我发现，一般情况下的大部分时间里，不是我在搞程序，而是程序在搞我。究其原因，是因为谭老师显然是一个理论家而非实践家，在看他那伟大的《C语言程序设计》的时候，他书中的大部分例子对我而言只是起到了酒精的作用：看时感觉很High很懂，而事实上转天即忘。你知道，当一门伟大的语言堕落到只用于解答纯粹的数学问题而对解决实际问题百无一用的时候，学习者也容易堕入到自以为是的怪圈，即：自以为什么都懂了，而事实上什么都没懂。不幸的是，在IT圈也如同在娱乐圈一样，凡事也是要讲潜规则的：做为一个底层程序员，不是你能说会道资本家就会给你工资，做不出东西来只有一条路可选那就是卷铺盖走人－－长得帅被老板娘看上的除外。

于是乎，满以为找到黄金宝藏的我时运不齐、命途多舛，刚刚挤进门就被赶了出来。被赶出来之后我就再也没有碰C这个东西。并转行做起了设计和责编（混饭吃），再后来的故事就有点俗套了：因生计故，最后被逼良为那什么成了一名PHP程序员并一路混到了今天。

当然，这段话和我要写的书评完全没有关系，按小说的逻辑来说可以算是个楔子，即交代完主人公的前世今生，下面才是正文。

从上面的介绍您应该可以看到，我其实是个菜鸟。那么，聪明的您、资深的您也许就要问了，这博文怎么回事？找一个这么没文化的菜鸟来写书评，海猫同学脑子进水了吧？－－说得有道理，我估计也是，海猫嘛，在海上泡这么久的猫，脑子不进水那是神，或者机器猫。

而事实是，高手是不写书评的，高手都写序去了，比如为这本书写序的三位专家，那可是国内Python界如雷贯耳的名字（我还就用夸张的词，不怕你说我拍马屁，何况，他们本来不是马，你们鄙视不到我。）：　　

一、李迎辉（limodou，史称木头）：Python-cn社区资深会员，貌似创始人之一？UliPad的作者。
二、黄冬：新浪邮件中心Leader，貌似在写一个开源的DNS服务器。
三、冯大辉：著名DBA，《Learning Python》（Python语言入门）第一版的译者之一，国内Python先行者之一，dbanotes.net站长。　　

大家可以看到，大师们是不屑于写书评的。但这活总有人干呀对吧，所以，这就有我这等小角色的用武之地了。因为书评者，读者眼中事也。

言归正转，首先说，这是一本好书－－无论你认同与否。或许你要说：扯吧你就，你帮别人写书评，你当然不会说这是一本不好的书呀。随便你怎么理解，但我要说，这真的是一本好书，理由是：它除了是一本好书还是一本好书。（有这么胡搅蛮缠的吗？）

我有我的理由：　

一、真正用Python或者PHP做过网站的都知道，脚本语言最大的不足就是效率问题，同样的一个处理，用C写的模块来处理，可能会比用脚本语言写出来的快上10倍甚至更多，而这也正是PHP Perl存在的理由以及诸多C写的python模块存在的理由。举一个最直接的例子，在我用python来解析JSON的时候，经测试，cjson的处理速度是py-json处理速度的9倍。而在我使用python-memcach模块的时候，也同样有这样的问题，C写的模块，其匹配key的效率基本上是py-memcache的4－5倍，尤其是对较长的字符key的匹配。这就说明，如果要写出高效率的脚本程序来，那么用C来写模块是必由之路，所谓算法优化之类的讨论完全是属于扯谈，程序员中没多少是很牛的数学家，如果你不能曲径通幽，那我劝你还是老老实实地把握好语言的优势，也可算是蹊径之一。而《Python源代码分析》正好为你提供了研究python核心代码的知识，让你成为Python高效率程序开发员成为可能。　

二、研究一门脚本语言，深入的去研究其运行机制是很重要的，因为这可以为你以后写出更高效率的代码打下基础，毫无疑问，一个懂得脚本程序运行机制的开发人员，写的程序无论是执行效率还是程序规范，都会比一个只会字符串操作的开发人员写出来的强的。这就如，一个懂得重力加速度以及人体脆弱部位的人与一个啥都不懂的人，在跳楼自杀的效率上总是前者高于后者一样（这什么破比喻呀）。　　

三、纵观全书，作者对Python的对象机制、数据类型机制、编译机制、内存管理机制，分析得还是比较透彻的，这在一定程度上有助于从C阵营转过来的Python新手更快的理解Python。

四、这本书的作者陈儒老师文学功底很深，像个文人，纵观全书，诸多词汇信手拈来，行云流水。抛开其中一些晦涩的术语不谈，光文字就很精彩。比如下面这很有意思的一段："列位看官，花开两朵，各表一枝。我们先把这个问题放一放，看一看在Python开始运行时，第一个PyListObject对象被创建时的情形。嗯，这有点像上帝创世纪，挺有趣的。"－－是不是有点古龙或者金庸的味道？

当然，不能总是夸奖，也有不足，不足之处在于有些地方作者太过于注重语言表达而不是平铺直叙，我觉得这可能是作者忽略了技术书的使命的结果，或者也许是作者对自己文字水平太过自信的结果，无论如何，我们不得不承认的是，作者的优点也恰恰是其缺点。尽管书中太量的实例在一定程度上弥补了这种不足，但瑕不掩疵，终为诟病。

而需要说明的是，这书说实话并不适合Python初学者，尤其是没有C或者C＋＋基础的初学者。　　

以上为个人看了几篇样章之后的观感，不足成其为书评。只算是一家之言吧。如前面所言，本人技术水平不怎么样，不敢做更深层次的技术上的评判，但愿没有误导您。倘若误导成为了事实，欢迎你骂我，但请别带上我爸妈以及我的亲人－－因为他们比我更不懂技术，这不是他们的错。

作者：搜狐老韩

更多推荐书评：

黄冬先生推荐序

冯大辉先生推荐序

Limodou先生推荐序

作者陈儒先生博客

• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师

做GUI系统的时候，总是想去掉DOS窗口，而一般的做法是用pythonw.exe启动。很可惜，目前的2.5版本的pythonw是有一些bug的。见：http://mail.python.org/pipermail/python-bugs-list/2004-June/023703.html 。我在做项目的时候就遇到过这类问题，而且还有一些乱七八糟解释不了的问题，而用python.exe启动就是好的，但是恼人的黑窗口又出现了。

其实有一种办法可以解决，不能跨平台，仅限windows。是用windows api的ShowWindow方法，将console隐藏（就是看不到而已）。需要win32api库（copy两个文件win32api.pyd和win32gui.pyd就行了）。

import win32api, win32gui
ct = win32api.GetConsoleTitle()
hd = win32gui.FindWindow(0,ct)
win32gui.ShowWindow(hd,0)

很简单吧，就是获得console的handle，然后隐藏（0分别代表NULL和SW_HIDE）。启动还是用python.exe。

不过有一个缺点，DOS窗口在开始的时候会闪一下，:-)。

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师

      公司从成立之初就开始互联网voip相关产品开发运营，也曾经有过大规模的开发团队，团队成员也都非常有资历。虽然最后有不少人因为各种原因不开心的离开，但当我不经意间看到过去的代码，不由得不佩服过去同事们的水平和努力。

      然而我们的voip运营质量始终不能令人满意，常常听到用户反应，同一台机器同一个时刻，别的产品用的很好，偏偏我们的不好。心里非常的不服气、很着急、也很纳闷。

     稍微接触过的同行都知道，voip的技术复杂度非常高，而且几乎都是C代码。团队组建和持续的稳定的投入是开发上面临的大问题。因此每每市场部同事在我面前抱怨的时候，都是我心里非常难受和煎熬的时刻。多少个日日夜夜，也因此而泡在无数个开源项目里、论坛里，想找到突破口。

      可是昨天发生了一件事，让我非常震撼。一个使用我们公司通道的代理商，号称团队健全、流量稳定。结果为了个最基本的语音编解码的设置问题而自己琢磨一整天不说，期间一直商务技术都是这个在我开来极其不专业的家伙，中间和我通电话的时候还在充当公司客服。可以断定，他所谓的公司就他一个人。结果当他昨天晚上接通后，在我们看来最不好的路由，他打过来的电话语音质量比我们系统任何时候的都要好。

      于是就按照中间他让我帮忙解决问题所看到的系统信息，google了下。让我非常汗颜，他所盗版的平台，价格也就几万元人民币。系统不仅设计开发的非常完善，而且可运营性非常强。其成本远远低于当初的人力成本和公司投入。

      感慨读书多的人，解决问题的思路太闭塞；感慨互联网已经不是那个埋头苦干的时代，生态链已经形成。

      其实纵观国外成功的IT企业，其历程无一例外是一系列成功的收购史。如思科、微软、IBM、google、yahoo等等，数不胜数。反观国内的成功企业，腾讯、百度都是埋头自己开发，遇到类似的或有关联的公司，非得拼了命的要打死不可。如robbin所说，这些公司的成功，走狗屎运的是绝大多数。

      该调整下自己的思路了……

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师

编者按： 由陈儒（Robert Chen）先生著，哲思自由软件社区审校的 《Python源码剖析——深度探索动态语言核心技术》 一书即将上市。

在向各路大侠约请 《Python源码剖析》 书评的过程中，偶发搜集搜狐老韩先生（非韩乔生也～）连珠妙语之奇想，期冀某日能整出一本 老韩语录，在此要让诸君先睹一语为快：“而事实是，高手是不写书评的，高手都写序去了，比如为这本书写序的三位专家，那可是国内Python界如雷贯耳的名字（我还就用夸张的词，不怕你说我拍马屁，何况，他们本来不是马，你们鄙视不到我。）：”

一、李迎辉（limodou，史称木头）：Python-cn社区资深会员，貌似创始人之一？UliPad的作者。

二、黄冬：新浪邮件中心Leader，貌似在写一个开源的DNS服务器。

三、冯大辉：著名DBA，《Python Cookbook》第一版的译者之一，国内Python先行者之一，dbanotes.net站长。

欢迎大家登陆互动网评论、试读和预订：

http://www.china-pub.com/39994

让我们做得更好 ――《 Python 源码剖析》序

作者：Limodou

Python 我想已经越来越不是个陌生的词了，越来越多的人开始学习它，宣传它，使用它，甚至用它找到了工作。那么如果你了解 Python ，我想问一下，你对它有多了解呢？它是一种什么语言？如何实现的？有哪些对象，它们是如何处理的？你了解 Python 的虚拟机吗？它的运行环境呢？其实作为初学者或只是使用者，你的确不必了解这么多细节的内容，但是探究事物的原理，分析底层细节却也是许多人之所以成为高手，老鸟的原因，因为你知道别人不知道的东西，掌握了别人不了解的技术，使得你的见解、分析、以至于作品都可能超过别人。那么本书就是向你提供了一个了解 Python 底层细节的机会，你可以沿着作者的思路和角度去体会 Python 的工作原理、底层的细节，一点点了解 Python 源码中的精妙之处，有助于更好的掌握 Python 并编写出高质量的程序。

本书涉及的内容深入到 Python 的方方面面，象 Python 的对象实现机制，它们是如何用 C 来表现的，对象的特性是如何实现的，对象是如何管理的，不同对象，如 int, str, dict, list 等对象的处理； Python 的虚拟机框架，作用域的实现，运行时环境， pyc 文件，类机制等；还有一些高级话题，如内存管理， GIL( Global Interpreter Lock) 与多线程，模块动态加载等。

在接触到本书之前，我已经在作者的 Blog 上见到过部分内容，那时已经被作者不懈的毅力和深厚的功力所折服。说实话，由于经常接触 Python ，对于原本熟悉的 C 语言也越来越陌生，更不要说去“啃” Python 的 C 代码了。而 Robert Chen 可以从源码中进行有条理的分析和整理，并终于出版此书不仅让人敬佩，更替广大的 Python 爱好者表示感谢。因此当出版社希望我为本书作一个序，我毫不犹豫地答应下来。

第一次见到 Robert Chen 还是在 CPUG 的一次会课上，那时 Robert Chen 给大家带来关于《 Python 作用域与名字空间》的一个讲座，让在坐的 Pythoner 更深入地对 Python 的作用域机制有了深刻地理解，效果非常好，讨论也很热烈。这种从源码的角度来讲述的 Python 的一些规则，使得理解不再是形式上或规则上的，而是本质上或实现上的理解，让我们可以做到“知其然，更知其所以然”。

如果你是一位热心的 Pythoner ，想必会知道中文 Python 邮件列表 ( http://groups.google.com/group/python-cn ) ，那么在其中有些问题的回复中，你会发现 Robert Chen 会从源码及字节码实现的角度来回答一些问题，非常有说服力。因此当许多 Python 爱好者得知 Robert Chen 将出版此书都非常盼望，现在终于同大家见面了，幸甚！

从个人角度来说，本书不仅仅是高水平，高质量的一本书，就是纵观国内外 Python 的书籍，它也是第一本从源码角度来写的一本书，所以意义非常。目前国内原创的 Python 书籍还不多，就我所知国内已经出版的几本 Python 方面的书反响并不好，而本书应该不会让你失望。

不过本书应该不是面向初学者的书，因为它涉及了许多的内容和知识，建议你具备象 C ，数据结构，操作系统，编译原理等方面的基础知识，并且具备一定的编程经验。

再次感谢 Robert Chen 带来的这份礼物！

Limodou 于 2008 年春

• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师

// Scala
def ways(c:Int,ls:List[Int]):Int =ls match{
    case Nil   => if(c == 0) 1 else 0
    case x::xs => 0.to(c/x).foldLeft(0){ (s,n) => s+ways(c-x*n,xs) }
}
ways(200,200::100::50::20::10::5::2::1::Nil)

// Scala
//a,b,c是否恰为123456789的一个排列
def suit(a:Int,b:Int,c:Int):Boolean ={
    var fs =new Array[Boolean](10)
    def test(n:Int){
        var t =n
        while(t != 0){
            fs(t%10) =true
            t = t/10
        }
    }
    test(a)
    test(b)
    test(c)
    fs.slice(1,10).forall(_==true)
}
1234.to(9876).filter{ n => 
    2.to(Math.sqrt(n)).filter{ n%_==0 }.exists{ k => suit(k,n/k,n) }
}.foldLeft(0){ _+_ }

// Scala
def gcd(a:Int,b:Int):Int =if(a==0) b else gcd(b%a,a)
var ls = for{ a <- 1 to 9
             b <- 1 to 9
             c <- 1 until b
             if 9*b*c+a*b == 10*a*c
         } yield (c,b)
var (a,b) = ls.foldLeft(Pair(1,1)){(p,v) =>(p._1*v._1,p._2*v._2)}
var res = b/gcd(a,b)

// Scala
object Euler034 extends Application {
    var fac = Array.range(0,10).map{ n => 1.to(n).foldLeft(1){ _*_ } }
    var res = 0
    for(n <- 10 to 7*fac(9)){
        var sum = n.toString.foldLeft(0){ (s,i) => s+fac(i-'0') }
        if(sum == n) res += n
    }
    println(res)
}

// Scala
import java.util.Arrays.{binarySearch => find}
import java.util.BitSet
import scala.collection.jcl.LinkedList

object Euler035 extends Application{
    /**
       得到小于bound的素数从小到大组成的Array
       Sieve of Eratosthenes 
    */
    def takePrime(bound:Int):Array[Int] = {
        if(bound <= 2) return Array()
        var set = new BitSet(bound)
        var idx = 2
        var lst = new LinkedList[Int]
        lst.add(2)
        while(idx < bound){
            var sp = lst.last
            var st = sp*2
            while(st <= bound){
                set.set(st)
                st += sp
            }
            st = sp+1
            while(st < bound && set.get(st)) st += 1
            if(st < bound) lst.add(st)
            idx = st
        }
        lst.toArray
    }
    val pa = takePrime(1000000)
    val po = Array(1000000,100000,10000,1000,100,10,1)
    
    def suit(p:Int):Boolean ={
        var pow = po.find{_<p}.get
        var cpy = p
        do{
            cpy = cpy/10 + cpy%10*pow
            if(find(pa,cpy) < 0) return false
        }while(cpy != p)
        true
    } 
    
    var res = pa.filter{ suit _ }.length
    println(res)
}

// Scala
def isPalin(n:Int):Boolean ={
    var cpy =n
    var inv =0
    while(cpy != 0){
        inv = inv*10 + cpy%10
        cpy = cpy/10
    }
    if(inv != n) return false
    while(inv != 0){
        cpy = cpy<<1
        if((inv&1) != 0) cpy = cpy|1
        inv = inv>>>1
    }
    cpy == n
}

1.until(1000000).filter{ n => isPalin(n) }.foldLeft(0){ _+ _}

// Scala
import java.util.Arrays.{binarySearch => find}
import java.util.BitSet
import scala.collection.jcl.LinkedList

object Euler037 extends Application{
    /**
       得到小于bound的素数从小到大组成的Array
       Sieve of Eratosthenes 
    */
    def takePrime(bound:Int):Array[Int] = {
        if(bound <= 2) return Array()
        var set = new BitSet(bound)
        var idx = 2
        var lst = new LinkedList[Int]
        lst.add(2)
        while(idx < bound){
            var sp = lst.last
            var st = sp*2
            while(st <= bound){
                set.set(st)
                st += sp
            }
            st = sp+1
            while(st < bound && set.get(st)) st += 1
            if(st < bound) lst.add(st)
            idx = st
        }
        lst.toArray
    }
    val pa = takePrime(1000000)
    val po = Array(1000000,100000,10000,1000,100,10,1)
    
    def suit(p:Int):Boolean ={
        var pow = po.find{_<p}.get
        var cpy = p
        var cpx = p
        do{
            cpy = cpy%pow
            cpx = cpx/10
            pow = pow/10
            if(find(pa,cpx) < 0||find(pa,cpy) < 0) return false
        }while(pow > 1)
        true
    } 
    
    var res = pa.filter{ suit _ }.foldLeft(0){ _+_ }
    println(res)
}

// Scala
object Euler038 extends Application {
    var res = "0"
    
    def suit(s:String):Boolean = {
        if(s.length != 9) return false
        var fs =new Array[Boolean](10)
        for(c <- s)
            if(c=='0') return false
            else if(fs(c-'0')) return false
            else  fs(c-'0') =true
        true
    }
    
    for(n <- 1 until 100000){
        var n2s =""
        var mul =1
        do{
            n2s += n*mul
            mul += 1
        }while(n2s.length<9)
        if(suit(n2s) && n2s>res)  res = n2s
    }
    println(res)
}

// Scala
var res =0
var max =0
for(p <- 1 until 1000){
    var c =0
    for{ a <- 1 until p/2
         b <- 1 to a
         if a*a+b*b==(p-a-b)*(p-a-b)
    } c += 1
    if(c > max){
        max =c
        res =p
    }
}
res

// Scala
var sb = new StringBuilder
var n =1
while(sb.length < 1000000){
    sb.append(n)
    n += 1
}
var res = 1
var idx = 1
for(i <- 0 to 6){
    res = res*(sb(idx-1)-'0')
    idx = idx*10
}
res

• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师

《Python 核心编程》第二版总算要出了，这本是一个振奋人心的消息，毕竟有超过 10 位以上的 Python 爱好者一起合作翻译了这本书，能够翻译完这本长达 1000 页的 Python 巨著，这是非常不容易的。

最早是在 《Core Python Programming》(中文第二版)有奖书评活动 看到这个消息的，里面的链接指向 CPUG 的推广页 ，打开就能看到清风同学帅气的照片了 :D。不过仔细一看译者却另有其人，封皮上赫然写着“宋吉广”，但这本书可是 CPUG 组织翻译的啊，为什么译者却另有其人了呢？

看一下 China-pub 中此书的序言 部分，可以很有意思的看到贡献者列表，但正是这些贡献者们完成了本书超过 90% 以上的翻译任务。

这本书的翻译开始与 2007 年 10 月份，针对这个翻译 CPUG 还专门成立了名为 OpenBookProject 的小组。就在这个小组上，依然可以看到当时开始启动《Python 核心编程》翻译项目的页面，Py核心编程第二版翻译工程倡议！ 。翻译项目启动之后收到了非常多 Pythoner 的支持，CPUG 的老大 Zoom.Quiet 更是带头参与。现在在啄木鸟社区依然可以看到这个主题页面 。

这本书的翻译可以说历时 3 个月左右吧，判随严格的审校制度，质量得到了保证。在啄木鸟的页面 审校计划 里面可以看到所有的参与者以及参与审校的朋友们，大家付出了很多的心血保证这次翻译的完成，在这份邮件 里面，可以看到项目在 12 月出总算胜利结束了。

但是随着翻译结束，关于此书的消息就一直没有下文了，没人知道这本书什么时候会出版，这本书也没有作为 PDF 在网上流传。但目前这本书却已经在市面上开始销售了，并且译者也不再是 CPUG 所熟悉的名字，我大概看了一下 CSDN 在网上提供的示例章节，并且对比 OpenBookProject 中此书的翻译，我的直觉告诉我，这些翻译就是来自 CPUG 的朋友们，没有他们的努力，这本书不可能完成。

但是还是这个译者的问题，列表中的 CorePy 就是宋吉广，为什么他当初匿名参与，不愿意透露自己的身份，再者，为什么出版的时候他就以自己的名字作为译者，将广大参与翻译的 Pythoner 作为了贡献者。虽然我没有参与这次翻译，但是就算作为一个旁观者，我觉得也有必要出来说一下。

我们都是技术工作者，因为喜爱 Python 这门语言互相认识，并且希望能够推广 Python，大家一腔热情翻译的书最后却以别人的名字出版了，难道不觉得很难受吗。更多的还有出版涉及的利益问题，大家花了大力气翻译，但最后出版社和 宋吉广倒是占了不少便宜，反而大家什么都没有得到。如果大家不是很在乎这一块，我觉得至少也应该交给 CPUG，作为建设费用，日后可以添置服务器，设备之用。

资料：

• 《Python 核心编程》SVN 资源库
• 参与者列表

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师

• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师

用python写了个程序，分析flv的结构，并把帧类型和时间戳等信息写到文件。python在小工具方面果然不错的。

VARX = 16*16
HVARX = 16


def convertUnicodeToInt(file,bytesnum):
    result = 0
    for i in range(bytesnum):
        x = ord(file.read(1))*pow(VARX,bytesnum-i-1)
        result += x
    return int(result)

def readTimeStamp(f):
    """
    read timestamp from flv, and convert to integer (make read point go 4 steps)
    """
    base_time = convertUnicodeToInt(f,3)
    upper_time = convertUnicodeToInt(f,1)
    return pow(VARX,3)*upper_time+base_time

def rewriteTimeStampe(f,base_time):
    """
    rewrite timestamp into flv (make read point go 4 steps)
    """
    lower_time = base_time%(VARX**3)
    f.write(chr(lower_time/(VARX**2)))
    f.write(chr(lower_time%(VARX**2)/VARX))
    f.write(chr(lower_time%VARX))
    f.write(chr(base_time/(VARX**3)))
    f.seek(0,1)

def writeTagSize(f,base_time):
    """
    write tagsize before tag area in flv (make read point go 4 steps)
    """
    lower_time = base_time%(VARX**3)
    f.write(chr(base_time/(VARX**3)))
    f.write(chr(lower_time/(VARX**2)))
    f.write(chr(lower_time%(VARX**2)/VARX))
    f.write(chr(lower_time%VARX))
    f.seek(0,1)


def readFrameTypeAndCodecID(f):
    """
    read and get video tag info (make read point go 1 steps)
    """
    num = ord(f.read(1))
    #print num/HVARX
    return (num/HVARX,num%HVARX)

def readSoundInfo(f):
    """
    read and get audio tag info (make read point go 1 steps)
        return format, rate, size and type
    """
    num = ord(f.read(1))
    return (num/HVARX, )



def RepairFlv(filename,audioOffset=0,videoOffset=0):
    """
    change timestamp of <filename>
    args:
        audioOffset, videoOffset -- time offset in milliseconds
    """
    print '<== repair flv ==>'
    f = open(filename,'r+b')
    try:
        if f.read(3) == 'FLV':
            f.seek(2,1) #go to the A/V tag, it must be 5
            #f.write(chr(5)) # 5 represent flv contains both video and audio '0101'
            #f.seek(0,1)
            headerlength = convertUnicodeToInt(f,4)
            print 'the FLV header\'s length is %s'%(headerlength,)
            #go through header
            f.seek(headerlength,0)
            print 'begin reading tags'
            while True:
                f.seek(4,1)#previoustagsize, ignore it
                tagtype = ord(f.read(1))# tag type
                timestamp = None
                datalength = convertUnicodeToInt(f,3) #read data field length
                if tagtype == 18:#script tag
                    f.seek(datalength+7,1)#ignore script tag area
                elif tagtype == 9:#video tag
                    timestamp = readTimeStamp(f)

                    # change audio timestamp to force A/V sync
                    if timestamp+videoOffset<0:
                        timestamp = 0
                    else:
                        timestamp = timestamp+videoOffset
                    f.seek(-4,1)
                    rewriteTimeStampe(f,timestamp)

                    f.seek(3,1) #jump streamID
                    readFrameTypeAndCodecID(f)#f.read(1)#frametype,codecid = readFrameTypeAndCodecID(f) # go 1 step
                    f.seek(datalength-1,1)#ignore video tag area
                elif tagtype == 8:#audio tag
                    timestamp = readTimeStamp(f)

                    # change audio timestamp to force A/V sync
                    if timestamp+audioOffset<0:
                        timestamp = 0
                    else:
                        timestamp = timestamp+audioOffset
                    f.seek(-4,1)
                    rewriteTimeStampe(f,timestamp)

                    f.seek(3,1) #jump streamID
                    f.read(1)
                    f.seek(datalength-1,1)#ignore audio tag area

                print 'tag\'s type %s and timestamp is %s'%(tagtype, timestamp)

    except Exception, err:
        print err.message
    finally:
        f.close()


if __name__ == '__main__':
    import tkFileDialog, os, sys
    filename = tkFileDialog.askopenfilename(initialdir=os.getcwd())
    ouff = open('flvys.txt','w')
    sys.stdout = ouff
    RepairFlv(filename)
    ouff.close()

• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师

/**
  &#Euler013.scala
  @author: Eastsun
*/
object Euler013 extends Application {                 
    var src = """37107287533902102798797998220837590246510135740250
                 46376937677490009712648124896970078050417018260538
                 74324986199524741059474233309513058123726617309629
                 91942213363574161572522430563301811072406154908250
                 23067588207539346171171980310421047513778063246676
                 89261670696623633820136378418383684178734361726757
                 28112879812849979408065481931592621691275889832738
                 44274228917432520321923589422876796487670272189318
                 47451445736001306439091167216856844588711603153276
                 70386486105843025439939619828917593665686757934951
                 62176457141856560629502157223196586755079324193331
                 64906352462741904929101432445813822663347944758178
                 92575867718337217661963751590579239728245598838407
                 58203565325359399008402633568948830189458628227828
                 80181199384826282014278194139940567587151170094390
                 35398664372827112653829987240784473053190104293586
                 86515506006295864861532075273371959191420517255829
                 71693888707715466499115593487603532921714970056938
                 54370070576826684624621495650076471787294438377604
                 53282654108756828443191190634694037855217779295145
                 36123272525000296071075082563815656710885258350721
                 45876576172410976447339110607218265236877223636045
                 17423706905851860660448207621209813287860733969412
                 81142660418086830619328460811191061556940512689692
                 51934325451728388641918047049293215058642563049483
                 62467221648435076201727918039944693004732956340691
                 15732444386908125794514089057706229429197107928209
                 55037687525678773091862540744969844508330393682126
                 18336384825330154686196124348767681297534375946515
                 80386287592878490201521685554828717201219257766954
                 78182833757993103614740356856449095527097864797581
                 16726320100436897842553539920931837441497806860984
                 48403098129077791799088218795327364475675590848030
                 87086987551392711854517078544161852424320693150332
                 59959406895756536782107074926966537676326235447210
                 69793950679652694742597709739166693763042633987085
                 41052684708299085211399427365734116182760315001271
                 65378607361501080857009149939512557028198746004375
                 35829035317434717326932123578154982629742552737307
                 94953759765105305946966067683156574377167401875275
                 88902802571733229619176668713819931811048770190271
                 25267680276078003013678680992525463401061632866526
                 36270218540497705585629946580636237993140746255962
                 24074486908231174977792365466257246923322810917141
                 91430288197103288597806669760892938638285025333403
                 34413065578016127815921815005561868836468420090470
                 23053081172816430487623791969842487255036638784583
                 11487696932154902810424020138335124462181441773470
                 63783299490636259666498587618221225225512486764533
                 67720186971698544312419572409913959008952310058822
                 95548255300263520781532296796249481641953868218774
                 76085327132285723110424803456124867697064507995236
                 37774242535411291684276865538926205024910326572967
                 23701913275725675285653248258265463092207058596522
                 29798860272258331913126375147341994889534765745501
                 18495701454879288984856827726077713721403798879715
                 38298203783031473527721580348144513491373226651381
                 34829543829199918180278916522431027392251122869539
                 40957953066405232632538044100059654939159879593635
                 29746152185502371307642255121183693803580388584903
                 41698116222072977186158236678424689157993532961922
                 62467957194401269043877107275048102390895523597457
                 23189706772547915061505504953922979530901129967519
                 86188088225875314529584099251203829009407770775672
                 11306739708304724483816533873502340845647058077308
                 82959174767140363198008187129011875491310547126581
                 97623331044818386269515456334926366572897563400500
                 42846280183517070527831839425882145521227251250327
                 55121603546981200581762165212827652751691296897789
                 32238195734329339946437501907836945765883352399886
                 75506164965184775180738168837861091527357929701337
                 62177842752192623401942399639168044983993173312731
                 32924185707147349566916674687634660915035914677504
                 99518671430235219628894890102423325116913619626622
                 73267460800591547471830798392868535206946944540724
                 76841822524674417161514036427982273348055556214818
                 97142617910342598647204516893989422179826088076852
                 87783646182799346313767754307809363333018982642090
                 10848802521674670883215120185883543223812876952786
                 71329612474782464538636993009049310363619763878039
                 62184073572399794223406235393808339651327408011116
                 66627891981488087797941876876144230030984490851411
                 60661826293682836764744779239180335110989069790714
                 85786944089552990653640447425576083659976645795096
                 66024396409905389607120198219976047599490197230297
                 64913982680032973156037120041377903785566085089252
                 16730939319872750275468906903707539413042652315011
                 94809377245048795150954100921645863754710598436791
                 78639167021187492431995700641917969777599028300699
                 15368713711936614952811305876380278410754449733078
                 40789923115535562561142322423255033685442488917353
                 44889911501440648020369068063960672322193204149535
                 41503128880339536053299340368006977710650566631954
                 81234880673210146739058568557934581403627822703280
                 82616570773948327592232845941706525094512325230608
                 22918802058777319719839450180888072429661980811197
                 77158542502016545090413245809786882778948721859617
                 72107838435069186155435662884062257473692284509516
                 20849603980134001723930671666823555245252804609722
                 53503534226472524250874054075591789781264330331690"""
        var res = src.split("\\D+")
                     .map{ _.foldLeft(0:BigInt){ (a,b) => a*10+(b-'0') } }
                     .reduceLeft[BigInt]{ _+_ }
                     .toString
                     .substring(0,10)
        println(res)
}

    //Scala
    def lenOfPath(n:Long):Int ={
        var len =1
        var copy =n
        while(copy != 1){
            copy = if(copy%2 == 0) copy/2 else copy*3+1
            len += 1
        }
        len
    }
    var res =0
    var len =0
    for(n <- 1 until 1000000){
        val tmp =lenOfPath(n)
        if(tmp > len){
            len =tmp
            res =n
        }
    }
    res

    //Scala
    //Hint:就是求组合数C(40,20)
    1.to(20).foldLeft(1:BigInt){ (i,n) => i*(n+20)/n }

//Scala
var num = (1:BigInt)<<1000
num.toString.foldLeft(0){ _+_-'0' }

    //Scala
    val tens = Array(0,0,6,6,5,5,5,7,6,6)
    val units = Array(0,3,3,5,4,4,3,5,5,4,
                      3,6,6,8,8,7,7,9,8,8)
    def lenOf(n:Int):Int ={
        val high =n/100
        val low =n%100
        var len =0
        if(high !=0) len = 7 + units(high)
        if(high!=0 && low!=0) len += 3
        if(low <20) len+units(low)
        else len+tens(low/10)+units(low%10)
    }
    1.to(999).foldLeft(11){ (a,b) => a+lenOf(b) }

/**
   &#Euler018.scala
   @author Eastsun
*/
object Euler018 extends Application {
    var src ="""75
                95 64
                17 47 82
                18 35 87 10
                20 04 82 47 65
                19 01 23 75 03 34
                88 02 77 73 07 63 67
                99 65 04 28 06 16 70 92
                41 41 26 56 83 40 80 70 33
                41 48 72 33 47 32 37 16 94 29
                53 71 44 65 25 43 91 52 97 51 14
                70 11 33 28 77 73 17 78 39 68 17 57
                91 71 52 38 17 14 91 43 58 50 27 29 48
                63 66 04 68 89 53 67 30 73 16 69 87 40 31
                04 62 98 27 23 09 70 98 73 93 38 53 60 04 23
             """
    var num = src.split("(?m:$\\s*)")
                 .map{ _.split("\\s+")
                        .map{ _.foldLeft(0){ _*10+_-'0' } } 
                 }
    def path(row:Int,col:Int):Int =
        if(row ==num.length-1) num(row)(col)
        else num(row)(col) +path(row+1,col).max(path(row+1,col+1))
    
    println(path(0,0))
}

    //Scala
    def daysOfMonth(year:Int,month:Int):Int = month match{
        case 4|6|9|11        => 30
        case 1|3|5|7|8|10|12 => 31
        case _  => if(year%400==0||(year%4==0&&year%100!=0)) 29 else 28
    }
    var offset = 1.to(12).foldLeft(1){(s,m) => s+daysOfMonth(1900,m)}
    var res = 0
    for(year <- 1901 to 2000;month <- 1 to 12){
        if(offset%7 == 0) res += 1
        offset += daysOfMonth(year,month)
    }
    res

//Scala
1.to(100).foldLeft(1:BigInt){ _*_ }.toString.foldLeft(0){ _+_-'0' }

//Scala
    def sumOfDivisor(n:Int):Int ={
        if(n <= 1) return 0
        var sum =1
        var div =2
        while(div*div < n){
            if(n%div == 0) sum =sum+div+n/div
            div += 1
        }
        if(div*div == n) sum+div else sum
    }
    var res =0
    for(n <- 2 until 10000){
        val sd =sumOfDivisor(n)
        if(sd<n && sumOfDivisor(sd)==n) res =res+sd+n
    }
    res

/**
   &#Euler022.scala
   @author Eastsun
*/
import java.util.Scanner
import java.io.File
import scala.collection.jcl.LinkedList
import scala.util.Sorting._

object Euler022 extends Application {
    var scan = new Scanner(new File("names.txt")).useDelimiter("\"(,\")?")
    var list = new LinkedList[String]
    while(scan.hasNext()) list.add(scan.next())
    scan.close()
    var array =list.toArray
    quickSort(array)
    var res = array.zipWithIndex.foldLeft(0){(v,s) =>
                  v +(s._2+1)*s._1.foldLeft(0){ _+_-'A'+1 }
              }
    println(res)
}

• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师

记得博文视点出版公司最近出过一本书，名为《编程之美》，很是畅销。但是在我撰写《开源技术选型手册》的编写手记的时候，首先浮在脑海中的词汇是“遗憾之美”。前几天Lisa（本书责任编辑）告诉我，书稿终于拿去出片了，那一时刻我能感受到在电脑的那端，她肯定也在长舒一口气，虽然也许还有些忐忑。然后我们又聊起书中的一些遗憾，比如可能会有某些地方标点符号不正确，有些句子可能不够顺畅等等。这种感觉，我在从前做杂志期间经常有过，自己感觉非常费心费力，本认为非常完美的东西，在印刷之后常会又找到这样或者那样的Bug。对于类似的问题，我们可以无限小地避免，但要完全消灭，可能就违背了“万事无绝对”的“真理”，我就开玩笑地告诉Lisa——遗憾有时也是很美的，相信我们下次会做的更好。 这也许有点为自己开脱的意思，可是回想整本书从策划到撰写到成书的经过，这种感觉逐渐为“平和”所代替。想起在策划之初，周筠老师几次找到我，再拉上孟岩和方舟，进行沟通。先是总结这本书的前身《开源大本营》中的经验和教训，然后列出值得继续发扬和需要避免的地方，有的放矢地开始第二轮的迭代。而后将能联系上，可能会参与本书写作的作者拉到五道口蓝旗营的万圣书园开始头脑风暴。凯峰、李剑、玉宝等人先根据讨论的图书结构撰写样章，然后大家以此为靶子进行“攻击”和完善，最后总结出一个相对可行的框架结构，这也是现在本书的骨骼主体。单是万圣书园的几次聚会，我想就令几多参与人员回味的了，另外，要知道，有两次博文的朋友们还是专程从武汉赶到北京来参加的……还记得当时方舟为了让这本书的版式更加完美，还专门买了几本日本同行出版的砖头书，然后我们两个猫在丽都饭店附近的雕刻时光进行研究，详谈甚乐。因为种种原因，最终这些版式可能没有最终采用，但这个“遗憾”不也是一个很美好的记忆吗？ 如果要列出这半年来值得回忆的事情，我想躺在摇椅上摇上几宿也不一定能叙述完毕，包括责任编辑Lisa的耐心催促，包括每个作者对自己作品的精益求精，包括对本书的针对性宣传，包括后期制作过程中的各种误会，包括封面的设计，包括作者之一袁峰前些天发邮件给我说，因为父亲的去世使他没有更多精力将稿件写到最佳，很是抱歉等等。尤其值得一提的是，在这次汶川地震灾难面前，我们的所有作者表现出了自己诚挚的关注和爱心，一致同意将自己的稿费全部捐献给灾区，在本书的文前页每人还送上一句祝福，向灾区的人民表达问候。从这些等等一切的“琐事”中，我想每一个参与其中的人都会收获到自己的独特感受。 从一开始，《开源技术选型手册》这本书的定位就是面向项目经理、技术经理、高级软件工程师包括CTO等的，我们将每个领域的专家汇集在一起，将他们的经验和智慧汇集在一起，力求在尽量少的篇幅内给这些技术选型决策者提供最有价值的参考。本书是多人协作完成，在写作过程中，也许会有这样或者那样的偏差，如果读者有所体察和发现，我们都欢迎大家不吝赐教。因为如果还有下次的话，这本书在反馈的基础之上肯定会做更新，肯定会更加完美。我想让后来者看到更完美的作品对每个作者和读者都是理应担当的责任，如果这也算是一种“责任”的话。 每一个作品，哪怕是不完美的作品的背后都蕴含了无数人的努力，《开源技术选型手册》也是一样。不做书不知道做书难，这次的经历让我实实在在感受到了做书人的艰辛，借写手记的机会也向那些所有从事出版行业的“苦命人”们表示敬意！

作者：霍泰稳

----------------------------------------------------------------------------

《开源技术选型手册》的相关链接：

CSDN总裁蒋涛先生的序言：开源在中国——机会和挑战 本书

总策划霍泰稳的写作感言：《开源技术选型手册》的遗憾之美

作者之一柯自聪的写作感言：开源的思想，社区的力量

作者之一高昂的写作感言：开源技术选型手册推荐

作者之一张凯峰的写作感言：《开源技术选型手册》编写手记

作者之一刘长炯的写作感言：欢迎关注《开源技术选型手册》

原文出处：http://blog.csdn.net/bvbook/archive/2008/05/22/2468977.aspx

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师

winxp环境，采用apache2.0.63

1、mod_python

   a.拷贝mod_python.so 到 apache/modules下

   b.修改 apache 配置文件 httpd.conf ，增加以下内容

   LoadModule python_module modules/mod_python.so

   并且在文件尾部增加

   Include "d:/workspace/python/django_app/apache/apache_django_mod_python.conf"

   django_app为你的django程序目录，apache_django_mod_python.conf内容：

<VirtualHost *:80>

   <Location "/">

        #采用django用户认证时会用到
        AuthType Basic

        SetHandler python-program
         PythonPath "['D:/workspace/python','D:/workspace/python/django_app','D:/workspace/python/django_app/apps',..'c:/python25/Lib/site-packages/django'] + sys.path"
         PythonHandler django_app.my_handler
         PythonAuthenHandler django.contrib.auth.handlers.modpython

    </Location>

    Alias /media D:/workspace/python/divo3/htdocs/media
    <Location "/media">
        SetHandler None
    </Location>

    ErrorLog "logs/django_errors_log"
    CustomLog logs/django-access_log common
</VirtualHost>

   django_app.my_handler.py 内容：

#coding=utf-8
from django.core.handlers import modpython

def handler(req):
        import os, os.path, sys
        # 将当前路径插入到模块搜索路径中
        sys.path.append(os.path.dirname(__file__))
        # 加载其它路径
        # 设置站点的配置文件路径
        os.environ["DJANGO_SETTINGS_MODULE"] = 'django_app.settings'

        # 将请求原封不动交给 Django 处理， 并返回处理结果给浏览器
        return(modpython.handler(req))
# def

2、fastcgi

   a.拷贝mod_fastcgi-2.4.2-AP20.dll 到 apache/modules下

   b.修改 apache 配置文件 httpd.conf ，增加以下内容

  LoadModule fastcgi_module modules/mod_fastcgi-2.4.2-AP20.dll

   并且在文件尾部增加

   Include "d:/workspace/python/django_app/apache/apache_fastcgi.conf"

   django_app为你的django程序目录，apache_fastcgi.conf内容：

# python manage.py runfcgi method=threaded host=127.0.0.1 port=3033
FastCGIExternalServer "D:/workspace/python/django_app/dispatch.fcgi" -host 127.0.0.1:3033

<VirtualHost *:80>
  ServerName development
  DocumentRoot D:/workspace/python/django_app/

  Alias /media D:/workspace/python/django_app/htdocs/media

  RewriteEngine On
  #RewriteLogLevel 0
  RewriteRule ^/(media.*)$ /$1 [QSA,L,PT]
  RewriteCond %{REQUEST_FILENAME} !-f
  RewriteRule ^/(.*)$ /dispatch.fcgi/$1 [QSA,L]

  ErrorLog logs/dummy-host.example.com-error_log
  CustomLog logs/dummy-host.example.com-access_log common

</VirtualHost>

   dispat