Wählen Sie durch partielle string aus ein pandas DataFrame

Ich habe eine DataFrame mit 4 Säulen, von denen 2 enthält string-Werte. Ich Frage mich, ob es einen Weg, um Zeilen auszuwählen, die basierend auf eine teilweise übereinstimmung mit einem gegen eine bestimmte Spalte?

In anderen Worten, eine Funktion oder ein lambda-Funktion, die sowas machen würde wie 

re.search(pattern, cell_in_question)

Rückgabe ein boolean. Ich bin vertraut mit der syntax von df[df['A'] == "hello world"] aber kann nicht scheinen, einen Weg finden, das gleiche zu tun mit der Zeichenfolge übereinstimmen, sagen 'hello'.

Wäre jemand in der Lage zu zeigen mich in die richtige Richtung?

InformationsquelleAutor euforia | 2012-07-05
  1. 613

    Basierend auf github issue #620, wie es aussieht, werden Sie bald in der Lage sein, Folgendes zu tun:

    df[df['A'].str.contains("hello")]

    Update: vektorisiert von string-Methoden (d.h., Serie.str) sind in pandas 0.8.1 und bis.

    • Dies ist jetzt umgesetzt
    • Wie gehen wir über "Hallo" und "Großbritannien" wenn ich will, Sie zu finden, die mit "ODER" - Bedingung.
    • Da str.* Methoden behandeln die input-Muster als regulären Ausdruck verwenden, können Sie df[df['A'].str.contains("Hello|Britain")]
    • Ist es möglich, zu konvertieren .str.contains zu verwenden .query() api?
    • href="https://stackoverflow.com/q/44933071/395857">Wählen Sie die Zeilen durch die Zeichenfolge Abfrage mit pandas
    • df[df['value'].astype(str).str.contains('1234.+')] für das filtern von nicht-string " -Spalten.
    • Was ist mit "UND" Zustand - wie sehen Sie für mehrere Saiten auf den gleichen Zeit, so dass nicht nur "hello", aber ["hello", "hey", "hi"]?
    • zu "UND" Teilstrings, wenn die Reihenfolge der Teilstrings ist wichtig/bekannt, Sie könnte verwenden df[df.A.str.contains("STR1.*STR2")]. wenn die Reihenfolge unwichtig/unbekannt, df[df.A.str.contains("STR1") & df.A.str.contains("STR2")]
    • Ich habe Hinzugefügt, weitere Informationen über mehrere Teilstrings sucht hier.

    InformationsquelleAutor Garrett
  2. 152

    Ich bin mit pandas 0.14.1 auf macos in ipython notebook. Ich habe versucht, die vorgeschlagene Zeile oben:

    df[df['A'].str.contains("Hello|Britain")]

    und bekam eine Fehlermeldung: 

    "cannot index with vector containing NA /NaN values"

    aber es funktionierte perfekt, wenn ein "==True" - Bedingung wurde Hinzugefügt, wie hier:

    df[df['A'].str.contains("Hello|Britain")==True]
    • Oder Sie tun kann: df[df['Ein'].str.contains("Hallo|Großbritannien", na=False)]
    • Sowohl mit als auch ohne ==True funktionierte gut für mich.
    InformationsquelleAutor sharon
  3. 44

    Wenn jemand fragt, wie führen Sie ein Verwandtes problem: "Wählen Sie die Spalte durch die Zeichenfolge"

    Verwenden:

    df.filter(like='hello')  # select columns which contain the word hello

    Und wählen Sie die Zeilen durch partielle string matching, pass axis=0 zu filtern:

    # selects rows which contain the word hello in their index label
df.filter(like='hello', axis=0)
    • Dies kann destilliert werden, um: df.loc[:, df.columns.str.contains('a')]
    • was kann weiter destilliert, um df.filter(like='a')
    InformationsquelleAutor Philipp Schwarz
  4. 33

    Wie wähle ich aus, indem teilweise Zeichen von ein pandas DataFrame?

    Dieser Beitrag ist gedacht für Leser, die wollen

    • Suche nach einer Teilzeichenfolge in einem string-Spalte (der einfachste Fall)
    • Suche nach mehreren Teilzeichenketten (ähnlich isin)
    • match ganzes Wort aus dem text (z.B. "blau" sollte übereinstimmen "der Himmel ist blau", aber nicht "bluejay")
    • match mehrere ganze Wörter
    • Verstehen den Grund hinter "ValueError: keine index-Vektor mit NA /NaN-Werte"

    ...und würde gerne mehr darüber wissen, welche Methoden sollten bevorzugt werden gegenüber anderen.

    (P. S.: ich habe gesehen, eine Menge von Fragen zu ähnlichen Themen, ich dachte, es wäre gut, lassen Sie dieses hier.)

    Basic Für Die Suche Nach Teilzeichenfolgen

    # setup
