考虑如下代码：

#!/usr/bin/env python
p1 = Popen(["cat", "somebigfile"], stdout = PIPE)
p2 = Popen(["head"], stdin = p1.stdout, stdout = PIPE)
print p2.communicate()[0]

会出现

cat: write error: Broken pipe

原因是在Unix-like系统中，Python启动就会SIG_IGN掉SIG_PIPE，致使cat获取不了SIG_PIPE信号，还向已关闭的管道写入。很久之前就有人提出这个BUG了，这个BUG在Python 3.x已经修复，但是一直没有在Python 2.x实现。

解决方法如下：
1. 下载对应版本的Python源码，找到Lib\subprocess.py（我发现2.6.x的跟2.7.x的就不同）
2. 把该文件放到项目文件夹，改名为sub.py
3. 作如下改动：

--- /usr/lib/python2.6/subprocess.py    2010-04-16 21:58:41.000000000 +0800
+++ sub.py      2011-08-26 17:45:57.576284992 +0800
@@ -429,7 +429,7 @@
     import fcntl
     import pickle
 
-__all__ = ["Popen", "PIPE", "STDOUT", "call", "check_call", "CalledProcessError"]
+__all__ = ["Popen", "PIPE", "STDOUT", "call", "check_call", "CalledProcessError", "_eintr_retry_call"]
 
 try:
     MAXFD = os.sysconf("SC_OPEN_MAX")

4. 新建new_subprocess.py， 建立Popen_new类，继承原来subprocess的Popen，并把sub.py里面Popen类的POSIX版本的_execute_child方法copy过来。

5. 在

if cwd is not None:
	os.chdir(cwd)

后面加上如下代码：

import signal
signals = ('SIGPIPE', 'SIGXFZ', 'SIGXFSZ')
for sig in signals:
	if hasattr(signal, sig):
		signal.signal(getattr(signal, sig), signal.SIG_DFL)

（此处有一个示例，Python 2.6.5版本的）

6. 在项目里

from new_subprocess import Popen_new as Popen

即可

Python内置marshal, cPickle等序列化库，但cPickle效率不太理想，marshal文档也说不保证版本兼容性。今天在列表中看到几个第三方库，故自己测试下：

测试脚本：

#!/usr/bin/env python

import sys,os,time
import cPickle
import marshal
import shelve
import tnetstring
import msgpack

def get_dict():
    d = {}
    for i in xrange(500000):
        d[i] = "abcd" * 10

    return d

import time, functools

def timeit(func):
    @functools.wraps(func)
    def __do__(*args,**kwargs):
        start = time.time()
        result= func(*args,**kwargs)
        print '%s used time %ss'%(func.__name__,time.time()-start)
        return result
    return __do__

@timeit
def marshal_dump(d):
    return marshal.dumps(d)

@timeit
def marshal_load(s):
    return marshal.loads(s)

def marshal_test(d):
    s = marshal_dump(d)
    marshal_load(s)

@timeit
def cPickle_dump(d):
    return cPickle.dumps(d, cPickle.HIGHEST_PROTOCOL)
@timeit
def cPickle_load(s):
    return cPickle.loads(s)

def cPickle_test(d):
    s = cPickle_dump(d)
    cPickle_load(s)

@timeit
def tnetstring_dump(d):
    return tnetstring.dumps(d)

@timeit
def tnetstring_load(s):
    return tnetstring.loads(s)

def tnetstring_test(d):
    s = tnetstring_dump(d)
    tnetstring_load(s)

@timeit
def msgpack_dump(d):
    return msgpack.packb(d)

@timeit
def msgpack_load(s):
    return msgpack.unpackb(s)

def msgpack_test(d):
    s= msgpack_dump(d)
    msgpack_load(s)

def main():
    d = get_dict()
    marshal_test(d)
    cPickle_test(d)
    tnetstring_test(d)
    msgpack_test(d)

if __name__ == "__main__":
    main()

在一台Ubuntu 10.04 32bit，双核Intel(R) Xeon(TM) CPU 3.06GHz机器上，有如下成绩：

marshal_dump used time 0.18213891983s
marshal_load used time 0.335217952728s
cPickle_dump used time 2.73869895935s
cPickle_load used time 0.558264017105s
tnetstring_dump used time 0.622045040131s
tnetstring_load used time 0.311910152435s
msgpack_dump used time 1.07127404213s
msgpack_load used time 0.27454996109s

结论

• cPickle最慢，基本上可以抛弃
• marshal虽然有不兼容隐患，但如果能保证相同的Python版本，还是可以一用
• tnetstring无论序列化或反序列化速度都比较中庸
• msgpack反序列化最快，如果读多写少的应用场景是最佳选择。而且msgpack支持多语言。

Python中有自动gc，这个gc在一般情况下也可以清除循环引用的对象。

不过有个例外的情况：一个对象显式定义了__del__方法。

例如如下的代码：

#!/usr/bin/env python

class Foo:
    def __init__(self):
        self._bar = {"test": self.test}
        print "construct"

    def test(self):
        print "test"

    def __del__(self):
        print "del"

f = Foo()
del f

运行结果是不会打印”del”的。

文档里面也有写到：
http://docs.python.org/library/gc.html#gc.garbage

gc.garbage
A list of objects which the collector found to be unreachable but could not be freed (uncollectable objects). By default, this list contains only objects with __del__() methods. [1] Objects that have __del__() methods and are part of a reference cycle cause the entire reference cycle to be uncollectable, including objects not necessarily in the cycle but reachable only from it. Python doesn’t collect such cycles automatically because, in general, it isn’t possible for Python to guess a safe order in which to run the __del__() methods. If you know a safe order, you can force the issue by examining the garbage list, and explicitly breaking cycles due to your objects within the list. Note that these objects are kept alive even so by virtue of being in the garbage list, so they should be removed from garbage too. For example, after breaking cycles, do del gc.garbage[:] to empty the list. It’s generally better to avoid the issue by not creating cycles containing objects with __del__() methods, and garbage can be examined in that case to verify that no such cycles are being created.

当一个对象显式定义了__del__方法，而且里面有循环引用，Python不会自动回收这个对象。如果这种情况没有正确处理，会造成内存泄漏。

解决的办法是在__del__中手动解除循环引用，或者干脆避免这种有循环引用的写法。

这个问题导致数据库连接不能释放，终于在周末晚上数据库连接爆了，丢脸啊。

PS: 这次事件也再一次显示“分层架构互不信任防雪崩策略”的重要性。这个出事的DB是一个slave，它的max_connection和max_user_connection是一样的，而且连接超时竟然是8小时……如果max_user_connection设小点，顶多是使用这个用户的系统挂掉，而不会是所有使用这个DB的系统都挂掉，把影响隔离起来。

python有一个编译好的模块，需要增加一个方法。由于不想修改源代码再编译，所以使用动态绑定方法来给实例增加方法。

第一印象，想到使用如下方法：

def foo(self):
	print self.name

a = A()
a.foo = foo

>>> a.foo()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: foo() takes exactly 1 argument (0 given)

结果是无法访问实例的变量。 比较新绑定的方法与原有的实例方法，发现原有的实例方法是bound method。只有bound method才能访问实例的变量。

要动态为实例绑定方法，可以使用new模块(http://docs.python.org/library/new.html)。 （文档中说new模块已经过期，推荐使用types模块。但我看types的文档，想不明白如何取代new模块）

import new
a.foo = new.instancemethod(foo, a, A)

问题又来了，新加的方法里有调用实例的私有函数（以双下划线开头），报了如下错误：

class A():
    def __private(self):
        print "private"

    def public(self):
        self.__private()

def foo(self):
    self.__private()

a = A()
import new
a.foo = new.instancemethod(foo, a, A)
a.foo()

Traceback (most recent call last):
  File "E:tmptest.py", line 14, in <module>
    a.foo()
  File "E:tmptest.py", line 9, in foo
    self.__private()
AttributeError: A instance has no attribute '__private'

通过观察原有方法和动态绑定方法的字节码，发现LOAD_ATTR有差别。原有方法的LOAD_ATTR是“_A__private”，动态绑定的方法的LOAD_ATTR是“__private”

class A():
    def __private(self):
        print "private"

    def public(self):
        self.__private()

def foo(self):
    self.__private()

a = A()
import dis
dis.dis(a.public)
a.public()

import new
a.foo = new.instancemethod(foo, a, A)
dis.dis(a.foo)
a.foo()

  6           0 LOAD_FAST                0 (self)
              3 LOAD_ATTR                0 (_A__private) # a.public
              6 CALL_FUNCTION            0
              9 POP_TOP
             10 LOAD_CONST               0 (None)
             13 RETURN_VALUE
private
  9           0 LOAD_FAST                0 (self)
              3 LOAD_ATTR                0 (__private) # a.foo
              6 CALL_FUNCTION            0
              9 POP_TOP
             10 LOAD_CONST               0 (None)
             13 RETURN_VALUE

这里的原因是python会对private方法进行名字粉碎(name mangling) 。因此修改foo方法里面的调用为self._A__private()，通过。但这样修改后，方法对于不同的class会不通用，有待研究更好的方法