小编Nra*_*ras的帖子

我试图用正数和负数绘制矩阵.数字将在-1到1的间隔内,但不在整个范围内.例如,数字有时可以在-0.2到+0.8的范围内(参见下面的代码).我想使用bwr-colormap(蓝色 - >白色 - 红色),使零始终以白色进行颜色编码.-1应该用最暗的蓝色进行颜色编码,+1应该用最暗的红色进行颜色编码.这是一个例子,其中两个图只能用它们的颜色条区分.

import numpy
from matplotlib import pyplot as plt

# some arbitrary data to plot
x = numpy.linspace(0, 2*numpy.pi, 30)
y = numpy.linspace(0, 2*numpy.pi, 20)
[X, Y] = numpy.meshgrid(x, y)
Z = numpy.sin(X)*numpy.cos(Y)

fig = plt.figure()
plt.ion()
plt.set_cmap('bwr') # a good start: blue to white to red colormap

# a plot ranging from -1 to 1, hence the value 0 (the average) is colorcoded in white
ax = fig.add_subplot(1, 2, 1)
plt.pcolor(X, Y, Z)
plt.colorbar()

# …

我有一个pandas DataFrame,时间作为索引(1分钟Freq)和几列数据.有时数据包含NaN.如果是这样,我只想在间隙不超过5分钟的情况下进行插值.在这种情况下,这将是最多5个连续的NaN.数据可能如下所示(几个测试用例,显示了问题):

import numpy as np
import pandas as pd
from datetime import datetime

start = datetime(2014,2,21,14,50)
data = pd.DataFrame(index=[start + timedelta(minutes=1*x) for x in range(0, 8)],
                         data={'a': [123.5, np.NaN, 136.3, 164.3, 213.0, 164.3, 213.0, 221.1],
                               'b': [433.5, 523.2, 536.3, 464.3, 413.0, 164.3, 213.0, 221.1],
                               'c': [123.5, 132.3, 136.3, 164.3] + [np.NaN]*4,
                               'd': [np.NaN]*8,
                               'e': [np.NaN]*7 + [2330.3],
                               'f': [np.NaN]*4 + [2763.0, 2142.3, 2127.3, 2330.3],
                               'g': [2330.3] + [np.NaN]*7,
                               'h': [2330.3] + [np.NaN]*6 + [2777.7]})

它看起来像这样:

In [147]: data
Out[147]: …

我有一个pandas DataFrame,其中索引是列的子集,即索引中的每个值也是一个列名,还有其他列,所以像这样:

import pandas as pd
import numpy as np
df = pd.DataFrame(index=['John', 'Mary', 'Steven'],
                  columns=['John','Susan','Steven','Chris','Mary'],
                  data=np.arange(15).reshape(3,5))

我现在想要将"对角线"项设置为固定值,比如说0.0."对角线"是指那些条目值与列名匹配的条目.我可以通过迭代索引并在该循环中将每个"对角线"条目设置为0.0来实现.

for i in df.index:
    df.loc[i, i] = 0.0

但我想知道是否有更多的pythonic方式,也许是实现这一目标的矢量化.我认为必须有类似df.loc[df.index, df.index] = 0.0但不会产生预期效果的东西.

我遇到了一段Python代码,技术上看起来像这样:

def bar(b):
    return b*2

class MyClass(object):
    def __init__(self, a):
        self.a = a
        self.b = 10

    def foo(self, b=None):
        return bar(b if b is not None else self.b)

所以该类具有b固定属性foo,如果不带参数调用它,它将用作类方法的默认输入.

请假设b在这种情况下预计是浮动的.

请忽略未使用的self.a,否则使用它 - 我只是想确保您看到构造函数可以设置属性.

用法如下所示:

c = MyClass(2)
c.foo(3)  # returns 3*2 = 6
c.foo()  # returns 10*2 = 20

在这种情况下,我想知道foo- 方法.这是实现self.b默认值的好方法b吗？

以下两个建议中的一个或多或少是我想要的？如果是这样:为什么？

def foo(self, b=None):
    return bar(b or self.b)

要么

def foo(self, b=self.b):
    return bar(b)

我有一个用索引和列编写的pandas DataFrame,所有值都是NaN.现在我计算了一个结果,它可以用于DataFrame的多行,我想一次性分配它们.这可以通过循环完成,但我很确定这个赋值可以立即完成.

这是一个场景:

import pandas as pd
df = pd.DataFrame(index=['A', 'B', 'C'], columns=['C1', 'C2'])  # original df
s = pd.Series({'C1': 1, 'C2': 'ham'})  # a computed result
index = pd.Index(['A', 'C'])  # result is valid for rows 'A' and 'C'

天真的方法是

df.loc[index, :] = s

但这根本不会改变DataFrame.它仍然是

    C1   C2
A  NaN  NaN
B  NaN  NaN
C  NaN  NaN

如何完成这项任务？

考虑这个带有许多列的 DataFrame，但它在 列 中定义了一个功能'feature'，并在 列 中定义了一些值'values'。

我想要在额外的列中显示每个特征（组）的相对值所需的结果是由我在列中手动预先计算的'desired'

df = pd.DataFrame(
    data={
        'feature': [1, 1, 2, 3, 3, 3],
        'values': [30.0, 20.0, 25.0, 100.0, 250.0, 50.0],
        'desired': [0.6, 0.4, 1.0, 0.25, 0.625, 0.125],
        'more_columns': range(6),
    },
)

这导致了 DataFrame

   feature  values  desired  more_columns
0        1    30.0    0.600             0
1        1    20.0    0.400             1
2        2    25.0    1.000             2
3        3   100.0    0.250             3
4        3   250.0    0.625             4
5        3    50.0    0.125             5

因此，对于由特征定义的组，1所需的值为 …