df1 = pd.DataFrame({'col': ['foo', 'foobar', 'bar', 'baz']})
df1

      col
0     foo
1  foobar
2     bar
3     baz

    str.enthält kann verwendet werden, um entweder substring-Suche oder regex-basierte Suche. Die Suche standardmäßig auf regex-Basis, es sei denn, Sie explizit deaktivieren.

    Hier ist ein Beispiel von regex-basierte Suche, 

    # find rows in `df1` which contain "foo" followed by something
df1[df1['col'].str.contains(r'foo(?!$)')]

      col
1  foobar

    Manchmal regex-Suche ist nicht erforderlich, so geben Sie regex=False zu deaktivieren.

    #select all rows containing "foo"
df1[df1['col'].str.contains('foo', regex=False)]
# same as df1[df1['col'].str.contains('foo')] but faster.

      col
0     foo
1  foobar

    Leistung klug, regex-Suche ist langsamer als die substring-Suche:

    df2 = pd.concat([df1] * 1000, ignore_index=True)

%timeit df2[df2['col'].str.contains('foo')]
%timeit df2[df2['col'].str.contains('foo', regex=False)]

6.31 ms ± 126 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)
2.8 ms ± 241 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)

    Vermeiden Sie die Verwendung von regex-Suche, wenn Sie es nicht brauchen.

    Adressierung ValueErrors

    Manchmal, ist die Durchführung einer substring-Suche und-Filterung auf das Ergebnis Ergebnis in 

    ValueError: cannot index with vector containing NA / NaN values

    Dies ist in der Regel wegen des gemischten Daten oder NaNs in Ihre Spalte Objekt

    s = pd.Series(['foo', 'foobar', np.nan, 'bar', 'baz', 123])
s.str.contains('foo|bar')

0     True
1     True
2      NaN
3     True
4    False
5      NaN
dtype: object


s[s.str.contains('foo|bar')]
# ---------------------------------------------------------------------------
# ValueError                                Traceback (most recent call last)

    Alles, was nicht ist ein string kann nicht von string-Methoden angewendet werden, so ist das Ergebnis NaN (natürlich). Geben Sie In diesem Fall na=False zu ignorieren, nicht-string-Daten,

    s.str.contains('foo|bar', na=False)

0     True
1     True
2    False
3     True
4    False
5    False
dtype: bool

    Mehrere Substring-Suche

    Dies wird am einfachsten erreicht durch eine regex-Suche mit der regex ODER Rohr.

    # Slightly modified example.
df4 = pd.DataFrame({'col': ['foo abc', 'foobar xyz', 'bar32', 'baz 45']})
df4

          col
0     foo abc
1  foobar xyz
2       bar32
3      baz 45

df4[df4['col'].str.contains(r'foo|baz')]

          col
0     foo abc
1  foobar xyz
3      baz 45

    Können Sie auch erstellen Sie eine Liste von Begriffen, dann kommen Sie:

    terms = ['foo', 'baz']
df4[df4['col'].str.contains('|'.join(terms))]

          col
0     foo abc
1  foobar xyz
3      baz 45

    Manchmal ist es klug, um zu entkommen Ihren Bedingungen, wenn Sie Zeichen, die interpretiert werden kann als regex-Metazeichen. Wenn Sie Ihre Begriffe enthalten keine der folgenden Zeichen...

    . ^ $ * + ? { } [ ] \ | ( )

    Dann benötigen Sie re.Flucht zu Flucht Sie:

    import re
df4[df4['col'].str.contains('|'.join(map(re.escape, terms)))]

          col
0     foo abc
1  foobar xyz
3      baz 45

    re.escape hat den Effekt, dass die Flucht der Sonderzeichen, so dass Sie behandelt sind buchstäblich.

    re.escape(r'.foo^')
# '\\.foo\\^'

    Passende Wort(s)

    Standardmäßig die substring-Suche sucht nach der angegebenen Zeichenfolge/Muster unabhängig davon, ob es Wort ist oder nicht. Nur match full-Worte, die wir brauchen, um machen Verwendung von regulären Ausdrücken hier—insbesondere unsere Muster angeben müssen Wortgrenzen (\b).

    Beispielsweise 

    df3 = pd.DataFrame({'col': ['the sky is blue', 'bluejay by the window']})
