小编Bil*_*ill的帖子

我无法理解此Python调试程序会话中引发的以下异常：

(Pdb) p [move for move in move_values if move[0] == max_value]
*** NameError: name 'max_value' is not defined
(Pdb) [move for move in move_values]
[(0.5, (0, 0)), (0.5, (0, 1)), (0.5, (0, 2)), (0.5, (1, 0)), (0.5, (1, 1)), (0.5, (1, 2)), (0.5, (2, 0)), (0.5, (2, 1)), (0.5, (2, 2))]
(Pdb) max_value
0.5
(Pdb) (0.5, (0, 2))[0] == max_value
True
(Pdb) [move for move in move_values if move[0] == 0.5]
[(0.5, (0, 0)), (0.5, (0, 1)), (0.5, (0, …

这是"取消种子"随机数生成器的唯一方法:

np.random.seed(int(time.time()))

如果你想要在循环中使用某些代码来重复(例如测试),而其他代码要在每个循环中随机进行,那么在设置后如何将种子"重置"为随机数生成器？

以下代码说明了此问题:

import numpy as np

def test():
    np.random.seed(2)
    print("Repeatable test:", [np.random.randint(10) for i in range(3)])

for i in range(4):
    print("Random number:", np.random.randint(10))
    test()

Random number: 8
Repeatable test: [8, 8, 6]
Random number: 2
Repeatable test: [8, 8, 6]
Random number: 2
Repeatable test: [8, 8, 6]
Random number: 2
Repeatable test: [8, 8, 6]

期望的结果:我希望每个循环随机数是随机的.

我很乐意导入时间模块,如果这是唯一的方法,但我认为可能有一个更简单,更健壮的方式.

(根据这篇文章你不能得到当前的种子)

不确定这是否可能，但我正在尝试从具有位置和关键字参数的函数创建部分函数。问题是，我希望结果部分函数中的参数设置原始函数中的关键字参数之一 - 而不是其位置参数之一。

这是原始函数的定义：

def cost_function(self, X, y, weights=None, lambda_param=0.0):

我想要一个可以传递给 scipy.minimise 的部分函数，​​这样我就可以找到最佳权重值（权重是一个 ndarray）。

所以我需要的是一个只有一个参数的部分函数（x 说）：

例如

cost_func(x)

但我希望部分函数在调用原始函数时设置权重参数：

my_network.cost_function(X, y, weights=x, lambda_param=0.0)

（我知道我可以更改原始函数，以便权重参数是位置参数而不是关键字参数，但我不想这样做，因为我也想在没有权重参数集的情况下使用该函数）。

我是 Julia 的新手，正在尝试从本文复制的一些代码。它应该是在 Julia 中进行面向对象编程（即类）的一种方法：

using Lathe.stats: mean, std\n\nstruct NormalDistribution{P}\n    mu::Float64\n    sigma::Float64\n    pdf::P\nend\n\nfunction NormalDistribution(x::Array)\n        pdf(xt::Array) = [i = (i-\xce\xbc) / \xcf\x83 for i in xt]\n        return new{typeof(pdf)}(mean(x), std(x), pdf)\nend\n\nx = [5, 10, 15, 20]\ndist = NormalDistribution(x)\n

但是，当我在 Jupiter 笔记本中使用 Julia 1.1.1 运行此命令时，出现以下异常：

UndefVarError: new not defined\n\nStacktrace:\n [1] NormalDistribution(::Array{Int64,1}) at ./In[1]:11\n [2] top-level scope at In[1]:15\n

我在内部构造函数方法上找到了这个文档页面，它解释了它们有

\n

一个特殊的本地存在函数，称为new创建块类型的对象。

\n

（尽管上面链接的文档new说它是一个关键字）。

我可能错误地复制了代码，但也许有人可以解释如何实现原作者在文章中提出的建议。另外，我还不知道如何在 Julia 中进行调试，所以任何指针都会受到赞赏。

当您从另一个系列中减去一个系列时,如果第二个系列中没有要删除的记录,则结果包含NaN.

In [1]: import pandas as pd

In [2]: a = pd.Series({1: 100, 2: 102, 3: 103, 4: 104})

In [3]: a
Out[3]:
1    100
2    102
3    103
4    104
dtype: int64

In [4]: b = pd.Series({1: 5, 3: 7})

In [5]: a - b
Out[5]:
1    95.0
2     NaN
3    96.0
4     NaN
dtype: float64

假设缺失数据等于零,是否有更简单的方法进行减法？除了手动插入这样的零:

In [15]: b_dash = pd.Series(b, index=a.index).fillna(0.0)

In [16]: a - b_dash
Out[16]:
1     95.0
2    102.0
3     96.0
4    104.0
dtype: float64

我是 Dask 的新手，并认为这将是一项简单的任务。我想从多个 csv 文件加载数据并将其合并到一个 Dask 数据帧中。在本例中，有 5 个 csv 文件，每个文件有 10,000 行数据。显然我想给组合的数据框一个唯一的索引。

所以我这样做了：

import dask.dataframe as dd

# Define Dask computations
dataframes = [
    dd.read_csv(os.path.join(data_dir, filename)).set_index('Unnamed: 0')
    for filename in os.listdir(data_dir) if filename.endswith('.csv')
]

combined_df = dd.concat(dataframes).reset_index(drop=True)

如果我这样做，combined_df.head().index我会按预期得到这个：

RangeIndex(start=0, stop=5, step=1)

但combined_df.tail().index并不如预期：

RangeIndex(start=3252, stop=3257, step=1)

进一步检查发现索引值combined_df由 15 个独立的系列组成，长度大约为 3256，加起来总长度为 50000。请注意，csv 文件在第一列中都包含一个从 0 到 10000 的索引。

这里发生了什么，我如何获得一个从 0 到 50000 的标准整数索引，它是所有 csv 文件中总行数的总和？

背景

如果您需要测试上面的代码，这里有一个设置脚本来创建一些 csv 文件：

import os
import numpy as np
import …

我知道这一定很容易，但是我无法弄清楚或找到现有的答案...

说我有这个数据框...

>>> import pandas as pd
>>> import numpy as np
>>> dates = pd.date_range('20130101', periods=6)
>>> df = pd.DataFrame(np.nan, index=dates, columns=list('ABCD'))
>>> df
             A   B   C   D
2013-01-01 NaN NaN NaN NaN
2013-01-02 NaN NaN NaN NaN
2013-01-03 NaN NaN NaN NaN
2013-01-04 NaN NaN NaN NaN
2013-01-05 NaN NaN NaN NaN
2013-01-06 NaN NaN NaN NaN

设置一个系列的值很容易...

>>> df.loc[:, 'A'] = pd.Series([1,2,3,4,5,6], index=dates)
>>> df
            A   B   C   D
2013-01-01  1 NaN NaN NaN
2013-01-02  2 NaN …

我正在对来自 numpy 数组的标量值进行一些快速计算。正如文档中所说，

使用数组标量的主要优点是它们保留了数组类型（Python 可能没有可用的匹配标量类型，例如 int16）...

但是有没有比这更好（更快，更简洁）的方法来为现有数组标量分配一个新值：

>>> x = np.array(2.0, dtype='float32')

这有效但不是那么方便（我正在做其他算术并希望始终保留该类型）。

由于明显的原因，这不起作用：

>>> x = np.array(1.0, dtype='float32')
>>> print(x, type(x))
1.0 <class 'numpy.ndarray'>
>>> x = 2.0
>>> print(x, type(x))
2.0 <class 'float'>

这也不行：

>>> x = np.array(1.0, dtype='float32')
>>> x[] = 2.0
  File "<ipython-input-319-7f36071ff81d>", line 2
    x[] = 2.0
      ^
SyntaxError: invalid syntax

也不是这个：

>>> x = np.array(1.0, dtype='float32')
>>> x[:] = 2.0
---------------------------------------------------------------------------
IndexError                                Traceback (most recent call last)
<ipython-input-24-62cd4ca238ce> in <module>()
      1 x …