Pandas-Filterung für mehrere Teilstrings in Serie

Brauche ich zum filtern von Zeilen in einer pandas dataframe, so dass eine bestimmte Zeichenfolge-Spalte enthält mindestens eine aus einer Liste von Teilstrings zur Verfügung gestellt. Die Zeichenketten können ungewöhnliche /regex-Zeichen. Der Vergleich sollte nicht mit regex und ist der groß-und Kleinschreibung.

Beispiel:

lst = ['kdSj;af-!?', 'aBC+dsfa?\-', 'sdKaJg|dksaf-*']

Ich derzeit tragen Sie die Maske wie diese:

mask = np.logical_or.reduce([df[col].str.contains(i, regex=False, case=False) for i in lst])
df = df[mask]

Mein dataframe ist groß (~1mio Zeilen) und lst hat die Länge 100. Gibt es einen effizienteren Weg? Zum Beispiel, wenn das erste Element in lst gefunden wird, sollten wir Sie nicht haben, um zu testen alle nachfolgenden Zeichenfolgen für diese Zeile.

InformationsquelleAutor jpp | 2018-01-31

37

Wenn Sie ' re kleben mit pur-pandas, für Leistung und Funktionalität, die ich denke, Sie sollte Verwendung regex für diese Aufgabe. Allerdings werden Sie brauchen, um richtig zu escape-Sonderzeichen in den Zeichenketten ersten, um sicherzustellen, dass Sie abgestimmt sind buchstäblich (und nicht als regex-meta-Zeichen).

Dies ist einfach zu tun, mit re.Flucht:
```
>>> import re
>>> esc_lst = [re.escape(s) for s in lst]
```
Diese flüchtete Teilstrings können dann verbunden werden mit einem regex-Rohr |. Jede der Teilfolgen kann überprüft werden, eine Zeichenfolge, bis einer passt (oder haben Sie alle getestet).
```
>>> pattern = '|'.join(esc_lst)
```
Die Maskierung der Bühne ist, dann wird eine low-level-Schleife über die Zeilen:
```
df[col].str.contains(pattern, case=False)
```
Hier ist ein einfaches setup, um einen Eindruck zu bekommen, Leistung:
```
from random import randint, seed

seed(321)

# 100 substrings of 5 characters
lst = [''.join([chr(randint(0, 256)) for _ in range(5)]) for _ in range(100)]

# 50000 strings of 20 characters
strings = [''.join([chr(randint(0, 256)) for _ in range(20)]) for _ in range(50000)]

col = pd.Series(strings)
esc_lst = [re.escape(s) for s in lst]
pattern = '|'.join(esc_lst)
```
Dem vorgeschlagenen Verfahren dauert etwa 1 Sekunde (also vielleicht bis zu 20 Sekunden für 1 million Zeilen):
```
%timeit col.str.contains(pattern, case=False)
1 loop, best of 3: 981 ms per loop
```
Die Methode in der Frage dauerte ungefähr 5 Sekunden lang mit den gleichen Eingabedaten.

Es ist erwähnenswert, dass diese Zeiten 'schlechteste Fall' in dem Sinne, dass es keine übereinstimmungen (so alle Teilstrings überprüft wurden). Wenn es passt, als das timing zu verbessern.

InformationsquelleAutor Alex Riley

Könnten Sie versuchen, mit dem Aho-Corasick-Algorithmus. In der durchschnittlichen Fall, es ist O(n+m+p) wo n ist die Länge des such-strings und m ist die Länge des gesuchten Textes und p ist die Anzahl der output entspricht.

Den Aho-Corasick-Algorithmus ist oft verwendet mehrere Muster (Nadeln) in einen input-text (Heuhaufen).

pyahocorasick ist ein Python-wrapper um eine C-Implementierung des Algorithmus.

Lassen Sie uns vergleichen, wie schnell es ist, gegen einige alternativen. Unten ist ein benchmark
zeigt using_aho_corasick werden über 30x schneller als die original-Methode
(siehe in der Frage) auf eine 50K-Zeile DataFrame test-Fall:

|                    |     speed factor | ms per loop |
|                    | compared to orig |             |
|--------------------+------------------+-------------|
| using_aho_corasick |            30.7x |         140 |
| using_regex        |             2.7x |        1580 |
| orig               |             1.0x |        4300 |

In [89]: %timeit using_ahocorasick(col, lst)
10 loops, best of 3: 140 ms per loop

In [88]: %timeit using_regex(col, lst)
1 loop, best of 3: 1.58 s per loop

In [91]: %timeit orig(col, lst)
1 loop, best of 3: 4.3 s per loop