df3

                     col
0        the sky is blue
1  bluejay by the window

    Betrachten wir nun,

    df3[df3['col'].str.contains('blue')]

                     col
0        the sky is blue
1  bluejay by the window

    v/s 

    df3[df3['col'].str.contains(r'\bblue\b')]

               col
0  the sky is blue

    Mehrere Ganzes Wort Suchen

    Ähnlich wie oben, außer wir fügen Sie ein Wort-Grenze (\b) in den verbundenen Muster.

    p = r'\b(?:{})\b'.format('|'.join(map(re.escape, terms)))
df4[df4['col'].str.contains(p)]

       col
0  foo abc
3   baz 45

    Wo p sieht so aus,

    p
# '\\b(?:foo|baz)\\b'

    Eine Tolle Alternative: Verwenden Sie Liste Verstehens!

    Weil Sie können! Und sollten Sie! Sie sind in der Regel ein wenig schneller als das string-Methoden, da die string-Methoden sind schwer zu vectorise und haben in der Regel loopy-Implementierungen.

    Statt,

    df1[df1['col'].str.contains('foo', regex=False)]

    Verwenden Sie die in operator in einer Liste, comp,

    df1[['foo' in x for x in df1['col']]]

       col
0  foo abc
1   foobar

    Statt,

    regex_pattern = r'foo(?!$)'
df1[df1['col'].str.contains(regex_pattern)]

    Verwenden re.compile (cache deine regex) + - Muster.Suche in einer Liste, comp,

    p = re.compile(regex_pattern, flags=re.IGNORECASE)
df1[[bool(p.search(x)) for x in df1['col']]]

      col
1  foobar

    Wenn "col" hat NaN dann statt 

    df1[df1['col'].str.contains(regex_pattern, na=False)]

    Verwenden,

    def try_search(p, x):
    try:
        return bool(p.search(x))
    except TypeError:
        return False

p = re.compile(regex_pattern)
df1[[try_search(p, x) for x in df1['col']]]

      col
1  foobar

    Mehr Optionen für die Partielle String Matching: np.char.finden, np.Vektorisieren, DataFrame.query.

    Neben str.contains Liste und Verstehens, Sie können auch die folgenden alternativen.

    np.char.find

    Unterstützt substring-Suche (gelesen: keine regex) nur.

    df4[np.char.find(df4['col'].values.astype(str), 'foo') > -1]

          col
0     foo abc
1  foobar xyz

    np.vectorize

    Dies ist ein wrapper für eine Schleife, aber mit weniger Aufwand als die meisten pandas str Methoden.

    f = np.vectorize(lambda haystack, needle: needle in haystack)
f(df1['col'], 'foo')
# array([ True,  True, False, False])

df1[f(df1['col'], 'foo')]

       col
0  foo abc
1   foobar

    Regex-Lösungen möglich:

    regex_pattern = r'foo(?!$)'
p = re.compile(regex_pattern)
f = np.vectorize(lambda x: pd.notna(x) and bool(p.search(x)))
df1[f(df1['col'])]

      col
1  foobar

    DataFrame.query

    Unterstützt von string-Methoden, die durch die python-engine. Dies bietet keine sichtbaren performance-Vorteile, aber ist dennoch nützlich zu wissen, wenn Sie benötigen, um dynamisch erstellen Sie Ihre Abfragen.

    df1.query('col.str.contains("foo")', engine='python')

      col
