从python中的多索引数据框中获取索引号

Question

似乎有很多关于如何从熊猫数据框中获取最后一个索引值的答案，但我试图获取多索引数据框中第 0 级每个索引的最后一行的索引位置编号。我找到了一种使用循环的方法，但数据帧有数百万行，而且这个循环很慢。我认为有一种更蟒蛇的方式来做到这一点。

这是一个 df3 的小例子。我想在 df >> 最后一行更改为新股票之前获取索引中数字的列表（或者可能是数组）。索引列是我想要的结果。这是 df 的索引位置

Stock   Date      Index 
AAPL    12/31/2004  
        1/3/2005    
        1/4/2005    
        1/5/2005    
        1/6/2005    
        1/7/2005    
        1/10/2005   3475
AMZN    12/31/2004  
        1/3/2005    
        1/4/2005    
        1/5/2005    
        1/6/2005    
        1/7/2005    
        1/10/2005   6951
BAC     12/31/2004  
        1/3/2005    
        1/4/2005    
        1/5/2005    
        1/6/2005    
        1/7/2005    
       1/10/2005    10427

这是我正在使用的代码，其中数据框中的 df3

test_index_list = []
for start_index in range(len(df3)-1):
    end_index = start_index + 1
    if df3.index[start_index][0] != df3.index[end_index][0]:
       test_index_list.append(start_index)

Answer 1

我将divakar answer 与get_level_values 更改为MultiIndex 的第一级索引：

df = pd.DataFrame({'A':list('abcdef'),
                   'B':[4,5,4,5,5,4],
                   'C':[7,8,9,4,2,3],
                   'D':[1,3,5,7,1,0],
                   'E':[5,3,6,9,2,4],
                   'F':list('aaabbc')}).set_index(['F','A','B'])

print (df)
       C  D  E
F A B         
a a 4  7  1  5
  b 5  8  3  3
  c 4  9  5  6
b d 5  4  7  9
  e 5  2  1  2
c f 4  3  0  4

def start_stop_arr(initial_list):
    a = np.asarray(initial_list)
    mask = np.concatenate(([True], a[1:] != a[:-1], [True]))
    idx = np.flatnonzero(mask)
    stop = idx[1:]-1
    return stop

print (df.index.get_level_values(0))
Index(['a', 'a', 'a', 'b', 'b', 'c'], dtype='object', name='F')

print (start_stop_arr(df.index.get_level_values(0)))
[2 4 5]

Answer 2

dict.values

使用dict 跟踪值将最后找到的值作为重要的值。

list(dict(map(reversed, enumerate(df.index.get_level_values(0)))).values())

[2, 4, 5]

---

带循环

创建采用因式分解和唯一值数量的函数

def last(bins, k):
    a = np.zeros(k, np.int64)
    for i, b in enumerate(bins):
        a[b] = i
    return a

然后你可以得到分解

f, u = pd.factorize(df.index.get_level_values(0))
last(f, len(u))

array([2, 4, 5])

但是，MultiIndex 通常的构造方式是，labels 对象已经是因式分解，levels 对象是唯一值。

last(df.index.labels[0], df.index.levels[0].size)

array([2, 4, 5])

更重要的是，我们可以使用 Numba 来使用即时编译来超级充电。

from numba import njit

@njit
def nlast(bins, k):
    a = np.zeros(k, np.int64)
    for i, b in enumerate(bins):
        a[b] = i
    return a

nlast(df.index.labels[0], df.index.levels[0].size)

array([2, 4, 5])

---

时间

%%timeit
f, u = pd.factorize(df.index.get_level_values(0))
last(f, len(u))

641 µs ± 9.4 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)

---

%%timeit
f, u = pd.factorize(df.index.get_level_values(0))
nlast(f, len(u))

264 µs ± 11.1 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)

---

%%timeit
nlast(df.index.labels[0], len(df.index.levels[0]))

4.06 µs ± 43.6 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)

---

%%timeit
last(df.index.labels[0], len(df.index.levels[0]))

654 µs ± 14.2 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)

---

%%timeit
list(dict(map(reversed, enumerate(df.index.get_level_values(0)))).values())

709 µs ± 4.94 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)

---

jezrael 的解决方案。速度也很快。

%timeit start_stop_arr(df.index.get_level_values(0))

113 µs ± 83.1 ns per loop (mean ± std. dev. of 7 runs, 10000 loops each)

---

np.unique

我没有计时，因为我不喜欢它。见下文：

使用np.unique 和return_index 参数。这将返回找到每个唯一值的第一个位置。在此之后，我会进行一些移动以到达先前唯一值的最后一个位置。

注意：如果级别值位于连续组中，则此方法有效。如果不是，我们必须进行不值得的排序和取消排序。除非真的是这样，否则我会展示如何做到这一点。

i = np.unique(df.index.get_level_values(0), return_index=True)[1]
np.append(i[1:], len(df)) - 1

array([2, 4, 5])

---

设置

来自@jezrael

df = pd.DataFrame({'A':list('abcdef'),
                   'B':[4,5,4,5,5,4],
                   'C':[7,8,9,4,2,3],
                   'D':[1,3,5,7,1,0],
                   'E':[5,3,6,9,2,4],
                   'F':list('aaabbc')}).set_index(['F','A','B'])