Python Pandas データフレームでの計算処理について

Question

Python pandas dataframe で、実現できるのか教えてください。

下記のようなデータフレームで、列a だけがある状態から、列b の値を算出し追加したいです。
列b は、列aの値が、1行前からn行前のaよりも大きければnが入るとします。
（列aが前の行のaと同じまたは小さければ0が、
1行前だけのaよりも大きければ1が、
1行前・2行前のaよりも大きければ2が入ります。）

各行についてforループで、さらに何行前と比較するかをforループにというように
forループを2重にすれば書けることはわかるのですが、
そうではなく簡素に（各行についてループすることなく）書くことは可能でしょうか。
（whereなどをうまく使うのかなと思いましたがどうすれば良いのかわかりませんでした）

a	b
48	0
20	0
3	0
15	1
13	0
32	4
7	0
27	1
85	8
48	0

簡素になるならば、最大で５行前までを比較の対象とする、などとしてしまうことは可能です。
よろしくお願い致します。

Comments

[meg_]

> forループを2重にすれば書けることはわかるのですが、
そのコードはありますか？ ループ処理ですと何か問題があるのですか？

Answer 1

pandasでやるなら、expandingを使うのはどうでしょう。
(先頭からその行まで計算します)

applyの中のlambdaでやっていることは、Seriesを逆向きに並べ替えてcummaxをとって、先頭より値が小さいものの数を数えています。

df['b'] = (
    df['a'].expanding()
    .apply(
        lambda s: (s.iloc[-2::-1].cummax() < s.iloc[-1]).sum()
    ).astype(int))

Comments

[echizenkurage]

とてもシンプルなコード、どうもありがとうございました！！

Answer 2

生のpythonでの実装例です。

a列のデータ数が多くなければcalc_b0のようにベタに実装すれば十分だと思います。この方式の問題点はデータが[0, 1, 2, 3, ...]のように昇順に並んでいる場合、処理時間が長くなる点です。それでもデータ数500件くらいまでであれば気にならない範囲だと思います。

データ数が多い場合、

• データは整数のみ
• データの範囲は0〜10,000などある程度の範囲に絞られている

という条件を満たせる場合、Range Update Query(RUQ)というデータ構造を使用すると高速に処理できます。
calc_b1が実装例です。(RUQ実装はここからお借りしました)
処理したいデータが [0, 1, 2, ...,9999]のようにcalc_b0が苦手なデータの場合、私の環境ではcalc_b1の方が60倍以上高速です。

from timeit import timeit
from random import randint

def calc_b0(lst):
    res = []
    stack = [float('inf')]
    for l in lst:
        x = -1
        while stack[x] < l:
            x -= 1
        stack.append(l)
        res.append(-x-1)
    return res

def calc_b1(lst):
    N = 10001                   # 想定する数字は0～10,000まで
    N0 = 2**(N-1).bit_length()
    data = [None]*(2*N0)
    INF = (-1, 2**31-1)
    # 区間[l, r+1)の値をvに書き換える
    # vは(t, value)という値にする (新しい値ほどtは大きくなる)
    def update(l, r, v):
        L = l + N0; R = r + N0
        while L < R:
            if R & 1:
                R -= 1
                data[R-1] = v

            if L & 1:
                data[L-1] = v
                L += 1
            L >>= 1; R >>= 1

    # a_iの現在の値を取得
    def _query(k):
        k += N0-1
        s = INF
        while k >= 0:
            if data[k]:
                s = max(s, data[k])
            k = (k - 1) // 2
        return s
    # これを呼び出す
    def query(k):
        return _query(k)[1]

    res = []
    update(0, 10001, (0, 0))    # 0～10000を0で初期化
    for i, l in enumerate(lst):
        q = query(l)
        res.append(i - q)
        update(0, l+1, (0, i+1)) # 0～今回の数字までを塗り潰す
    return res

lst = [48, 20, 3, 15, 13, 32, 7, 27, 85, 48] # サンプルデータ
res0 = calc_b0(lst)
res1 = calc_b1(lst)
assert res0 == res1             # 結果が同じかチェック
print(res1)  # [0, 0, 0, 1, 0, 4, 0, 1, 8, 0]

lst = [randint(0, 1000) for _ in range(10000)] # データ点数の多いランダムデータ
assert calc_b0(lst) == calc_b1(lst) # 結果が同じかチェック

