orange's questions

我正在寻找一种方法来在脚本中确定另一个脚本设置了哪些环境变量。设置环境变量的脚本（env.sh）有各种逻辑来检索这些变量值，我想确定这些值是否从一个版本的存储库更改到另一个版本（但我无法跟踪env.shonly 的文件内容，因为即使它声明的环境变量发生了变化，它也可能保持不变）。

# main.sh

# Call env.sh to calculate a hash over the environment variables it has set (no idea how)
bash ./env.sh

# env.sh

export foo="foo" # could be changed directly in another version
export bar=`cat barversion` # content in `barversion` itself could change, but not env.sh
# ... more could be added, but we don't want to assume knowledge about this in main.sh

所引用的文件env.sh可能会发生变化，从而导致导出的环境变量发生变化，进而产生不同的哈希值

# barversion
1.0

bash ./env.sh理想情况下， in的调用main.sh实际上并不会污染环境变量范围main.sh（事实上bash ./env.sh不需要这样调用。该行只是一个占位符，用来指示我遇到困难的地方）。

任何帮助或正确方向的指示都将不胜感激。

当通过实例本身而不是类进行调用时，是否可以在 Python @classmethod 注释函数中访问对象实例？

class Foo(object):
  def __init__(self, text):
    self.text = text

  @classmethod
  def bar(cls):
    return None

print(Foo.bar())

foo = Foo('foo')
# If possible, I'd like to return "foo"
print(foo.bar())

我正在解决一个库的限制，该库通过实例（而不是类）调用类方法，并希望能够以某种方式解决我只能访问类的事实bar(cls)（我必须访问实例才能访问.text）。我认为这是不可能的，但我想我会问（对于这样一个小众的请求，我在互联网上也找不到任何东西）。

我正在尝试计算一段时间内的库存余额（水平），并将进出数量作为输入（以及每种库存的类别）。通常我会计算incoming - outgoing并结转到下一期（累计总和），但在这种情况下，额外的困难是余额可以在各个时间点被覆盖，从而将余额“重置”为这些值（并且从这个时间点开始，需要将进出量添加到这些覆盖中）。

我想出了一种计算方法，即在存在覆盖余额时（通过计算的负 cumsum；即在存在覆盖余额时将库存设置为 0）抵消计算的余额（=cumsum（传入-传出）），但当在不同时间存在多个覆盖时，这种方法不起作用。

这是我当前的方法，对于给定的数据框效果很好（=bal每个类别只有一个覆盖（）（cat））。

>>> df = pd.DataFrame({
...   'cat': ['a', 'a', 'b', 'b', 'a', 'a', 'a', 'a', 'a', 'b'],
...   'time': [1, 2, 1, 2, 4, 5, 6, 7, 8, 9],
...   'in': [None, 10, None, None, None, 20, 11, 9, 10, None],
...   'out': [10, None, None, 20, 10, 5, None, 30, None, None],
...   'bal': [None, None, None, None, 50, None, None, None, None, None]
                                       ^ at this time, the balance should be set to 50, irrespective of prior `in` and `out`.
... })
>>> 
>>> # cumsum goes by row, so order matters
>>> df = df.sort_values(by=['time'])
>>> df
  cat  time    in   out   bal
0   a     1   NaN  10.0   NaN
2   b     1   NaN   NaN   NaN
1   a     2  10.0   NaN   NaN
3   b     2   NaN  20.0   NaN
4   a     4   NaN  10.0  50.0
5   a     5  20.0   5.0   NaN
6   a     6  11.0   NaN   NaN
7   a     7   9.0  30.0   NaN
8   a     8  10.0   NaN   NaN
9   b     9   NaN   NaN   NaN
>>> 
>>> 
>>> # Calculate the balance as if 'bal' (the override) wasn't there (cumsum(in - out))
>>> df['inout'] = df['in'].fillna(0) - df['out'].fillna(0)
>>> df['cumsum'] = df[['cat', 'inout']].groupby(['cat']).cumsum()
>>> df
  cat  time    in   out   bal  inout  cumsum
0   a     1   NaN  10.0   NaN  -10.0   -10.0
2   b     1   NaN   NaN   NaN    0.0     0.0
1   a     2  10.0   NaN   NaN   10.0     0.0
3   b     2   NaN  20.0   NaN  -20.0   -20.0
4   a     4   NaN  10.0  50.0  -10.0   -10.0   <-- we want to override this with the value from 'bal' (50) and continue the calculation
5   a     5  20.0   5.0   NaN   15.0     5.0
6   a     6  11.0   NaN   NaN   11.0    16.0
7   a     7   9.0  30.0   NaN  -21.0    -5.0
8   a     8  10.0   NaN   NaN   10.0     5.0
9   b     9   NaN   NaN   NaN    0.0   -20.0
>>> 
>>> # Find the positions where a balance would override the calculated balance
>>> df['correction'] = -df.loc[pd.notnull(df['bal']), 'cumsum']
>>> df
  cat  time    in   out   bal  inout  cumsum  correction
