Überprüfen Sie, ob die Pandas-Spalte alle Elemente aus einer Liste enthält

Ich habe einen df wie diesen:

frame = pd.DataFrame({'a' : ['a,b,c', 'a,c,f', 'b,d,f','a,z,c']})

Und eine Liste von Gegenständen:

letters = ['a','c']

Mein Ziel ist es, alle Zeilen zu erhalten frame, die mindestens die 2 Elemente enthaltenletters

Ich habe mir diese Lösung ausgedacht:

for i in letters:
    subframe = frame[frame['a'].str.contains(i)]

Dies gibt mir, was ich will, aber es ist möglicherweise nicht die beste Lösung in Bezug auf Skalierbarkeit. Gibt es eine "vektorisierte" Lösung? Vielen Dank

Ich würde eine Liste von Serien erstellen und dann eine vektorisierte anwenden np.all:

contains = [frame['a'].str.contains(i) for i in letters]
resul = frame[np.all(contains, axis=0)]

Es gibt wie erwartet:

       a
0  a,b,c
1  a,c,f
3  a,z,c

Eine Möglichkeit besteht darin, die Spaltenwerte mithilfe von Listen in Listen aufzuteilen str.splitund zu überprüfen, ob set(letters)es sich um eine subsetder erhaltenen Listen handelt:

letters_s = set(letters)
frame[frame.a.str.split(',').map(letters_s.issubset)]

     a
0  a,b,c
1  a,c,f
3  a,z,c
​

Benchmark:

def serge(frame):
    contains = [frame['a'].str.contains(i) for i in letters]
    return frame[np.all(contains, axis=0)]

def yatu(frame):
    letters_s = set(letters)
    return frame[frame.a.str.split(',').map(letters_s.issubset)]

def austin(frame):
    mask =  frame.a.apply(lambda x: np.intersect1d(x.split(','), letters).size > 0)
    return frame[mask]

def datanovice(frame):
    s = frame['a'].str.split(',').explode().isin(letters).groupby(level=0).cumsum()
    return frame.loc[s[s.ge(2)].index.unique()]

perfplot.show(
    setup=lambda n: pd.concat([frame]*n, axis=0).reset_index(drop=True), 

    kernels=[
        lambda df: serge(df),
        lambda df: yatu(df),
        lambda df: df[df['a'].apply(lambda x: np.all([*map(lambda l: l in x, letters)]))],
        lambda df: austin(df),
        lambda df: datanovice(df),
    ],

    labels=['serge', 'yatu', 'bruno','austin', 'datanovice'],
    n_range=[2**k for k in range(0, 18)],
    equality_check=lambda x, y: x.equals(y),
    xlabel='N'
)

Sie können verwenden np.intersect1d:

import pandas as pd
import numpy as np

frame = pd.DataFrame({'a' : ['a,b,c', 'a,c,f', 'b,d,f','a,z,c']})
letters = ['a','c']

mask =  frame.a.apply(lambda x: np.intersect1d(x.split(','), letters).size > 0)
print(frame[mask])

    a
0  a,b,c
1  a,c,f
3  a,z,c

Dies löst es auch:

frame[frame['a'].apply(lambda x: np.all([*map(lambda l: l in x, letters)]))]

Verwenden Sie set.issubset :

frame = pd.DataFrame({'a' : ['a,b,c', 'a,c,f', 'b,d,f','a,z,c','x,y']})
letters = ['a','c']

frame[frame['a'].apply(lambda x: set(letters).issubset(x))]

Out:

       a
0  a,b,c
1  a,c,f
3  a,z,c

IIUC explodeund ein Boolescher Filter

Die Idee ist, eine einzelne Reihe zu erstellen, dann können wir anhand des Index die Anzahl der wahren Vorkommen Ihrer Liste anhand einer kumulativen Summe gruppieren

s = frame['a'].str.split(',').explode().isin(letters).groupby(level=0).cumsum()

print(s)

0    1.0
0    1.0
0    2.0
1    1.0
1    2.0
1    2.0
2    0.0
2    0.0
2    0.0
3    1.0
3    1.0
3    2.0

frame.loc[s[s.ge(2)].index.unique()]

out:

       a
0  a,b,c
1  a,c,f
3  a,z,c

frame.iloc[[x for x in range(len(frame)) if set(letters).issubset(frame.iloc[x,0])]]

Ausgabe:

        a
 0  a,b,c
 1  a,c,f
 3  a,z,c

timeit

%%timeit
#hermes
frame.iloc[[x for x in range(len(frame)) if set(letters).issubset(frame.iloc[x,0])]]

Ausgabe

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