Hier das setup für die benchmark. Es wird auch überprüft, ob die Ausgabe entspricht dem Ergebnis orig:

import numpy as np
import random
import pandas as pd
import ahocorasick
import re

random.seed(321)

def orig(col, lst):
    mask = np.logical_or.reduce([col.str.contains(i, regex=False, case=False) 
                                 for i in lst])
    return mask

def using_regex(col, lst):
    """https://stackoverflow.com/a/48590850/190597 (Alex Riley)"""
    esc_lst = [re.escape(s) for s in lst]
    pattern = '|'.join(esc_lst)
    mask = col.str.contains(pattern, case=False)
    return mask

def using_ahocorasick(col, lst):
    A = ahocorasick.Automaton(ahocorasick.STORE_INTS)
    for word in lst:
        A.add_word(word.lower())
    A.make_automaton() 
    col = col.str.lower()
    mask = col.apply(lambda x: bool(list(A.iter(x))))
    return mask

N = 50000
# 100 substrings of 5 characters
lst = [''.join([chr(random.randint(0, 256)) for _ in range(5)]) for _ in range(100)]

# N strings of 20 characters
strings = [''.join([chr(random.randint(0, 256)) for _ in range(20)]) for _ in range(N)]
# make about 10% of the strings match a string from lst; this helps check that our method works
strings = [_ if random.randint(0, 99) < 10 else _+random.choice(lst) for _ in strings]

col = pd.Series(strings)

expected = orig(col, lst)
for name, result in [('using_regex', using_regex(col, lst)),
                     ('using_ahocorasick', using_ahocorasick(col, lst))]:
    status = 'pass' if np.allclose(expected, result) else 'fail'
    print('{}: {}'.format(name, status))

sehr interessant. wäre es möglich, verwenden Sie dieses Paket in ein pandas dataframe oder mindern die performance (wegen der Schleife, die ich denke)?
Der benchmark oben gezeigt wird, würde immer noch gelten. Oben A.iter ist aufgerufen, in einem Aufruf col.apply wo col ist ein Pandabären-Serie. Das ist nicht sehr viel anders aus (oder vielleicht sogar genau das gleiche wie) was würden Sie tun, mit ein pandas DataFrame. Mit apply hat etwa die gleiche Leistung wie ein einfaches Python-Schleife, aber Sie würden noch immer der Vorteil der Verwendung von Aho-Corasick-Algorithmus.

InformationsquelleAutor unutbu

0

Mit einem einfacheres Beispiel & Kleinschreibung ignorieren (groß-oder Kleinbuchstabe)

Filtern und bekommen einen binären Vektor:

Will ich zu finden, alle Elemente einer pd.Series, v enthalten, "an" oder "Og". Und erhalten Sie 1, wenn das element enthält das Muster, oder 0, wenn nicht.

Ich verwende den re:
```
import re
```
Mein Vektor:
```
v=pd.Series(['cAt','dog','the rat','mouse','froG'])

[Out]:

0        cAt
1        dog
2    the rat
3      mouse
4       froG
```
Will ich zu finden, alle Elemente von v, die "auf" oder "Og".
Dies ist, ich kann definieren, meine pattern als:
```
pattern='at|Og'
```
Da ich möchte, dass ein Vektor mit 1s, wenn das Element enthält das Muster, oder 0, wenn nicht.

Erstelle ich einen einheitlichen Vektor mit der gleichen Länge wie v:
```
v_binary=[1]*len(v)
```
Ich erhalten boolenean s ist Truewenn ein element venthält die patternoder Falsewenn es nicht enthalten ist.
```
s=v.str.contains(pattern, flags=re.IGNORECASE, regex=True)
```
Zu erhalten, die den binären Vektor I multiplizieren Sie die v_binary*s:
```
v_binary*s

[Out]

0    1
1    1
2    1
3    0
4    1
```
- Oder einfach nur s.astype(int) anstatt das ganze den binären Vektor-Logik. Ich sehe keinen grundlegenden Unterschied oder Vorteil im Vergleich zu @AlexRiley Lösung, Sie können sehen?
- Du hast so Recht! Danke, ich werde meinen Beitrag Bearbeiten und setzen
- In der Tat, ich bin immer ein problem. Könnten Sie mir bitte helfen mit diesem: pattern='wiring | media | elect' v=pd.Series(['electricity fault']) s=v.str.contains(pattern, flags=re.IGNORECASE, regex=True) print(s) Ausgabe: 0 False dtype: bool
InformationsquelleAutor pink.slash

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.

Mit einem einfacheres Beispiel & Kleinschreibung ignorieren (groß-oder Kleinbuchstabe)

Filtern und bekommen einen binären Vektor: