小编usu*_* me的帖子

有时我的Ipython笔记本会崩溃,因为我print在一个大循环或一个递归函数中留下了一个语句.内核显示busy,stop按钮通常没有响应.最终Chrome会问我是否要杀死该页面或等待.

有没有办法限制给定单元格中的输出行数？或者任何其他方法来避免这个问题？

我使用%memit魔术函数来测量内存使用情况:

In [1]: %memit n = pow(10, 7); range(n)
peak memory: 568 MiB, increment: 272 MiB

In [2]: %memit n = pow(10, 7); set(xrange(n))
peak memory: 824 MiB, increment: 447 MiB

好的,所以似乎有一个中间步骤,其中xrange(n)实例化为完整列表.但是,如果我将列表分成10个子列表,并将它们逐个联合起来呢？这会更有效,对吧？

In [3]: %memit n = pow(10, 7); reduce(set.union, (set(xrange(p, n, 10)) for p in range(10)))
peak memory: 1260 MiB, increment: 897 MiB

嗯,这没有按预期进行.为什么这种reduce方法消耗的内存比set(xrange(n))？

所以我想对齐包含非ascii字符的字段.以下似乎不起作用:

for word1, word2 in [['hello', 'world'], ['?????', '??']]:
    print "{:<20} {:<20}".format(word1, word2)

hello                world
?????      ??

有解决方案吗？

我还没有找到一种很好的方法来监视Python脚本的内存使用情况multiprocessing.更具体地说,我这样说:

import time

biglist = range(pow(10, 7))
time.sleep(5)

内存使用量为1.3 GB,由两者/usr/bin/time -v和top.但现在,说我这样做:

import time
from multiprocessing import Pool

def worker(x):
    biglist = range(pow(10, 7))
    time.sleep(5)
    return

Pool(5).map(worker, range(5))

现在top报告5 x 1.3 GB,这是正确的.但/usr/bin/time -v仍然报告1.3 GB,这是没有意义的.如果它正在测量父进程的消耗,那么应该说0.如果它正在测量父进程和子进程,那么它应该报告5 x 1.3 GB.为什么说1.3 GB？现在让我们尝试copy-on-write:

import time
from multiprocessing import Pool

biglist = range(pow(10, 7))

def worker(x):
    time.sleep(5)
    return

Pool(5).map(worker, range(5))

现在/usr/bin/time -v报告1.3 GB(再次),这是正确的.但top报告6 x 1.3 GB,这是不正确的.使用copy-on-write,它应该只报告1.3 GB.

如何使用multiprocessing？可靠地监视Python脚本的内存使用情况？

至少可以考虑使用3种类型的n-gram来表示文本文档:

• 字节级n-gram
• 字符级n-gram
• 字级n-gram

我不清楚哪一个应该用于给定的任务(聚类,分类等).我在某处读到,当文字包含拼写错误时,字符级别的n-gram优于字级n-gram,因此"Mary loves dogs"仍然类似于"Mary lpves dogs".

选择"正确"表示还有其他标准需要考虑吗？

所以列表是不可用的:

>>> { [1,2]:3 }
TypeError: unhashable type: 'list'

以下页面给出了解释:

列表是可变类型,不能用作字典中的键(它可以就地更改,使得键不再可以在字典的内部哈希表中找到).

我理解为什么不可能将可变对象用作字典键.但是,即使我只是尝试哈希列表(独立于字典创建),Python也会引发相同的异常

>>> hash( [1,2] )
TypeError: unhashable type: 'list'

Python这样做是为了保证可变类型永远不会被用作字典键吗？或者是否存在使可变对象无法散列的另一个原因,无论我打算如何使用它们？

以下函数返回None:

In [5]: def f():
   ...:     pass

所以我对这个输出并不感到惊讶:

In [8]: dis.dis(f)
  2           0 LOAD_CONST               0 (None)
              3 RETURN_VALUE        

In [10]: f.__code__.co_consts
Out[10]: (None,)

好的,这是有道理的.但是现在,考虑以下功能:

In [11]: def g():
   ....:     return 1

In [12]: dis.dis(g)
  2           0 LOAD_CONST               1 (1)
              3 RETURN_VALUE        

In [13]: g.__code__.co_consts
Out[13]: (None, 1)

g不使用None,为什么会这样co_consts？

说我有一个列表L。如何获得K组所有分区上的迭代器？

示例：L = [2,3,5,7,11，13]，K = 3

3组的所有可能分区的列表：

[ [ 2 ], [ 3, 5], [ 7,11,13] ]
[ [ 2,3,5 ], [ 7, 11], [ 13] ]
[ [ 3, 11 ], [ 5, 7], [ 2, 13] ]
[ [ 3 ], [ 11 ], [ 5, 7, 2, 13] ]
etc...

===更新===

我正在研究一个似乎可行的解决方案，所以我只复制粘贴它即可

# -*- coding: utf-8 -*-

import itertools 

# return ( list1 - list0 )
def l1_sub_l0( l1, l0 ) :
    """Substract two lists"""
    #
    copy_l1 …

说你有：

int f( const T a ) { ... }
int g( const T &a ) { ... }

我理解constin的用法g：我们不知道a函数外是如何使用的，所以我们想保护它不被修改。但是我不明白constin的使用f，哪里a是本地副本。为什么我们需要保护它不被修改？

所以我可以在列表上创建一个反向迭代器:

list(reversed([0,1,2,3]))

[3, 2, 1, 0]

我以为这只是简单地调用getitem从指数len(...)-1到0.但是我不能这样做:

list(reversed(xrange(4)))

[3, 2, 1, 0]

现在我有点困惑.这会创建列表xrange(4)然后反转它吗？如果没有,它如何知道最后一个元素是什么以及如何倒退？我阅读了文档,但没有用.