小编Nat*_*iel的帖子

在如何动态更新ipython笔记本(在一个单元格内)循环中的绘图的答案中,给出了如何在Python循环内动态更新Jupyter笔记本内部的绘图的示例.然而,这可以通过在每次迭代中销毁和重新创建绘图来实现,并且其中一个线程中的注释指出可以通过使用new-ish %matplotlib nbaggmagic 来改善这种情况,这提供了嵌入在笔记本中的交互式图形,而不是而不是静态图像.

然而,nbagg就我所知,这个奇妙的新功能似乎完全没有记录,我无法找到如何使用它来动态更新绘图的示例.因此,我的问题是,如何使用nbagg后端有效地更新Jupyter/Python笔记本中的现有绘图？由于在matplotlib中动态更新绘图通常是一个棘手的问题,一个简单的工作示例将是一个巨大的帮助.指向该主题的任何文档的指针也非常有用.

要清楚我要求的是:我想要做的是运行一些模拟代码进行几次迭代,然后绘制其当前状态的图,然后再运行几次迭代,然后更新图表以反映当前状态,等等.因此,我们的想法是绘制一个绘图,然后在没有任何用户交互的情况下更新绘图中的数据,而不会破坏和重新创建整个事物.

以下是对上述链接问题的答案的一些略微修改的代码,通过每次重新绘制整个数字来实现这一点.我希望获得相同的结果,但更有效地使用nbagg.

%matplotlib inline
import time
import pylab as pl
from IPython import display
for i in range(10):
    pl.clf()
    pl.plot(pl.randn(100))
    display.display(pl.gcf())
    display.clear_output(wait=True)
    time.sleep(1.0)

通常在我的内部循环中,我需要以"环绕"方式索引数组,因此如果数组大小为100并且我的代码要求元素-2,则应该给出元素98.在许多高级语言中作为Python,人们可以简单地使用my_array[index % array_size],但由于某种原因,C的整数运算(通常)向零舍入而不是一致向下舍入,因此当给定负的第一个参数时,其模运算符返回负结果.

通常我知道这index不会少于-array_size,在这些情况下我只是这样做my_array[(index + array_size) % array_size].但是,有时这无法得到保证,对于那些情况,我想知道实现始终为正模数函数的最快方法.有几种"聪明"的方法可以在没有分支的情况下完成,例如

inline int positive_modulo(int i, int n) {
    return (n + (i % n)) % n;
}

要么

inline int positive_modulo(int i, int n) {
    return (i % n) + (n * (i < 0));
}

当然,我可以对这些进行分析,以找出哪个是我系统中最快的,但我不禁担心我可能错过了一个更好的,或者我的机器上的速度可能在另一个机器上很慢.

那么有没有一种标准的方法可以做到这一点,或者一些我错过的聪明技巧可能是最快的方式？

此外,我知道这可能是一厢情愿的想法,但如果有一种方法可以自动矢量化,那将是惊人的.

是否有Pythonic和有效的方法来检查Numpy数组是否包含给定行的至少一个实例？"有效"是指它在找到第一个匹配行时终止,而不是遍历整个数组,即使已经找到了结果.

使用Python数组,这可以非常干净地完成if row in array:,但是这不像我对Numpy数组所期望的那样工作,如下所示.

使用Python数组:

>>> a = [[1,2],[10,20],[100,200]]
>>> [1,2] in a
True
>>> [1,20] in a
False

但是Numpy数组给出了不同的,而且看起来很奇怪的结果.(__contains__方法ndarray似乎没有记录.)

>>> a = np.array([[1,2],[10,20],[100,200]])
>>> np.array([1,2]) in a
True
>>> np.array([1,20]) in a
True
>>> np.array([1,42]) in a
True
>>> np.array([42,1]) in a
False

我无法理解PyTorch的LSTM模块(以及类似的RNN和GRU)的文档.关于产出,它说:

输出:输出,(h_n,c_n)

• output(seq_len,batch,hidden_​​size*num_directions):包含来自RNN最后一层的输出要素(h_t)的张量,每个t.如果已将torch.nn.utils.rnn.PackedSequence作为输入,则输出也将是打包序列.
• h_n(num_layers*num_directions,batch,hidden_​​size):包含t = seq_len隐藏状态的张量
• c_n(num_layers*num_directions,batch,hidden_​​size):包含t = seq_len的单元格状态的张量

似乎变量output和h_n两者都给出了隐藏状态的值.是否h_n只是冗余地提供已经包含的最后一个时间步骤output,或者还有什么比它更多的东西？

每当我运行一个在OS X 10.8上打开任何类型窗口的Python脚本时,无论是GLUT窗口还是QT窗口或其他任何窗口,我都会看到如下所示的消息:

2013-09-11 14:36:53.321 Python[3027:f07] ApplePersistenceIgnoreState: Existing state will not be touched. New state will be written to /var/folders/0x/25_70mj17tb1ypm1c_js8jd40000gq/T/org.python.python.savedState

我使用通过MacPorts安装的python2.7.

这是一个小麻烦,但我很想知道这个消息意味着什么,以及我能做些什么来阻止它.是因为我的系统配置错误,还是每个人都得到了这个？

我想在Atom编辑器中更改注释的颜色.通过一些谷歌搜索,我发现我可以将以下内容放在我的.atom/styles.less文件中:

atom-text-editor::shadow .comment {
    color: #ffffaa;
}