0     foo
1  foobar

    Mehr Informationen auf query und eval Familie von Methoden gefunden werden können zu Dynamische Auswertung eines Ausdrucks in pandas mit pd.eval().

    Empfohlene Verwendung Vorrang

    1. (Ersten) str.contains, für seine Einfachheit in der Handhabung NaNs und gemischte Daten
    2. Liste Verstehens, für seine Leistung (vor allem, wenn Ihre Daten ist rein Zeichenketten)
    3. np.vectorize
    4. (Letzten) df.query
    • Könnten Sie das Bearbeiten in die richtige Methode zu verwenden, wenn die Suche nach einem string in zwei oder mehr Spalten? Grundsätzlich: any(needle in haystack for needling in ['foo', 'bar'] and haystack in (df['col'], df['col2'])) und Variationen habe ich versucht alle den choke (es beschwert sich über any() und das ist auch richtig so... Aber der doc ist selig unklar, wie so ein query.
    • x: x.str.enthält('foo|bar')).jede(axis=1)
    • href="https://stackoverflow.com/questions/57238715/extracting-rows-with-substring-containing-whitespace-after-in-pandas-df">Extrahieren von Zeilen mit Teilstring mit Leerzeichen nach dem " + " in pandas df Es wurde bald beantwortet, aber möchten Sie vielleicht einen Blick auf Sie.
    • Sieht aus wie Sie verpasste den Teil meiner Antwort, wo ich erwähnte regex-Metazeichen: "Manchmal ist es klug, um zu entkommen Ihren Bedingungen, wenn Sie Zeichen, die interpretiert werden kann als regex-Metazeichen".
    • damals dachte ich, nur der Raum als problem und durchsucht diese Seite und Dokumentations-Seite für die gleichen. Beim schreiben der Frage, Besondere char kam mir in den Sinn und ich bekam schnell Antworten, bevor ich könnte nach ihm suchen. Tolle Antwort von dir! +1
    • Sehr hilfreich!!! Warum müssen Sie einfügen r wenn regex = True standardmäßig? zB hier: df1[df1['col'].str.contains(r'foo(?!$)')]
    • r in diesem Fall wird verwendet, um anzuzeigen, dass ein raw-string-Literale. Diese machen es einfacher zu schreiben regular expression strings. stackoverflow.com/q/2081640

    InformationsquelleAutor cs95
  5. 27

    Kurze Notiz: wenn Sie möchten, zu tun-Auswahl, basierend auf der Zeichenfolge im index enthaltenen, versuchen Sie Folgendes:

    df['stridx']=df.index
df[df['stridx'].str.contains("Hello|Britain")]
    • Sie können nur df[df.index.to_series().str.enthält('LLChit')]
    InformationsquelleAutor Christian
  6. 20

    Sagen, Sie haben die folgenden DataFrame:

    >>> df = pd.DataFrame([['hello', 'hello world'], ['abcd', 'defg']], columns=['a','b'])
>>> df
       a            b
0  hello  hello world
1   abcd         defg

    Können Sie immer die in - operator in einen lambda-Ausdruck zu erstellen Sie Ihre filter.

    >>> df.apply(lambda x: x['a'] in x['b'], axis=1)
0     True
1    False
dtype: bool

    Der trick dabei ist die Verwendung der axis=1 option in der apply übergeben Elemente der lambda-Funktion Zeile für Zeile, im Gegensatz zu Spalte um Spalte.

    • Wie ändere ich oben zu sagen, dass x['a'] existiert nur in den Anfang der x['b']?
    • beziehen, ist eine schlechte Idee, hier in Bezug auf Leistung und Speicher. Siehe diese Antwort.
    InformationsquelleAutor Mike
  7. 7

    Hier ist, was ich am Ende dabei für die partielle string übereinstimmt. Wenn jemand ein effizienter Weg, dies zu tun, lassen Sie es mich bitte wissen.

    def stringSearchColumn_DataFrame(df, colName, regex):
    newdf = DataFrame()
    for idx, record in df[colName].iteritems():

        if re.search(regex, record):
            newdf = concat([df[df[colName] == record], newdf], ignore_index=True)

    return newdf
    • Sollte die 2x bis 3x schneller, wenn Sie kompilieren regex vor der Schleife: regex = re.compile(regex) und dann wenn regex.Suche nach(Rekord)
    • href="https://docs.python.org/3.6/library/re.html#re.compile" >docs.python.org/3.6/library/re.html#re.compile sagt, dass die jüngsten regexs sind für Sie zwischengespeichert werden, so brauchen Sie nicht selbst kompilieren.
    • Verwenden Sie nicht iteritems Durchlaufen Sie ein DataFrame. Es zählt zuletzt im Hinblick auf pandorability und Leistung
    InformationsquelleAutor euforia
  8. 0

    Gibt es Antworten, bevor diese das erreichen der gestellten Funktion, trotzdem möchte ich Ihnen zeigen, die meisten in der Regel so:

    df.filter(regex=".*STRING_YOU_LOOK_FOR.*")

    Diese Weise können Sie Holen Sie sich die Spalte, die Sie für alles, was der Weg ist schrieb.

    ( Obviusly, Sie haben zu schreiben, die richtige regex-Ausdruck für jeden Fall )

    • Diese Filter auf die Spalte Header. Es ist nicht allgemein, ist es falsch.
    InformationsquelleAutor xpeiro
Schreibe einen Kommentar