0   a     1   NaN  10.0   NaN  -10.0   -10.0         NaN
2   b     1   NaN   NaN   NaN    0.0     0.0         NaN
1   a     2  10.0   NaN   NaN   10.0     0.0         NaN
3   b     2   NaN  20.0   NaN  -20.0   -20.0         NaN
4   a     4   NaN  10.0  50.0  -10.0   -10.0        10.0
5   a     5  20.0   5.0   NaN   15.0     5.0         NaN
6   a     6  11.0   NaN   NaN   11.0    16.0         NaN
7   a     7   9.0  30.0   NaN  -21.0    -5.0         NaN
8   a     8  10.0   NaN   NaN   10.0     5.0         NaN
9   b     9   NaN   NaN   NaN    0.0   -20.0         NaN
>>> 
>>> 
>>> # Calculate with the corrected balance
>>> df['inout2'] = df['in'].fillna(0) - df['out'].fillna(0) + df['bal'].fillna(0) + df['correction'].fillna(0)
>>> df['cumsum2'] = df[['cat', 'inout2']].groupby(['cat']).cumsum()
>>> df
  cat  time    in   out   bal  inout  cumsum  correction  inout2  cumsum2
0   a     1   NaN  10.0   NaN  -10.0   -10.0         NaN   -10.0    -10.0
2   b     1   NaN   NaN   NaN    0.0     0.0         NaN     0.0      0.0
1   a     2  10.0   NaN   NaN   10.0     0.0         NaN    10.0      0.0
3   b     2   NaN  20.0   NaN  -20.0   -20.0         NaN   -20.0    -20.0
4   a     4   NaN  10.0  50.0  -10.0   -10.0        10.0    50.0     50.0 (override from 'bal')
5   a     5  20.0   5.0   NaN   15.0     5.0         NaN    15.0     65.0 <--- 50 (override) +15 (in-out)
6   a     6  11.0   NaN   NaN   11.0    16.0         NaN    11.0     76.0
7   a     7   9.0  30.0   NaN  -21.0    -5.0         NaN   -21.0     55.0
8   a     8  10.0   NaN   NaN   10.0     5.0         NaN    10.0     65.0
9   b     9   NaN   NaN   NaN    0.0   -20.0         NaN     0.0    -20.0
>>> 
>>> 
>>> df[df['cat'] == 'a']
  cat  time    in   out   bal  inout  cumsum  correction  inout2  cumsum2
0   a     1   NaN  10.0   NaN  -10.0   -10.0         NaN   -10.0    -10.0
1   a     2  10.0   NaN   NaN   10.0     0.0         NaN    10.0      0.0
4   a     4   NaN  10.0  50.0  -10.0   -10.0        10.0    50.0     50.0
5   a     5  20.0   5.0   NaN   15.0     5.0         NaN    15.0     65.0
6   a     6  11.0   NaN   NaN   11.0    16.0         NaN    11.0     76.0
7   a     7   9.0  30.0   NaN  -21.0    -5.0         NaN   -21.0     55.0
8   a     8  10.0   NaN   NaN   10.0     5.0         NaN    10.0     65.0
 

看起来不错。在索引 4 处，简单余额计算被覆盖（原为 -10，现在为 50，符合预期），并且后续期间的流入流出按预期添加。

然而，当我引入另一个覆盖时，上述算法就会中断。

df = pd.DataFrame({
  'cat': ['a', 'a', 'b', 'b', 'a', 'a', 'a', 'a', 'a', 'b'],
  'time': [1, 2, 1, 2, 4, 5, 6, 7, 8, 9],
  'in': [None, 10, None, None, None, 20, 11, 9, 10, None],
  'out': [10, None, None, 20, 10, 5, None, 30, None, None],
  'bal': [None, None, None, None, 50, None, None, 30, None, None]
  #                                                ^
})

... same pipeline as before

>>> df
  cat  time    in   out   bal  inout  cumsum  correction  inout2  cumsum2
0   a     1   NaN  10.0   NaN  -10.0   -10.0         NaN   -10.0    -10.0
2   b     1   NaN   NaN   NaN    0.0     0.0         NaN     0.0      0.0
1   a     2  10.0   NaN   NaN   10.0     0.0         NaN    10.0      0.0
3   b     2   NaN  20.0   NaN  -20.0   -20.0         NaN   -20.0    -20.0
4   a     4   NaN  10.0  50.0  -10.0   -10.0        10.0    50.0     50.0  # still ok
5   a     5  20.0   5.0   NaN   15.0     5.0         NaN    15.0     65.0
6   a     6  11.0   NaN   NaN   11.0    16.0         NaN    11.0     76.0
7   a     7   9.0  30.0  30.0  -21.0    -5.0         5.0    14.0     90.0  # expect 30
8   a     8  10.0   NaN   NaN   10.0     5.0         NaN    10.0    100.0  # expect 30 + 10 = 40
9   b     9   NaN   NaN   NaN    0.0   -20.0         NaN     0.0    -20.0

我想修改算法以保持使用的简单性cumsum（功能性），但不知道该如何进行。这几乎就像我需要一个条件累计值，当满足条件时（在本例中为 中的值bal），它会替换中间值。但是，我更愿意计算另一个校正列（或修复现有的校正列）并添加它（但我遇到了障碍，因为我可能看得太久了）。任何帮助都非常感谢。