这很好 - 现在我有明亮的黄色评论要求被注意而不是淡入背景.麻烦的是它现在看起来像下面

正如您所看到的,注释的文本颜色已更改,但注释中的注释分隔符和链接仍保留在默认的几乎不可见的灰色中,这看起来有点傻.

我的问题是(1)如何更改这些项目的颜色,更重要的是(2)我在哪里可以查看如何更改这些项目的颜色？

请注意,我不是网络程序员,对CSS或任何相关技术一无所知.因此,我正在寻找一个相当逐步的解决方案,与所发现的解决方案形成鲜明对比,例如,在这个问题的答案中,它假设了这个问题的内部运作的大量背景.

我有一个numpy数组,我想获得第i点的"邻域".通常我使用的数组是二维的,但下面的一维示例说明了我正在寻找的内容.如果

A = numpy.array([0,10,20,30,40,50,60,70,80,90])

然后,元素4的(大小5)邻域是[20,30,40,50,60],并且这可以通过这样做容易地获得A[i-2:i+3].

但是,我还需要邻域"环绕"数组的边缘,以便元素0 [80,90,0,10,20]的邻域是和元素9的邻域[70,80,90,0,10].我似乎无法找到一种优雅的方法来做到这一点,所以每次出现时我都不得不使用一些复杂,烦人的逻辑(这对我来说很常见).在2D情况下,点的邻域将是矩形阵列.

所以我的问题是,是否有一种巧妙的方式来表达这个"环绕邻居"操作在numpy？我更喜欢返回切片而不是副本的东西,但可读性和速度是最重要的考虑因素.

我注意到Python让我这样做:

>>> {1: "foo"} < {2: "bar"}
True

它允许我为列表,deques等做同样的事情.什么是<在Python中应用于字典时的语义？

一般来说,在哪里可以找到<任何给定类型集合的语义？在大多数情况下,似乎没有在文档中找到.例如:

>>> help(dict.__cmp__)

Help on wrapper_descriptor:

__cmp__(...)
    x.__cmp__(y) <==> cmp(x,y)

>>> help(cmp)

Help on built-in function cmp in module __builtin__:

cmp(...)
    cmp(x, y) -> integer

    Return negative if x<y, zero if x==y, positive if x>y.

我问,因为我有一个表格的元组列表(int, dict).我想根据第一个元素对这个数组进行排序,但如果第一个元素对于两个项目是相等的,那么我不关心第二个元素.我想知道是否myArray.sort()会做一些复杂的事情,包括在这种情况下通过dicts递归,或者它只返回一个任意值.

我刚刚开始<random>第一次使用C++ 11的标题,但仍有一些东西看起来有点神秘.这个问题是关于完成一项非常简单的任务的预期的,惯用的,最佳实践方法.

目前,在我的代码的一部分我有这样的事情:

std::default_random_engine eng {std::random_device{}()};
std::uniform_int_distribution<> random_up_to_A {0, A};
std::uniform_int_distribution<> random_up_to_B {0, B};
std::uniform_int_distribution<> random_up_to_some_other_constant {0, some_other_constant};

然后当我想要一个0和BI之间的整数调用random_up_to_B(eng).

由于这开始看起来有点傻,我想实现一个函数rnd,rnd(n, eng)返回0到n之间的随机整数.

像下面这样的东西应该工作

template <class URNG>
int rnd(int n, URNG &eng) {
    std::uniform_int_distribution<> dist {0, n};
    return dist(eng);
}

但这涉及每次创建一个新的分发对象,我得到的印象不是你应该这样做的方式.

所以我的问题是,使用<random>标题提供的抽象来完成这个简单任务的预期最佳实践方法是什么？我问,因为我一定要做比以后更复杂的事情,我想确保我以正确的方式使用这个系统.

我正在编写一个Haskell程序,它涉及模拟一个抽象机器,它具有内部状态,接受输入并提供输出.我知道如何使用状态monad实现这一点,从而产生更清晰,更易于管理的代码.

我的问题是,当我有两个(或更多)有状态对象相互交互时,我不知道如何使用相同的技巧.下面我给出了一个高度简化的问题版本,并勾勒出我到目前为止的内容.

为了这个问题,让我们假设一个机器的内部状态只包含一个整数寄存器,因此它的数据类型是

data Machine = Register Int
        deriving (Show)

(实际的机器可能有多个寄存器,程序指针,调用堆栈等等,但现在不要担心.)在上一个问题之后我知道如何使用状态monad实现机器,所以我不必显式传递其内部状态.在这个简化的示例中,导入后实现如下所示Control.Monad.State.Lazy:

addToState :: Int -> State Machine ()
addToState i = do
        (Register x) <- get
        put $ Register (x + i)

getValue :: State Machine Int
getValue = do
        (Register i) <- get
        return i

这让我可以写出类似的东西

program :: State Machine Int
program = do
        addToState 6
        addToState (-4)
        getValue

runProgram = evalState program (Register 0)

这会将6添加到寄存器,然后减去4,然后返回结果.状态monad跟踪机器的内部状态,以便"程序"代码不必明确跟踪它.

在命令式语言的面向对象样式中,这个"程序"代码可能看起来像

def runProgram(machine):
    machine.addToState(6)
    machine.addToState(-4)
    return machine.getValue()

在这种情况下,如果我想模拟两台彼此交互的机器,我可能会写

def …