用 AsyncResult 对象的 forget()方法

result = some_task.delay()
result.forget()

让程序员给种子的目的就是为了使程序的行为是可以复现的。
给定一个种子，随机数生成器生成的随机数序列是固定不变的。在调试程序的时候，给一个固定的种子，保证每次程序跑的时候使用的是相同的随机数序列。因为可能有些 BUG 只有在特定的随机数时才会触发，我就能保证在调试的时候每次跑都会触发这个 BUG 。如果标准库内置了变化的种子（比如用时间戳）而无法人为固定，那你就会发现，你的程序有的时候没 BUG ，有的时候有 BUG ， BUG 的复现不受你的控制，从而大大增加了调试的难度。
当然，调试完成后，用于生产环境中的程序还是得用非固定值（比如时间戳）来作为种子。

py3 的坑
i / k not in s: i / k 的结果是 float...
应该用 //

@dtysky

IP的去耦和分离是对的。我的设想是，开发一个IP间的可配置(最好是runtime reconfigurable)的通信框架，让图像数据能被多个IP处理：input data->IP1->IP2->IP3->output data。用户可以在ARM上配置，IP1是什么功能，参数是什么，IP2是什么功能，参数是什么，etc..。一种方案是用partial reconfiguration，比如FPGA上设置3个reconfigurable region。这时数据流是input data->R1->R2->R3->output data，然后对所有可以使用的IP生成它们的partial bitstream，这样用户就可以选择R1, R2, R3里分别载入什么IP，实现动态配置。

>>想过直接写一个py实现的verilog + systemverilog解析器直接绕过Modelsim

没看明白。。你是想做一个verilog仿真器？看波形的那种？那么这个东西只是测试用的，生成IP不需要啊

LZ进行了HW vs SW算法结果的比较，SW是Python实现，只是对图像输出的精度进行了比较。
既然用了Zynq，何不试着用Zynq ARM里的NEON来实现SW算法，和HW算法进行一下性能的比较。如果是HW胜，可以进一步考虑给图像处理IP做一个linux下的driver，让linux/zynq下运行的程序可以使用FPGA上的IP来加速图像处理算法。还可以把IP串起来做一个reconfigurable image processing pipeline，比如先缩放后旋转再滤波之类的，来加速对视频串流的处理

class SVM:
def __init__(self,kernel=linear_kernel):
self._kernel = kernel
def exec_kernel(x, y, **kwargs):
self._kernel(x, y, **kwargs)

svm = SVM(kernel=gaussian_kernel)
svm.exec_kernel(x, y, sigma=5)

@muziyue @mengskysama 第4组数据并不仅仅是空数据，而是EOF。可以在python console里试试raw_input().strip() 然后不是按回车，而是Ctrl+D（发送EOF），就会报EOFError异常了。raw_input()里文档也说"When EOF is read, EOFError is raised"。所以必须要捕获EOFError这个异常。

try:
....print len((raw_input().split() or [''])[-1])
except EOFError:
....print 0

@no13bus 用chain的好处是task之间的依赖关系比较清晰，直接对应业务逻辑; 并且celery会自己保存中间结果(TasksA的结果)，可以直接用result.parent.get()查看

celery 可以用chain把前一个task的返回值传给下一个task:

# (4 + 4) * 8 * 10
>>> res = chain(add.s(4, 4), mul.s(8), mul.s(10))

你可以用TaskA拉数据，如果有数据就返回数据，没有数据就返回None.
TaskB取TaskA的返回值作参数，如果是None就直接返回，如果是非None就处理数据更新数据库

@hahastudio 有道理，原来是码错了。。

@hahastudio @14 setdefault 看着简短，但速度还是没有直截了当的if else快 (大约快30%)

https://gist.github.com/starsoi/ef3c813ebd2c04e3e8ff.js

直接用json.loads就行了啊

from __future__ import print_function

s = """
{"text":"Photo: seco http://tumblr.com/xjd1bnfg4w","id_str":"28965133095010304","id":28965133095010304,"created_at":"Sun Jan 23 24:00:00 +0000 2011","retweeted":false,"retweet_count":0,"favorited":false,"user":{"id_str":"45378162","id":45378162,"screen_name":"Cosmic_dog","name":"Pablo"},"requested_id":28965133095010304}
"""

from json import loads

row = loads(s)

for k, v in row.items():
if isinstance(v, dict):
print(k+': ')
for ki, vi in v.items():
print(' '+ki+': ', vi)
else:
print(k+': ', v)

@hit9 我的timeit多算了10000次的iter()的开销。。。把iter放到setup里就一样了

>>> timeit('zip(*[b]*2)', setup='a=range(100000);b=iter(a)', number=10000)
0.022448062896728516

@hit9 zip(*[iter(lst)]*2) 太慢了

>>> timeit('zip(*[iter(a)]*2)', setup='a=range(100000);b=iter(a)', number=10000)
18.37099289894104

受你的启发，这样可读性更高，而且也超快:

b=iter(a)
zip(b,b)

>>> timeit('zip(b,b)', setup='a=range(100000);b=iter(a)', number=10000) 0.022648096084594727

b=iter(a)
[(x, b.next()) for x in b]
速度比上面的zip快，尤其是当a很大的时候

Python 2.7.3

>>> timeit('zip(a[::2], a[1::2])', setup='a=[1,2,3,4,5,6,7,8]', number=10000)
0.00456690788269043

>>> timeit('[(x, b.next()) for x in b]', setup='a=[1,2,3,4,5,6,7,8];b=iter(a)', number=10000)
0.0014100074768066406

>>> timeit('zip(a[::2], a[1::2])', setup='a=range(100000)', number=10000)
21.61440110206604

>>> timeit('[(x, b.next()) for x in b]', setup='a=range(100000);b=iter(a)', number=10000)
0.022505998611450195

现在的渲染器一般自己就支持网络渲染。在100台机器上装上渲染器的slave端，然后渲染器的master端就会自动把渲染任务分配给那100台机器去算。
所以说做渲染云，就是买渲染器装在机器上就行。就看你买不买得起渲染器了