將“缺失”的多索引行插入 Pandas 數據幀

Question

我有一個帶有兩級多索引的 Pandas DataFrame。 第二級是數字，應該對第一級索引的每個唯一值進行排序和順序，但有間隙。 如何插入“缺失”的行？ 樣本輸入：

import pandas as pd
df = pd.DataFrame(list(range(5)),
                  index=pd.MultiIndex.from_tuples([('A',1), ('A',3),
                                                   ('B',2), ('B',3), ('B',6)]),
                  columns='value')
#     value
#A 1      0
#  3      1
#B 2      2
#  3      3
#  6      4

預期輸出：

#     value
#A 1      0
#  2    NaN
#  3      1
#B 2      2
#  3      3
#  4    NaN
#  5    NaN
#  6      4

我懷疑我可以使用resample ，但我無法將數字轉換為類似日期的任何內容。

Answer 1

如果有遺囑，就有辦法。 我並不為此感到自豪，但我認為它有效。

嘗試：

def f(x):
    levels = x.index.remove_unused_levels().levels
    x = x.reindex(pd.MultiIndex.from_product([levels[0], np.arange(levels[1][0], levels[1][-1]+1)]))
    return x

df.groupby(level=0, as_index=False, group_keys=False).apply(f)

輸出：

     value
A 1    0.0
  2    NaN
  3    1.0
B 2    2.0
  3    3.0
  4    NaN
  5    NaN
  6    4.0

Answer 2

經過深思熟慮，我能夠自己想出一個解決方案。 從它是多么糟糕的事實來判斷，我面臨的問題不是一個非常典型的問題。

new_index = d.index.to_frame()\
                .groupby(0)[1]\
                .apply(lambda x:
                         pd.Series(1, index=range(x.min(), x.max() + 1))).index
d.reindex(new_index)

Answer 3

您可以簡單地使用以下取決於缺少的索引：

result.unstack(1).stack(0, dropna=False).fillna(0)

當您取消堆疊時，pandas 將 df 展開為具有行和列，並且在上面的示例中，級別 1 索引將是列名。 然后，再次通過堆疊，您將 df 返回到其原始形式，但是，這次您需要確保使用dropna=False以便 NaN 值將在那里丟失索引。 最后，使用.fillna(0)是可選的，這取決於您想對 NaN 值做什么。

Answer 4

沒有考慮品味，但我認為回到列表理解會導致代碼更具可讀性：

df.reindex(
    pd.MultiIndex.from_tuples([
        (level_0, level_1)
        for level_0 in df.reset_index(0).level_0.unique()
        for level_1 in range(
            df.reset_index(1).loc[level_0, "level_1"].min(),
            df.reset_index(1).loc[level_0, "level_1"].max()+1
        )
]))

# Output:
#value
#A  1   0.0
#   2   NaN
#   3   1.0
#B  2   2.0
#   3   3.0
#   4   NaN
#   5   NaN
#   6   4.0

雖然這當然比沿着apply路線走慢：

list-comprehension: 2.57 ms ± 19 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)
DYZ apply: 1.25 ms ± 8.75 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)
Scott's apply: 2.19 ms ± 9.84 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)