lst = list(range(10000))         # 昇順にソートされているデータ
print(timeit('calc_b0(lst)', globals=globals(), number=10))  # 25.5021925秒
print(timeit('calc_b1(lst)', globals=globals(), number=10))  # 0.39431319999999914秒

Comments

[echizenkurage]

シンプルなのと爆速なのの２通りご回答頂き、どうもありがとうございました。勉強になります！

Answer 3

いわば勝ち残り戦での防衛回数を求める問題と考え、numpyにて実装しました。

import numpy as np

def calc(lst):
    lst = np.array(lst)
    L = len(lst)

    # リング上の選手の「位置」と「値（強さ）」
    # 強さの昇順で並びをキープする
    # 配列サイズは固定で最大分を用意
    idxs = np.zeros(L,dtype=int)
    vals = np.zeros(L,dtype=int)

    ret = np.zeros(L,dtype=int) # 各選手の防衛回数

    # 防衛回数の算出
    def calc_ret(idxs, idx):
        if idxs.shape[0] > 0:
            ret[idxs] = idxs - idx - 1 # 各選手の位置 - 挑戦者の位置 - 1

    # 逆順にリングに上がる
    count = 0 # リング上にいる選手の数
    for i in range(L):

        # 挑戦者
        idx = L-i-1
        val = lst[idx]

        st = L-count # リング上にいる先頭（最弱）選手の位置

        # リング上にいる選手内での挑戦者のランク（位置）を決定
        # searchsortedはバイナリサーチなので速いはず
        p = 0
        if count > 0:
            p = np.searchsorted(vals[-count:], val, side='right')

        # pより手前にいる選手は挑戦者以下なのでリングから脱落
        # 脱落者の防衛回数を算出
        calc_ret(idxs[st:st+p], idx)

        # この時点で挑戦者は最弱なので先頭に追加
        count = count - p + 1
        st = L-count
        idxs[st] = idx
        vals[st] = val

    # 最後に生き残った選手の防衛回数を算出
    calc_ret(idxs[-count:], -1)

    return ret.tolist()


N = 100000
for lst in [np.random.randint(1,N,N), 
            np.arange(1,N), 
            np.array([48, 20, 3, 15, 13, 32, 7, 27, 85, 48]),
            np.array([1,1,2,3])]:

    lst = lst.tolist()
    print('-----')
    print(lst)
    ret1 = calc(lst)
    print(ret1)

"""
-----
[48, 20, 3, 15, 13, 32, 7, 27, 85, 48]
[0, 0, 0, 1, 0, 4, 0, 1, 8, 0]
-----
[1, 1, 2, 3]
[0, 0, 2, 3]
"""

Comments

[退会済みユーザー]

「列aが前の行のaと同じまたは小さければ0」なので、 p = np.searchsorted(vals, val, side='right') では。

[can110]

> （列aが前の行のaと同じまたは小さければ0が～
なので、同値なら条件を満たさないと解釈してデフォルトのleftとしていますが、どうなんでしょうね。

[can110]

dljfab さん
> （列aが前の行のaと同じまたは小さければ0が～
にて、同値のあるデータで確認しました。
right（=同値含む左側は条件を満たさない）のが正しい結果と思いますので回答修正しました。
ご指摘感謝します。

[echizenkurage]

ご回答ありがとうございました！

Answer 4

簡素ではない方法です。

import pandas as pd

df = pd.DataFrame({
    'a': [48, 20, 3, 15, 13, 32, 7, 27, 85, 48],
})

#
dfx = df[df['a'].diff().gt(0)].apply(lambda x: df.loc[:(x.name-1),'a'].gt(df.loc[x.name,'a']), axis=1)
dfx = dfx.index - dfx[dfx.columns[::-1]].fillna(False).idxmax(axis=1) - 1
df = df.assign(b = dfx.mask(dfx == 0, dfx.index)).fillna(0, downcast='infer')
print(df)

Comments

[echizenkurage]

ご回答ありがとうございました。
他のデータでやってみたところ、マイナスの数字になるところがありました。
例）
a b
0 56 0
1 28 0
2 45 1
3 58 -4
4 10 0
5 55 1
6 78 -1
7 86 7
8 78 0
9 56 0

しかしながら3行でのコーディング、勉強になります。ありがとうございました！