Jeśli masz ramkę danych Pandas taką jak ta:

import pandas as pd
import numpy as np
df = pd.DataFrame({'today': [['a', 'b', 'c'], ['a', 'b'], ['b']], 
                   'yesterday': [['a', 'b'], ['a'], ['a']]})

                 today        yesterday
0      ['a', 'b', 'c']       ['a', 'b']
1           ['a', 'b']            ['a']
2                ['b']            ['a']                          
... etc

Ale mając około 100 000 wpisów, szukam dodawania i usuwania tych list w dwóch kolumnach według wierszy.

Jest to porównywalne z tym pytaniem: Pandas: Jak porównać kolumny z wierszami w ramce danych z Pandami (nie dla pętli)? ale patrzę na różnice, a Pandas.applymetoda wydaje się nie być tak szybka dla tak wielu wpisów. To jest kod, którego obecnie używam. Pandas.applyz numpy's setdiff1dmetodą:

additions = df.apply(lambda row: np.setdiff1d(row.today, row.yesterday), axis=1)
removals  = df.apply(lambda row: np.setdiff1d(row.yesterday, row.today), axis=1)

Działa to dobrze, jednak 120 000 wpisów zajmuje około minuty. Czy jest więc szybszy sposób na osiągnięcie tego?

Nie jestem pewien co do wydajności, ale przy braku lepszego rozwiązania może to mieć zastosowanie:

temp = df[['today', 'yesterday']].applymap(set)
removals = temp.diff(periods=1, axis=1).dropna(axis=1)
additions = temp.diff(periods=-1, axis=1).dropna(axis=1) 

Przeprowadzki:

  yesterday
0        {}
1        {}
2       {a}

Wzbogacenie:

  today
0   {c}
1   {b}
2   {b}

df['today'].apply(set) - df['yesterday'].apply(set)

Zasugeruję, abyś obliczył additionsi removalsw ramach tego samego zastosowania.

Wygeneruj większy przykład

import pandas as pd
import numpy as np
df = pd.DataFrame({'today': [['a', 'b', 'c'], ['a', 'b'], ['b']], 
                   'yesterday': [['a', 'b'], ['a'], ['a']]})
df = pd.concat([df for i in range(10_000)], ignore_index=True)

Twoje rozwiązanie

%%time
additions = df.apply(lambda row: np.setdiff1d(row.today, row.yesterday), axis=1)
removals  = df.apply(lambda row: np.setdiff1d(row.yesterday, row.today), axis=1)
CPU times: user 10.9 s, sys: 29.8 ms, total: 11 s
Wall time: 11 s

Twoje rozwiązanie dotyczy tylko jednego

%%time
df["out"] = df.apply(lambda row: [np.setdiff1d(row.today, row.yesterday),
                                  np.setdiff1d(row.yesterday, row.today)], axis=1)
df[['additions','removals']] = pd.DataFrame(df['out'].values.tolist(), columns=['additions','removals'])
df = df.drop("out", axis=1)

CPU times: user 4.97 s, sys: 16 ms, total: 4.99 s
Wall time: 4.99 s

Za pomocą set

Chyba że twoje listy są bardzo duże, których możesz uniknąć numpy

def fun(x):
    a = list(set(x["today"]).difference(set(x["yesterday"])))
    b = list((set(x["yesterday"])).difference(set(x["today"])))
    return [a,b]

%%time
df["out"] = df.apply(fun, axis=1)
df[['additions','removals']] = pd.DataFrame(df['out'].values.tolist(), columns=['additions','removals'])
df = df.drop("out", axis=1)

CPU times: user 1.56 s, sys: 0 ns, total: 1.56 s
Wall time: 1.56 s

Rozwiązanie @ r.ook

Jeśli jesteś zadowolony z posiadania zestawów zamiast list jako danych wyjściowych, możesz użyć kodu @ r.ook

%%time
temp = df[['today', 'yesterday']].applymap(set)
removals = temp.diff(periods=1, axis=1).dropna(axis=1)
additions = temp.diff(periods=-1, axis=1).dropna(axis=1) 
CPU times: user 93.1 ms, sys: 12 ms, total: 105 ms
Wall time: 104 ms

@Andreas K. rozwiązanie

%%time
df['additions'] = (df['today'].apply(set) - df['yesterday'].apply(set))
df['removals'] = (df['yesterday'].apply(set) - df['today'].apply(set))

CPU times: user 161 ms, sys: 28.1 ms, total: 189 ms
Wall time: 187 ms

i możesz w końcu dodać, .apply(list)aby uzyskać ten sam wynik

Oto pomysł przeniesienia części obliczeniowej na wektoryzowane narzędzia NumPy. Zbierzemy wszystkie dane do pojedynczych tablic dla każdego nagłówka, wykonamy wszystkie wymagane dopasowanie na NumPy i ostatecznie przekroimy z powrotem do wymaganych pozycji wierszy. Na NumPy, który wykonuje część do podnoszenia ciężarów, będziemy używać haszowania na podstawie identyfikatorów grup i identyfikatorów w obrębie każdej używanej grupy np.searchsorted. Korzystamy również z liczb, ponieważ są one szybsze dzięki NumPy. Implementacja wyglądałaby mniej więcej tak -

t = df['today']
y = df['yesterday']
tc = np.concatenate(t)
yc = np.concatenate(y)

tci,tcu = pd.factorize(tc)

tl = np.array(list(map(len,t)))
ty = np.array(list(map(len,y)))

grp_t = np.repeat(np.arange(len(tl)),tl)
grp_y = np.repeat(np.arange(len(ty)),ty)

sidx = tcu.argsort()
idx = sidx[np.searchsorted(tcu,yc,sorter=sidx)]

s = max(tci.max(), idx.max())+1
tID = grp_t*s+tci
yID = grp_y*s+idx

t_mask = np.isin(tID, yID, invert=True)
y_mask = np.isin(yID, tID, invert=True)

t_se = np.r_[0,np.bincount(grp_t,t_mask).astype(int).cumsum()]
y_se = np.r_[0,np.bincount(grp_y,y_mask).astype(int).cumsum()]

Y = yc[y_mask].tolist()
T = tc[t_mask].tolist()

A = pd.Series([T[i:j] for (i,j) in zip(t_se[:-1],t_se[1:])])
R = pd.Series([Y[i:j] for (i,j) in zip(y_se[:-1],y_se[1:])])

Dalsza optymalizacja jest możliwa na etapach obliczania t_maski y_mask, gdzie np.searchsortedmożna go ponownie użyć.

Moglibyśmy również użyć prostego przypisania tablicy jako alternatywy dla isinkroku, który należy wykonać, t_maska y_masktak -

M = max(tID.max(), yID.max())+1
mask = np.empty(M, dtype=bool)

mask[tID] = True
mask[yID] = False
t_mask = mask[tID]

mask[yID] = True
mask[tID] = False
y_mask = mask[yID]